repo_name
stringlengths 6
130
| hexsha
list | file_path
list | code
list | apis
list |
|---|---|---|---|---|
stevenwudi/CarND-Traffic-Sign-Classifier-Project
|
[
"78d7392317b8d01b8ce968328960b269f64403c9"
] |
[
"test_single.py"
] |
[
"# The followings are the DenseNets module, the training was actually taken place in the `run_dense_net.py` file.\n# Sorry, I really like Pycharm (and to be fair, Pytorch is so much an easier language to debug)\nimport os\nos.environ['CUDA_VISIBLE_DEVICES'] = '2'\nfrom models import DenseNet\nfrom data_providers.utils import get_data_provider_by_name\nimport tensorflow as tf\nimport numpy as np\nimport json\nimport pandas as pd\nfrom tqdm import tqdm\nimport random\nimport time\nfrom matplotlib import pyplot as plt\n# Visualizations will be shown in the notebook.\n# % matplotlib inline\nfrom matplotlib import gridspec\n\n# Load pickled data\nimport pickle\ntraining_file = './data/train.p'\nvalidation_file = './data/valid.p'\ntesting_file = './data/test.p'\n\nwith open(training_file, mode='rb') as f:\n train = pickle.load(f)\nwith open(validation_file, mode='rb') as f:\n valid = pickle.load(f)\nwith open(testing_file, mode='rb') as f:\n test = pickle.load(f)\n\nX_train, y_train = train['features'], train['labels']\nX_valid, y_valid = valid['features'], valid['labels']\nX_test, y_test_origin = test['features'], test['labels']\n\n\ntrain_params_cifar = {\n 'batch_size': 64,\n 'n_epochs': 500,\n 'initial_learning_rate': 0.05,\n 'reduce_lr_epoch_1': 50, # epochs * 0.5\n 'reduce_lr_epoch_2': 75, # epochs * 0.75\n 'validation_set': True,\n 'validation_split': None, # None or float\n 'shuffle': 'every_epoch', # None, once_prior_train, every_epoch\n 'normalization': 'by_chanels', # None, divide_256, divide_255, by_chanels\n 'use_YUV': True,\n 'use_Y': False, # use only Y channel\n 'data_augmentation': 0, # [0, 1]\n}\n\n\n# We save this model params.json from the trained model\nwith open('model_params.json', 'r') as fp:\n model_params = json.load(fp)\n\n# some default params dataset/architecture related\ntrain_params = train_params_cifar\nprint(\"Params:\")\nfor k, v in model_params.items():\n print(\"\\t%s: %s\" % (k, v))\nprint(\"Train params:\")\nfor k, v in train_params.items():\n print(\"\\t%s: %s\" % (k, v))\n\n\nmodel_params['use_Y'] = False\nprint(\"Prepare training data...\")\ndata_provider = get_data_provider_by_name(model_params['dataset'], train_params)\nprint(\"Initialize the model..\")\ntf.reset_default_graph()\nmodel = DenseNet(data_provider=data_provider, **model_params)\nprint(\"Loading trained model\")\nmodel.load_model()\n\nprint(\"Data provider test images: \", data_provider.test.num_examples)\nprint(\"Testing...\")\nloss, accuracy = model.test(data_provider.test, batch_size=30)\n\nimport cv2\ndef labels_to_one_hot(labels, n_classes=43+1):\n \"\"\"Convert 1D array of labels to one hot representation\n\n Args:\n labels: 1D numpy array\n \"\"\"\n new_labels = np.zeros((n_classes,))\n new_labels[labels] = 1\n return new_labels\nnewimages = []\nnewlabels = []\nnew_onehot = []\nnewlabelsdata = []\ndirectories = \"./newimages\"\nsubdirs = os.listdir(directories)\nfor subdir in subdirs:\n classId = int(subdir.split(\"-\")[0])\n classinfo = {'label':classId,'count':0, 'samples':[]}\n filepath = directories+\"/\"+subdir\n for filename in os.listdir(filepath):\n image_filepath = filepath+\"/\"+filename\n image = cv2.imread(image_filepath)\n image_rgb = cv2.resize(image, (32, 32), interpolation=cv2.INTER_AREA)\n image = image_rgb.copy()\n image[:, :, 0] = image_rgb[:, :, 2]\n image[:, :, 2] = image_rgb[:, :, 0]\n newimages.append(image)\n newlabels.append(classId)\n new_onehot.append(labels_to_one_hot(classId))\n classinfo['count'] += 1\n classinfo['samples'].append(len(newimages)-1)\n if classinfo['count'] > 0:\n print(\"appending: \", classinfo)\n newlabelsdata.append(classinfo)\n\nnewimages = np.array(newimages)\nnewlabels = np.array(newlabels)\nnew_onehot = np.array(new_onehot)\n\nfrom data_providers.GermanTrafficSign import RGB2YUV\n\nX_test_new = RGB2YUV(newimages)\nnew_image = np.zeros(X_test_new.shape)\n\nfor i in range(X_test_new.shape[-1]):\n new_image[:, :, :, i] = ((X_test_new[:, :, :, i] - data_provider._means[i]) /data_provider._stds[i])\n\n\ny_new_onehot = model.predictions_one_image(new_image)[0]\npredict_classId = np.argmax(y_new_onehot, axis=1)\n\n\n\nincorrectlist = []\nfor i in range(len(y_new_onehot)):\n correct_classId = np.argmax(new_onehot[i],0)\n predict_classId = np.argmax(y_new_onehot[i],0)\n incorrectlist.append({'index':i, 'correct':correct_classId, 'predicted':predict_classId})\n\n\nincorrectmatrix = {}\nmodeCount = 0\nfor i in range(len(incorrectlist)):\n predicted = incorrectlist[i]['predicted']\n correct = incorrectlist[i]['correct']\n index = incorrectlist[i]['index']\n bucket = str(correct) + \"+\" + str(predicted)\n incorrectinstance = incorrectmatrix.get(bucket, {'count': 0, 'samples': []})\n\n # add to the count\n count = incorrectinstance['count'] + 1\n\n # add to samples of this correct to predicted condition\n samples = incorrectinstance['samples']\n samples.append(index)\n\n # put back in the list\n incorrectmatrix[bucket] = {'count': count, 'correct': correct, 'predicted': predicted, 'samples': samples}\n\n # update most common error\n if count > modeCount:\n modeCount = count\n modeBucket = bucket\n\n\n# get the list of buckets and sort them\ndef compare_bucket_count(bucket):\n return modeCount - incorrectmatrix[bucket]['count']\n\n\nsortedBuckets = list(incorrectmatrix.keys())\nsortedBuckets.sort(key=compare_bucket_count)\n\n# get the unique number of original picture sizes and the min and max last instance\nn_buckets = len(sortedBuckets)\n\n# print the stats\nprint(\"\\nNumber of unique buckets in incorrect set: \", n_buckets, \"\\n\")\nprint(\"Mode Bucket: \", modeBucket, \"with count: \", modeCount)\nclassLabelList = pd.read_csv('signnames.csv')\nprint(\"\\nDistribution of buckets with predicted test dataset labels:\")\nfor n in range(len(sortedBuckets)):\n bucket = sortedBuckets[n]\n cclassId = incorrectmatrix[bucket]['correct']\n pclassId = incorrectmatrix[bucket]['predicted']\n count = incorrectmatrix[bucket]['count']\n cdescription = classLabelList[classLabelList.ClassId == cclassId].SignName.to_string(header=False, index=False)\n pdescription = classLabelList[classLabelList.ClassId == pclassId].SignName.to_string(header=False, index=False)\n print(\n \"incorrect set count: {0:4d} CClassId: {1:02d} Description: {2}\\n PClassId: {3:02d} Description: {4}\".format(\n count, cclassId, cdescription, pclassId, pdescription))\n\n\ndef draw_sample_correctmatrix(datasettxt, sortedBuckets, incorrectmatix, dataset, cmap=None):\n n_maxsamples = 8\n n_labels = len(sortedBuckets)\n\n # size of each sample\n fig = plt.figure(figsize=(n_maxsamples * 1.8, n_labels))\n w_ratios = [1 for n in range(n_maxsamples)]\n w_ratios[:0] = [int(n_maxsamples * 0.8)]\n h_ratios = [1 for n in range(n_labels)]\n\n # gridspec\n time.sleep(1) # wait for 1 second for the previous print to appear!\n grid = gridspec.GridSpec(n_labels, n_maxsamples + 1, wspace=0.0, hspace=0.0, width_ratios=w_ratios,\n height_ratios=h_ratios)\n labelset_pbar = tqdm(range(n_labels), desc=datasettxt, unit='labels')\n for a in labelset_pbar:\n cclassId = incorrectmatrix[sortedBuckets[n_labels - a - 1]]['correct']\n pclassId = incorrectmatrix[sortedBuckets[n_labels - a - 1]]['predicted']\n cdescription = classLabelList[classLabelList.ClassId == cclassId].SignName.to_string(header=False, index=False)\n pdescription = classLabelList[classLabelList.ClassId == pclassId].SignName.to_string(header=False, index=False)\n count = incorrectmatrix[sortedBuckets[n_labels - a - 1]]['count']\n for b in range(n_maxsamples + 1):\n i = a * (n_maxsamples + 1) + b\n ax = plt.Subplot(fig, grid[i])\n if b == 0:\n ax.annotate(\n 'CClassId %d (%d): %s\\nPClassId %d: %s' % (cclassId, count, cdescription, pclassId, pdescription),\n xy=(0, 0), xytext=(0.0, 0.3))\n ax.set_xticks([])\n ax.set_yticks([])\n fig.add_subplot(ax)\n else:\n if (b - 1) < count:\n image = dataset[incorrectmatrix[sortedBuckets[n_labels - a - 1]]['samples'][b - 1]]\n if cmap == None:\n ax.imshow(image)\n else:\n # yuv = cv2.split(image)\n # ax.imshow(yuv[0], cmap=cmap)\n ax.imshow(image, cmap=cmap)\n ax.set_xticks([])\n ax.set_yticks([])\n fig.add_subplot(ax)\n\n # hide the borders\\\n if a == (n_labels - 1):\n all_axes = fig.get_axes()\n for ax in all_axes:\n for sp in ax.spines.values():\n sp.set_visible(False)\n\n plt.show()"
] |
[
[
"numpy.array",
"numpy.zeros",
"matplotlib.pyplot.Subplot",
"tensorflow.reset_default_graph",
"matplotlib.pyplot.figure",
"numpy.argmax",
"matplotlib.pyplot.show",
"pandas.read_csv",
"matplotlib.gridspec.GridSpec"
]
] |
ianpan870102/neural-network-on-finance-data
|
[
"b032a869e9f6ea662c9e299259a200346eb76bb4"
] |
[
"midprice_profit_label/profit_evaluate/data_generate.py"
] |
[
"import psycopg2, psycopg2.extras\nimport time\nimport numpy as np\nimport pandas as pd\n\nfrom datetime import timedelta, date\n\n\ndef date_range(start_date, end_date):\n for n in range(int((end_date - start_date).days)):\n yield start_date + timedelta(n)\n\n\ndef generate_by_month():\n conn = psycopg2.connect(**eval(open('auth.txt').read()))\n cmd = conn.cursor(cursor_factory=psycopg2.extras.DictCursor)\n\n start_date = date(2010, 1, 1)\n end_date = date(2010, 7, 1)\n\n prices = []\n\n with open('dt_index.txt', 'w') as f:\n #run from start_date to end_date-1 day\n for single_date in date_range(start_date, end_date):\n cmd.execute('select * from market_index where mid = 1 and dt=%(dt)s',\n dict(dt=single_date.strftime(\"%Y-%m-%d\")))\n recs = cmd.fetchall()\n\n if recs == []:\n continue\n\n df = pd.DataFrame(recs, columns=recs[0].keys())\n\n prices = prices + [df['close'].tolist()]\n\n f.write(single_date.strftime(\"%Y-%m-%d\") + '\\n')\n\n # print(prices)\n # print(np.shape(prices))\n\n np.save(('price_201001~06.npy'), prices)\n\n\ndef generate_by_txt():\n conn = psycopg2.connect(**eval(open('auth.txt').read()))\n cmd = conn.cursor(cursor_factory=psycopg2.extras.DictCursor)\n\n prices = []\n\n with open('dt_threshold=10.txt', 'r') as f:\n dates = f.readlines()\n # print(dates)\n\n for index, date in enumerate(dates):\n cmd.execute('select * from market_index where mid = 1 and dt=%(dt)s', dict(dt=date))\n recs = cmd.fetchall()\n\n if recs == []:\n continue\n\n df = pd.DataFrame(recs, columns=recs[0].keys())\n\n prices = prices + [df['close'].tolist()]\n\n # print(prices)\n # print(np.shape(prices))\n\n np.save(('price_threshold=10.npy'), prices)\n\n\nif __name__ == '__main__':\n generate_by_month()\n"
] |
[
[
"numpy.save"
]
] |
lilohuang/TensorBox
|
[
"7c25a6db1a997ce072965488649b664bc4a4858c"
] |
[
"evaluate.py"
] |
[
"import tensorflow as tf\nimport os\nimport json\nimport subprocess\nfrom scipy.misc import imread, imresize\nfrom scipy import misc\n\nfrom train import build_forward\nfrom utils.annolist import AnnotationLib as al\nfrom utils.train_utils import add_rectangles, rescale_boxes\n\nimport cv2\nimport argparse\n\ndef get_image_dir(args):\n weights_iteration = int(args.weights.split('-')[-1])\n expname = '_' + args.expname if args.expname else ''\n image_dir = '%s/images_%s_%d%s' % (os.path.dirname(args.weights), os.path.basename(args.test_boxes)[:-5], weights_iteration, expname)\n return image_dir\n\ndef get_results(args, H):\n tf.reset_default_graph()\n x_in = tf.placeholder(tf.float32, name='x_in', shape=[H['image_height'], H['image_width'], 3])\n if H['use_rezoom']:\n pred_boxes, pred_logits, pred_confidences, pred_confs_deltas, pred_boxes_deltas = build_forward(H, tf.expand_dims(x_in, 0), 'test', reuse=None)\n grid_area = H['grid_height'] * H['grid_width']\n pred_confidences = tf.reshape(tf.nn.softmax(tf.reshape(pred_confs_deltas, [grid_area * H['rnn_len'], 2])), [grid_area, H['rnn_len'], 2])\n if H['reregress']:\n pred_boxes = pred_boxes + pred_boxes_deltas\n else:\n pred_boxes, pred_logits, pred_confidences = build_forward(H, tf.expand_dims(x_in, 0), 'test', reuse=None)\n saver = tf.train.Saver()\n with tf.Session() as sess:\n sess.run(tf.global_variables_initializer())\n saver.restore(sess, args.weights)\n\n pred_annolist = al.AnnoList()\n\n true_annolist = al.parse(args.test_boxes)\n data_dir = os.path.dirname(args.test_boxes)\n image_dir = get_image_dir(args)\n os.makedirs(image_dir)\n for i in range(len(true_annolist)):\n true_anno = true_annolist[i]\n orig_img = imread('%s/%s' % (data_dir, true_anno.imageName))[:,:,:3]\n img = imresize(orig_img, (H[\"image_height\"], H[\"image_width\"]), interp='cubic')\n feed = {x_in: img}\n (np_pred_boxes, np_pred_confidences) = sess.run([pred_boxes, pred_confidences], feed_dict=feed)\n pred_anno = al.Annotation()\n pred_anno.imageName = true_anno.imageName\n new_img, rects = add_rectangles(H, [img], np_pred_confidences, np_pred_boxes,\n use_stitching=True, rnn_len=H['rnn_len'], min_conf=args.min_conf, tau=args.tau, show_suppressed=args.show_suppressed)\n \n pred_anno.rects = rects\n pred_anno.imagePath = os.path.abspath(data_dir)\n pred_anno = rescale_boxes((H[\"image_height\"], H[\"image_width\"]), pred_anno, orig_img.shape[0], orig_img.shape[1])\n pred_annolist.append(pred_anno)\n \n imname = '%s/%s' % (image_dir, os.path.basename(true_anno.imageName))\n misc.imsave(imname, new_img)\n if i % 25 == 0:\n print(i)\n return pred_annolist, true_annolist\n\ndef main():\n parser = argparse.ArgumentParser()\n parser.add_argument('--weights', required=True)\n parser.add_argument('--expname', default='')\n parser.add_argument('--test_boxes', required=True)\n parser.add_argument('--gpu', default=0)\n parser.add_argument('--logdir', default='output')\n parser.add_argument('--iou_threshold', default=0.5, type=float)\n parser.add_argument('--tau', default=0.25, type=float)\n parser.add_argument('--min_conf', default=0.2, type=float)\n parser.add_argument('--show_suppressed', default=True, type=bool)\n args = parser.parse_args()\n os.environ['CUDA_VISIBLE_DEVICES'] = str(args.gpu)\n hypes_file = '%s/hypes.json' % os.path.dirname(args.weights)\n with open(hypes_file, 'r') as f:\n H = json.load(f)\n expname = args.expname + '_' if args.expname else ''\n pred_boxes = '%s.%s%s' % (args.weights, expname, os.path.basename(args.test_boxes))\n true_boxes = '%s.gt_%s%s' % (args.weights, expname, os.path.basename(args.test_boxes))\n\n\n pred_annolist, true_annolist = get_results(args, H)\n pred_annolist.save(pred_boxes)\n true_annolist.save(true_boxes)\n\n try:\n rpc_cmd = './utils/annolist/doRPC.py --minOverlap %f %s %s' % (args.iou_threshold, true_boxes, pred_boxes)\n print('$ %s' % rpc_cmd)\n rpc_output = subprocess.check_output(rpc_cmd, shell=True)\n print(rpc_output)\n txt_file = [line for line in rpc_output.split('\\n') if line.strip()][-1]\n output_png = '%s/results.png' % get_image_dir(args)\n plot_cmd = './utils/annolist/plotSimple.py %s --output %s' % (txt_file, output_png)\n print('$ %s' % plot_cmd)\n plot_output = subprocess.check_output(plot_cmd, shell=True)\n print('output results at: %s' % plot_output)\n except Exception as e:\n print(e)\n\nif __name__ == '__main__':\n main()\n"
] |
[
[
"tensorflow.expand_dims",
"tensorflow.Session",
"tensorflow.reset_default_graph",
"tensorflow.train.Saver",
"scipy.misc.imresize",
"tensorflow.reshape",
"scipy.misc.imread",
"tensorflow.placeholder",
"scipy.misc.imsave",
"tensorflow.global_variables_initializer"
]
] |
bill-teng/mxnet-test
|
[
"39a2c0cff1be8b8277b2e0a8c55214acc186a49c"
] |
[
"example/warpctc/ocr_predict.py"
] |
[
"#!/usr/bin/env python2.7\n# coding=utf-8\nfrom __future__ import print_function\nimport sys, os\ncurr_path = os.path.dirname(os.path.abspath(os.path.expanduser(__file__)))\nsys.path.append(\"../../amalgamation/python/\")\nsys.path.append(\"../../python/\")\n\nfrom mxnet_predict import Predictor\nimport mxnet as mx\n\nimport numpy as np\nimport cv2\nimport os\n\nclass lstm_ocr_model(object):\n # Keep Zero index for blank. (CTC request it)\n CONST_CHAR='0123456789'\n def __init__(self, path_of_json, path_of_params):\n super(lstm_ocr_model, self).__init__()\n self.path_of_json = path_of_json\n self.path_of_params = path_of_params\n self.predictor = None\n self.__init_ocr()\n\n def __init_ocr(self):\n num_label = 4 # Set your max length of label, add one more for blank\n batch_size = 1\n\n num_hidden = 100\n num_lstm_layer = 2\n init_c = [('l%d_init_c'%l, (batch_size, num_hidden)) for l in range(num_lstm_layer)]\n init_h = [('l%d_init_h'%l, (batch_size, num_hidden)) for l in range(num_lstm_layer)]\n init_states = init_c + init_h\n\n all_shapes = [('data', (batch_size, 80 * 30))] + init_states + [('label', (batch_size, num_label))]\n all_shapes_dict = {}\n for _shape in all_shapes:\n all_shapes_dict[_shape[0]] = _shape[1]\n self.predictor = Predictor(open(self.path_of_json).read(),\n open(self.path_of_params).read(),\n all_shapes_dict)\n\n def forward_ocr(self, img):\n img = cv2.resize(img, (80, 30))\n img = img.transpose(1, 0)\n img = img.reshape((80 * 30))\n img = np.multiply(img, 1/255.0)\n self.predictor.forward(data=img)\n prob = self.predictor.get_output(0)\n label_list = []\n for p in prob:\n max_index = np.argsort(p)[::-1][0]\n label_list.append(max_index)\n return self.__get_string(label_list)\n\n def __get_string(self, label_list):\n # Do CTC label rule\n # CTC cannot emit a repeated symbol on consecutive timesteps\n ret = []\n label_list2 = [0] + list(label_list)\n for i in range(len(label_list)):\n c1 = label_list2[i]\n c2 = label_list2[i+1]\n if c2 == 0 or c2 == c1:\n continue\n ret.append(c2)\n # change to ascii\n s = ''\n for l in ret:\n if l > 0 and l < (len(lstm_ocr_model.CONST_CHAR)+1):\n c = lstm_ocr_model.CONST_CHAR[l-1]\n else:\n c = ''\n s += c\n return s\n\nif __name__ == '__main__':\n _lstm_ocr_model = lstm_ocr_model('ocr-symbol.json', 'ocr-0010.params')\n img = cv2.imread('sample.jpg', 0)\n _str = _lstm_ocr_model.forward_ocr(img)\n print('Result: ', _str)\n\n"
] |
[
[
"numpy.multiply",
"numpy.argsort"
]
] |
duncanmmacleod/nestcheck
|
[
"09dbaee638bd8689dfe64b438a36f7167fcf724c"
] |
[
"nestcheck/estimators.py"
] |
[
"#!/usr/bin/env python\n\"\"\"\nFunctions for estimating quantities from nested sampling runs.\nEach estimator function should have arguments:\n\n.. code-block:: python\n\n def estimator_func(self, ns_run, logw=None, simulate=False):\n ...\n\nAny additional arguments required for the function should be keyword\narguments.\n\nThe ``logw`` argument allows the log weights for the points in the run to be\nprovided - this is useful if many estimators are being calculated from\nthe same run as it allows ``logw`` to only be calculated once. If it is not\nspecified, ``logw`` is calculated from the run when required.\n\nThe simulate argument is passed to ``ns_run_utils.get_logw``, and is only used\nif the function needs to calculate ``logw``.\n\"\"\"\n\nimport functools\nimport numpy as np\nimport scipy\nimport nestcheck.ns_run_utils\n\n\n# Estimators\n# ----------\n\ndef count_samples(ns_run, **kwargs):\n r\"\"\"Number of samples in run.\n\n Unlike most estimators this does not require log weights, but for\n convenience will not throw an error if they are specified.\n\n Parameters\n ----------\n ns_run: dict\n Nested sampling run dict (see the data_processing module\n docstring for more details).\n\n Returns\n -------\n int\n \"\"\"\n kwargs.pop('logw', None)\n kwargs.pop('simulate', None)\n if kwargs:\n raise TypeError('Unexpected **kwargs: {0}'.format(kwargs))\n return ns_run['logl'].shape[0]\n\n\ndef logz(ns_run, logw=None, simulate=False):\n r\"\"\"Natural log of Bayesian evidence :math:`\\log \\mathcal{Z}`.\n\n Parameters\n ----------\n ns_run: dict\n Nested sampling run dict (see the data_processing module\n docstring for more details).\n logw: None or 1d numpy array, optional\n Log weights of samples.\n simulate: bool, optional\n Passed to ns_run_utils.get_logw if logw needs to be\n calculated.\n\n Returns\n -------\n float\n \"\"\"\n if logw is None:\n logw = nestcheck.ns_run_utils.get_logw(ns_run, simulate=simulate)\n return scipy.special.logsumexp(logw)\n\n\ndef evidence(ns_run, logw=None, simulate=False):\n r\"\"\"Bayesian evidence :math:`\\log \\mathcal{Z}`.\n\n Parameters\n ----------\n ns_run: dict\n Nested sampling run dict (see the data_processing module\n docstring for more details).\n logw: None or 1d numpy array, optional\n Log weights of samples.\n simulate: bool, optional\n Passed to ns_run_utils.get_logw if logw needs to be\n calculated.\n\n Returns\n -------\n float\n \"\"\"\n if logw is None:\n logw = nestcheck.ns_run_utils.get_logw(ns_run, simulate=simulate)\n return np.exp(scipy.special.logsumexp(logw))\n\n\ndef param_mean(ns_run, logw=None, simulate=False, param_ind=0,\n handle_indexerror=False):\n \"\"\"Mean of a single parameter (single component of theta).\n\n Parameters\n ----------\n ns_run: dict\n Nested sampling run dict (see the data_processing module\n docstring for more details).\n logw: None or 1d numpy array, optional\n Log weights of samples.\n simulate: bool, optional\n Passed to ns_run_utils.get_logw if logw needs to be\n calculated.\n param_ind: int, optional\n Index of parameter for which the mean should be calculated. This\n corresponds to the column of ns_run['theta'] which contains the\n parameter.\n handle_indexerror: bool, optional\n Make the function function return nan rather than raising an\n IndexError if param_ind >= ndim. This is useful when applying\n the same list of estimators to data sets of different dimensions.\n\n Returns\n -------\n float\n \"\"\"\n if logw is None:\n logw = nestcheck.ns_run_utils.get_logw(ns_run, simulate=simulate)\n w_relative = np.exp(logw - logw.max())\n try:\n return (np.sum(w_relative * ns_run['theta'][:, param_ind])\n / np.sum(w_relative))\n except IndexError:\n if handle_indexerror:\n return np.nan\n else:\n raise\n\n\ndef param_cred(ns_run, logw=None, simulate=False, probability=0.5,\n param_ind=0):\n \"\"\"One-tailed credible interval on the value of a single parameter\n (component of theta).\n\n Parameters\n ----------\n ns_run: dict\n Nested sampling run dict (see the data_processing module\n docstring for more details).\n logw: None or 1d numpy array, optional\n Log weights of samples.\n simulate: bool, optional\n Passed to ns_run_utils.get_logw if logw needs to be\n calculated.\n probability: float, optional\n Quantile to estimate - must be in open interval (0, 1).\n For example, use 0.5 for the median and 0.84 for the upper\n 84% quantile. Passed to weighted_quantile.\n param_ind: int, optional\n Index of parameter for which the credible interval should be\n calculated. This corresponds to the column of ns_run['theta']\n which contains the parameter.\n\n Returns\n -------\n float\n \"\"\"\n if logw is None:\n logw = nestcheck.ns_run_utils.get_logw(ns_run, simulate=simulate)\n w_relative = np.exp(logw - logw.max()) # protect against overflow\n return weighted_quantile(probability, ns_run['theta'][:, param_ind],\n w_relative)\n\n\ndef param_squared_mean(ns_run, logw=None, simulate=False, param_ind=0):\n \"\"\"Mean of the square of single parameter (second moment of its\n posterior distribution).\n\n Parameters\n ----------\n ns_run: dict\n Nested sampling run dict (see the data_processing module\n docstring for more details).\n logw: None or 1d numpy array, optional\n Log weights of samples.\n simulate: bool, optional\n Passed to ns_run_utils.get_logw if logw needs to be\n calculated.\n param_ind: int, optional\n Index of parameter for which the second moment should be\n calculated. This corresponds to the column of ns_run['theta']\n which contains the parameter.\n\n Returns\n -------\n float\n \"\"\"\n if logw is None:\n logw = nestcheck.ns_run_utils.get_logw(ns_run, simulate=simulate)\n w_relative = np.exp(logw - logw.max()) # protect against overflow\n w_relative /= np.sum(w_relative)\n return np.sum(w_relative * (ns_run['theta'][:, param_ind] ** 2))\n\n\ndef r_mean(ns_run, logw=None, simulate=False):\n \"\"\"Mean of the radial coordinate (magnitude of theta vector).\n\n Parameters\n ----------\n ns_run: dict\n Nested sampling run dict (see the data_processing module\n docstring for more details).\n logw: None or 1d numpy array, optional\n Log weights of samples.\n simulate: bool, optional\n Passed to ns_run_utils.get_logw if logw needs to be\n calculated.\n\n Returns\n -------\n float\n \"\"\"\n if logw is None:\n logw = nestcheck.ns_run_utils.get_logw(ns_run, simulate=simulate)\n w_relative = np.exp(logw - logw.max())\n r = np.sqrt(np.sum(ns_run['theta'] ** 2, axis=1))\n return np.sum(w_relative * r) / np.sum(w_relative)\n\n\ndef r_cred(ns_run, logw=None, simulate=False, probability=0.5):\n \"\"\"One-tailed credible interval on the value of the radial coordinate\n (magnitude of theta vector).\n\n Parameters\n ----------\n ns_run: dict\n Nested sampling run dict (see the data_processing module\n docstring for more details).\n logw: None or 1d numpy array, optional\n Log weights of samples.\n simulate: bool, optional\n Passed to ns_run_utils.get_logw if logw needs to be\n calculated.\n probability: float, optional\n Quantile to estimate - must be in open interval (0, 1).\n For example, use 0.5 for the median and 0.84 for the upper\n 84% quantile. Passed to weighted_quantile.\n\n Returns\n -------\n float\n \"\"\"\n if logw is None:\n logw = nestcheck.ns_run_utils.get_logw(ns_run, simulate=simulate)\n w_relative = np.exp(logw - logw.max()) # protect against overflow\n r = np.sqrt(np.sum(ns_run['theta'] ** 2, axis=1))\n return weighted_quantile(probability, r, w_relative)\n\n\n# Helper functions\n# ----------------\n\n\ndef get_latex_name(func_in, **kwargs):\n \"\"\"\n Produce a latex formatted name for each function for use in labelling\n results.\n\n Parameters\n ----------\n func_in: function\n kwargs: dict, optional\n Kwargs for function.\n\n Returns\n -------\n latex_name: str\n Latex formatted name for the function.\n \"\"\"\n if isinstance(func_in, functools.partial):\n func = func_in.func\n assert not set(func_in.keywords) & set(kwargs), (\n 'kwargs={0} and func_in.keywords={1} contain repeated keys'\n .format(kwargs, func_in.keywords))\n kwargs.update(func_in.keywords)\n else:\n func = func_in\n param_ind = kwargs.pop('param_ind', 0)\n probability = kwargs.pop('probability', 0.5)\n kwargs.pop('handle_indexerror', None)\n if kwargs:\n raise TypeError('Unexpected **kwargs: {0}'.format(kwargs))\n ind_str = r'{\\hat{' + str(param_ind + 1) + '}}'\n latex_name_dict = {\n 'count_samples': r'samples',\n 'logz': r'$\\mathrm{log} \\mathcal{Z}$',\n 'evidence': r'$\\mathcal{Z}$',\n 'r_mean': r'$\\overline{|\\theta|}$',\n 'param_mean': r'$\\overline{\\theta_' + ind_str + '}$',\n 'param_squared_mean': r'$\\overline{\\theta^2_' + ind_str + '}$'}\n # Add credible interval names\n if probability == 0.5:\n cred_str = r'$\\mathrm{median}('\n else:\n # format percent without trailing zeros\n percent_str = ('%f' % (probability * 100)).rstrip('0').rstrip('.')\n cred_str = r'$\\mathrm{C.I.}_{' + percent_str + r'\\%}('\n latex_name_dict['param_cred'] = cred_str + r'\\theta_' + ind_str + ')$'\n latex_name_dict['r_cred'] = cred_str + r'|\\theta|)$'\n try:\n return latex_name_dict[func.__name__]\n except KeyError as err:\n err.args = err.args + ('get_latex_name not yet set up for ' +\n func.__name__,)\n raise\n\n\ndef weighted_quantile(probability, values, weights):\n \"\"\"\n Get quantile estimate for input probability given weighted samples using\n linear interpolation.\n\n Parameters\n ----------\n probability: float\n Quantile to estimate - must be in open interval (0, 1).\n For example, use 0.5 for the median and 0.84 for the upper\n 84% quantile.\n values: 1d numpy array\n Sample values.\n weights: 1d numpy array\n Corresponding sample weights (same shape as values).\n\n Returns\n -------\n quantile: float\n \"\"\"\n assert 1 > probability > 0, (\n 'credible interval prob= ' + str(probability) + ' not in (0, 1)')\n assert values.shape == weights.shape\n assert values.ndim == 1\n assert weights.ndim == 1\n sorted_inds = np.argsort(values)\n quantiles = np.cumsum(weights[sorted_inds]) - (0.5 * weights[sorted_inds])\n quantiles /= np.sum(weights)\n return np.interp(probability, quantiles, values[sorted_inds])\n"
] |
[
[
"scipy.special.logsumexp",
"numpy.sum",
"numpy.interp",
"numpy.argsort",
"numpy.cumsum"
]
] |
dukebw/rethinking-network-pruning
|
[
"5486af65530f61e6688e542f1f2f13dbebf88e69",
"5486af65530f61e6688e542f1f2f13dbebf88e69"
] |
[
"cifar/weight-level/utils/visualize.py",
"cifar/l1-norm-pruning/res56prune.py"
] |
[
"import matplotlib.pyplot as plt\nimport numpy as np\n\nimport torch\nimport torch.nn as nn\nimport torchvision\nimport torchvision.transforms as transforms\n\nfrom .misc import * \n\n\n__all__ = ['make_image', 'show_batch', 'show_mask', 'show_mask_single']\n\n# functions to show an image\ndef make_image(img, mean=(0,0,0), std=(1,1,1)):\n for i in range(0, 3):\n img[i] = img[i] * std[i] + mean[i] # unnormalize\n npimg = img.numpy()\n return np.transpose(npimg, (1, 2, 0))\n\ndef gauss(x,a,b,c):\n return torch.exp(-torch.pow(torch.add(x,-b),2).div(2*c*c)).mul(a)\n\ndef colorize(x):\n ''' Converts a one-channel grayscale image to a color heatmap image '''\n if x.dim() == 2:\n torch.unsqueeze(x, 0, out=x)\n if x.dim() == 3:\n cl = torch.zeros([3, x.size(1), x.size(2)])\n cl[0] = gauss(x,.5,.6,.2) + gauss(x,1,.8,.3)\n cl[1] = gauss(x,1,.5,.3)\n cl[2] = gauss(x,1,.2,.3)\n cl[cl.gt(1)] = 1\n elif x.dim() == 4:\n cl = torch.zeros([x.size(0), 3, x.size(2), x.size(3)])\n cl[:,0,:,:] = gauss(x,.5,.6,.2) + gauss(x,1,.8,.3)\n cl[:,1,:,:] = gauss(x,1,.5,.3)\n cl[:,2,:,:] = gauss(x,1,.2,.3)\n return cl\n\ndef show_batch(images, Mean=(2, 2, 2), Std=(0.5,0.5,0.5)):\n images = make_image(torchvision.utils.make_grid(images), Mean, Std)\n plt.imshow(images)\n plt.show()\n\n\ndef show_mask_single(images, mask, Mean=(2, 2, 2), Std=(0.5,0.5,0.5)):\n im_size = images.size(2)\n\n # save for adding mask\n im_data = images.clone()\n for i in range(0, 3):\n im_data[:,i,:,:] = im_data[:,i,:,:] * Std[i] + Mean[i] # unnormalize\n\n images = make_image(torchvision.utils.make_grid(images), Mean, Std)\n plt.subplot(2, 1, 1)\n plt.imshow(images)\n plt.axis('off')\n\n # for b in range(mask.size(0)):\n # mask[b] = (mask[b] - mask[b].min())/(mask[b].max() - mask[b].min())\n mask_size = mask.size(2)\n # print('Max %f Min %f' % (mask.max(), mask.min()))\n mask = (upsampling(mask, scale_factor=im_size/mask_size))\n # mask = colorize(upsampling(mask, scale_factor=im_size/mask_size))\n # for c in range(3):\n # mask[:,c,:,:] = (mask[:,c,:,:] - Mean[c])/Std[c]\n\n # print(mask.size())\n mask = make_image(torchvision.utils.make_grid(0.3*im_data+0.7*mask.expand_as(im_data)))\n # mask = make_image(torchvision.utils.make_grid(0.3*im_data+0.7*mask), Mean, Std)\n plt.subplot(2, 1, 2)\n plt.imshow(mask)\n plt.axis('off')\n\ndef show_mask(images, masklist, Mean=(2, 2, 2), Std=(0.5,0.5,0.5)):\n im_size = images.size(2)\n\n # save for adding mask\n im_data = images.clone()\n for i in range(0, 3):\n im_data[:,i,:,:] = im_data[:,i,:,:] * Std[i] + Mean[i] # unnormalize\n\n images = make_image(torchvision.utils.make_grid(images), Mean, Std)\n plt.subplot(1+len(masklist), 1, 1)\n plt.imshow(images)\n plt.axis('off')\n\n for i in range(len(masklist)):\n mask = masklist[i].data.cpu()\n # for b in range(mask.size(0)):\n # mask[b] = (mask[b] - mask[b].min())/(mask[b].max() - mask[b].min())\n mask_size = mask.size(2)\n # print('Max %f Min %f' % (mask.max(), mask.min()))\n mask = (upsampling(mask, scale_factor=im_size/mask_size))\n # mask = colorize(upsampling(mask, scale_factor=im_size/mask_size))\n # for c in range(3):\n # mask[:,c,:,:] = (mask[:,c,:,:] - Mean[c])/Std[c]\n\n # print(mask.size())\n mask = make_image(torchvision.utils.make_grid(0.3*im_data+0.7*mask.expand_as(im_data)))\n # mask = make_image(torchvision.utils.make_grid(0.3*im_data+0.7*mask), Mean, Std)\n plt.subplot(1+len(masklist), 1, i+2)\n plt.imshow(mask)\n plt.axis('off')\n\n\n\n# x = torch.zeros(1, 3, 3)\n# out = colorize(x)\n# out_im = make_image(out)\n# plt.imshow(out_im)\n# plt.show()",
"import argparse\nimport numpy as np\nimport os\n\nimport torch\nimport torch.nn as nn\nfrom torchvision import datasets, transforms\n\nfrom models import resnet\n\n\n# Prune settings\nparser = argparse.ArgumentParser(description='PyTorch Slimming CIFAR prune')\nparser.add_argument('--dataset', type=str, default='cifar10',\n help='training dataset (default: cifar10)')\nparser.add_argument('--test-batch-size', type=int, default=256, metavar='N',\n help='input batch size for testing (default: 256)')\nparser.add_argument('--no-cuda', action='store_true', default=False,\n help='disables CUDA training')\nparser.add_argument('--depth', type=int, default=56,\n help='depth of the resnet')\nparser.add_argument('--model', default='', type=str, metavar='PATH',\n help='path to the model (default: none)')\nparser.add_argument('--save', default='', type=str, metavar='PATH',\n help='path to save pruned model (default: none)')\nparser.add_argument('-v', default='A', type=str, \n help='version of the model')\n\nargs = parser.parse_args()\nargs.cuda = not args.no_cuda and torch.cuda.is_available()\n\nif not os.path.exists(args.save):\n os.makedirs(args.save)\n\nmodel = resnet(depth=args.depth, dataset=args.dataset)\n\nif args.cuda:\n model.cuda()\nif args.model:\n if os.path.isfile(args.model):\n print(\"=> loading checkpoint '{}'\".format(args.model))\n checkpoint = torch.load(args.model)\n args.start_epoch = checkpoint['epoch']\n best_prec1 = checkpoint['best_prec1']\n model.load_state_dict(checkpoint['state_dict'])\n print(\"=> loaded checkpoint '{}' (epoch {}) Prec1: {:f}\"\n .format(args.model, checkpoint['epoch'], best_prec1))\n else:\n print(\"=> no checkpoint found at '{}'\".format(args.resume))\n\nprint('Pre-processing Successful!')\n\n# simple test model after Pre-processing prune (simple set BN scales to zeros)\ndef test(model):\n kwargs = {'num_workers': 1, 'pin_memory': True} if args.cuda else {}\n if args.dataset == 'cifar10':\n test_loader = torch.utils.data.DataLoader(\n datasets.CIFAR10('./data.cifar10', train=False, transform=transforms.Compose([\n transforms.ToTensor(),\n transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))])),\n batch_size=args.test_batch_size, shuffle=False, **kwargs)\n elif args.dataset == 'cifar100':\n test_loader = torch.utils.data.DataLoader(\n datasets.CIFAR100('./data.cifar100', train=False, transform=transforms.Compose([\n transforms.ToTensor(),\n transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))])),\n batch_size=args.test_batch_size, shuffle=False, **kwargs)\n else:\n raise ValueError(\"No valid dataset is given.\")\n model.eval()\n correct = 0\n for data, target in test_loader:\n if args.cuda:\n data, target = data.cuda(), target.cuda()\n output = model(data)\n pred = output.data.max(1, keepdim=True)[1] # get the index of the max log-probability\n correct += pred.eq(target.data.view_as(pred)).cpu().sum()\n\n print('\\nTest set: Accuracy: {}/{} ({:.1f}%)\\n'.format(\n correct, len(test_loader.dataset), 100. * correct / len(test_loader.dataset)))\n return correct / float(len(test_loader.dataset))\n\nwith torch.no_grad():\n acc = test(model)\n\nskip = {\n 'A': [16, 20, 38, 54],\n 'B': [16, 18, 20, 34, 38, 54],\n}\n\nprune_prob = {\n 'A': [0.1, 0.1, 0.1],\n 'B': [0.6, 0.3, 0.1],\n}\n\nlayer_id = 1\ncfg = []\ncfg_mask = []\nfor m in model.modules():\n if isinstance(m, nn.Conv2d):\n out_channels = m.weight.data.shape[0]\n if layer_id in skip[args.v]:\n cfg_mask.append(torch.ones(out_channels))\n cfg.append(out_channels)\n layer_id += 1\n continue\n if layer_id % 2 == 0:\n if layer_id <= 18:\n stage = 0\n elif layer_id <= 36:\n stage = 1\n else:\n stage = 2\n prune_prob_stage = prune_prob[args.v][stage]\n weight_copy = m.weight.data.abs().clone().cpu().numpy()\n L1_norm = np.sum(weight_copy, axis=(1,2,3))\n num_keep = int(out_channels * (1 - prune_prob_stage))\n arg_max = np.argsort(L1_norm)\n arg_max_rev = arg_max[::-1][:num_keep]\n mask = torch.zeros(out_channels)\n mask[arg_max_rev.tolist()] = 1\n cfg_mask.append(mask)\n cfg.append(num_keep)\n layer_id += 1\n continue\n layer_id += 1\n\nnewmodel = resnet(dataset=args.dataset, depth=args.depth, cfg=cfg)\nif args.cuda:\n newmodel.cuda()\n\nstart_mask = torch.ones(3)\nlayer_id_in_cfg = 0\nconv_count = 1\nfor [m0, m1] in zip(model.modules(), newmodel.modules()):\n if isinstance(m0, nn.Conv2d):\n if conv_count == 1:\n m1.weight.data = m0.weight.data.clone()\n elif conv_count % 2 == 0:\n mask = cfg_mask[layer_id_in_cfg]\n idx = np.squeeze(np.argwhere(np.asarray(mask.cpu().numpy())))\n if idx.size == 1:\n idx = np.resize(idx, (1,))\n w = m0.weight.data[idx.tolist(), :, :, :].clone()\n m1.weight.data = w.clone()\n layer_id_in_cfg += 1\n else:\n mask = cfg_mask[layer_id_in_cfg-1]\n idx = np.squeeze(np.argwhere(np.asarray(mask.cpu().numpy())))\n if idx.size == 1:\n idx = np.resize(idx, (1,))\n w = m0.weight.data[:, idx.tolist(), :, :].clone()\n m1.weight.data = w.clone()\n conv_count += 1\n elif isinstance(m0, nn.BatchNorm2d):\n if conv_count % 2 == 1:\n mask = cfg_mask[layer_id_in_cfg-1]\n idx = np.squeeze(np.argwhere(np.asarray(mask.cpu().numpy())))\n if idx.size == 1:\n idx = np.resize(idx, (1,))\n m1.weight.data = m0.weight.data[idx.tolist()].clone()\n m1.bias.data = m0.bias.data[idx.tolist()].clone()\n m1.running_mean = m0.running_mean[idx.tolist()].clone()\n m1.running_var = m0.running_var[idx.tolist()].clone()\n continue\n m1.weight.data = m0.weight.data.clone()\n m1.bias.data = m0.bias.data.clone()\n m1.running_mean = m0.running_mean.clone()\n m1.running_var = m0.running_var.clone()\n elif isinstance(m0, nn.Linear):\n m1.weight.data = m0.weight.data.clone()\n m1.bias.data = m0.bias.data.clone()\n\ntorch.save({'cfg': cfg, 'state_dict': newmodel.state_dict()}, os.path.join(args.save, 'pruned.pth.tar'))\n\nnum_parameters = sum([param.nelement() for param in newmodel.parameters()])\nold_num_params = sum([p.nelement() for p in model.parameters()])\nprint(newmodel)\nmodel = newmodel\nacc = test(model)\n\nprint(f'number of parameters: {str(num_parameters)} down from {old_num_params}')\nwith open(os.path.join(args.save, \"prune.txt\"), \"w\") as fp:\n fp.write(\"Number of parameters: \\n\"+str(num_parameters)+\"\\n\")\n fp.write(\"Test accuracy: \\n\"+str(acc)+\"\\n\")\n"
] |
[
[
"torch.add",
"torch.unsqueeze",
"numpy.transpose",
"matplotlib.pyplot.show",
"matplotlib.pyplot.imshow",
"matplotlib.pyplot.axis",
"matplotlib.pyplot.subplot"
],
[
"torch.zeros",
"numpy.sum",
"torch.no_grad",
"torch.ones",
"numpy.resize",
"torch.cuda.is_available",
"torch.load",
"numpy.argsort"
]
] |
Toby-SZZ/STDC-Seg
|
[
"9273e03b02241fda107962bfc7bd366310a8d23b"
] |
[
"train.py"
] |
[
"#!/usr/bin/python\n# -*- encoding: utf-8 -*-\nfrom logger import setup_logger\nfrom models.model_stages import BiSeNet\nfrom cityscapes import CityScapes\nfrom loss.loss import OhemCELoss\nfrom loss.detail_loss import DetailAggregateLoss\nfrom evaluation import MscEvalV0\nfrom optimizer_loss import Optimizer\n\nimport torch\nimport torch.nn as nn\nfrom torch.utils.data import DataLoader\nimport torch.nn.functional as F\nimport torch.distributed as dist\n\nimport os\nimport os.path as osp\nimport logging\nimport time\nimport datetime\nimport argparse\n\nlogger = logging.getLogger()\n\ndef str2bool(v):\n if v.lower() in ('yes', 'true', 't', 'y', '1'):\n return True\n elif v.lower() in ('no', 'false', 'f', 'n', '0'):\n return False\n else:\n raise argparse.ArgumentTypeError('Unsupported value encountered.')\n\n\ndef parse_args():\n parse = argparse.ArgumentParser()\n parse.add_argument(\n '--local_rank',\n dest = 'local_rank',\n type = int,\n default = -1,\n )\n parse.add_argument(\n '--n_workers_train',\n dest = 'n_workers_train',\n type = int,\n default = 8,\n )\n parse.add_argument(\n '--n_workers_val',\n dest = 'n_workers_val',\n type = int,\n default = 0,\n )\n parse.add_argument(\n '--n_img_per_gpu',\n dest = 'n_img_per_gpu',\n type = int,\n default = 4,\n )\n parse.add_argument(\n '--max_iter',\n dest = 'max_iter',\n type = int,\n default = 40000,\n )\n parse.add_argument(\n '--save_iter_sep',\n dest = 'save_iter_sep',\n type = int,\n default = 1000,\n )\n parse.add_argument(\n '--warmup_steps',\n dest = 'warmup_steps',\n type = int,\n default = 1000,\n ) \n parse.add_argument(\n '--mode',\n dest = 'mode',\n type = str,\n default = 'train',\n )\n parse.add_argument(\n '--ckpt',\n dest = 'ckpt',\n type = str,\n default = None,\n )\n parse.add_argument(\n '--respath',\n dest = 'respath',\n type = str,\n default = None,\n )\n parse.add_argument(\n '--backbone',\n dest = 'backbone',\n type = str,\n default = 'CatNetSmall',\n )\n parse.add_argument(\n '--pretrain_path',\n dest = 'pretrain_path',\n type = str,\n default = '',\n )\n parse.add_argument(\n '--use_conv_last',\n dest = 'use_conv_last',\n type = str2bool,\n default = False,\n )\n parse.add_argument(\n '--use_boundary_2',\n dest = 'use_boundary_2',\n type = str2bool,\n default = False,\n )\n parse.add_argument(\n '--use_boundary_4',\n dest = 'use_boundary_4',\n type = str2bool,\n default = False,\n )\n parse.add_argument(\n '--use_boundary_8',\n dest = 'use_boundary_8',\n type = str2bool,\n default = False,\n )\n parse.add_argument(\n '--use_boundary_16',\n dest = 'use_boundary_16',\n type = str2bool,\n default = False,\n )\n return parse.parse_args()\n\n\ndef train():\n args = parse_args()\n \n save_pth_path = os.path.join(args.respath, 'pths')\n dspth = './data'\n \n # print(save_pth_path)\n # print(osp.exists(save_pth_path))\n # if not osp.exists(save_pth_path) and dist.get_rank()==0: \n if not osp.exists(save_pth_path):\n os.makedirs(save_pth_path)\n \n \n torch.cuda.set_device(args.local_rank)\n dist.init_process_group(\n backend = 'nccl',\n init_method = 'env://',\n world_size = torch.cuda.device_count(),\n rank=args.local_rank\n )\n \n setup_logger(args.respath)\n ## dataset\n n_classes = 19\n n_img_per_gpu = args.n_img_per_gpu\n n_workers_train = args.n_workers_train\n n_workers_val = args.n_workers_val\n use_boundary_16 = args.use_boundary_16\n use_boundary_8 = args.use_boundary_8\n use_boundary_4 = args.use_boundary_4\n use_boundary_2 = args.use_boundary_2\n \n mode = args.mode\n cropsize = [1024, 512]\n randomscale = (0.125, 0.25, 0.375, 0.5, 0.625, 0.75, 0.875, 1.0, 1.125, 1.25, 1.375, 1.5)\n\n if dist.get_rank()==0: \n logger.info('n_workers_train: {}'.format(n_workers_train))\n logger.info('n_workers_val: {}'.format(n_workers_val))\n logger.info('use_boundary_2: {}'.format(use_boundary_2))\n logger.info('use_boundary_4: {}'.format(use_boundary_4))\n logger.info('use_boundary_8: {}'.format(use_boundary_8))\n logger.info('use_boundary_16: {}'.format(use_boundary_16))\n logger.info('mode: {}'.format(args.mode))\n \n \n ds = CityScapes(dspth, cropsize=cropsize, mode=mode, randomscale=randomscale)\n sampler = torch.utils.data.distributed.DistributedSampler(ds)\n dl = DataLoader(ds,\n batch_size = n_img_per_gpu,\n shuffle = False,\n sampler = sampler,\n num_workers = n_workers_train,\n pin_memory = False,\n drop_last = True)\n # exit(0)\n dsval = CityScapes(dspth, mode='val', randomscale=randomscale)\n sampler_val = torch.utils.data.distributed.DistributedSampler(dsval)\n dlval = DataLoader(dsval,\n batch_size = 2,\n shuffle = False,\n sampler = sampler_val,\n num_workers = n_workers_val,\n drop_last = False)\n\n\n ## model\n ignore_idx = 255\n net = BiSeNet(backbone=args.backbone, n_classes=n_classes, pretrain_model=args.pretrain_path, \n use_boundary_2=use_boundary_2, use_boundary_4=use_boundary_4, use_boundary_8=use_boundary_8, \n use_boundary_16=use_boundary_16, use_conv_last=args.use_conv_last)\n\n if not args.ckpt is None:\n net.load_state_dict(torch.load(args.ckpt, map_location='cpu'))\n net.cuda()\n net.train()\n net = nn.parallel.DistributedDataParallel(net,\n device_ids = [args.local_rank, ],\n output_device = args.local_rank,\n find_unused_parameters=True\n )\n\n score_thres = 0.7\n n_min = n_img_per_gpu*cropsize[0]*cropsize[1]//16\n criteria_p = OhemCELoss(thresh=score_thres, n_min=n_min, ignore_lb=ignore_idx)\n criteria_16 = OhemCELoss(thresh=score_thres, n_min=n_min, ignore_lb=ignore_idx)\n criteria_32 = OhemCELoss(thresh=score_thres, n_min=n_min, ignore_lb=ignore_idx)\n boundary_loss_func = DetailAggregateLoss()\n ## optimizer\n maxmIOU50 = 0.\n maxmIOU75 = 0.\n momentum = 0.9\n weight_decay = 5e-4\n lr_start = 1e-2\n max_iter = args.max_iter\n save_iter_sep = args.save_iter_sep\n power = 0.9\n warmup_steps = args.warmup_steps\n warmup_start_lr = 1e-5\n\n if dist.get_rank()==0: \n print('max_iter: ', max_iter)\n print('save_iter_sep: ', save_iter_sep)\n print('warmup_steps: ', warmup_steps)\n optim = Optimizer(\n model = net.module,\n loss = boundary_loss_func,\n lr0 = lr_start,\n momentum = momentum,\n wd = weight_decay,\n warmup_steps = warmup_steps,\n warmup_start_lr = warmup_start_lr,\n max_iter = max_iter,\n power = power)\n \n ## train loop\n msg_iter = 50\n loss_avg = []\n loss_boundery_bce = []\n loss_boundery_dice = []\n st = glob_st = time.time()\n diter = iter(dl)\n epoch = 0\n for it in range(max_iter):\n try:\n im, lb = next(diter)\n if not im.size()[0]==n_img_per_gpu: raise StopIteration\n except StopIteration:\n epoch += 1\n sampler.set_epoch(epoch)\n diter = iter(dl)\n im, lb = next(diter)\n im = im.cuda()\n lb = lb.cuda()\n H, W = im.size()[2:]\n lb = torch.squeeze(lb, 1)\n\n optim.zero_grad()\n\n\n if use_boundary_2 and use_boundary_4 and use_boundary_8:\n out, out16, out32, detail2, detail4, detail8 = net(im)\n \n if (not use_boundary_2) and use_boundary_4 and use_boundary_8:\n out, out16, out32, detail4, detail8 = net(im)\n\n if (not use_boundary_2) and (not use_boundary_4) and use_boundary_8:\n out, out16, out32, detail8 = net(im)\n\n if (not use_boundary_2) and (not use_boundary_4) and (not use_boundary_8):\n out, out16, out32 = net(im)\n\n lossp = criteria_p(out, lb)\n loss2 = criteria_16(out16, lb)\n loss3 = criteria_32(out32, lb)\n \n boundery_bce_loss = 0.\n boundery_dice_loss = 0.\n \n \n if use_boundary_2: \n # if dist.get_rank()==0:\n # print('use_boundary_2')\n boundery_bce_loss2, boundery_dice_loss2 = boundary_loss_func(detail2, lb)\n boundery_bce_loss += boundery_bce_loss2\n boundery_dice_loss += boundery_dice_loss2\n \n if use_boundary_4:\n # if dist.get_rank()==0:\n # print('use_boundary_4')\n boundery_bce_loss4, boundery_dice_loss4 = boundary_loss_func(detail4, lb)\n boundery_bce_loss += boundery_bce_loss4\n boundery_dice_loss += boundery_dice_loss4\n\n if use_boundary_8:\n # if dist.get_rank()==0:\n # print('use_boundary_8')\n boundery_bce_loss8, boundery_dice_loss8 = boundary_loss_func(detail8, lb)\n boundery_bce_loss += boundery_bce_loss8\n boundery_dice_loss += boundery_dice_loss8\n\n loss = lossp + loss2 + loss3 + boundery_bce_loss + boundery_dice_loss\n \n loss.backward()\n optim.step()\n\n loss_avg.append(loss.item())\n\n loss_boundery_bce.append(boundery_bce_loss.item())\n loss_boundery_dice.append(boundery_dice_loss.item())\n\n ## print training log message\n if (it+1)%msg_iter==0:\n loss_avg = sum(loss_avg) / len(loss_avg)\n lr = optim.lr\n ed = time.time()\n t_intv, glob_t_intv = ed - st, ed - glob_st\n eta = int((max_iter - it) * (glob_t_intv / it))\n eta = str(datetime.timedelta(seconds=eta))\n\n loss_boundery_bce_avg = sum(loss_boundery_bce) / len(loss_boundery_bce)\n loss_boundery_dice_avg = sum(loss_boundery_dice) / len(loss_boundery_dice)\n msg = ', '.join([\n 'it: {it}/{max_it}',\n 'lr: {lr:4f}',\n 'loss: {loss:.4f}',\n 'boundery_bce_loss: {boundery_bce_loss:.4f}',\n 'boundery_dice_loss: {boundery_dice_loss:.4f}',\n 'eta: {eta}',\n 'time: {time:.4f}',\n ]).format(\n it = it+1,\n max_it = max_iter,\n lr = lr,\n loss = loss_avg,\n boundery_bce_loss = loss_boundery_bce_avg,\n boundery_dice_loss = loss_boundery_dice_avg,\n time = t_intv,\n eta = eta\n )\n \n logger.info(msg)\n loss_avg = []\n loss_boundery_bce = []\n loss_boundery_dice = []\n st = ed\n # print(boundary_loss_func.get_params())\n if (it+1)%save_iter_sep==0:# and it != 0:\n \n ## model\n logger.info('evaluating the model ...')\n logger.info('setup and restore model')\n \n net.eval()\n\n # ## evaluator\n logger.info('compute the mIOU')\n with torch.no_grad():\n single_scale1 = MscEvalV0()\n mIOU50 = single_scale1(net, dlval, n_classes)\n\n # single_scale2= MscEvalV0(scale=0.75)\n # mIOU75 = single_scale2(net, dlval, n_classes)\n\n\n save_pth = osp.join(save_pth_path, 'model_iter{}_mIOU50_{}.pth'\n .format(it+1, str(round(mIOU50,4))))\n \n state = net.module.state_dict() if hasattr(net, 'module') else net.state_dict()\n if dist.get_rank()==0: \n torch.save(state, save_pth)\n\n logger.info('training iteration {}, model saved to: {}'.format(it+1, save_pth))\n\n if mIOU50 > maxmIOU50:\n maxmIOU50 = mIOU50\n save_pth = osp.join(save_pth_path, 'model_maxmIOU50.pth'.format(it+1))\n state = net.module.state_dict() if hasattr(net, 'module') else net.state_dict()\n if dist.get_rank()==0: \n torch.save(state, save_pth)\n \n logger.info('max mIOU model saved to: {}'.format(save_pth))\n \n # if mIOU75 > maxmIOU75:\n # maxmIOU75 = mIOU75\n # save_pth = osp.join(save_pth_path, 'model_maxmIOU75.pth'.format(it+1))\n # state = net.module.state_dict() if hasattr(net, 'module') else net.state_dict()\n # if dist.get_rank()==0: torch.save(state, save_pth)\n # logger.info('max mIOU model saved to: {}'.format(save_pth))\n \n logger.info('mIOU50 is: {}'.format(mIOU50))\n logger.info('maxmIOU50 is: {}'.format(maxmIOU50))\n\n net.train()\n \n ## dump the final model\n save_pth = osp.join(save_pth_path, 'model_final.pth')\n net.cpu()\n state = net.module.state_dict() if hasattr(net, 'module') else net.state_dict()\n if dist.get_rank()==0: torch.save(state, save_pth)\n logger.info('training done, model saved to: {}'.format(save_pth))\n print('epoch: ', epoch)\n\nif __name__ == \"__main__\":\n train()\n"
] |
[
[
"torch.save",
"torch.no_grad",
"torch.nn.parallel.DistributedDataParallel",
"torch.cuda.device_count",
"torch.cuda.set_device",
"torch.squeeze",
"torch.utils.data.DataLoader",
"torch.utils.data.distributed.DistributedSampler",
"torch.load",
"torch.distributed.get_rank"
]
] |
Algorithmic-Alignment-Lab/openTAMP-legacy
|
[
"eecb950bd273da8cbed4394487630e8453f2c242",
"eecb950bd273da8cbed4394487630e8453f2c242",
"eecb950bd273da8cbed4394487630e8453f2c242"
] |
[
"opentamp/src/core/util_classes/no_openrave_body.py",
"opentamp/src/core/util_classes/backup_namo_predicates.py",
"opentamp/src/policy_hooks/namo/spread_prob3.py"
] |
[
"import numpy as np\nfrom math import cos, sin, atan2\nfrom errors_exceptions import OpenRAVEException\nfrom openravepy import quatFromAxisAngle, matrixFromPose, poseFromMatrix, \\\naxisAngleFromRotationMatrix, KinBody, GeometryType, RaveCreateRobot, \\\nRaveCreateKinBody, TriMesh, Environment, DOFAffine, IkParameterization, IkParameterizationType, \\\nIkFilterOptions, matrixFromAxisAngle, quatFromRotationMatrix\nfrom core.util_classes.robots import Robot, PR2, Baxter, Washer\n\nfrom core.util_classes.items import Item, Box, Can, BlueCan, RedCan, Circle, BlueCircle, RedCircle, GreenCircle, Obstacle, Wall, Table, Basket\n\nWALL_THICKNESS = 1\n\nclass OpenRAVEBody(object):\n def __init__(self, env, name, geom):\n assert env is not None\n self.name = name\n self._env = env\n self._geom = geom\n\n if env.GetKinBody(name) == None and env.GetRobot(name) == None:\n if isinstance(geom, Robot):\n self._add_robot(geom)\n elif isinstance(geom, Item):\n self._add_item(geom)\n else:\n raise OpenRAVEException(\"Geometry not supported for %s for OpenRAVEBody\"%geom)\n elif env.GetKinBody(name) != None:\n self.env_body = env.GetKinBody(name)\n else:\n self.env_body = env.GetRobot(name)\n self.set_transparency(0.5)\n\n def delete(self):\n self._env.Remove(self.env_body)\n\n def set_transparency(self, transparency):\n for link in self.env_body.GetLinks():\n for geom in link.GetGeometries():\n geom.SetTransparency(transparency)\n\n def _add_robot(self, geom):\n self.env_body = self._env.ReadRobotXMLFile(geom.shape)\n self.env_body.SetName(self.name)\n self._env.Add(self.env_body)\n geom.setup(self.env_body)\n\n def _add_item(self, geom):\n try:\n fun_name = \"self._add_{}\".format(geom._type)\n eval(fun_name)(geom)\n except:\n self._add_obj(geom)\n\n def _add_circle(self, geom):\n color = [1,0,0]\n if hasattr(geom, \"color\") and geom.color == 'blue':\n color = [0, 0, 1]\n elif hasattr(geom, \"color\") and geom.color == 'green':\n color = [0, 1, 0]\n elif hasattr(geom, \"color\") and geom.color == 'red':\n color = [1, 0, 0]\n\n self.env_body = OpenRAVEBody.create_cylinder(self._env, self.name, np.eye(4),\n [geom.radius, 2], color)\n self._env.AddKinBody(self.env_body)\n\n def _add_can(self, geom):\n color = [1,0,0]\n if hasattr(geom, \"color\") and geom.color == 'blue':\n color = [0, 0, 1]\n elif hasattr(geom, \"color\") and geom.color == 'green':\n color = [0, 1, 0]\n elif hasattr(geom, \"color\") and geom.color == 'red':\n color = [1, 0, 0]\n\n self.env_body = OpenRAVEBody.create_cylinder(self._env, self.name, np.eye(4),\n [geom.radius, geom.height], color)\n self._env.AddKinBody(self.env_body)\n\n def _add_obstacle(self, geom):\n obstacles = np.matrix('-0.576036866359447, 0.918128654970760, 1;\\\n -0.806451612903226,-1.07017543859649, 1;\\\n 1.01843317972350,-0.988304093567252, 1;\\\n 0.640552995391705,0.906432748538011, 1;\\\n -0.576036866359447, 0.918128654970760, -1;\\\n -0.806451612903226,-1.07017543859649, -1;\\\n 1.01843317972350,-0.988304093567252, -1;\\\n 0.640552995391705,0.906432748538011, -1')\n\n body = RaveCreateKinBody(self._env, '')\n vertices = np.array(obstacles)\n indices = np.array([[0, 1, 2], [2, 3, 0], [4, 5, 6], [6, 7, 4], [0, 4, 5],\n [0, 1, 5], [1, 2, 5], [5, 6, 2], [2, 3, 6], [6, 7, 3],\n [0, 3, 7], [0, 4, 7]])\n body.InitFromTrimesh(trimesh=TriMesh(vertices, indices), draw=True)\n body.SetName(self.name)\n for link in body.GetLinks():\n for geom in link.GetGeometries():\n geom.SetDiffuseColor((.9, .9, .9))\n self.env_body = body\n self._env.AddKinBody(body)\n\n def _add_box(self, geom):\n infobox = OpenRAVEBody.create_body_info(KinBody.Link.GeomType.Box, geom.dim, [0.5, 0.2, 0.1])\n self.env_body = RaveCreateKinBody(self._env,'')\n self.env_body.InitFromGeometries([infobox])\n self.env_body.SetName(self.name)\n self._env.Add(self.env_body)\n\n def _add_sphere(self, geom):\n infobox = OpenRAVEBody.create_body_info(KinBody.Link.GeomType.Sphere, [geom.radius], [0, 0, 1])\n self.env_body = RaveCreateKinBody(self._env,'')\n self.env_body.InitFromGeometries([infobox])\n self.env_body.SetName(self.name)\n self._env.Add(self.env_body)\n\n def _add_wall(self, geom):\n self.env_body = OpenRAVEBody.create_wall(self._env, geom.wall_type)\n self.env_body.SetName(self.name)\n self._env.Add(self.env_body)\n\n def _add_obj(self, geom):\n self.env_body = self._env.ReadKinBodyXMLFile(geom.shape)\n self.env_body.SetName(self.name)\n self._env.Add(self.env_body)\n\n def _add_table(self, geom):\n self.env_body = OpenRAVEBody.create_table(self._env, geom)\n self.env_body.SetName(self.name)\n self._env.Add(self.env_body)\n\n def _add_basket(self, geom):\n self.env_body = self._env.ReadKinBodyXMLFile(geom.shape)\n self.env_body.SetName(self.name)\n self._env.Add(self.env_body)\n\n def set_pose(self, base_pose, rotation = [0, 0, 0]):\n trans = None\n if np.any(np.isnan(base_pose)) or np.any(np.isnan(rotation)):\n return\n if isinstance(self._geom, Robot) and not isinstance(self._geom, Washer):\n trans = OpenRAVEBody.base_pose_to_mat(base_pose)\n elif len(base_pose) == 2:\n trans = OpenRAVEBody.base_pose_2D_to_mat(base_pose)\n else:\n trans = OpenRAVEBody.transform_from_obj_pose(base_pose, rotation)\n self.env_body.SetTransform(trans)\n\n def set_dof(self, dof_value_map):\n \"\"\"\n dof_value_map: A dict that maps robot attribute name to a list of corresponding values\n \"\"\"\n # make sure only sets dof for robot\n # assert isinstance(self._geom, Robot)\n if not isinstance(self._geom, Robot): return\n\n # Get current dof value for each joint\n dof_val = self.env_body.GetActiveDOFValues()\n\n for k, v in dof_value_map.items():\n if k not in self._geom.dof_map or np.any(np.isnan(v)): continue\n inds = self._geom.dof_map[k]\n try:\n dof_val[inds] = v\n except IndexError:\n print(('\\n\\n\\nBad index in set dof:', inds, k, v, self._geom, '\\n\\n\\n'))\n # Set new DOF value to the robot\n self.env_body.SetActiveDOFValues(dof_val)\n\n def _set_active_dof_inds(self, inds = None):\n \"\"\"\n Set active dof index to the one we are interested\n This function is implemented to simplify jacobian calculation in the CollisionPredicate\n inds: Optional list of index specifying dof index we are interested in\n \"\"\"\n robot = self.env_body\n if inds == None:\n dof_inds = np.ndarray(0, dtype=np.int)\n if robot.GetJoint(\"torso_lift_joint\") != None:\n dof_inds = np.r_[dof_inds, robot.GetJoint(\"torso_lift_joint\").GetDOFIndex()]\n dof_inds = np.r_[dof_inds, robot.GetManipulator(\"leftarm\").GetArmIndices()]\n dof_inds = np.r_[dof_inds, robot.GetManipulator(\"leftarm\").GetGripperIndices()]\n dof_inds = np.r_[dof_inds, robot.GetManipulator(\"rightarm\").GetArmIndices()]\n dof_inds = np.r_[dof_inds, robot.GetManipulator(\"rightarm\").GetGripperIndices()]\n robot.SetActiveDOFs(\n dof_inds,\n DOFAffine.X + DOFAffine.Y + DOFAffine.RotationAxis,\n [0, 0, 1])\n else:\n robot.SetActiveDOFs(inds)\n\n @staticmethod\n def create_cylinder(env, body_name, t, dims, color=[0, 1, 1]):\n infocylinder = OpenRAVEBody.create_body_info(GeometryType.Cylinder, dims, color)\n if type(env) != Environment:\n # import ipdb; ipdb.set_trace()\n print(\"Environment object is not valid\")\n cylinder = RaveCreateKinBody(env, '')\n cylinder.InitFromGeometries([infocylinder])\n cylinder.SetName(body_name)\n cylinder.SetTransform(t)\n return cylinder\n\n @staticmethod\n def create_box(env, name, transform, dims, color=[0,0,1]):\n infobox = OpenRAVEBody.create_body_info(KinBody.Link.GeomType.Box, dims, color, 0, True)\n box = RaveCreateKinBody(env,'')\n box.InitFromGeometries([infobox])\n box.SetName(name)\n box.SetTransform(transform)\n return box\n\n @staticmethod\n def create_sphere(env, name, transform, dims, color=[0,0,1]):\n infobox = OpenRAVEBody.create_body_info(GeometryType.Sphere, dims, color)\n sphere = RaveCreateKinBody(env,'')\n sphere.InitFromGeometries([infobox])\n sphere.SetName(name)\n sphere.SetTransform(transform)\n return sphere\n\n @staticmethod\n def create_body_info(body_type, dims, color, transparency = 0.8, visible = True):\n infobox = KinBody.Link.GeometryInfo()\n infobox._type = body_type\n infobox._vGeomData = dims\n infobox._bVisible = True\n infobox._fTransparency = transparency\n infobox._vDiffuseColor = color\n return infobox\n\n @staticmethod\n def create_wall(env, wall_type):\n component_type = KinBody.Link.GeomType.Box\n wall_color = [0.5, 0.2, 0.1]\n box_infos = []\n if wall_type == 'closet':\n wall_endpoints = [[-6.0,-8.0],[-6.0,4.0],[1.9,4.0],[1.9,8.0],[5.0,8.0],[5.0,4.0],[13.0,4.0],[13.0,-8.0],[-6.0,-8.0]]\n else:\n raise NotImplemented\n for i, (start, end) in enumerate(zip(wall_endpoints[0:-1], wall_endpoints[1:])):\n dim_x, dim_y = 0, 0\n thickness = WALL_THICKNESS\n if start[0] == end[0]:\n ind_same, ind_diff = 0, 1\n length = abs(start[ind_diff] - end[ind_diff])\n dim_x, dim_y = thickness, length/2 + thickness\n elif start[1] == end[1]:\n ind_same, ind_diff = 1, 0\n length = abs(start[ind_diff] - end[ind_diff])\n dim_x, dim_y = length/2 + thickness, thickness\n else:\n raise NotImplemented('Can only create axis-aligned walls')\n\n transform = np.eye(4)\n transform[ind_same, 3] = start[ind_same]\n if start[ind_diff] < end[ind_diff]:\n transform[ind_diff, 3] = start[ind_diff] + length/2\n else:\n transform[ind_diff, 3] = end[ind_diff] + length/2\n dims = [dim_x, dim_y, 1]\n box_info = OpenRAVEBody.create_body_info(component_type, dims, wall_color)\n box_info._t = transform\n box_infos.append(box_info)\n wall = RaveCreateKinBody(env, '')\n wall.InitFromGeometries(box_infos)\n return wall\n\n\n @staticmethod\n def get_wall_dims(wall_type='closet'):\n wall_endpoints = [[-6.0,-8.0],[-6.0,4.0],[1.9,4.0],[1.9,8.0],[5.0,8.0],[5.0,4.0],[13.0,4.0],[13.0,-8.0],[-6.0,-8.0]]\n dims = []\n for i, (start, end) in enumerate(zip(wall_endpoints[0:-1], wall_endpoints[1:])):\n dim_x, dim_y = 0, 0\n thickness = WALL_THICKNESS\n if start[0] == end[0]:\n ind_same, ind_diff = 0, 1\n length = abs(start[ind_diff] - end[ind_diff])\n dim_x, dim_y = thickness, length/2 + thickness\n elif start[1] == end[1]:\n ind_same, ind_diff = 1, 0\n length = abs(start[ind_diff] - end[ind_diff])\n dim_x, dim_y = length/2 + thickness, thickness\n else:\n raise NotImplemented('Can only create axis-aligned walls')\n\n transform = np.eye(4)\n transform[ind_same, 3] = start[ind_same]\n if start[ind_diff] < end[ind_diff]:\n transform[ind_diff, 3] = start[ind_diff] + length/2\n else:\n transform[ind_diff, 3] = end[ind_diff] + length/2\n dims.append(([dim_x, dim_y, 1], transform))\n return dims\n\n\n @staticmethod\n def create_basket_col(env):\n\n long_info1 = OpenRAVEBody.create_body_info(KinBody.Link.GeomType.Box, [.3,.15,.015], [0, 0.75, 1])\n long_info2 = OpenRAVEBody.create_body_info(KinBody.Link.GeomType.Box, [.3,.15,.015], [0, 0.75, 1])\n short_info1 = OpenRAVEBody.create_body_info(KinBody.Link.GeomType.Box, [.015,.15,.2], [0, 0.75, 1])\n short_info2 = OpenRAVEBody.create_body_info(KinBody.Link.GeomType.Box, [.015,.15,.2], [0, 0.75, 1])\n bottom_info = OpenRAVEBody.create_body_info(KinBody.Link.GeomType.Box, [.3,.015,.2], [0, 0.75, 1])\n\n long_info1._t = OpenRAVEBody.transform_from_obj_pose([0,-0.118,0.208],[0,0,0.055])\n long_info2._t = OpenRAVEBody.transform_from_obj_pose([0,-0.118,-0.208],[0,0,-0.055])\n short_info1._t = OpenRAVEBody.transform_from_obj_pose([0.309,-0.118,0],[-0.055,0,0])\n short_info2._t = OpenRAVEBody.transform_from_obj_pose([-0.309,-0.118,0],[0.055,0,0])\n bottom_info._t = OpenRAVEBody.transform_from_obj_pose([0,-0.25,0],[0,0,0])\n basket = RaveCreateRobot(env, '')\n basket.InitFromGeometries([long_info1, long_info2, short_info1, short_info2, bottom_info])\n return basket\n\n @staticmethod\n def create_table(env, geom):\n thickness = geom.thickness\n leg_height = geom.leg_height\n back = geom.back\n dim1, dim2 = geom.table_dim\n legdim1, legdim2 = geom.leg_dim\n\n table_color = [0.5, 0.2, 0.1]\n component_type = KinBody.Link.GeomType.Box\n tabletop = OpenRAVEBody.create_body_info(component_type, [dim1/2, dim2/2, thickness/2], table_color)\n\n leg1 = OpenRAVEBody.create_body_info(component_type, [legdim1/2, legdim2/2, leg_height/2], table_color)\n leg1._t[0, 3] = dim1/2 - legdim1/2\n leg1._t[1, 3] = dim2/2 - legdim2/2\n leg1._t[2, 3] = -leg_height/2 - thickness/2\n\n leg2 = OpenRAVEBody.create_body_info(component_type, [legdim1/2, legdim2/2, leg_height/2], table_color)\n leg2._t[0, 3] = dim1/2 - legdim1/2\n leg2._t[1, 3] = -dim2/2 + legdim2/2\n leg2._t[2, 3] = -leg_height/2 - thickness/2\n\n leg3 = OpenRAVEBody.create_body_info(component_type, [legdim1/2, legdim2/2, leg_height/2], table_color)\n leg3._t[0, 3] = -dim1/2 + legdim1/2\n leg3._t[1, 3] = dim2/2 - legdim2/2\n leg3._t[2, 3] = -leg_height/2 - thickness/2\n\n leg4 = OpenRAVEBody.create_body_info(component_type, [legdim1/2, legdim2/2, leg_height/2], table_color)\n leg4._t[0, 3] = -dim1/2 + legdim1/2\n leg4._t[1, 3] = -dim2/2 + legdim2/2\n leg4._t[2, 3] = -leg_height/2 - thickness/2\n\n if back:\n back_plate = OpenRAVEBody.create_body_info(component_type, [legdim1/10, dim2/2, leg_height-thickness/2], table_color)\n back_plate._t[0, 3] = dim1/2 - legdim1/10\n back_plate._t[1, 3] = 0\n back_plate._t[2, 3] = -leg_height/2 - thickness/4\n\n table = RaveCreateRobot(env, '')\n if not back:\n table.InitFromGeometries([tabletop, leg1, leg2, leg3, leg4])\n else:\n table.InitFromGeometries([tabletop, leg1, leg2, leg3, leg4, back_plate])\n return table\n\n @staticmethod\n def base_pose_2D_to_mat(pose):\n # x, y = pose\n assert len(pose) == 2\n x = pose[0]\n y = pose[1]\n rot = 0\n q = quatFromAxisAngle((0, 0, rot)).tolist()\n pos = [x, y, 0]\n # pos = np.vstack((x,y,np.zeros(1)))\n matrix = matrixFromPose(q + pos)\n return matrix\n\n @staticmethod\n def base_pose_3D_to_mat(pose):\n # x, y, z = pose\n assert len(pose) == 3\n x = pose[0]\n y = pose[1]\n z = pose[2]\n rot = 0\n q = quatFromAxisAngle((0, 0, rot)).tolist()\n pos = [x, y, z]\n # pos = np.vstack((x,y,np.zeros(1)))\n matrix = matrixFromPose(q + pos)\n return matrix\n\n @staticmethod\n def mat_to_base_pose_2D(mat):\n pose = poseFromMatrix(mat)\n x = pose[4]\n y = pose[5]\n return np.array([x,y])\n\n @staticmethod\n def base_pose_to_mat(pose):\n # x, y, rot = pose\n assert len(pose) == 3\n x = pose[0]\n y = pose[1]\n rot = pose[2]\n q = quatFromAxisAngle((0, 0, rot)).tolist()\n pos = [x, y, 0]\n # pos = np.vstack((x,y,np.zeros(1)))\n matrix = matrixFromPose(q + pos)\n return matrix\n\n @staticmethod\n def angle_pose_to_mat(pose):\n assert len(pose) == 1\n q = quatFromAxisAngle((0, 0, pose)).tolist()\n matrix = matrixFromPose(q + pos)\n return matrix\n\n @staticmethod\n def mat_to_base_pose(mat):\n pose = poseFromMatrix(mat)\n x = pose[4]\n y = pose[5]\n rot = axisAngleFromRotationMatrix(mat)[2]\n return np.array([x,y,rot])\n\n @staticmethod\n def obj_pose_from_transform(transform):\n trans = transform[:3,3]\n rot_matrix = transform[:3,:3]\n yaw, pitch, roll = OpenRAVEBody._ypr_from_rot_matrix(rot_matrix)\n # ipdb.set_trace()\n return np.array((trans[0], trans[1], trans[2], yaw, pitch, roll))\n\n @staticmethod\n def transform_from_obj_pose(pose, rotation = np.array([0,0,0])):\n x, y, z = pose\n alpha, beta, gamma = rotation\n Rz, Ry, Rx = OpenRAVEBody._axis_rot_matrices(pose, rotation)\n rot_mat = np.dot(Rz, np.dot(Ry, Rx))\n matrix = np.eye(4)\n matrix[:3,:3] = rot_mat\n matrix[:3,3] = [x,y,z]\n return matrix\n\n @staticmethod\n def _axis_rot_matrices(pose, rotation):\n x, y, z = pose\n alpha, beta, gamma = rotation\n Rz_2d = np.array([[cos(alpha), -sin(alpha)], [sin(alpha), cos(alpha)]])\n Ry_2d = np.array([[cos(beta), sin(beta)], [-sin(beta), cos(beta)]])\n Rx_2d = np.array([[cos(gamma), -sin(gamma)], [sin(gamma), cos(gamma)]])\n I = np.eye(3)\n Rz = I.copy()\n Rz[:2,:2] = Rz_2d\n Ry = I.copy()\n Ry[[[0],[2]],[0,2]] = Ry_2d\n Rx = I.copy()\n Rx[1:3,1:3] = Rx_2d\n # ipdb.set_trace()\n return Rz, Ry, Rx\n\n @staticmethod\n def _ypr_from_rot_matrix(r):\n # alpha\n yaw = atan2(r[1,0], r[0,0])\n # beta\n pitch = atan2(-r[2,0],np.sqrt(r[2,1]**2+r[2,2]**2))\n # gamma\n roll = atan2(r[2,1], r[2,2])\n # ipdb.set_trace()\n return (yaw, pitch, roll)\n\n @staticmethod\n def get_ik_transform(pos, rot, right_arm = True):\n trans = OpenRAVEBody.transform_from_obj_pose(pos, rot)\n # Openravepy flip the rotation axis by 90 degree, thus we need to change it back\n if right_arm:\n rot_mat = matrixFromAxisAngle([0, np.pi/2, 0])\n else:\n rot_mat = matrixFromAxisAngle([0, -np.pi/2, 0])\n trans_mat = trans[:3, :3].dot(rot_mat[:3, :3])\n trans[:3, :3] = trans_mat\n return trans\n\n def get_ik_arm_pose(self, pos, rot):\n # assert isinstance(self._geom, PR2)\n solutions = self.get_ik_from_pose(pos, rot, 'rightarm_torso')\n return solutions\n\n def get_ik_from_pose(self, pos, rot, manip_name, use6d=True):\n trans = OpenRAVEBody.get_ik_transform(pos, rot)\n solutions = self.get_ik_solutions(manip_name, trans, use6d)\n return solutions\n\n def get_ik_solutions(self, manip_name, trans, use6d=True):\n manip = self.env_body.GetManipulator(manip_name)\n if use6d:\n iktype = IkParameterizationType.Transform6D\n else:\n iktype = IkParameterizationType.Translation3D\n solutions = manip.FindIKSolutions(IkParameterization(trans, iktype),IkFilterOptions.CheckEnvCollisions)\n return solutions\n\n def get_close_ik_solution(self, manip_name, trans, dof_map=None):\n if dof_map is not None:\n self.set_dof(dof_map)\n\n manip = self.env_body.GetManipulator(manip_name)\n iktype = IkParameterizationType.Transform6D\n ik_param = IkParameterization(trans, iktype)\n solution = manip.FindIKSolution(ik_param, IkFilterOptions.IgnoreSelfCollisions)\n return solution\n\n def fwd_kinematics(self, manip_name, dof_map=None, mat_result=False):\n if dof_map is not None:\n self.set_dof(dof_map)\n\n trans = self.env_body.GetLink(manip_name).GetTransform()\n if mat_result:\n return trans\n\n pos = trans[:3, 3]\n quat = quatFromRotationMatrix(trans[:3, :3])\n return {'pos': pos, 'quat': quat}\n\n def param_fwd_kinematics(self, param, manip_names, t, mat_result=False):\n if not isinstance(self._geom, Robot): return\n\n attrs = list(param._attr_types.keys())\n dof_val = self.env_body.GetActiveDOFValues()\n for attr in attrs:\n if attr not in self._geom.dof_map: continue\n val = getattr(param, attr)[:, t]\n if np.any(np.isnan(val)): continue\n inds = self._geom.dof_map[attr]\n dof_val[inds] = val\n self.env_body.SetActiveDOFValues(dof_val)\n\n result = {}\n for manip_name in manip_names:\n result[manip_name] = self.fwd_kinematics(manip_name, mat_result=mat_result)\n\n return result\n",
"from core.internal_repr.predicate import Predicate\nfrom core.internal_repr.plan import Plan\nfrom core.util_classes.common_predicates import ExprPredicate\nfrom core.util_classes.openrave_body import OpenRAVEBody\nfrom errors_exceptions import PredicateException\nfrom sco_py.expr import Expr, AffExpr, EqExpr, LEqExpr\nimport numpy as np\n\nimport pybullet as p\n\nfrom collections import OrderedDict\n\nfrom pma.ll_solver_gurobi import NAMOSolver\n\n\n\"\"\"\nThis file implements the predicates for the 2D NAMO domain.\n\"\"\"\n\ndsafe = 1e-3 # 1e-1\n# dmove = 1.1e0 # 5e-1\ndmove = 1.5e0 # 5e-1\ncontact_dist = 5e-2 # dsafe\n\nRS_SCALE = 0.5\nN_DIGS = 5\nGRIP_TOL = 5e-1\nCOL_TS = 4 # 3\nNEAR_TOL = 0.4\n\n\nATTRMAP = {\n \"Robot\": (\n (\"pose\", np.array(list(range(2)), dtype=np.int)),\n (\"gripper\", np.array(list(range(1)), dtype=np.int)),\n (\"vel\", np.array(list(range(2)), dtype=np.int)),\n (\"acc\", np.array(list(range(2)), dtype=np.int)),\n ),\n \"Can\": ((\"pose\", np.array(list(range(2)), dtype=np.int)),),\n \"Target\": ((\"value\", np.array(list(range(2)), dtype=np.int)),),\n \"RobotPose\": (\n (\"value\", np.array(list(range(2)), dtype=np.int)),\n (\"gripper\", np.array(list(range(1)), dtype=np.int)),\n ),\n \"Obstacle\": ((\"pose\", np.array(list(range(2)), dtype=np.int)),),\n \"Grasp\": ((\"value\", np.array(list(range(2)), dtype=np.int)),),\n}\n\n\ndef add_to_attr_inds_and_res(t, attr_inds, res, param, attr_name_val_tuples):\n if param.is_symbol():\n t = 0\n for attr_name, val in attr_name_val_tuples:\n inds = np.where(param._free_attrs[attr_name][:, t])[0]\n getattr(param, attr_name)[inds, t] = val[inds]\n if param in attr_inds:\n res[param].extend(val[inds].flatten().tolist())\n attr_inds[param].append((attr_name, inds, t))\n else:\n res[param] = val[inds].flatten().tolist()\n attr_inds[param] = [(attr_name, inds, t)]\n\n\ndef process_traj(raw_traj, timesteps):\n \"\"\"\n Process raw_trajectory so that it's length is desired timesteps\n when len(raw_traj) > timesteps\n sample Trajectory by space to reduce trajectory size\n when len(raw_traj) < timesteps\n append last timestep pose util the size fits\n\n Note: result_traj includes init_dof and end_dof\n \"\"\"\n result_traj = []\n if len(raw_traj) == timesteps:\n result_traj = raw_traj.copy()\n else:\n traj_arr = [0]\n result_traj.append(raw_traj[0])\n # calculate accumulative distance\n for i in range(len(raw_traj) - 1):\n traj_arr.append(\n traj_arr[-1] + np.linalg.norm(raw_traj[i + 1] - raw_traj[i])\n )\n step_dist = traj_arr[-1] / (timesteps - 1)\n process_dist, i = 0, 1\n while i < len(traj_arr) - 1:\n if traj_arr[i] == process_dist + step_dist:\n result_traj.append(raw_traj[i])\n process_dist += step_dist\n elif traj_arr[i] < process_dist + step_dist < traj_arr[i + 1]:\n dist = process_dist + step_dist - traj_arr[i]\n displacement = (\n (raw_traj[i + 1] - raw_traj[i])\n / (traj_arr[i + 1] - traj_arr[i])\n * dist\n )\n result_traj.append(raw_traj[i] + displacement)\n process_dist += step_dist\n else:\n i += 1\n result_traj.append(raw_traj[-1])\n return np.array(result_traj).T\n\n\ndef get_rrt_traj(env, robot, active_dof, init_dof, end_dof):\n # assert body in env.GetRobot()\n active_dofs = robot.GetActiveDOFIndices()\n robot.SetActiveDOFs(active_dof)\n robot.SetActiveDOFValues(init_dof)\n\n params = Planner.PlannerParameters()\n params.SetRobotActiveJoints(robot)\n params.SetGoalConfig(end_dof) # set goal to all ones\n # # forces parabolic planning with 40 iterations\n # import ipdb; ipdb.set_trace()\n params.SetExtraParameters(\n \"\"\"<_postprocessing planner=\"parabolicsmoother\">\n <_nmaxiterations>20</_nmaxiterations>\n </_postprocessing>\"\"\"\n )\n\n planner = RaveCreatePlanner(env, \"birrt\")\n planner.InitPlan(robot, params)\n\n traj = RaveCreateTrajectory(env, \"\")\n result = planner.PlanPath(traj)\n if result == False:\n robot.SetActiveDOFs(active_dofs)\n return None\n traj_list = []\n for i in range(traj.GetNumWaypoints()):\n # get the waypoint values, this holds velocites, time stamps, etc\n data = traj.GetWaypoint(i)\n # extract the robot joint values only\n dofvalues = traj.GetConfigurationSpecification().ExtractJointValues(\n data, robot, robot.GetActiveDOFIndices()\n )\n # raveLogInfo('waypint %d is %s'%(i,np.round(dofvalues, 3)))\n traj_list.append(np.round(dofvalues, 3))\n robot.SetActiveDOFs(active_dofs)\n return np.array(traj_list)\n\n\ndef get_ompl_rrtconnect_traj(env, robot, active_dof, init_dof, end_dof):\n # assert body in env.GetRobot()\n dof_inds = robot.GetActiveDOFIndices()\n robot.SetActiveDOFs(active_dof)\n robot.SetActiveDOFValues(init_dof)\n\n params = Planner.PlannerParameters()\n params.SetRobotActiveJoints(robot)\n params.SetGoalConfig(end_dof) # set goal to all ones\n # forces parabolic planning with 40 iterations\n planner = RaveCreatePlanner(env, \"OMPL_RRTConnect\")\n planner.InitPlan(robot, params)\n traj = RaveCreateTrajectory(env, \"\")\n planner.PlanPath(traj)\n\n traj_list = []\n for i in range(traj.GetNumWaypoints()):\n # get the waypoint values, this holds velocites, time stamps, etc\n data = traj.GetWaypoint(i)\n # extract the robot joint values only\n dofvalues = traj.GetConfigurationSpecification().ExtractJointValues(\n data, robot, robot.GetActiveDOFIndices()\n )\n # raveLogInfo('waypint %d is %s'%(i,np.round(dofvalues, 3)))\n traj_list.append(np.round(dofvalues, 3))\n robot.SetActiveDOFs(dof_inds)\n return traj_list\n\n\ndef twostep_f(xs, dist, dim, pts=COL_TS, grad=False):\n if grad:\n res = []\n jac = np.zeros((0, 2 * dim))\n for t in range(pts):\n coeff = float(pts - t) / pts\n if len(xs) == 2:\n next_pos = coeff * xs[0] + (1 - coeff) * xs[1]\n else:\n next_pos = xs[0]\n res.append(dist(next_pos)[1])\n # jac = np.r_[jac, np.c_[coeff*res[t], (1-coeff)*res[t]]]\n jac = np.r_[jac, np.c_[res[t], res[t]]]\n return jac\n\n else:\n res = []\n for t in range(pts):\n coeff = float(pts - t) / pts\n if len(xs) == 2:\n next_pos = coeff * xs[0] + (1 - coeff) * xs[1]\n else:\n next_pos = xs[0]\n res.append(dist(next_pos)[0])\n return np.concatenate(res, axis=0)\n\n\nclass CollisionPredicate(ExprPredicate):\n def __init__(\n self,\n name,\n e,\n attr_inds,\n params,\n expected_param_types,\n dsafe=dsafe,\n debug=False,\n ind0=0,\n ind1=1,\n active_range=(0, 1),\n priority=3,\n ):\n self._debug = debug\n # if self._debug:\n # self._env.SetViewer(\"qtcoin\")\n self._cc = ctrajoptpy.GetCollisionChecker(self._env)\n\n self.dsafe = dsafe\n self.ind0 = ind0\n self.ind1 = ind1\n\n self._cache = {}\n self.n_cols = 1\n\n super(CollisionPredicate, self).__init__(\n name,\n e,\n attr_inds,\n params,\n expected_param_types,\n active_range=active_range,\n priority=priority,\n )\n\n def test(self, time, negated=False, tol=1e-4):\n # This test is overwritten so that collisions can be calculated correctly\n if not self.is_concrete():\n return False\n if time < 0:\n raise PredicateException(\"Out of range time for predicate '%s'.\" % self)\n try:\n result = self.neg_expr.eval(\n self.get_param_vector(time), tol=tol, negated=(not negated)\n )\n return result\n except IndexError:\n ## this happens with an invalid time\n raise PredicateException(\"Out of range time for predicate '%s'.\" % self)\n\n def plot_cols(self, env, t):\n _debug = self._debug\n self._env = env\n self._debug = True\n self.distance_from_obj(self.get_param_vector(t))\n self._debug = _debug\n\n # @profile\n def distance_from_obj(self, x, n_steps=0):\n flattened = tuple(x.round(N_DIGS).flatten())\n # if flattened in self._cache and self._debug is False:\n # return self._cache[flattened]\n p0 = self.params[self.ind0]\n p1 = self.params[self.ind1]\n # if hasattr(p0.geom, 'radius') and hasattr(p1.geom, 'radius'):\n # disp = pose1 - pose0\n # dist = np.linalg.norm(disp)\n # vals = np.zeros((self.n_cols, 1))\n # jacs = np.zeros((self.n_cols, 4))\n b0 = self._param_to_body[p0]\n b1 = self._param_to_body[p1]\n pose0 = x[0:2]\n pose1 = x[2:4]\n b0.set_pose(pose0)\n b1.set_pose(pose1)\n\n collisions = p.getClosestPoints(b0.body_id, b1.body_id, contact_dist)\n\n # if p1.name == 'obs0':\n # print b1.env_body.GetLinks()[0].GetCollisionData().vertices\n\n col_val, jac01 = self._calc_grad_and_val(\n p0.name, p1.name, pose0, pose1, collisions\n )\n # val = np.array([col_val])\n val = col_val\n jac = jac01\n # self._cache[flattened] = (val.copy(), jac.copy())\n\n return val, jac\n\n # @profile\n def _calc_grad_and_val(self, name0, name1, pose0, pose1, collisions):\n vals = np.zeros((self.n_cols, 1))\n jacs = np.zeros((self.n_cols, 4))\n\n val = -1 * float(\"inf\")\n # jac0 = np.zeros(2)\n # jac1 = np.zeros(2)\n results = []\n n_cols = len(collisions)\n assert n_cols <= self.n_cols\n jac = np.zeros((1, 4))\n\n p0 = filter(lambda p: p.name == name0, list(self._param_to_body.keys()))[0]\n p1 = filter(lambda p: p.name == name1, list(self._param_to_body.keys()))[0]\n\n b0 = self._param_to_body[p0]\n b1 = self._param_to_body[p1]\n for i, c in enumerate(collisions):\n linkA, linkB = c[3], c[4]\n # linkA, linkB = c.linkIndexA, c.linkIndexB\n linkAParent, linkBParent = c[1], c[2]\n # linkAParent, linkBParent = c.bodyUniqueIdA, c.bodyUniqueIdB\n sign = 0\n if linkAParent == b0.body_id and linkBParent == b1.body_id:\n # pt0, pt1 = c.positionOnA, c.positionOnB\n pt0, pt1 = c[5], c[6]\n linkRobot, linkObj = linkA, linkB\n sign = -1\n elif linkBParent == b0.body_id and linkAParent == b1.body_id:\n # pt0, pt1 = c.positionOnB, c.positionOnA\n pt1, pt0 = c[5], c[6]\n linkRobot, linkObj = linkB, linkA\n sign = 1\n else:\n continue\n\n distance = c[8] # c.contactDistance\n normal = np.array(c[7]) # c.contactNormalOnB # Pointing towards A\n results.append((pt0, pt1, distance))\n # if distance < self.dsafe and 'obs0' in [name0, name1] and not np.any(np.isnan(pose0)) and not np.any(np.isnan(pose1)):\n # print(name0, name1, distance, pose0, pose1)\n\n # plotting\n if self._debug:\n pt0[2] = 1.01\n pt1[2] = 1.01\n self._plot_collision(pt0, pt1, distance)\n print(\"pt0 = \", pt0)\n print(\"pt1 = \", pt1)\n print(\"distance = \", distance)\n print(\"normal = \", normal)\n\n vals[i, 0] = self.dsafe - distance\n jacs[i, :2] = -1 * normal[:2]\n jacs[i, 2:] = normal[:2]\n\n if self._debug:\n print(\"options: \", results)\n print(\"selected: \", chosen_pt0, chosen_pt1)\n print(\"selected distance: \", chosen_distance)\n self._plot_collision(chosen_pt0, chosen_pt1, chosen_distance)\n\n # if jac0 is None or jac1 is None or val is None:\n # import ipdb; ipdb.set_trace()\n return np.array(vals).reshape((self.n_cols, 1)), np.array(jacs).reshape(\n (self.n_cols, 4)\n )\n\n def _plot_collision(self, ptA, ptB, distance):\n self.handles = []\n if not np.allclose(ptA, ptB, atol=1e-3):\n if distance < 0:\n self.handles.append(\n self._env.drawarrow(p1=ptA, p2=ptB, linewidth=0.01, color=(1, 0, 0))\n )\n else:\n self.handles.append(\n self._env.drawarrow(p1=ptA, p2=ptB, linewidth=0.01, color=(0, 0, 0))\n )\n\n\nclass HLPoseUsed(ExprPredicate):\n def __init__(self, name, params, expected_param_types, env=None):\n ## At Can Target\n self.pose = params[0]\n if self.pose.is_symbol():\n k = \"value\"\n else:\n k = \"pose\"\n attr_inds = OrderedDict([(self.pose, [(k, np.array([0, 1], dtype=np.int))])])\n\n A = np.zeros((2, 2))\n b = np.zeros((2, 1))\n val = np.zeros((2, 1))\n aff_e = AffExpr(A, b)\n e = EqExpr(aff_e, val)\n super(HLPoseUsed, self).__init__(\n name, e, attr_inds, params, expected_param_types, priority=-2\n )\n self.hl_info = True\n\n def test(self, time, negated=False, tol=1e-4):\n if negated:\n return True\n return super(HLPoseUsed, self).test(time, tol=tol)\n\n\nclass HLPoseAtGrasp(HLPoseUsed):\n\n # RobotAt Robot Can Grasp\n\n def __init__(self, name, params, expected_param_types, env=None):\n ## At Robot RobotPose\n self.r, self.c, self.g = params\n k = \"pose\" if not self.r.is_symbol() else \"value\"\n attr_inds = OrderedDict(\n [\n (self.r, [(k, np.array([0, 1], dtype=np.int))]),\n (self.c, [(\"pose\", np.array([0, 1], dtype=np.int))]),\n (self.g, [(\"value\", np.array([0, 1], dtype=np.int))]),\n ]\n )\n\n A = np.c_[\n np.r_[np.eye(2), -np.eye(2)],\n np.r_[-np.eye(2), np.eye(2)],\n np.r_[-np.eye(2), np.eye(2)],\n ]\n b = np.zeros((4, 1))\n val = NEAR_TOL * np.ones((4, 1))\n aff_e = AffExpr(A, b)\n e = LEqExpr(aff_e, val)\n super(HLPoseUsed, self).__init__(\n name, e, attr_inds, params, expected_param_types\n )\n self.hl_info = True\n\n\nclass HLAtGrasp(HLPoseUsed):\n pass\n\n\nclass HLPoseAtGrasp(HLPoseUsed):\n pass\n\n\nclass At(ExprPredicate):\n def __init__(self, name, params, expected_param_types, env=None):\n ## At Can Target\n self.can, self.targ = params\n attr_inds = OrderedDict(\n [\n (self.can, [(\"pose\", np.array([0, 1], dtype=np.int))]),\n (self.targ, [(\"value\", np.array([0, 1], dtype=np.int))]),\n ]\n )\n\n A = np.c_[np.eye(2), -np.eye(2)]\n b = np.zeros((2, 1))\n val = np.zeros((2, 1))\n aff_e = AffExpr(A, b)\n e = EqExpr(aff_e, val)\n super(At, self).__init__(\n name, e, attr_inds, params, expected_param_types, priority=-2\n )\n\n\nclass AtNEq(ExprPredicate):\n def __init__(self, name, params, expected_param_types, env=None):\n ## At Can Target\n self.can, self.eq, self.targ = params\n attr_inds = OrderedDict(\n [\n (self.can, [(\"pose\", np.array([0, 1], dtype=np.int))]),\n (self.targ, [(\"value\", np.array([0, 1], dtype=np.int))]),\n ]\n )\n\n if self.can is not self.eq:\n A = np.c_[np.eye(2), -np.eye(2)]\n b = np.zeros((2, 1))\n val = np.zeros((2, 1))\n else:\n A = np.zeros((2, 4))\n b = np.ones((2, 1))\n val = np.zeros((2, 1))\n\n aff_e = AffExpr(A, b)\n e = EqExpr(aff_e, val)\n super(AtNEq, self).__init__(\n name, e, attr_inds, params, expected_param_types, priority=-2\n )\n\n\nclass RobotAt(At):\n\n # RobotAt Robot RobotPose\n\n def __init__(self, name, params, expected_param_types, env=None):\n ## At Robot RobotPose\n self.r, self.rp = params\n attr_inds = OrderedDict(\n [\n (self.r, [(\"pose\", np.array([0, 1], dtype=np.int))]),\n (self.rp, [(\"value\", np.array([0, 1], dtype=np.int))]),\n ]\n )\n\n A = np.c_[np.eye(2), -np.eye(2)]\n b = np.zeros((2, 1))\n val = np.zeros((2, 1))\n aff_e = AffExpr(A, b)\n e = EqExpr(aff_e, val)\n super(At, self).__init__(name, e, attr_inds, params, expected_param_types)\n\n\nclass BoxAt(At):\n pass\n\n\nclass Near(At):\n def __init__(self, name, params, expected_param_types, env=None):\n self.r, self.c = params\n attr_inds = OrderedDict(\n [\n (self.r, [(\"pose\", np.array([0, 1], dtype=np.int))]),\n (self.c, [(\"value\", np.array([0, 1], dtype=np.int))]),\n ]\n )\n\n A = np.c_[np.r_[np.eye(2), -np.eye(2)], np.r_[-np.eye(2), np.eye(2)]]\n b = np.zeros((4, 1))\n val = NEAR_TOL * np.ones((4, 1))\n aff_e = AffExpr(A, b)\n e = LEqExpr(aff_e, val)\n super(At, self).__init__(name, e, attr_inds, params, expected_param_types)\n\n\nclass RobotNearTarget(At):\n def __init__(self, name, params, expected_param_types, env=None):\n ## At Robot RobotPose\n self.r, self.t = params\n attr_inds = OrderedDict(\n [\n (self.r, [(\"pose\", np.array([0, 1], dtype=np.int))]),\n (self.t, [(\"value\", np.array([0, 1], dtype=np.int))]),\n ]\n )\n\n A = np.c_[np.r_[np.eye(2), -np.eye(2)], np.r_[-np.eye(2), np.eye(2)]]\n b = np.zeros((4, 1))\n val = 0.25 * np.ones((4, 1))\n aff_e = AffExpr(A, b)\n e = LEqExpr(aff_e, val)\n super(At, self).__init__(name, e, attr_inds, params, expected_param_types)\n\n\nclass RobotNear(At):\n\n # RobotAt Robot Can\n\n def __init__(self, name, params, expected_param_types, env=None):\n ## At Robot RobotPose\n self.r, self.c = params\n attr_inds = OrderedDict(\n [\n (self.r, [(\"pose\", np.array([0, 1], dtype=np.int))]),\n (self.c, [(\"pose\", np.array([0, 1], dtype=np.int))]),\n ]\n )\n\n A = np.c_[np.r_[np.eye(2), -np.eye(2)], np.r_[-np.eye(2), np.eye(2)]]\n b = np.zeros((4, 1))\n val = 2 * np.ones((4, 1))\n aff_e = AffExpr(A, b)\n e = LEqExpr(aff_e, val)\n super(At, self).__init__(name, e, attr_inds, params, expected_param_types)\n\n\nclass NotRobotNear(At):\n\n # RobotAt Robot Can\n\n def __init__(self, name, params, expected_param_types, env=None):\n ## At Robot RobotPose\n self.r, self.c = params\n attr_inds = OrderedDict(\n [\n (self.r, [(\"pose\", np.array([0, 1], dtype=np.int))]),\n (self.c, [(\"pose\", np.array([0, 1], dtype=np.int))]),\n ]\n )\n\n A = np.c_[np.r_[np.eye(2), -np.eye(2)], np.r_[-np.eye(2), np.eye(2)]]\n b = np.zeros((4, 1))\n val = -2 * np.ones((4, 1))\n aff_e = AffExpr(A, b)\n e = LEqExpr(aff_e, val)\n super(At, self).__init__(name, e, attr_inds, params, expected_param_types)\n\n\nclass RobotWithinBounds(At):\n\n # RobotAt Robot Can\n\n def __init__(self, name, params, expected_param_types, env=None):\n ## At Robot RobotPose\n self.r, self.c = params\n attr_inds = OrderedDict([(self.r, [(\"pose\", np.array([0, 1], dtype=np.int))])])\n\n A = np.c_[np.eye(2), -np.eye(2)]\n b = np.zeros((4, 1))\n val = 1.5e1 * np.ones((4, 1))\n aff_e = AffExpr(A, b)\n e = LEqExpr(aff_e, val)\n super(At, self).__init__(name, e, attr_inds, params, expected_param_types)\n\n\nclass RobotNearGrasp(At):\n\n # RobotAt Robot Can Grasp\n\n def __init__(self, name, params, expected_param_types, env=None):\n ## At Robot RobotPose\n self.r, self.c, self.g = params\n attr_inds = OrderedDict(\n [\n (self.r, [(\"pose\", np.array([0, 1], dtype=np.int))]),\n (self.c, [(\"pose\", np.array([0, 1], dtype=np.int))]),\n (self.g, [(\"value\", np.array([0, 1], dtype=np.int))]),\n ]\n )\n\n A = np.c_[\n np.r_[np.eye(2), -np.eye(2)],\n np.r_[-np.eye(2), np.eye(2)],\n np.r_[-np.eye(2), np.eye(2)],\n ]\n b = np.zeros((4, 1))\n val = 1.5 * np.ones((4, 1))\n aff_e = AffExpr(A, b)\n e = LEqExpr(aff_e, val)\n super(At, self).__init__(name, e, attr_inds, params, expected_param_types)\n\n\nclass RobotAtGrasp(At):\n\n # RobotAt Robot Can Grasp\n\n def __init__(self, name, params, expected_param_types, env=None):\n ## At Robot RobotPose\n self.r, self.c, self.g = params\n k = \"pose\" if not self.r.is_symbol() else \"value\"\n attr_inds = OrderedDict(\n [\n (self.r, [(k, np.array([0, 1], dtype=np.int))]),\n (self.c, [(\"pose\", np.array([0, 1], dtype=np.int))]),\n (self.g, [(\"value\", np.array([0, 1], dtype=np.int))]),\n ]\n )\n\n A = np.c_[\n np.r_[np.eye(2), -np.eye(2)],\n np.r_[-np.eye(2), np.eye(2)],\n np.r_[-np.eye(2), np.eye(2)],\n ]\n b = np.zeros((4, 1))\n val = NEAR_TOL * np.ones((4, 1))\n aff_e = AffExpr(A, b)\n e = LEqExpr(aff_e, val)\n super(At, self).__init__(name, e, attr_inds, params, expected_param_types)\n\n\nclass RobotPoseAtGrasp(At):\n pass\n\n\nclass RobotWithinReach(At):\n\n # RobotAt Robot Target\n\n def __init__(self, name, params, expected_param_types, env=None):\n ## At Robot RobotPose\n self.r, self.t = params\n attr_inds = OrderedDict(\n [\n (self.r, [(\"pose\", np.array([0, 1], dtype=np.int))]),\n (self.t, [(\"value\", np.array([0, 1], dtype=np.int))]),\n ]\n )\n\n A = np.c_[np.r_[np.eye(2), -np.eye(2)], np.r_[-np.eye(2), np.eye(2)]]\n b = np.zeros((4, 1))\n val = 20 * np.ones((4, 1))\n aff_e = AffExpr(A, b)\n e = LEqExpr(aff_e, val)\n super(At, self).__init__(name, e, attr_inds, params, expected_param_types)\n\n\nclass GripperClosed(ExprPredicate):\n def __init__(self, name, params, expected_param_types, env=None):\n (self.robot,) = params\n attr_inds = OrderedDict(\n [(self.robot, [(\"gripper\", np.array([0], dtype=np.int))])]\n )\n A = np.ones((1, 1))\n b = np.zeros((1, 1))\n val = np.ones((1, 1)) # (GRIP_TOL + 1e-1) * -np.ones((1,1))\n aff_e = AffExpr(A, b)\n e = EqExpr(aff_e, val)\n # e = LEqExpr(aff_e, val)\n\n neg_val = -np.ones((1, 1)) # (GRIP_TOL - 1e-1) * np.ones((1,1))\n neg_aff_e = AffExpr(A, b)\n self.neg_expr = EqExpr(neg_aff_e, neg_val)\n # self.neg_expr = LEqExpr(neg_aff_e, neg_val)\n super(GripperClosed, self).__init__(\n name, e, attr_inds, params, expected_param_types, priority=-2\n )\n\n def get_expr(self, negated):\n if negated:\n return self.neg_expr\n else:\n return self.expr\n\n\nclass InContact(CollisionPredicate):\n\n # InContact, Robot, RobotPose, Target\n\n def __init__(self, name, params, expected_param_types, env=None, debug=False):\n self._env = env\n self.robot, self.rp, self.targ = params\n attr_inds = OrderedDict(\n [\n (self.rp, [(\"value\", np.array([0, 1], dtype=np.int))]),\n (self.targ, [(\"value\", np.array([0, 1], dtype=np.int))]),\n ]\n )\n self._param_to_body = {\n self.rp: self.lazy_spawn_or_body(self.rp, self.rp.name, self.rp.geom),\n self.targ: self.lazy_spawn_or_body(\n self.targ, self.targ.name, self.targ.geom\n ),\n }\n\n INCONTACT_COEFF = 1e1\n f = lambda x: INCONTACT_COEFF * self.distance_from_obj(x)[0]\n grad = lambda x: INCONTACT_COEFF * self.distance_from_obj(x)[1]\n\n col_expr = Expr(f, grad)\n val = np.ones((1, 1)) * dsafe * INCONTACT_COEFF\n # val = np.zeros((1, 1))\n e = EqExpr(col_expr, val)\n super(InContact, self).__init__(\n name,\n e,\n attr_inds,\n params,\n expected_param_types,\n debug=debug,\n ind0=1,\n ind1=2,\n active_range=(0, 0),\n )\n\n def test(self, time, negated=False, tol=1e-4):\n return super(CollisionPredicate, self).test(time, negated, tol)\n\n\nclass Collides(CollisionPredicate):\n\n # Collides Can Obstacle (wall)\n\n def __init__(self, name, params, expected_param_types, env=None, debug=False):\n self._env = env\n self.c, self.w = params\n attr_inds = OrderedDict(\n [\n (self.c, [(\"pose\", np.array([0, 1], dtype=np.int))]),\n (self.w, [(\"pose\", np.array([0, 1], dtype=np.int))]),\n ]\n )\n self._param_to_body = {\n self.c: self.lazy_spawn_or_body(self.c, self.c.name, self.c.geom),\n self.w: self.lazy_spawn_or_body(self.w, self.w.name, self.w.geom),\n }\n\n def f(x):\n return -twostep_f([x[:4], x[4:8]], self.distance_from_obj, 4)\n\n def grad(x):\n return -twostep_f([x[:4], x[4:8]], self.distance_from_obj, 4, grad=True)\n\n def f_neg(x):\n return -f(x)\n\n def grad_neg(x):\n return grad(x)\n\n # f = lambda x: -self.distance_from_obj(x)[0]\n # grad = lambda x: -self.distance_from_obj(x)[1]\n\n ## so we have an expr for the negated predicate\n # f_neg = lambda x: self.distance_from_obj(x)[0]\n # def grad_neg(x):\n # # print self.distance_from_obj(x)\n # return -self.distance_from_obj(x)[1]\n\n N_COLS = 8\n\n col_expr = Expr(f, grad)\n val = np.zeros((COL_TS * N_COLS, 1))\n e = LEqExpr(col_expr, val)\n\n col_expr_neg = Expr(f_neg, grad_neg)\n self.neg_expr = LEqExpr(col_expr_neg, -val)\n\n super(Collides, self).__init__(\n name, e, attr_inds, params, expected_param_types, ind0=0, ind1=1\n )\n self.n_cols = N_COLS\n # self.priority = 1\n\n def get_expr(self, negated):\n if negated:\n return self.neg_expr\n else:\n return None\n\n\nclass TargetGraspCollides(Collides):\n def __init__(self, name, params, expected_param_types, env=None, debug=False):\n self._env = env\n self.c, self.w, self.g = params\n if self.c.is_symbol():\n k = \"value\"\n else:\n k = \"pose\"\n attr_inds = OrderedDict(\n [\n (self.c, [(k, np.array([0, 1], dtype=np.int))]),\n (self.w, [(\"pose\", np.array([0, 1], dtype=np.int))]),\n (self.g, [(\"value\", np.array([0, 1], dtype=np.int))]),\n ]\n )\n self._param_to_body = {\n self.c: self.lazy_spawn_or_body(self.c, self.c.name, self.c.geom),\n self.w: self.lazy_spawn_or_body(self.w, self.w.name, self.w.geom),\n }\n\n dist = 1.5\n\n def f(x):\n disp = x[:2] + dist * x[4:6]\n new_x = np.concatenate([disp, x[2:4]])\n return -self.distance_from_obj(new_x)[0]\n\n def grad(x):\n disp = x[:2] + dist * x[4:6]\n new_x = np.concatenate([disp, x[2:4]])\n jac = self.distance_from_obj(new_x)[1]\n return np.c_[np.zeros((8, 2)), jac]\n\n def f_neg(x):\n return -f(x)\n\n def grad_neg(x):\n return grad(x)\n\n # f = lambda x: -self.distance_from_obj(x)[0]\n # grad = lambda x: -self.distance_from_obj(x)[1]\n\n ## so we have an expr for the negated predicate\n # f_neg = lambda x: self.distance_from_obj(x)[0]\n # def grad_neg(x):\n # # print self.distance_from_obj(x)\n # return -self.distance_from_obj(x)[1]\n\n N_COLS = 8\n\n col_expr = Expr(f, grad)\n val = np.zeros((N_COLS, 1))\n e = LEqExpr(col_expr, val)\n\n col_expr_neg = Expr(f_neg, grad_neg)\n self.neg_expr = LEqExpr(col_expr_neg, -val)\n\n super(Collides, self).__init__(\n name,\n e,\n attr_inds,\n params,\n expected_param_types,\n ind0=0,\n ind1=1,\n active_range=(0, 0),\n priority=2,\n )\n self.n_cols = N_COLS\n # self.priority = 1\n\n\nclass RobotCanGraspCollides(Collides):\n def __init__(self, name, params, expected_param_types, env=None, debug=False):\n self._env = env\n self.c, self.w, self.g = params\n if self.c.is_symbol():\n k = \"value\"\n else:\n k = \"pose\"\n attr_inds = OrderedDict(\n [\n (self.c, [(k, np.array([0, 1], dtype=np.int))]),\n (self.w, [(\"pose\", np.array([0, 1], dtype=np.int))]),\n (self.g, [(\"value\", np.array([0, 1], dtype=np.int))]),\n ]\n )\n self._param_to_body = {\n self.c: self.lazy_spawn_or_body(self.c, self.c.name, self.c.geom),\n self.w: self.lazy_spawn_or_body(self.w, self.w.name, self.w.geom),\n }\n\n def f(x):\n return -self.distance_from_obj(x[:4])[0]\n\n def grad(x):\n jac = self.distance_from_obj(x[:4])[1]\n return np.c_[jac, np.zeros((8, 2))]\n\n def f_neg(x):\n return -f(x)\n\n def grad_neg(x):\n return grad(x)\n\n # f = lambda x: -self.distance_from_obj(x)[0]\n # grad = lambda x: -self.distance_from_obj(x)[1]\n\n ## so we have an expr for the negated predicate\n # f_neg = lambda x: self.distance_from_obj(x)[0]\n # def grad_neg(x):\n # # print self.distance_from_obj(x)\n # return -self.distance_from_obj(x)[1]\n\n N_COLS = 8\n\n col_expr = Expr(f, grad)\n val = np.zeros((N_COLS, 1))\n e = LEqExpr(col_expr, val)\n\n col_expr_neg = Expr(f_neg, grad_neg)\n self.neg_expr = LEqExpr(col_expr_neg, -val)\n\n super(Collides, self).__init__(\n name,\n e,\n attr_inds,\n params,\n expected_param_types,\n ind0=0,\n ind1=1,\n active_range=(0, 0),\n priority=2,\n )\n self.n_cols = N_COLS\n # self.priority = 1\n\n\nclass CanGraspCollides(TargetGraspCollides):\n pass\n\n\nclass TargetCanGraspCollides(TargetGraspCollides):\n pass\n\n\nclass TargetCollides(Collides):\n def __init__(self, name, params, expected_param_types, env=None, debug=False):\n self._env = env\n self.c, self.w = params\n attr_inds = OrderedDict(\n [\n (self.c, [(\"value\", np.array([0, 1], dtype=np.int))]),\n (self.w, [(\"pose\", np.array([0, 1], dtype=np.int))]),\n ]\n )\n self._param_to_body = {\n self.c: self.lazy_spawn_or_body(self.c, self.c.name, self.c.geom),\n self.w: self.lazy_spawn_or_body(self.w, self.w.name, self.w.geom),\n }\n\n def f(x):\n return -self.distance_from_obj(x)[0]\n\n def grad(x):\n return self.distance_from_obj(x)[1]\n\n def f_neg(x):\n return -f(x)\n\n def grad_neg(x):\n return grad(x)\n\n # f = lambda x: -self.distance_from_obj(x)[0]\n # grad = lambda x: -self.distance_from_obj(x)[1]\n\n ## so we have an expr for the negated predicate\n # f_neg = lambda x: self.distance_from_obj(x)[0]\n # def grad_neg(x):\n # # print self.distance_from_obj(x)\n # return -self.distance_from_obj(x)[1]\n\n N_COLS = 8\n\n col_expr = Expr(f, grad)\n val = np.zeros((N_COLS, 1))\n e = LEqExpr(col_expr, val)\n\n col_expr_neg = Expr(f_neg, grad_neg)\n self.neg_expr = LEqExpr(col_expr_neg, -val)\n\n super(Collides, self).__init__(\n name,\n e,\n attr_inds,\n params,\n expected_param_types,\n ind0=0,\n ind1=1,\n active_range=(0, 0),\n )\n self.n_cols = N_COLS\n # self.priority = 1\n\n\nclass PoseCollides(TargetCollides):\n pass\n\n\nclass RCollides(CollisionPredicate):\n\n # RCollides Robot Obstacle (Wall)\n\n def __init__(self, name, params, expected_param_types, env=None, debug=False):\n self._env = env\n self.hl_ignore = True\n self.r, self.w = params\n attr_inds = OrderedDict(\n [\n (self.r, [(\"pose\", np.array([0, 1], dtype=np.int))]),\n (self.w, [(\"pose\", np.array([0, 1], dtype=np.int))]),\n ]\n )\n self._param_to_body = {\n self.r: self.lazy_spawn_or_body(self.r, self.r.name, self.r.geom),\n self.w: self.lazy_spawn_or_body(self.w, self.w.name, self.w.geom),\n }\n\n # f = lambda x: -self.distance_from_obj(x)[0]\n # grad = lambda x: -self.distance_from_obj(x)[1]\n\n neg_coeff = 1e4\n neg_grad_coeff = 1e-3\n\n \"\"\"\n ## so we have an expr for the negated predicate\n def f_neg(x):\n d = neg_coeff * self.distance_from_obj(x)[0]\n # if np.any(d > 0):\n # import ipdb; ipdb.set_trace()\n # self.distance_from_obj(x)\n return d\n\n def grad_neg(x):\n # print self.distance_from_obj(x)\n return -neg_grad_coeff * self.distance_from_obj(x)[1]\n \"\"\"\n\n def f(x):\n return -twostep_f([x[:4], x[4:8]], self.distance_from_obj, 4)\n\n def grad(x):\n return -twostep_f([x[:4], x[4:8]], self.distance_from_obj, 4, grad=True)\n\n def f_neg(x):\n return -neg_coeff * f(x)\n\n def grad_neg(x):\n return neg_grad_coeff * grad(x)\n\n # f = lambda x: -self.distance_from_obj(x)[0]\n # grad = lambda x: -self.distance_from_obj(x)[1]\n\n N_COLS = 8\n col_expr = Expr(f, grad)\n val = np.zeros((COL_TS * N_COLS, 1))\n e = LEqExpr(col_expr, val)\n\n col_expr_neg = Expr(f_neg, grad_neg)\n self.neg_expr = LEqExpr(col_expr_neg, -val)\n\n super(RCollides, self).__init__(\n name, e, attr_inds, params, expected_param_types, ind0=0, ind1=1\n )\n self.n_cols = N_COLS\n\n # self.priority = 1\n\n def resample(self, negated, time, plan):\n assert negated\n res = OrderedDict()\n attr_inds = OrderedDict()\n a = 0\n while a < len(plan.actions) and plan.actions[a].active_timesteps[1] <= time:\n a += 1\n\n if a >= len(plan.actions) or time == plan.actions[a].active_timesteps[0]:\n return None, None\n\n act = plan.actions[a]\n\n if time == plan.actions[a].active_timesteps[1]:\n x = self.get_param_vector(time)\n val, jac = self.distance_from_obj(x, 0)\n jac = jac[0, :2]\n else:\n x1 = self.get_param_vector(time)\n x2 = self.get_param_vector(time + 1)\n jac = -twostep_f([x1, x2], self.distance_from_obj, 4, grad=True)\n jac = np.mean(jac[:, :2], axis=0)\n\n if np.all(jac == 0):\n return None, None\n\n jac = jac / (np.linalg.norm(jac) + 1e-3)\n\n new_robot_pose = self.r.pose[:, time] + np.random.uniform(0.1, 0.5) * jac\n st = max(max(time - 3, 0), act.active_timesteps[0])\n et = min(min(time + 3, plan.horizon - 1), act.active_timesteps[1])\n for i in range(st, et):\n dist = float(np.abs(i - time))\n if i <= time:\n inter_rp = (dist / 3.0) * self.r.pose[:, st] + (\n (3.0 - dist) / 3.0\n ) * new_robot_pose\n else:\n inter_rp = (dist / 3.0) * self.r.pose[:, et] + (\n (3.0 - dist) / 3.0\n ) * new_robot_pose\n\n add_to_attr_inds_and_res(i, attr_inds, res, self.r, [(\"pose\", inter_rp)])\n return res, attr_inds\n\n def get_expr(self, negated):\n if negated:\n return self.neg_expr\n else:\n return None\n\n\nclass Obstructs(CollisionPredicate):\n\n # Obstructs, Robot, RobotPose, RobotPose, Can;\n\n def __init__(self, name, params, expected_param_types, env=None, debug=False):\n self._env = env\n self.hl_ignore = True\n self.r, self.startp, self.endp, self.c = params\n attr_inds = OrderedDict(\n [\n (self.r, [(\"pose\", np.array([0, 1], dtype=np.int))]),\n (self.c, [(\"pose\", np.array([0, 1], dtype=np.int))]),\n ]\n )\n self._param_to_body = {\n self.r: self.lazy_spawn_or_body(self.r, self.r.name, self.r.geom),\n self.c: self.lazy_spawn_or_body(self.c, self.c.name, self.c.geom),\n }\n\n self.rs_scale = RS_SCALE\n\n # f = lambda x: -self.distance_from_obj(x)[0]\n # grad = lambda x: -self.distance_from_obj(x)[1]\n\n neg_coeff = 1e2\n neg_grad_coeff = 1e-3\n \"\"\"\n ## so we have an expr for the negated predicate\n f_neg = lambda x: neg_coeff*self.distance_from_obj(x)[0]\n def grad_neg(x):\n # print self.distance_from_obj(x)\n return neg_grad_coeff*self.distance_from_obj(x)[1]\n \"\"\"\n\n def f(x):\n return -twostep_f([x[:4], x[4:8]], self.distance_from_obj, 4)\n\n def grad(x):\n return -twostep_f([x[:4], x[4:8]], self.distance_from_obj, 4, grad=True)\n\n def f_neg(x):\n return -neg_coeff * f(x)\n\n def grad_neg(x):\n return -neg_grad_coeff * grad(x)\n\n col_expr = Expr(f, grad)\n val = np.zeros((1, 1))\n e = LEqExpr(col_expr, val)\n\n col_expr_neg = Expr(f_neg, grad_neg)\n self.neg_expr = LEqExpr(col_expr_neg, -val)\n\n super(Obstructs, self).__init__(\n name, e, attr_inds, params, expected_param_types, ind0=0, ind1=3\n )\n # self.priority=1\n\n def resample(self, negated, time, plan):\n assert negated\n res = OrderedDict()\n attr_inds = OrderedDict()\n # for param in [self.startp, self.endp]:\n # val, inds = sample_pose(plan, param, self.r, self.rs_scale)\n # if val is None:\n # continue\n # res.extend(val[inds].flatten().tolist())\n # # inds[0] returns the x values of the indices which is what we care\n # # about, because the y values correspond to time.\n # attr_inds[param] = [('value', inds[0])]\n # import ipdb; ipdb.set_trace()\n a = 0\n while a < len(plan.actions) and plan.actions[a].active_timesteps[1] <= time:\n a += 1\n\n if a >= len(plan.actions) or time == plan.actions[a].active_timesteps[0]:\n return None, None\n\n act = plan.actions[a]\n\n disp = self.c.pose[:, time] - self.r.pose[:, time]\n use_t = time\n new_disp = disp\n if (\n time < plan.actions[a].active_timesteps[1]\n and np.linalg.norm(disp)\n > self.r.geom.radius + self.c.geom.radius + self.dsafe\n ):\n new_disp = self.c.pose[:, time + 1] - self.r.pose[:, time + 1]\n\n if (\n np.linalg.norm(new_disp)\n < self.r.geom.radius + self.c.geom.radius + self.dsafe\n ):\n disp = new_disp\n else:\n disp = (disp + new_disp) / 2.0\n\n if disp[0] == 0:\n orth = np.array([1.0, 0.0])\n elif disp[1] == 0:\n orth = np.array([0.0, 1.0])\n else:\n orth = np.array([1.0 / disp[0], -1.0 / disp[1]])\n disp += 1e-5\n\n st = max(max(time - 3, 0), act.active_timesteps[0])\n et = min(min(time + 3, plan.horizon - 1), act.active_timesteps[1])\n long_disp = self.r.pose[:, et] - self.r.pose[:, st]\n long_disp /= np.linalg.norm(long_disp)\n d1, d2 = long_disp.dot(orth), long_disp.dot(-orth)\n\n if d1 > d2:\n w1, w2 = 0.1, 0.9\n else:\n w1, w2 = 0.9, 0.1\n orth *= np.random.choice([-1.0, 1.0], p=[w1, w2])\n orth = orth / np.linalg.norm(orth)\n\n rdisp = (\n -(self.c.geom.radius + self.r.geom.radius + self.dsafe + 1e-1)\n * disp\n / np.linalg.norm(disp)\n )\n orth = rdisp # + np.random.uniform(0.5, 2.) * orth\n # orth *= np.random.uniform(0.7, 1.5) * (self.c.geom.radius + self.r.geom.radius + self.dsafe)\n # orth += np.random.uniform([-0.15, 0.15], [-0.15, 0.15])\n\n # new_robot_pose = self.r.pose[:, time] + orth\n disp = orth\n st = max(max(time - 3, 1), act.active_timesteps[0] + 1)\n et = min(min(time + 3, plan.horizon - 1), act.active_timesteps[1])\n ref_st = max(max(time - 3, 0), act.active_timesteps[0])\n ref_et = min(min(time + 3, plan.horizon - 1), act.active_timesteps[1])\n for i in range(st, et):\n dist = float(np.abs(i - time))\n if i <= time:\n inter_rp = (dist / 3.0) * self.r.pose[:, st] + ((3.0 - dist) / 3.0) * (\n self.r.pose[:, st] + disp\n )\n inter_rp = (dist / 3.0) * self.r.pose[:, ref_st] + (\n (3.0 - dist) / 3.0\n ) * (self.r.pose[:, time] + disp)\n else:\n inter_rp = (dist / 3.0) * self.r.pose[:, et] + ((3.0 - dist) / 3.0) * (\n self.r.pose[:, et] + disp\n )\n inter_rp = (dist / 3.0) * self.r.pose[:, ref_et] + (\n (3.0 - dist) / 3.0\n ) * (self.r.pose[:, time] + disp)\n\n add_to_attr_inds_and_res(i, attr_inds, res, self.r, [(\"pose\", inter_rp)])\n return res, attr_inds\n\n def get_expr(self, negated):\n if negated:\n return self.neg_expr\n else:\n return None\n\n\nclass WideObstructs(Obstructs):\n def __init__(self, name, params, expected_param_types, env=None, debug=False):\n super(WideObstructs, self).__init__(\n name, params, expected_param_types, env, debug\n )\n self.dsafe = 0.2\n\n\ndef sample_pose(plan, pose, robot, rs_scale):\n targets = plan.get_param(\"InContact\", 2, {0: robot, 1: pose})\n # http://docs.scipy.org/doc/numpy/reference/generated/numpy.where.html\n inds = np.where(pose._free_attrs[\"value\"])\n if np.sum(inds) == 0:\n return None, None ## no resampling for this one\n if len(targets) == 1:\n # print \"one target\", pose\n random_dir = np.random.rand(2, 1) - 0.5\n random_dir = random_dir / np.linalg.norm(random_dir)\n # assumes targets are symbols\n val = targets[0].value + random_dir * 3 * robot.geom.radius\n elif len(targets) == 0:\n ## old generator -- just add a random perturbation\n # print \"no targets\", pose\n val = np.random.normal(pose.value[:, 0], scale=rs_scale)[:, None]\n else:\n raise NotImplementedError\n # print pose, val\n pose.value = val\n\n ## make the pose collision free\n _, collision_preds = plan.get_param(\"RCollides\", 1, negated=True, return_preds=True)\n _, at_preds = plan.get_param(\n \"RobotAt\", 1, {0: robot, 1: pose}, negated=False, return_preds=True\n )\n preds = [(collision_preds[0], True), (at_preds[0], False)]\n old_pose = robot.pose.copy()\n old_free = robot._free_attrs[\"pose\"].copy()\n robot.pose = pose.value.copy()\n robot._free_attrs[\"pose\"][:] = 1\n\n wall = collision_preds[0].params[1]\n old_w_pose = wall.pose.copy()\n wall.pose = wall.pose[:, 0][:, None]\n\n old_priority = [p.priority for p, n in preds]\n for p, n in preds:\n p.priority = -1\n p = Plan.create_plan_for_preds(preds, collision_preds[0]._env)\n s = NAMOSolver(transfer_norm=\"l2\")\n success = s._solve_opt_prob(p, 0, resample=False, verbose=False)\n\n # print success\n\n ## debugging\n # import viewer\n # v = viewer.OpenRAVEViewer.create_viewer()\n # v.draw_plan_ts(p, 0)\n # print pose.value, val\n\n ## restore the old values\n robot.pose = old_pose\n robot._free_attrs[\"pose\"] = old_free\n for i, (p, n) in enumerate(preds):\n p.priority = old_priority[i]\n\n wall.pose = old_w_pose\n\n return pose.value, inds\n\n\nclass ObstructsHolding(CollisionPredicate):\n\n # ObstructsHolding, Robot, RobotPose, RobotPose, Can, Can;\n def __init__(self, name, params, expected_param_types, env=None, debug=False):\n self._env = env\n r, startp, endp, obstr, held = params\n self.r = r\n self.startp, self.endp = startp, endp\n self.obstr = obstr\n self.held = held\n\n self.rs_scale = RS_SCALE\n\n attr_inds = OrderedDict(\n [\n (r, [(\"pose\", np.array([0, 1], dtype=np.int))]),\n (obstr, [(\"pose\", np.array([0, 1], dtype=np.int))]),\n (held, [(\"pose\", np.array([0, 1], dtype=np.int))]),\n ]\n )\n\n self._param_to_body = {\n r: self.lazy_spawn_or_body(r, r.name, r.geom),\n obstr: self.lazy_spawn_or_body(obstr, obstr.name, obstr.geom),\n held: self.lazy_spawn_or_body(held, held.name, held.geom),\n }\n\n # f = lambda x: -self.distance_from_obj(x)[0]\n # grad = lambda x: -self.distance_from_obj(x)[1]\n\n neg_coeff = 1e2\n neg_grad_coeff = 1e-3\n ## so we have an expr for the negated predicate\n # f_neg = lambda x: neg_coeff*self.distance_from_obj(x)[0]\n # grad_neg = lambda x: neg_grad_coeff*self.distance_from_obj(x)[1]\n\n def f(x):\n if self.obstr.name == self.held.name:\n return -twostep_f([x[:4], x[4:8]], self.distance_from_obj, 4)\n else:\n return -twostep_f([x[:6], x[6:12]], self.distance_from_obj, 6)\n\n def grad(x):\n if self.obstr.name == self.held.name:\n return -twostep_f([x[:4], x[4:8]], self.distance_from_obj, 4, grad=True)\n else:\n return -twostep_f(\n [x[:6], x[6:12]], self.distance_from_obj, 6, grad=True\n )\n\n def f_neg(x):\n return -neg_coeff * f(x)\n\n def grad_neg(x):\n return -neg_grad_coeff * grad(x)\n\n col_expr = Expr(f, grad)\n val = np.zeros((1, 1))\n e = LEqExpr(col_expr, val)\n\n if self.held != self.obstr:\n col_expr_neg = Expr(f_neg, grad_neg)\n else:\n new_f_neg = lambda x: 0.0 * f(x) # self.distance_from_obj(x)[0]\n new_grad_neg = lambda x: -grad(x) # self.distance_from_obj(x)[1]\n col_expr_neg = Expr(new_f_neg, new_grad_neg)\n self.neg_expr = LEqExpr(col_expr_neg, val)\n\n super(ObstructsHolding, self).__init__(\n name, e, attr_inds, params, expected_param_types\n )\n # self.priority=1\n\n def resample(self, negated, time, plan):\n assert negated\n\n a = 0\n while a < len(plan.actions) and plan.actions[a].active_timesteps[1] <= time:\n a += 1\n\n if a >= len(plan.actions) or time == plan.actions[a].active_timesteps[0]:\n return None, None\n act = plan.actions[a]\n\n res = OrderedDict()\n attr_inds = OrderedDict()\n disp1 = self.obstr.pose[:, time] - self.held.pose[:, time]\n disp2 = self.obstr.pose[:, time] - self.r.pose[:, time]\n disp = disp1 if np.linalg.norm(disp1) < np.linalg.norm(disp2) else disp2\n if disp[0] == 0:\n orth = np.array([1.0, 0.0])\n elif disp[1] == 0:\n orth = np.array([0.0, 1.0])\n else:\n orth = np.array([1.0 / disp[0], -1.0 / disp[1]])\n disp += 1e-4\n\n st = max(max(time - 3, 0), act.active_timesteps[0])\n et = min(min(time + 3, plan.horizon - 1), act.active_timesteps[1])\n long_disp = self.r.pose[:, et] - self.r.pose[:, st]\n long_disp /= np.linalg.norm(long_disp)\n d1, d2 = long_disp.dot(orth), long_disp.dot(-orth)\n\n if d1 > d2:\n w1, w2 = 0.1, 0.9\n else:\n w1, w2 = 0.9, 0.1\n orth *= np.random.choice([-1.0, 1.0], p=[w1, w2])\n orth = orth / np.linalg.norm(orth)\n\n rdisp = (\n -(self.obstr.geom.radius + self.held.geom.radius + self.dsafe + 2e-1)\n * disp\n / np.linalg.norm(disp)\n )\n orth = rdisp + np.random.uniform(0.2, 0.5) * orth\n # orth *= np.random.uniform(1.2, 1.8) * (self.obstr.geom.radius + self.r.geom.radius)\n # orth += np.random.uniform([-0.15, 0.15], [-0.15, 0.15])\n\n # ## assumes that self.startp, self.endp and target are all symbols\n # t_local = 0\n # for param in [self.startp, self.endp]:\n # ## there should only be 1 target that satisfies this\n # ## otherwise, choose to fail here\n # val, inds = sample_pose(plan, param, self.r, self.rs_scale)\n # if val is None:\n # continue\n # res.extend(val[inds].flatten().tolist())\n # ## inds[0] returns the x values of the indices which is what we care\n # ## about, because the y values correspond to time.\n # attr_inds[param] = [('value', inds[0])]\n\n new_robot_pose = self.r.pose[:, time] + orth\n new_held_pose = self.held.pose[:, time] + orth\n # add_to_attr_inds_and_res(time, attr_inds, res, self.r, [('pose', new_robot_pose)])\n # add_to_attr_inds_and_res(time, attr_inds, res, self.held, [('pose', new_held_pose)])\n st = max(max(time - 3, 0), act.active_timesteps[0])\n et = min(min(time + 3, plan.horizon - 1), act.active_timesteps[1])\n for i in range(st, et):\n dist = float(np.abs(i - time))\n if i <= time:\n inter_rp = (dist / 3.0) * self.r.pose[:, st] + ((3.0 - dist) / 3.0) * (\n self.r.pose[:, st] + orth\n )\n inter_hp = (dist / 3.0) * self.held.pose[:, st] + (\n (3.0 - dist) / 3.0\n ) * (self.held.pose[:, st] + orth)\n else:\n inter_rp = (dist / 3.0) * self.r.pose[:, et] + ((3.0 - dist) / 3.0) * (\n self.r.pose[:, et] + orth\n )\n inter_hp = (dist / 3.0) * self.held.pose[:, et] + (\n (3.0 - dist) / 3.0\n ) * (self.held.pose[:, et] + orth)\n\n add_to_attr_inds_and_res(i, attr_inds, res, self.r, [(\"pose\", inter_rp)])\n add_to_attr_inds_and_res(i, attr_inds, res, self.held, [(\"pose\", inter_rp)])\n return res, attr_inds\n\n def get_expr(self, negated):\n if negated:\n return self.neg_expr\n else:\n return None\n\n def distance_from_obj(self, x, n_steps=0):\n # x = [rpx, rpy, obstrx, obstry, heldx, heldy]\n b0 = self._param_to_body[self.r]\n b1 = self._param_to_body[self.obstr]\n\n pose_r = x[0:2]\n pose_obstr = x[2:4]\n\n b0.set_pose(pose_r)\n b1.set_pose(pose_obstr)\n\n collisions1 = p.getClosestPoints(b0.body_id, b1.body_id, contact_dist)\n col_val1, jac01 = self._calc_grad_and_val(\n self.r.name, self.obstr.name, pose_r, pose_obstr, collisions1\n )\n\n if self.obstr.name == self.held.name:\n ## add dsafe to col_val1 b/c we're allowed to touch, but not intersect\n ## 1e-3 is there because the collision checker's value has some error.\n col_val1 -= self.dsafe + 1e-3\n val = np.array(col_val1)\n jac = jac01\n\n else:\n b2 = self._param_to_body[self.held]\n pose_held = x[4:6]\n b2.set_pose(pose_held)\n\n collisions2 = p.getClosestPoints(b2.body_id, b1.body_id, contact_dist)\n\n col_val2, jac21 = self._calc_grad_and_val(\n self.held.name, self.obstr.name, pose_held, pose_obstr, collisions2\n )\n\n if col_val1 > col_val2:\n val = np.array(col_val1)\n jac = np.c_[jac01, np.zeros((1, 2))].reshape((1, 6))\n else:\n val = np.array(col_val2)\n jac = np.c_[np.zeros((1, 2)), jac21[:, 2:], jac21[:, :2]].reshape(\n (1, 6)\n )\n\n return val, jac\n\n\nclass WideObstructsHolding(ObstructsHolding):\n def __init__(self, name, params, expected_param_types, env=None, debug=False):\n super(WideObstructsHolding, self).__init__(\n name, params, expected_param_types, env, debug\n )\n self.dsafe = 0.2\n\n\nclass InGripper(ExprPredicate):\n\n # InGripper, Robot, Can, Grasp\n\n def __init__(self, name, params, expected_param_types, env=None, debug=False):\n self.r, self.can, self.grasp = params\n attr_inds = OrderedDict(\n [\n (self.r, [(\"pose\", np.array([0, 1], dtype=np.int))]),\n (self.can, [(\"pose\", np.array([0, 1], dtype=np.int))]),\n (self.grasp, [(\"value\", np.array([0, 1], dtype=np.int))]),\n ]\n )\n # want x0 - x2 = x4, x1 - x3 = x5\n A = 1e1 * np.array([[1, 0, -1, 0, -1, 0], [0, 1, 0, -1, 0, -1]])\n b = np.zeros((2, 1))\n\n e = AffExpr(A, b)\n e = EqExpr(e, np.zeros((2, 1)))\n\n super(InGripper, self).__init__(\n name, e, attr_inds, params, expected_param_types, priority=-2\n )\n\n\nclass Retreat(ExprPredicate):\n def __init__(self, name, params, expected_param_types, env=None, debug=False):\n self.r, self.can, self.grasp = params\n attr_inds = OrderedDict(\n [\n (self.r, [(\"pose\", np.array([0, 1], dtype=np.int))]),\n (self.grasp, [(\"value\", np.array([0, 1], dtype=np.int))]),\n ]\n )\n # want x0 - x2 = x4, x1 - x3 = x5\n A = 1e1 * np.array([[1, 0, 0.5, 0, -1, 0, 0, 0], [0, 1, 0, 0.5, 0, -1, 0, 0]])\n b = np.zeros((2, 1))\n\n e = AffExpr(A, b)\n e = EqExpr(e, np.zeros((2, 1)))\n\n super(Retreat, self).__init__(\n name,\n e,\n attr_inds,\n params,\n expected_param_types,\n priority=-2,\n active_range=(0, 1),\n )\n\n\nclass GraspValid(ExprPredicate):\n\n # GraspValid RobotPose Target Grasp\n\n def __init__(self, name, params, expected_param_types, env=None, debug=False):\n self.rp, self.target, self.grasp = params\n attr_inds = OrderedDict(\n [\n (self.rp, [(\"value\", np.array([0, 1], dtype=np.int))]),\n (self.target, [(\"value\", np.array([0, 1], dtype=np.int))]),\n (self.grasp, [(\"value\", np.array([0, 1], dtype=np.int))]),\n ]\n )\n # want x0 - x2 = x4, x1 - x3 = x5\n A = np.array([[1, 0, -1, 0, -1, 0], [0, 1, 0, -1, 0, -1]])\n b = np.zeros((2, 1))\n\n e = AffExpr(A, b)\n e = EqExpr(e, np.zeros((2, 1)))\n\n super(GraspValid, self).__init__(\n name, e, attr_inds, params, expected_param_types, priority=0\n )\n\n\nclass RobotStationary(ExprPredicate):\n\n # Stationary, Can\n\n def __init__(self, name, params, expected_param_types, env=None, debug=False):\n (self.c,) = params\n attr_inds = OrderedDict([(self.c, [(\"pose\", np.array([0, 1], dtype=np.int))])])\n A = np.array([[1, 0, -1, 0], [0, 1, 0, -1]])\n b = np.zeros((2, 1))\n e = EqExpr(AffExpr(A, b), np.zeros((2, 1)))\n super(RobotStationary, self).__init__(\n name,\n e,\n attr_inds,\n params,\n expected_param_types,\n active_range=(0, 1),\n priority=-2,\n )\n\n\nclass RobotRetreat(ExprPredicate):\n\n # Stationary, Can\n\n def __init__(self, name, params, expected_param_types, env=None, debug=False):\n self.c, self.g = params\n attr_inds = OrderedDict(\n [\n (self.c, [(\"pose\", np.array([0, 1], dtype=np.int))]),\n (self.g, [(\"value\", np.array([0, 1], dtype=np.int))]),\n ]\n )\n A = np.array([[1, 0, 1, 0, -1, 0, 0, 0], [0, 1, 0, 1, 0, -1, 0, 0]])\n b = np.zeros((2, 1))\n e = EqExpr(AffExpr(A, b), np.zeros((2, 1)))\n super(RobotRetreat, self).__init__(\n name,\n e,\n attr_inds,\n params,\n expected_param_types,\n active_range=(0, 1),\n priority=-2,\n )\n\n\nclass Stationary(ExprPredicate):\n\n # Stationary, Can\n\n def __init__(self, name, params, expected_param_types, env=None, debug=False):\n (self.c,) = params\n attr_inds = OrderedDict([(self.c, [(\"pose\", np.array([0, 1], dtype=np.int))])])\n A = np.array([[1, 0, -1, 0], [0, 1, 0, -1]])\n b = np.zeros((2, 1))\n e = EqExpr(AffExpr(A, b), np.zeros((2, 1)))\n super(Stationary, self).__init__(\n name,\n e,\n attr_inds,\n params,\n expected_param_types,\n active_range=(0, 1),\n priority=-2,\n )\n\n\nclass StationaryNEq(ExprPredicate):\n\n # StationaryNEq, Can, Can\n # Assuming robot only holding one object,\n # it checks whether the can in the first argument is stationary\n # if that first can is not the second can which robot is holding\n\n def __init__(self, name, params, expected_param_types, env=None, debug=False):\n self.c, self.c_held = params\n attr_inds = OrderedDict([(self.c, [(\"pose\", np.array([0, 1], dtype=np.int))])])\n if self.c.name == self.c_held.name:\n A = np.zeros((1, 4))\n b = np.zeros((1, 1))\n else:\n A = np.array([[1, 0, -1, 0], [0, 1, 0, -1]])\n b = np.zeros((2, 1))\n e = EqExpr(AffExpr(A, b), b)\n super(StationaryNEq, self).__init__(\n name,\n e,\n attr_inds,\n params,\n expected_param_types,\n active_range=(0, 1),\n priority=-2,\n )\n\n\nclass StationaryW(ExprPredicate):\n\n # StationaryW, Wall(Obstacle)\n\n def __init__(self, name, params, expected_param_types, env=None, debug=False):\n (self.w,) = params\n attr_inds = OrderedDict([(self.w, [(\"pose\", np.array([0, 1], dtype=np.int))])])\n A = np.array([[1, 0, -1, 0], [0, 1, 0, -1]])\n b = np.zeros((2, 1))\n e = EqExpr(AffExpr(A, b), b)\n super(StationaryW, self).__init__(\n name,\n e,\n attr_inds,\n params,\n expected_param_types,\n active_range=(0, 1),\n priority=-2,\n )\n\n\nclass IsMP(ExprPredicate):\n\n # IsMP Robot\n\n def __init__(\n self, name, params, expected_param_types, env=None, debug=False, dmove=dmove\n ):\n (self.r,) = params\n ## constraints |x_t - x_{t+1}| < dmove\n ## ==> x_t - x_{t+1} < dmove, -x_t + x_{t+a} < dmove\n attr_inds = OrderedDict([(self.r, [(\"pose\", np.array([0, 1], dtype=np.int))])])\n A = np.array([[1, 0, -1, 0], [0, 1, 0, -1], [-1, 0, 1, 0], [0, -1, 0, 1]])\n b = np.zeros((4, 1))\n e = LEqExpr(AffExpr(A, b), dmove * np.ones((4, 1)))\n super(IsMP, self).__init__(\n name,\n e,\n attr_inds,\n params,\n expected_param_types,\n active_range=(0, 1),\n priority=-2,\n )\n\n\nclass VelWithinBounds(At):\n\n # RobotAt Robot Can\n\n def __init__(self, name, params, expected_param_types, env=None):\n ## At Robot RobotPose\n self.r, self.c = params\n attr_inds = OrderedDict([(self.r, [(\"vel\", np.array([0, 1], dtype=np.int))])])\n\n A = np.c_[np.eye(2), -np.eye(2)]\n b = np.zeros((4, 1))\n val = dmove * np.ones((4, 1))\n aff_e = AffExpr(A, b)\n e = LEqExpr(aff_e, val)\n super(At, self).__init__(name, e, attr_inds, params, expected_param_types)\n\n\nclass AccWithinBounds(At):\n\n # RobotAt Robot Can\n\n def __init__(self, name, params, expected_param_types, env=None):\n ## At Robot RobotPose\n self.r, self.c = params\n attr_inds = OrderedDict([(self.r, [(\"acc\", np.array([0, 1], dtype=np.int))])])\n\n A = np.c_[np.eye(2), -np.eye(2)]\n b = np.zeros((4, 1))\n val = 2.5e1 * np.ones((4, 1))\n aff_e = AffExpr(A, b)\n e = LEqExpr(aff_e, val)\n super(At, self).__init__(name, e, attr_inds, params, expected_param_types)\n\n\nclass VelValid(ExprPredicate):\n\n # VelValid Robot\n\n def __init__(\n self, name, params, expected_param_types, env=None, debug=False, dmove=dmove\n ):\n (self.r,) = params\n ## constraints |x_t - x_{t+1}| < dmove\n ## ==> x_t - x_{t+1} < dmove, -x_t + x_{t+a} < dmove\n attr_inds = OrderedDict(\n [\n (\n self.r,\n [\n (\"pose\", np.array([0, 1], dtype=np.int)),\n (\"vel\", np.array([0, 1], dtype=np.int)),\n ],\n ),\n ]\n )\n A = np.array(\n [\n [-1, 0, 1, 0, 1, 0, 0, 0],\n [0, -1, 0, 1, 0, 1, 0, 0],\n ]\n )\n b = np.zeros((4, 1))\n\n e = LEqExpr(AffExpr(A, b), dmove * np.ones((4, 1)))\n super(VelValid, self).__init__(\n name,\n e,\n attr_inds,\n params,\n expected_param_types,\n active_range=(0, 1),\n priority=-2,\n )\n\n\nclass Decelerating(ExprPredicate):\n def __init__(\n self, name, params, expected_param_types, env=None, debug=False, dmove=dmove\n ):\n (self.r,) = params\n ## constraints |x_t - x_{t+1}| < dmove\n ## ==> x_t - x_{t+1} < dmove, -x_t + x_{t+a} < dmove\n attr_inds = OrderedDict(\n [\n (self.r, [(\"vel\", np.array([0, 1], dtype=np.int))]),\n ]\n )\n A = np.array(\n [\n [-1, 0, 1, 0],\n [0, -1, 0, 1],\n ]\n )\n b = np.zeros((4, 1))\n\n e = LEqExpr(AffExpr(A, b), b.copy())\n super(VelValid, self).__init__(\n name,\n e,\n attr_inds,\n params,\n expected_param_types,\n active_range=(0, 1),\n priority=-2,\n )\n\n\nclass Accelerating(ExprPredicate):\n def __init__(\n self, name, params, expected_param_types, env=None, debug=False, dmove=dmove\n ):\n (self.r,) = params\n ## constraints |x_t - x_{t+1}| < dmove\n ## ==> x_t - x_{t+1} < dmove, -x_t + x_{t+a} < dmove\n attr_inds = OrderedDict(\n [\n (self.r, [(\"vel\", np.array([0, 1], dtype=np.int))]),\n ]\n )\n A = np.array(\n [\n [1, 0, -1, 0],\n [0, 1, 0, -1],\n ]\n )\n b = np.zeros((4, 1))\n\n e = LEqExpr(AffExpr(A, b), b.copy())\n super(VelValid, self).__init__(\n name,\n e,\n attr_inds,\n params,\n expected_param_types,\n active_range=(0, 1),\n priority=-2,\n )\n\n\nclass VelValid(ExprPredicate):\n\n # VelValid Robot\n\n def __init__(\n self, name, params, expected_param_types, env=None, debug=False, dmove=dmove\n ):\n (self.r,) = params\n ## constraints |x_t - x_{t+1}| < dmove\n ## ==> x_t - x_{t+1} < dmove, -x_t + x_{t+a} < dmove\n attr_inds = OrderedDict(\n [\n (\n self.r,\n [\n (\"pose\", np.array([0, 1], dtype=np.int)),\n (\"vel\", np.array([0, 1], dtype=np.int)),\n ],\n ),\n ]\n )\n A = np.array(\n [\n [-1, 0, 1, 0, 1, 0, 0, 0],\n [0, -1, 0, 1, 0, 1, 0, 0],\n ]\n )\n b = np.zeros((4, 1))\n\n e = LEqExpr(AffExpr(A, b), dmove * np.ones((4, 1)))\n super(VelValid, self).__init__(\n name,\n e,\n attr_inds,\n params,\n expected_param_types,\n active_range=(0, 1),\n priority=-2,\n )\n\n\nclass AccValid(VelValid):\n\n # AccValid Robot\n\n def __init__(\n self, name, params, expected_param_types, env=None, debug=False, dmove=dmove\n ):\n super(AccValid, self).__init__(\n name, params, expected_param_types, env, debug, dmove\n )\n self.attr_inds = OrderedDict(\n [\n (\n self.r,\n [\n (\"vel\", np.array([0, 1], dtype=np.int)),\n (\"acc\", np.array([0, 1], dtype=np.int)),\n ],\n ),\n ]\n )\n",
"\"\"\"\nDefines utility functions for planning in the sorting domain\n\"\"\"\nimport copy\nfrom collections import OrderedDict\nimport itertools\nimport numpy as np\nimport random\nimport time\n\nfrom core.internal_repr.plan import Plan\nfrom core.util_classes.namo_predicates import dsafe, GRIP_VAL\nfrom core.util_classes.openrave_body import *\nfrom pma.hl_solver import FFSolver\nfrom opentamp.src.policy_hooks.utils.load_task_definitions import get_tasks, plan_from_str\nfrom opentamp.src.policy_hooks.utils.policy_solver_utils import *\nimport policy_hooks.utils.policy_solver_utils as utils\n\nNO_COL = True\nNUM_OBJS = 4\nNUM_TARGS = 4\nSORT_CLOSET = False\nUSE_PERTURB = False\nOPT_MCTS_FEEDBACK = True\nN_GRASPS = 4\nFIX_TARGETS = False\n\nCONST_TARGETS = False\nCONST_ORDER = False\n\n# domain_file = \"../domains/namo_domain/new_namo.domain\"\ndomain_file = \"../domains/namo_domain/nopose.domain\"\nmapping_file = \"policy_hooks/namo/sorting_task_mapping_8\"\npddl_file = \"../domains/namo_domain/sorting_domain_3.pddl\"\n\ndescriptor = 'namo_{0}_obj_sort_closet_{1}_perturb_{2}_feedback_to_tree_{3}'.format(NUM_OBJS, SORT_CLOSET, USE_PERTURB, OPT_MCTS_FEEDBACK)\n\n# END_TARGETS = [(0., 5.8),\n# (0., 5.),\n# (0., 4.),\n# (2., -2.),\n# (0., -2.),\n# (4., 0.),\n# (-4, 0.),\n# (4., -2.),\n# (-4., -2.),\n# (-2., -2.)]\n\nEND_TARGETS =[(0., 5.8), (0., 5.), (0., 4.)] if SORT_CLOSET else []\nEND_TARGETS.extend([(7., 0.),\n (-7., 0.),\n (2.5, 0.),\n (-2.5, 0.),\n (2.5, -6.5),\n (-2.5, -6.5),\n (7., -6.5),\n (-7., -6.5),\n ])\n\nn_aux = 4\npossible_can_locs = [(0, 57), (0, 50), (0, 43), (0, 35)] if SORT_CLOSET else []\nMAX_Y = 25\n# possible_can_locs.extend(list(itertools.product(range(-45, 45, 2), range(-35, MAX_Y, 2))))\n\n# possible_can_locs.extend(list(itertools.product(range(-50, 50, 4), range(-50, -10, 2))))\n#possible_can_locs.extend(list(itertools.product(range(-50, 50, 4), range(-40, 0, 2))))\n#possible_can_locs.extend(list(itertools.product(list(range(-70, 70, 2)), list(range(-60, 10, 2)))))\n# possible_can_locs.extend(list(itertools.product(range(-50, 50, 4), range(6, 25, 4))))\npossible_can_locs.extend(list(itertools.product(list(range(-55, -40, 2)), list(range(10, 22, 2)))))\npossible_can_locs.extend(list(itertools.product(list(range(-55, -40, 2)), list(range(-40, -15, 2)))))\npossible_can_locs.extend(list(itertools.product(list(range(-10, 10, 2)), list(range(10, 22, 2)))))\npossible_can_locs.extend(list(itertools.product(list(range(-10, 10, 2)), list(range(-40, -15, 2)))))\npossible_can_locs.extend(list(itertools.product(list(range(40, 55, 2)), list(range(10, 20, 2)))))\npossible_can_locs.extend(list(itertools.product(list(range(-40, 55, 2)), list(range(-40, -15, 2)))))\n\n\nfor i in range(len(possible_can_locs)):\n loc = list(possible_can_locs[i])\n loc[0] *= 0.1\n loc[1] *= 0.1\n possible_can_locs[i] = tuple(loc)\n\n\ndef prob_file(descr=None):\n if descr is None:\n descr = 'sort_closet_prob_{0}_{1}end_{2}_{3}aux'.format(NUM_OBJS, len(END_TARGETS), n_aux, N_GRASPS)\n return \"../domains/namo_domain/namo_probs/{0}.prob\".format(descr)\n\n\ndef get_prim_choices(task_list=None):\n out = OrderedDict({})\n if task_list is None:\n out[utils.TASK_ENUM] = sorted(list(get_tasks(mapping_file).keys()))\n else:\n out[utils.TASK_ENUM] = sorted(task_list)\n out[utils.OBJ_ENUM] = ['can{0}'.format(i) for i in range(NUM_OBJS)]\n out[utils.TARG_ENUM] = []\n for i in range(n_aux):\n out[utils.TARG_ENUM] += ['aux_target_{0}'.format(i)]\n if FIX_TARGETS:\n for i in range(len(END_TARGETS)):\n out[utils.TARG_ENUM] += ['end_target_{0}'.format(i)]\n else:\n out[utils.TARG_ENUM] += ['can{0}_end_target'.format(i) for i in range(NUM_OBJS)]\n out[utils.GRASP_ENUM] = ['grasp{0}'.format(i) for i in range(N_GRASPS)]\n return out\n\n\ndef get_vector(config):\n state_vector_include = {\n 'pr2': ['pose', 'gripper'] ,\n }\n for i in range(config['num_objs']):\n state_vector_include['can{0}'.format(i)] = ['pose']\n\n action_vector_include = {\n 'pr2': ['pose', 'gripper']\n }\n\n target_vector_include = {\n 'can{0}_end_target'.format(i): ['value'] for i in range(config['num_objs'])\n }\n for i in range(n_aux):\n target_vector_include['aux_target_{0}'.format(i)] = ['value']\n if FIX_TARGETS:\n for i in range(len(END_TARGETS)):\n target_vector_include['end_target_{0}'.format(i)] = ['value']\n\n\n return state_vector_include, action_vector_include, target_vector_include\n\n\ndef get_random_initial_state_vec(config, plans, dX, state_inds, conditions):\n# Information is track by the environment\n x0s = []\n targ_maps = []\n for i in range(conditions):\n x0 = np.zeros((dX,))\n\n # x0[state_inds['pr2', 'pose']] = np.random.uniform([-3, -4], [3, -2]) # [0, -2]\n # x0[state_inds['pr2', 'pose']] = np.random.uniform([-3, -1], [3, 1])\n can_locs = copy.deepcopy(possible_can_locs)\n # can_locs = copy.deepcopy(END_TARGETS)\n locs = []\n pr2_loc = None\n spacing = 2.5\n valid = [1 for _ in range(len(can_locs))]\n while len(locs) < config['num_objs'] + 1:\n locs = []\n random.shuffle(can_locs)\n pr2_loc = can_locs[0]\n locs.append(pr2_loc)\n valid = [1 for _ in range(len(can_locs))]\n valid[0] = 0\n for m in range(1, len(can_locs)):\n if np.linalg.norm(np.array(pr2_loc) - np.array(can_locs[m])) < spacing:\n valid[m] = 0\n for j in range(config['num_objs']):\n for n in range(1, len(can_locs)):\n if valid[n]:\n locs.append(can_locs[n])\n valid[n] = 0\n for m in range(n+1, len(can_locs)):\n if not valid[m]: continue\n if np.linalg.norm(np.array(can_locs[n]) - np.array(can_locs[m])) < spacing:\n valid[m] = 0\n break\n spacing -= 0.1\n\n spacing = 2.5\n targs = []\n can_targs = [can_locs[i] for i in range(len(can_locs)) if (valid[i] or not NO_COL)]\n old_valid = copy.copy(valid)\n while not FIX_TARGETS and len(targs) < config['num_targs']:\n targs = []\n pr2_loc = locs[0]\n random.shuffle(can_targs)\n valid = [1 for _ in range(len(can_targs))]\n for m in range(0, len(can_targs)):\n if np.linalg.norm(np.array(pr2_loc) - np.array(can_targs[m])) < spacing:\n valid[m] = 0\n for j in range(config['num_targs']):\n for n in range(0, len(can_targs)):\n if valid[n]:\n targs.append(can_targs[n])\n valid[n] = 0\n for m in range(n+1, len(can_targs)):\n if not valid[m]: continue\n if np.linalg.norm(np.array(can_targs[n]) - np.array(can_targs[m])) < spacing:\n valid[m] = 0\n break\n\n spacing -= 0.1\n\n for l in range(len(locs)):\n locs[l] = np.array(locs[l])\n x0[state_inds['pr2', 'pose']] = locs[0]\n for o in range(config['num_objs']):\n x0[state_inds['can{0}'.format(o), 'pose']] = locs[o+1]\n x0[state_inds['pr2', 'gripper']] = -1.\n x0s.append(x0)\n if FIX_TARGETS:\n targ_range = list(range(config['num_objs'] - config['num_targs']))\n inds = list(range(len(EMD_TARGETS))) if CONST_TARGETS else np.random.permutation(list(range(len(END_TARGETS))))\n next_map = {'can{0}_end_target'.format(no): END_TARGETS[o] for no, o in enumerate(inds[:config['num_objs']])}\n inplace = targ_range if CONST_ORDER else np.random.choice(list(range(config['num_objs'])), len(targ_range), replace=False)\n for n in targ_range:\n x0[state_inds['can{0}'.format(inplace[n]), 'pose']] = END_TARGETS[inds[inplace[n]]]\n next_map.update({'end_target_{0}'.format(i): END_TARGETS[i] for i in range(len(END_TARGETS))})\n else:\n inds = np.random.permutation(list(range(config['num_objs'])))\n next_map = {'can{0}_end_target'.format(o): targs[no] for no, o in enumerate(inds[:config['num_targs']])}\n if config['num_targs'] < config['num_objs']:\n next_map.update({'can{0}_end_target'.format(o): locs[o+1] for o in inds[config['num_targs']:config['num_objs']]})\n for a in range(n_aux):\n if a == 0:\n next_map['aux_target_{0}'.format(a)] = (0, 0)\n elif a % 2:\n next_map['aux_target_{0}'.format(a)] = (-int(a/2.+0.5), 0)\n else:\n next_map['aux_target_{0}'.format(a)] = (int(a/2.+0.5), 0)\n targ_maps.append(next_map)\n return x0s, targ_maps\n\ndef parse_hl_plan(hl_plan):\n plan = []\n for i in range(len(hl_plan)):\n action = hl_plan[i]\n act_params = action.split()\n task = act_params[1].lower()\n next_params = [p.lower() for p in act_params[2:]]\n plan.append((task, next_params))\n return plan\n\ndef get_plans(use_tf=False):\n tasks = get_tasks(mapping_file)\n task_ids = sorted(list(tasks.keys()))\n prim_options = get_prim_choices()\n plans = {}\n openrave_bodies = {}\n env = None\n params = None\n sess = None\n for task in tasks:\n next_task_str = copy.deepcopy(tasks[task])\n for i in range(len(prim_options[utils.OBJ_ENUM])):\n for j in range(len(prim_options[utils.TARG_ENUM])):\n for k in range(len(prim_options[utils.GRASP_ENUM])):\n obj = prim_options[utils.OBJ_ENUM][i]\n targ = prim_options[utils.TARG_ENUM][j]\n grasp = prim_options[utils.GRASP_ENUM][k]\n new_task_str = []\n for step in next_task_str:\n new_task_str.append(step.format(obj, targ, grasp))\n plan = plan_from_str(new_task_str, prob_file(), domain_file, env, openrave_bodies, params=params, sess=sess, use_tf=use_tf)\n plan.params['pr2'].gripper[0,0] = -GRIP_VAL\n params = plan.params\n plans[(task_ids.index(task), i, j, k)] = plan\n if env is None:\n env = plan.env\n for param in list(plan.params.values()):\n if hasattr(param, 'geom'):\n if not hasattr(param, 'openrave_body') or param.openrave_body is None:\n param.openrave_body = OpenRAVEBody(env, param.name, param.geom)\n openrave_bodies[param.name] = param.openrave_body\n sess = plan.sess\n\n return plans, openrave_bodies, env\n\ndef get_end_targets(num_cans=NUM_OBJS, num_targs=NUM_OBJS, targs=None, randomize=False, possible_locs=END_TARGETS):\n raise Exception('Bad method call')\n target_map = {}\n inds = list(range(NUM_TARGS)) # np.random.permutation(range(num_targs))\n for n in range(num_cans):\n if n > num_targs and targs is not None:\n target_map['can{0}_end_target'.format(n)] = np.array(targs[n])\n else:\n if randomize:\n ind = inds[n]\n else:\n ind = n\n\n target_map['can{0}_end_target'.format(n)] = np.array(possible_locs[ind])\n\n if SORT_CLOSET:\n target_map['middle_target'] = np.array([0., 0.])\n target_map['left_target_1'] = np.array([-1., 0.])\n target_map['right_target_1'] = np.array([1., 0.])\n # target_map['left_target_2'] = np.array([-2., 0.])\n # target_map['right_target_2'] = np.array([2., 0.])\n return target_map\n\n\ndef setup(hyperparams):\n wall_dims = OpenRAVEBody.get_wall_dims('closet')\n config = {\n 'obs_include': ['overhead_camera'],\n 'include_files': [],\n 'include_items': [\n {'name': 'pr2', 'type': 'cylinder', 'is_fixed': False, 'pos': (0, 0, 0.5), 'dimensions': (0.6, 1.), 'rgba': (1, 1, 1, 1)},\n ],\n 'view': False,\n 'image_dimensions': (hyperparams['image_width'], hyperparams['image_height'])\n }\n\n self.main_camera_id = 0\n colors = [[1, 0, 0, 1], [0, 1, 0, 1], [0, 0, 1, 1], [1, 1, 0, 1], [1, 0, 1, 1], [0.5, 0.75, 0.25, 1], [0.75, 0.5, 0, 1], [0.25, 0.25, 0.5, 1], [0.5, 0, 0.25, 1], [0, 0.5, 0.75, 1], [0, 0, 0.5, 1]]\n\n items = config['include_items']\n prim_options = get_prim_choices()\n for name in prim_options[OBJ_ENUM]:\n if name =='pr2': continue\n cur_color = colors.pop(0)\n items.append({'name': name, 'type': 'cylinder', 'is_fixed': False, 'pos': (0, 0, 0.5), 'dimensions': (0.4, 1.), 'rgba': tuple(cur_color)})\n # items.append({'name': '{0}_end_target'.format(name), 'type': 'cylinder', 'is_fixed': False, 'pos': (10, 10, 0.5), 'dimensions': (0.8, 0.2), 'rgba': tuple(cur_color)})\n for i in range(len(wall_dims)):\n dim, next_trans = wall_dims[i]\n next_trans[0,3] -= 3.5\n next_dim = dim # [dim[1], dim[0], dim[2]]\n pos = next_trans[:3,3] # [next_trans[1,3], next_trans[0,3], next_trans[2,3]]\n items.append({'name': 'wall{0}'.format(i), 'type': 'box', 'is_fixed': True, 'pos': pos, 'dimensions': next_dim, 'rgba': (0.2, 0.2, 0.2, 1)})\n\n generate_xml(BASE_XML, ENV_XML, include_files=config['include_files'], include_items=config['include_items'])\n\n\n\n\n\n\n\n\n\n\n\n# CODE FROM OLDER VERSION OF PROB FILE BELOW THIS\n\n\n\ndef get_sorting_problem(can_locs, targets, pr2, grasp, failed_preds=[]):\n hl_plan_str = \"(define (problem sorting_problem)\\n\"\n hl_plan_str += \"(:domain sorting_domain)\\n\"\n\n hl_plan_str += \"(:objects\"\n for can in can_locs:\n hl_plan_str += \" {0} - Can\".format(can)\n\n for target in targets:\n hl_plan_str += \" {0} - Target\".format(target)\n\n hl_plan_str += \")\\n\"\n\n hl_plan_str += parse_initial_state(can_locs, targets, pr2, grasp, failed_preds)\n\n goal_state = {}\n goal_str = \"(:goal (and\"\n for i in range(len(can_locs)):\n goal_str += \" (CanAtTarget can{0} can{1}_end_target)\".format(i, i)\n goal_state[\"(CanAtTarget can{0} can{1}_end_target)\".format(i, i)] = True\n\n goal_str += \"))\\n\"\n\n hl_plan_str += goal_str\n\n hl_plan_str += \"\\n)\"\n return hl_plan_str, goal_state\n\ndef parse_initial_state(can_locs, targets, pr2, grasp, failed_preds=[]):\n hl_init_state = \"(:init \"\n for can1 in can_locs:\n loc1 = can_locs[can1]\n t1 = targets[can1+'_end_target']\n if loc1[1] < 3.5: continue\n for can2 in can_locs:\n if can2 == can1: continue\n loc2 = can_locs[can2]\n t2 = targets[can2+'_end_target']\n if loc2[1] < 3.5: continue\n if loc1[1] < loc2[1]:\n hl_init_state += \" (CanObstructs {0} {1})\".format(can1, can2)\n hl_init_state += \" (WaitingOnCan {0} {1})\".format(can2, can1)\n else:\n hl_init_state += \" (CanObstructs {0} {1})\".format(can2, can1)\n hl_init_state += \" (WaitingOnCan {0} {1})\".format(can1, can2)\n\n for t1 in targets:\n loc1 = targets[t1]\n if loc1[1] < 3.5 or np.abs(loc1[0]) > 0.5: continue\n for t2 in targets:\n if t1 == t2: continue\n loc2 = targets[t2]\n if loc2[1] < 3.5 or np.abs(loc2[0]) > 0.5: continue\n if loc2[1] > loc1[1]:\n hl_init_state += \" (InFront {0} {1})\".format(t1, t2)\n\n\n\n for can in can_locs:\n loc = can_locs[can]\n\n hl_init_state += \" (CanInReach {0})\".format(can)\n\n closest_target = None\n closest_dist = np.inf\n for target in targets:\n if targets[target][1] > 3.5 \\\n and np.abs(targets[target][0]) < 0.5 \\\n and loc[1] > 3.5 \\\n and loc[1] < targets[target][1] \\\n and np.abs(loc[0]) < 0.5 \\\n and target[3] != can[3]:\n hl_init_state += \" (CanObstructsTarget {0} {1})\".format(can, target)\n\n dist = np.sum((targets[target] - loc)**2)\n if dist < closest_dist:\n closest_dist = dist\n closest_target = target\n\n if closest_dist < 0.001:\n hl_init_state += \" (CanAtTarget {0} {1})\".format(can, closest_target)\n\n if np.all(np.abs(loc - pr2 + grasp) < 0.2):\n hl_init_state += \" (CanInGripper {0})\".format(can)\n\n if np.all(np.abs(loc - pr2 + grasp) < 1.0):\n hl_init_state += \" (NearCan {0})\".format(can)\n\n # Only mark the closest obstruction; it needs to be cleared first.\n for pred in failed_preds:\n if pred[0].get_type().lower() == 'obstructs':\n if \" (CanObstructsTarget {0} {1})\".format(pred[0].c.name, pred[2].name) not in hl_init_state:\n if pred[0].c.name != pred[1].name:\n hl_init_state += \" (CanObstructs {0} {1})\".format(pred[0].c.name, pred[1].name)\n hl_init_state += \" (CanObstructsTarget {0} {1})\".format(pred[0].c.name, pred[2].name)\n break\n\n if pred[0].get_type().lower() == 'obstructsholding':\n if \" (CanObstructsTarget {0} {1})\".format(pred[0].obstr.name, pred[2].name) not in hl_init_state:\n if pred[0].obstr.name != pred[1].name:\n hl_init_state += \" (CanObstructs {0} {1})\".format(pred[0].obstr.name, pred[1].name)\n hl_init_state += \" (CanObstructsTarget {0} {1})\".format(pred[0].obstr.name, pred[2].name)\n break\n\n\n hl_init_state += \")\\n\"\n # print hl_init_state\n return hl_init_state\n\ndef get_hl_plan(prob, plan_id):\n with open(pddl_file, 'r+') as f:\n domain = f.read()\n hl_solver = FFSolver(abs_domain=domain)\n return hl_solver._run_planner(domain, prob, 'namo_{0}'.format(plan_id))\n\ndef parse_hl_plan(hl_plan):\n plan = []\n for i in range(len(hl_plan)):\n action = hl_plan[i]\n act_params = action.split()\n task = act_params[1].lower()\n next_params = [p.lower() for p in act_params[2:]]\n plan.append((task, next_params))\n return plan\n\ndef hl_plan_for_state(state, targets, plan_id, param_map, state_inds, failed_preds=[]):\n can_locs = {}\n\n for param_name in param_map:\n param = param_map[param_name]\n if param_map[param_name]._type == 'Can':\n can_locs[param.name] = state[state_inds[param.name, 'pose']]\n\n prob, goal = get_sorting_problem(can_locs, targets, state[state_inds['pr2', 'pose']], param_map['grasp0'].value[:,0], failed_preds)\n hl_plan = get_hl_plan(prob, plan_id)\n if hl_plan == Plan.IMPOSSIBLE:\n # print 'Impossible HL plan for {0}'.format(prob)\n return []\n return parse_hl_plan(hl_plan)\n\ndef get_ll_plan_str(hl_plan, num_cans):\n tasks = get_tasks(mapping_file)\n ll_plan_str = []\n actions_per_task = []\n last_pose = \"ROBOT_INIT_POSE\"\n region_targets = {}\n for i in range(len(hl_plan)):\n action = hl_plan[i]\n act_params = action.split()\n next_task_str = copy.deepcopy(tasks[act_params[1].lower()])\n can = act_params[2].lower()\n if len(act_params) > 3:\n target = act_params[3].upper()\n else:\n target = \"CAN{}_INIT_TARGET\".format(can[-1])\n\n for j in range(len(next_task_str)):\n next_task_str[j]= next_task_str[j].format(can, target)\n ll_plan_str.extend(next_task_str)\n actions_per_task.append((len(next_task_str), act_params[1].lower()))\n return ll_plan_str, actions_per_task\n\ndef get_plan(num_cans):\n cans = [\"Can{0}\".format(i) for i in range(num_cans)]\n can_locs = get_random_initial_can_locations(num_cans)\n end_targets = get_can_end_targets(num_cans)\n prob, goal_state = get_sorting_problem(can_locs, end_targets)\n hl_plan = get_hl_plan(prob)\n ll_plan_str, actions_per_task = get_ll_plan_str(hl_plan, num_cans)\n plan = plan_from_str(ll_plan_str, prob_file().format(num_cans), domain_file, None, {})\n for i in range(len(can_locs)):\n plan.params['can{0}'.format(i)].pose[:,0] = can_locs[i]\n plan.params['can{0}_init_target'.format(i)].value[:,0] = plan.params['can{0}'.format(i)].pose[:,0]\n plan.params['can{0}_end_target'.format(i)].value[:, 0] = end_targets[i]\n\n task_timesteps = []\n cur_act = 0\n for i in range(len(hl_plan)):\n num_actions = actions_per_task[i][0]\n final_t = plan.actions[cur_act+num_actions-1].active_timesteps[1]\n task_timesteps.append((final_t, actions_per_task[i][1]))\n cur_act += num_actions\n\n plan.task_breaks = task_timesteps\n return plan, task_timesteps, goal_state\n\n\ndef fill_random_initial_configuration(plan):\n for param in plan.params:\n if plan.params[param]._Type == \"Can\":\n next_pos = random.choice(possible_can_locs)\n plan.params[param].pose[:,0] = next_pos\n\ndef get_random_initial_can_locations(num_cans):\n locs = []\n stop = False\n while not len(locs):\n locs = []\n for _ in range(num_cans):\n next_loc = random.choice(possible_can_locs)\n start = time.time()\n while len(locs) and np.any(np.abs(np.array(locs)[:,:2]-next_loc[:2]) < 0.6):\n next_loc = random.choice(possible_can_locs)\n if time.time() - start > 10:\n locs = []\n start = time.time()\n stop = True\n break\n\n if stop: break\n locs.append(next_loc)\n\n def compare_locs(a, b):\n if b[0] > a[0]: return 1\n if b[0] < a[0]: return -1\n if b[1] > a[1]: return 1\n if b[1] < a[1]: return -1\n return 0\n\n # locs.sort(compare_locs)\n\n return locs\n\ndef sorting_state_encode(state, plan, targets, task=(None, None, None)):\n pred_list = []\n for param_name in plan.params:\n param = plan.params[param_name]\n if param._type == 'Can':\n for target_name in targets:\n pred_list.append('CanAtTarget {0} {1}'.format(param_name, target_name))\n\n state_encoding = dict(list(zip(pred_list, list(range(len(pred_list))))))\n hl_state = np.zeros((len(pred_list)))\n for param_name in plan.params:\n if plan.params[param_name]._type != 'Can': continue\n for target_name in targets:\n if np.all(np.abs(state[plan.state_inds[param_name, 'pose']] - targets[target_name]) < 0.1):\n hl_state[state_encoding['CanAtTarget {0} {1}'.format(param_name, target_name)]] = 1\n\n if task[0] is not None:\n for target_name in targets:\n hl_state[state_encoding['CanAtTarget {0} {1}'.format(task[1], target_name)]] = 0\n hl_state[state_encoding['CanAtTarget {0} {1}'.format(task[1], task[2])]] = 1\n\n return tuple(hl_state)\n\ndef get_plan_for_task(task, targets, num_cans, env, openrave_bodies):\n tasks = get_tasks(mapping_file)\n next_task_str = copy.deepcopy(tasks[task])\n for j in range(len(next_task_str)):\n next_task_str[j]= next_task_str[j].format(*targets)\n\n return plan_from_str(next_task_str, prob_file().format(num_cans), domain_file, env, openrave_bodies)\n"
] |
[
[
"numpy.array",
"numpy.matrix",
"numpy.dot",
"numpy.isnan",
"numpy.eye",
"numpy.ndarray",
"numpy.sqrt"
],
[
"numpy.concatenate",
"numpy.random.normal",
"numpy.array",
"numpy.linalg.norm",
"numpy.random.choice",
"numpy.random.rand",
"numpy.zeros",
"numpy.round",
"numpy.sum",
"numpy.ones",
"numpy.mean",
"numpy.eye",
"numpy.where",
"numpy.allclose",
"numpy.random.uniform",
"numpy.abs",
"numpy.all"
],
[
"numpy.sum",
"numpy.array",
"numpy.abs",
"numpy.zeros"
]
] |
jedgedrudd/PyBaMM
|
[
"79c9d34978382d50e09adaf8bf74c8fa4723f759"
] |
[
"pybamm/spatial_methods/spatial_method.py"
] |
[
"#\n# A general spatial method class\n#\nimport pybamm\nimport numpy as np\nfrom scipy.sparse import eye, kron, coo_matrix, csr_matrix\n\n\nclass SpatialMethod:\n \"\"\"\n A general spatial methods class, with default (trivial) behaviour for some spatial\n operations.\n All spatial methods will follow the general form of SpatialMethod in\n that they contain a method for broadcasting variables onto a mesh,\n a gradient operator, and a diverence operator.\n\n Parameters\n ----------\n mesh : :class: `pybamm.Mesh`\n Contains all the submeshes for discretisation\n \"\"\"\n\n def __init__(self, mesh):\n # add npts_for_broadcast to mesh domains for this particular discretisation\n for dom in mesh.keys():\n for i in range(len(mesh[dom])):\n mesh[dom][i].npts_for_broadcast = mesh[dom][i].npts\n self._mesh = mesh\n\n @property\n def mesh(self):\n return self._mesh\n\n def spatial_variable(self, symbol):\n \"\"\"\n Convert a :class:`pybamm.SpatialVariable` node to a linear algebra object that\n can be evaluated (here, a :class:`pybamm.Vector` on either the nodes or the\n edges).\n\n Parameters\n -----------\n symbol : :class:`pybamm.SpatialVariable`\n The spatial variable to be discretised.\n\n Returns\n -------\n :class:`pybamm.Vector`\n Contains the discretised spatial variable\n \"\"\"\n symbol_mesh = self.mesh.combine_submeshes(*symbol.domain)\n if symbol.name.endswith(\"_edge\"):\n return pybamm.Vector(symbol_mesh[0].edges, domain=symbol.domain)\n else:\n return pybamm.Vector(symbol_mesh[0].nodes, domain=symbol.domain)\n\n def broadcast(self, symbol, domain, auxiliary_domains, broadcast_type):\n \"\"\"\n Broadcast symbol to a specified domain.\n\n Parameters\n ----------\n symbol : :class:`pybamm.Symbol`\n The symbol to be broadcasted\n domain : iterable of strings\n The domain to broadcast to\n broadcast_type : str\n The type of broadcast, either: 'primary' or 'full'\n\n Returns\n -------\n broadcasted_symbol: class: `pybamm.Symbol`\n The discretised symbol of the correct size for the spatial method\n \"\"\"\n\n primary_pts_for_broadcast = sum(\n self.mesh[dom][0].npts_for_broadcast for dom in domain\n )\n\n full_pts_for_broadcast = sum(\n subdom.npts_for_broadcast for dom in domain for subdom in self.mesh[dom]\n )\n\n if broadcast_type == \"primary\":\n out = pybamm.Outer(\n symbol, pybamm.Vector(np.ones(primary_pts_for_broadcast), domain=domain)\n )\n out.auxiliary_domains = auxiliary_domains\n\n elif broadcast_type == \"full\":\n out = symbol * pybamm.Vector(np.ones(full_pts_for_broadcast), domain=domain)\n\n return out\n\n def gradient(self, symbol, discretised_symbol, boundary_conditions):\n \"\"\"\n Implements the gradient for a spatial method.\n\n Parameters\n ----------\n symbol: :class:`pybamm.Symbol`\n The symbol that we will take the gradient of.\n discretised_symbol: :class:`pybamm.Symbol`\n The discretised symbol of the correct size\n\n boundary_conditions : dict\n The boundary conditions of the model\n ({symbol.id: {\"left\": left bc, \"right\": right bc}})\n\n Returns\n -------\n :class: `pybamm.Array`\n Contains the result of acting the discretised gradient on\n the child discretised_symbol\n \"\"\"\n raise NotImplementedError\n\n def divergence(self, symbol, discretised_symbol, boundary_conditions):\n \"\"\"\n Implements the divergence for a spatial method.\n\n Parameters\n ----------\n symbol: :class:`pybamm.Symbol`\n The symbol that we will take the gradient of.\n discretised_symbol: :class:`pybamm.Symbol`\n The discretised symbol of the correct size\n boundary_conditions : dict\n The boundary conditions of the model\n ({symbol.id: {\"left\": left bc, \"right\": right bc}})\n\n Returns\n -------\n :class: `pybamm.Array`\n Contains the result of acting the discretised divergence on\n the child discretised_symbol\n \"\"\"\n raise NotImplementedError\n\n def laplacian(self, symbol, discretised_symbol, boundary_conditions):\n \"\"\"\n Implements the laplacian for a spatial method.\n\n Parameters\n ----------\n symbol: :class:`pybamm.Symbol`\n The symbol that we will take the gradient of.\n discretised_symbol: :class:`pybamm.Symbol`\n The discretised symbol of the correct size\n boundary_conditions : dict\n The boundary conditions of the model\n ({symbol.id: {\"left\": left bc, \"right\": right bc}})\n\n Returns\n -------\n :class: `pybamm.Array`\n Contains the result of acting the discretised laplacian on\n the child discretised_symbol\n \"\"\"\n raise NotImplementedError\n\n def gradient_squared(self, symbol, discretised_symbol, boundary_conditions):\n \"\"\"\n Implements the inner product of the gradient with itself for a spatial method.\n\n Parameters\n ----------\n symbol: :class:`pybamm.Symbol`\n The symbol that we will take the gradient of.\n discretised_symbol: :class:`pybamm.Symbol`\n The discretised symbol of the correct size\n\n boundary_conditions : dict\n The boundary conditions of the model\n ({symbol.id: {\"left\": left bc, \"right\": right bc}})\n\n Returns\n -------\n :class: `pybamm.Array`\n Contains the result of taking the inner product of the result of acting\n the discretised gradient on the child discretised_symbol with itself\n \"\"\"\n raise NotImplementedError\n\n def integral(self, child, discretised_child):\n \"\"\"\n Implements the integral for a spatial method.\n\n Parameters\n ----------\n child: :class:`pybamm.Symbol`\n The symbol to which is being integrated\n discretised_child: :class:`pybamm.Symbol`\n The discretised symbol of the correct size\n\n Returns\n -------\n :class: `pybamm.Array`\n Contains the result of acting the discretised integral on\n the child discretised_symbol\n \"\"\"\n raise NotImplementedError\n\n def indefinite_integral(self, child, discretised_child):\n \"\"\"\n Implements the indefinite integral for a spatial method.\n\n Parameters\n ----------\n child: :class:`pybamm.Symbol`\n The symbol to which is being integrated\n discretised_child: :class:`pybamm.Symbol`\n The discretised symbol of the correct size\n\n Returns\n -------\n :class: `pybamm.Array`\n Contains the result of acting the discretised indefinite integral on\n the child discretised_symbol\n \"\"\"\n raise NotImplementedError\n\n def boundary_integral(self, child, discretised_child, region):\n \"\"\"\n Implements the boundary integral for a spatial method.\n\n Parameters\n ----------\n child: :class:`pybamm.Symbol`\n The symbol to which is being integrated\n discretised_child: :class:`pybamm.Symbol`\n The discretised symbol of the correct size\n region: str\n The region of the boundary over which to integrate. If region is None\n (default) the integration is carried out over the entire boundary. If\n region is `negative tab` or `positive tab` then the integration is only\n carried out over the appropriate part of the boundary corresponding to\n the tab.\n\n Returns\n -------\n :class: `pybamm.Array`\n Contains the result of acting the discretised boundary integral on\n the child discretised_symbol\n \"\"\"\n raise NotImplementedError\n\n def delta_function(self, symbol, discretised_symbol):\n \"\"\"\n Implements the delta function on the approriate side for a spatial method.\n\n Parameters\n ----------\n symbol: :class:`pybamm.Symbol`\n The symbol to which is being integrated\n discretised_symbol: :class:`pybamm.Symbol`\n The discretised symbol of the correct size\n \"\"\"\n raise NotImplementedError\n\n def internal_neumann_condition(\n self, left_symbol_disc, right_symbol_disc, left_mesh, right_mesh\n ):\n \"\"\"\n A method to find the internal neumann conditions between two symbols\n on adjacent subdomains.\n\n Parameters\n ----------\n left_symbol_disc : :class:`pybamm.Symbol`\n The discretised symbol on the left subdomain\n right_symbol_disc : :class:`pybamm.Symbol`\n The discretised symbol on the right subdomain\n left_mesh : list\n The mesh on the left subdomain\n right_mesh : list\n The mesh on the right subdomain\n \"\"\"\n\n raise NotImplementedError\n\n def boundary_value_or_flux(self, symbol, discretised_child):\n \"\"\"\n Returns the boundary value or flux using the approriate expression for the\n spatial method. To do this, we create a sparse vector 'bv_vector' that extracts\n either the first (for side=\"left\") or last (for side=\"right\") point from\n 'discretised_child'.\n\n Parameters\n -----------\n symbol: :class:`pybamm.Symbol`\n The boundary value or flux symbol\n discretised_child : :class:`pybamm.StateVector`\n The discretised variable from which to calculate the boundary value\n\n Returns\n -------\n :class:`pybamm.MatrixMultiplication`\n The variable representing the surface value.\n \"\"\"\n if any(len(self.mesh[dom]) > 1 for dom in discretised_child.domain):\n raise NotImplementedError(\"Cannot process 2D symbol in base spatial method\")\n if isinstance(symbol, pybamm.BoundaryGradient):\n raise TypeError(\"Cannot process BoundaryGradient in base spatial method\")\n n = sum(self.mesh[dom][0].npts for dom in discretised_child.domain)\n if symbol.side == \"left\":\n # coo_matrix takes inputs (data, (row, col)) and puts data[i] at the point\n # (row[i], col[i]) for each index of data. Here we just want a single point\n # with value 1 at (0,0).\n # Convert to a csr_matrix to allow indexing and other functionality\n left_vector = csr_matrix(coo_matrix(([1], ([0], [0])), shape=(1, n)))\n bv_vector = pybamm.Matrix(left_vector)\n elif symbol.side == \"right\":\n # as above, but now we want a single point with value 1 at (0, n-1)\n right_vector = csr_matrix(coo_matrix(([1], ([0], [n - 1])), shape=(1, n)))\n bv_vector = pybamm.Matrix(right_vector)\n\n out = bv_vector @ discretised_child\n # boundary value removes domain\n out.domain = []\n return out\n\n def mass_matrix(self, symbol, boundary_conditions):\n \"\"\"\n Calculates the mass matrix for a spatial method.\n\n Parameters\n ----------\n symbol: :class:`pybamm.Variable`\n The variable corresponding to the equation for which we are\n calculating the mass matrix.\n boundary_conditions : dict\n The boundary conditions of the model\n ({symbol.id: {\"left\": left bc, \"right\": right bc}})\n\n Returns\n -------\n :class:`pybamm.Matrix`\n The (sparse) mass matrix for the spatial method.\n \"\"\"\n # NOTE: for different spatial methods the matrix may need to be adjusted\n # to account for Dirichlet boundary conditions. Here, we just have the default\n # behaviour that the mass matrix is the identity.\n\n # Create appropriate submesh by combining submeshes in domain\n submesh = self.mesh.combine_submeshes(*symbol.domain)\n\n # Get number of points in primary dimension\n n = submesh[0].npts\n\n # Create mass matrix for primary dimension\n prim_mass = eye(n)\n\n # Get number of points in secondary dimension\n sec_pts = len(submesh)\n\n # Convert to csr_matrix as required by some solvers\n mass = csr_matrix(kron(eye(sec_pts), prim_mass))\n return pybamm.Matrix(mass)\n\n def process_binary_operators(self, bin_op, left, right, disc_left, disc_right):\n \"\"\"Discretise binary operators in model equations. Default behaviour is to\n return a new binary operator with the discretised children.\n\n Parameters\n ----------\n bin_op : :class:`pybamm.BinaryOperator`\n Binary operator to discretise\n left : :class:`pybamm.Symbol`\n The left child of `bin_op`\n right : :class:`pybamm.Symbol`\n The right child of `bin_op`\n disc_left : :class:`pybamm.Symbol`\n The discretised left child of `bin_op`\n disc_right : :class:`pybamm.Symbol`\n The discretised right child of `bin_op`\n\n Returns\n -------\n :class:`pybamm.BinaryOperator`\n Discretised binary operator\n\n \"\"\"\n return bin_op.__class__(disc_left, disc_right)\n\n def concatenation(self, disc_children):\n \"\"\"Discrete concatenation object.\n\n Parameters\n ----------\n disc_children : list\n List of discretised children\n\n Returns\n -------\n :class:`pybamm.DomainConcatenation`\n Concatenation of the discretised children\n \"\"\"\n return pybamm.DomainConcatenation(disc_children, self.mesh)\n"
] |
[
[
"scipy.sparse.coo_matrix",
"numpy.ones",
"scipy.sparse.eye"
]
] |
aragilar/astroML
|
[
"d3f6279eb632957662338761cb559a1dcd541fb0",
"d3f6279eb632957662338761cb559a1dcd541fb0"
] |
[
"astroML/density_estimation/tests/test_empirical.py",
"astroML_fig_tests/test.py"
] |
[
"import numpy as np\nfrom numpy.testing import assert_allclose\nfrom scipy.stats import norm\nfrom astroML.density_estimation import\\\n EmpiricalDistribution, FunctionDistribution\n\n\ndef test_empirical_distribution(N=1000, rseed=0):\n np.random.seed(rseed)\n X = norm.rvs(0, 1, size=N)\n dist = EmpiricalDistribution(X)\n X2 = dist.rvs(N)\n\n meanX = X.mean()\n meanX2 = X2.mean()\n\n stdX = X.std()\n stdX2 = X2.std()\n\n assert_allclose([meanX, stdX], [meanX2, stdX2], atol=3 / np.sqrt(N))\n\n\ndef test_function_distribution(N=1000, rseed=0):\n f = norm(0, 1).pdf\n # go from -10 to 10 to check interpolation in presence of zeros\n dist = FunctionDistribution(f, -10, 10)\n\n np.random.seed(rseed)\n X = dist.rvs(N)\n\n meanX = X.mean()\n stdX = X.std()\n\n assert_allclose([meanX, stdX], [0, 1], atol=3 / np.sqrt(N))\n",
"import os\nimport fnmatch\nfrom contextlib import contextmanager\nfrom nose import SkipTest\n\nimport matplotlib\nfrom matplotlib import colors\nmatplotlib.use('Agg')\n\n# set some font properties\nmatplotlib.rc('text', usetex=True)\nmatplotlib.rc('font', family='serif', style='normal', variant='normal',\n stretch='normal', weight='normal',)\n\nimport matplotlib.pyplot as plt\nfrom matplotlib.testing.compare import compare_images\nfrom matplotlib.testing.noseclasses import ImageComparisonFailure\n\n\nKNOWN_FAILURES = [\n\n # System-dependent benchmark stuff\n 'book_figures/chapter2/fig_sort_scaling.py',\n 'book_figures/chapter2/fig_search_scaling.py',\n\n # MCMC (why doesn't random seed work???\n 'book_figures/chapter5/fig_cauchy_mcmc.py',\n 'book_figures/chapter5/fig_signal_background.py',\n 'book_figures/chapter5/fig_model_comparison_mcmc.py',\n 'book_figures/chapter5/fig_gaussgauss_mcmc.py',\n 'book_figures/chapter8/fig_outlier_rejection.py',\n 'book_figures/chapter10/fig_arrival_time.py',\n 'book_figures/chapter10/fig_matchedfilt_burst.py',\n 'book_figures/chapter10/fig_matchedfilt_chirp.py',\n 'book_figures/chapter10/fig_matchedfilt_chirp2.py',\n]\n\n\n@contextmanager\ndef set_cwd(directory):\n cwd = os.getcwd()\n if directory: os.chdir(directory)\n yield\n os.chdir(cwd) \n\n\ndef check_figure(filename, tol=1E-3):\n \"\"\"\n Compare the given filename to the baseline\n \"\"\"\n file_fmt = os.path.splitext(filename)[0] + \"_{0}.png\"\n\n dirname, fname = os.path.split(filename)\n\n baseline = os.path.abspath(os.path.join(os.path.dirname(__file__),\n 'baseline', file_fmt))\n result = os.path.abspath(os.path.join(os.path.dirname(__file__),\n 'results', file_fmt))\n\n resultdir = os.path.dirname(result)\n if not os.path.exists(resultdir):\n os.makedirs(resultdir)\n\n plt.close('all')\n\n with set_cwd(dirname):\n with open(fname) as f:\n code = compile(f.read(), \"somefile.py\", 'exec')\n exec(code, {'pl' : plt, 'plt' : plt, 'pylab' : plt})\n\n for fignum in plt.get_fignums():\n fig = plt.figure(fignum)\n\n if colors.colorConverter.to_rgb(fig.get_facecolor()) == (0, 0, 0):\n fig.savefig(result.format(fignum), facecolor='k', edgecolor='none')\n else:\n fig.savefig(result.format(fignum))\n\n err = compare_images(baseline.format(fignum),\n result.format(fignum),\n tol)\n if err:\n if filename in KNOWN_FAILURES:\n raise SkipTest(\"known errors in {0}\".format(filename))\n else:\n raise ImageComparisonFailure(err)\n\n\ndef test_book_figures(tol=0.1):\n cwd = os.getcwd()\n\n for chapter in os.listdir('book_figures'):\n if not os.path.isdir(os.path.join(cwd, 'book_figures', chapter)):\n continue\n for filename in os.listdir(os.path.join(cwd, 'book_figures', chapter)):\n if not fnmatch.fnmatch(filename, \"fig_*.py\"):\n continue\n os.chdir(cwd)\n filename = os.path.join('book_figures', chapter, filename)\n yield check_figure, filename, tol\n"
] |
[
[
"numpy.random.seed",
"scipy.stats.norm.rvs",
"scipy.stats.norm",
"numpy.sqrt"
],
[
"matplotlib.use",
"matplotlib.pyplot.close",
"matplotlib.pyplot.figure",
"matplotlib.rc",
"matplotlib.pyplot.get_fignums",
"matplotlib.testing.noseclasses.ImageComparisonFailure"
]
] |
SuzukiDaichi-git/ai_edge_contest
|
[
"9fc62503dc755da33d7ffa6f85862964dba1c8d5"
] |
[
"train/eval.py"
] |
[
"#!/usr/bin/env python3\n# encoding: utf-8\nimport os\nimport cv2\ncv2.setNumThreads(0)\nimport numpy as np\n\nfrom utils.visualize import print_iou, show_img, show_prediction\nfrom engine.evaluator import Evaluator\nfrom engine.logger import get_logger\nfrom seg_opr.metric import hist_info, compute_score\n\nlogger = get_logger()\n\n\nclass SegEvaluator(Evaluator):\n def func_per_iteration(self, data, device, iter=None):\n if self.config is not None: config = self.config\n img = data['data']\n label = data['label']\n name = data['fn']\n\n if len(config.eval_scale_array) == 1:\n pred = self.whole_eval(img, None, device)\n else:\n pred = self.sliding_eval(img, config.eval_crop_size, config.eval_stride_rate, device)\n hist_tmp, labeled_tmp, correct_tmp = hist_info(config.num_classes, pred, label)\n results_dict = {'hist': hist_tmp, 'labeled': labeled_tmp, 'correct': correct_tmp}\n\n if self.save_path is not None:\n fn = name + '.png'\n cv2.imwrite(os.path.join(self.save_path, fn), pred)\n logger.info('Save the image ' + fn)\n \n # tensorboard logger does not fit multiprocess\n if self.logger is not None and iter is not None:\n colors = self.dataset.get_class_colors()\n image = img\n clean = np.zeros(label.shape)\n comp_img = show_img(colors, config.background, image, clean, label, pred)\n self.logger.add_image('vis', np.swapaxes(np.swapaxes(comp_img, 0, 2), 1, 2), iter)\n \n print(\"self.show_prediction = \", self.show_prediction)\n if self.show_image or self.show_prediction:\n colors = self.dataset.get_class_colors()\n image = img\n clean = np.zeros(label.shape)\n if self.show_image:\n comp_img = show_img(colors, config.background, image, clean, label, pred)\n else:\n comp_img = show_prediction(colors, config.background, image, pred)\n cv2.imwrite(os.path.join(os.path.realpath('.'), self.config.save, \"eval\", name+\".vis.png\"), comp_img[:,:,::-1])\n # cv2.imwrite(name + \".png\", comp_img[:,:,::-1])\n\n return results_dict\n \n def compute_metric(self, results):\n hist = np.zeros((self.config.num_classes, self.config.num_classes))\n correct = 0\n labeled = 0\n count = 0\n for d in results:\n hist += d['hist']\n correct += d['correct']\n labeled += d['labeled']\n count += 1\n\n iu, mean_IU, mean_IU_no_back, mean_pixel_acc = compute_score(hist, correct, labeled)\n result_line = print_iou(iu, mean_pixel_acc, self.dataset.get_class_names(), True)\n return result_line, mean_IU\n"
] |
[
[
"numpy.swapaxes",
"numpy.zeros"
]
] |
meyerd/brewPipe
|
[
"48f20ccd3ac7cefb899164407de3cd61ce17000a"
] |
[
"brewPipe/preprocess/numpy_null.py"
] |
[
"#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\nimport os\nimport numpy as np\nfrom ..pipelineState import PipelineStateInterface\nfrom ..data import BrewPipeDataFrame\n\n__author__ = 'Dominik Meyer <meyerd@mytum.de>'\n\n\nclass NumpyNullPreprocessor(PipelineStateInterface):\n \"\"\"\n This is an example class of preprocessor, that\n takes numpy data from the data loader and outputs\n numpy data again. Basically, it does nothing, and is\n just a testcase to get some interface definitions going.\n \"\"\"\n\n def __init__(self, intermediate_directory=\"intermediates\"):\n \"\"\"\n :param intermediate_directory: Directory, where the\n intermediate pandas dataframe should be persisted\n to.\n \"\"\"\n super(NumpyNullPreprocessor, self).__init__()\n\n self._intermediate_directory = intermediate_directory\n self._cached = False\n self._cached_object = None\n\n def _persist_numpy(self, arr, name):\n filename = os.path.join(self._intermediate_directory,\n 'NumpyNullPreprocessor' + name)\n with open(filename, 'w') as f:\n np.save(f, arr)\n return filename\n\n def _load_numpy(self, name):\n filename = os.path.join(self._intermediate_directory,\n 'NumpyNullPreprocessor' + name)\n with open(filename, 'r') as f:\n arr = np.load(f)\n return arr\n\n def preprocess(self, dataframe):\n def cb(name):\n obj = self\n inp = dataframe\n h = obj.get(inp.name)\n tmp = None\n if not h or h != inp.hash:\n org = inp.data\n # preprocessing would happen here and be put to tmp\n tmp = org\n h = inp.hash\n obj._persist_numpy(tmp, inp.name)\n obj.put(inp.name, h)\n else:\n if self._cached and self._cached == inp.hash:\n return self._cached_object\n tmp = obj._load_numpy(inp.name)\n self._cached_object = tmp\n self._cached = inp.hash\n return tmp\n\n h = 0\n if not self.get(dataframe.name) is None:\n h = self.get(dataframe.name)\n r = BrewPipeDataFrame(dataframe.name, lazy_frame=True, hash=h, callback=cb)\n return r\n\n\n"
] |
[
[
"numpy.load",
"numpy.save"
]
] |
pcuenca/Real-ESRGAN
|
[
"9ff1944d06e9d7fe86c68bbf1a244cff403f064e"
] |
[
"tests/test_utils.py"
] |
[
"import numpy as np\nfrom basicsr.archs.rrdbnet_arch import RRDBNet\n\nfrom realesrgan.utils import RealESRGANer\n\n\ndef test_realesrganer():\n # initialize with default model\n restorer = RealESRGANer(\n scale=4,\n model_path='experiments/pretrained_models/RealESRGAN_x4plus.pth',\n model=None,\n tile=10,\n tile_pad=10,\n pre_pad=2,\n half=False)\n assert isinstance(restorer.model, RRDBNet)\n assert restorer.half is False\n # initialize with user-defined model\n model = RRDBNet(num_in_ch=3, num_out_ch=3, num_feat=64, num_block=6, num_grow_ch=32, scale=4)\n restorer = RealESRGANer(\n scale=4,\n model_path='experiments/pretrained_models/RealESRGAN_x4plus_anime_6B.pth',\n model=model,\n tile=10,\n tile_pad=10,\n pre_pad=2,\n half=True)\n # test attribute\n assert isinstance(restorer.model, RRDBNet)\n assert restorer.half is True\n\n # ------------------ test pre_process ---------------- #\n img = np.random.random((12, 12, 3)).astype(np.float32)\n restorer.pre_process(img)\n assert restorer.img.shape == (1, 3, 14, 14)\n # with modcrop\n restorer.scale = 1\n restorer.pre_process(img)\n assert restorer.img.shape == (1, 3, 16, 16)\n\n # ------------------ test process ---------------- #\n restorer.process()\n assert restorer.output.shape == (1, 3, 64, 64)\n\n # ------------------ test post_process ---------------- #\n restorer.mod_scale = 4\n output = restorer.post_process()\n assert output.shape == (1, 3, 60, 60)\n\n # ------------------ test tile_process ---------------- #\n restorer.scale = 4\n img = np.random.random((12, 12, 3)).astype(np.float32)\n restorer.pre_process(img)\n restorer.tile_process()\n assert restorer.output.shape == (1, 3, 64, 64)\n\n # ------------------ test enhance ---------------- #\n img = np.random.random((12, 12, 3)).astype(np.float32)\n result = restorer.enhance(img, outscale=2)\n assert result[0].shape == (24, 24, 3)\n assert result[1] == 'RGB'\n\n # ------------------ test enhance with 16-bit image---------------- #\n img = np.random.random((4, 4, 3)).astype(np.uint16) + 512\n result = restorer.enhance(img, outscale=2)\n assert result[0].shape == (8, 8, 3)\n assert result[1] == 'RGB'\n\n # ------------------ test enhance with gray image---------------- #\n img = np.random.random((4, 4)).astype(np.float32)\n result = restorer.enhance(img, outscale=2)\n assert result[0].shape == (8, 8)\n assert result[1] == 'L'\n\n # ------------------ test enhance with RGBA---------------- #\n img = np.random.random((4, 4, 4)).astype(np.float32)\n result = restorer.enhance(img, outscale=2)\n assert result[0].shape == (8, 8, 4)\n assert result[1] == 'RGBA'\n\n # ------------------ test enhance with RGBA, alpha_upsampler---------------- #\n restorer.tile_size = 0\n img = np.random.random((4, 4, 4)).astype(np.float32)\n result = restorer.enhance(img, outscale=2, alpha_upsampler=None)\n assert result[0].shape == (8, 8, 4)\n assert result[1] == 'RGBA'\n"
] |
[
[
"numpy.random.random"
]
] |
AmineAitLemqeddem/sdia-python
|
[
"1990e6244b25a2204684e3498110cf54fa829a3e"
] |
[
"src/lab2/box_window.py"
] |
[
"import numpy as np\n\nfrom lab2.utils import get_random_number_generator\n\n\n# todo clean up the docstrings\nclass BoxWindow:\n \"\"\"[summary]BoxWindow class representing a virtual n-dimensional bounded Box\"\"\"\n\n def __init__(self, args):\n \"\"\"[summary]Initialization of Box's parameters\n\n Args:\n args ([numpy array list]): [this argument represents the bounds of the box]\n \"\"\"\n self.bounds = args\n\n def __str__(self):\n \"\"\"[summary] BoxWindow: :math:`[a_1, b_1] \\times [a_2, b_2] \\times \\cdots`\n\n Returns:\n [str]: [description of the Box's bounds]\n \"\"\"\n\n shape = (self.bounds).shape\n representation = \"BoxWindow: \"\n # * consider for a, b in self.bounds\n # ! use f-strings\n for i in range(shape[0] - 1): # ? why not self.dimension()\n representation = (\n representation\n + \"[\"\n + str((self.bounds)[i][0])\n + \", \"\n + str((self.bounds)[i][1])\n + \"]\"\n + \" x \"\n )\n\n representation = (\n representation\n + \"[\"\n + str((self.bounds)[shape[0] - 1][0])\n + \", \"\n + str((self.bounds)[shape[0] - 1][1])\n + \"]\"\n )\n\n return representation\n\n def __len__(self):\n \"\"\"[summary]\n\n Returns:\n [int: [the dimension of the box]\n \"\"\"\n return ((self.bounds).shape)[0] # * no need to use ()\n\n def __contains__(self, args):\n \"\"\"[summary]This method tests if an element (args) is inside the box\n\n Args:\n args ([numpy array list]): [the element to test]\n\n Returns:\n [bool]: [True if the element is inside the box , False if not]\n \"\"\"\n # * consider for (a, b), x in zip(self.bounds, point)\n # * or exploit numpy vectorization power\n flag = True\n for i in range(self.__len__()): # ? use len(self) of self.dimension\n if args[i] >= self.bounds[i][0] and args[i] <= self.bounds[i][1]:\n flag = True\n else:\n return False\n\n return flag # ? flag is never modified and always returns True\n\n # todo write tests\n def dimension(self):\n \"\"\"[summary]\n This method is similar to the method __len__ described above\n \"\"\"\n return self.__len__() # ? why not using use len(self)\n\n # todo write tests\n def volume(self):\n \"\"\"[summary]\n This method calculates the volume of the Box\n \"\"\"\n v = 1\n # * exploit numpy vectors, use - or np.diff, and np.prod\n for i in range(self.dimension()):\n # * use *= operator\n v = v * abs((self.bounds[i][1] - self.bounds[i][0]))\n\n return v\n\n def indicator_function(self, args):\n \"\"\"[summary]\n This method is similar to the method __contains__ described above\n\n Args:\n args ([numpy array list]): [the element to test]\n\n Returns:\n [bool]: [True if the element is inside the box , False if not]\n \"\"\"\n # ? isn't it equivalent to return args in self\n if self.__contains__(args):\n return True\n else:\n return False\n\n def center(self):\n \"\"\"[summary] determinate the center of the box\n\n Returns:\n [numpy array list]: [the center of the box]\n \"\"\"\n # * Nice try!\n # ? how about np.mean(self.bounds)\n c = np.zeros(self.__len__())\n for i in range(self.__len__()):\n c[i] = np.mean(self.bounds[i])\n return c\n\n def rand(self, n=1, rng=None):\n \"\"\"[summary]\n Generate ``n`` points uniformly at random inside the :py:class:`BoxWindow`.\n\n Args:\n n (int, optional): [description]. Defaults to 1.\n rng ([type], optional): [description]. Defaults to None.\n\n Returns:\n Randomly n elements that belong to the box\n \"\"\"\n rng = get_random_number_generator(rng)\n # ? readability why not using self.dimension()\n L = np.ones((n, self.__len__())) # liste des points\n # * exploit numpy, rng.uniform(a, b, size=n)\n for i in range(n):\n for j in range(self.__len__()):\n x = rng.random()\n\n L[i][j] = (1 - x) * self.bounds[j][0] + x * self.bounds[j][1]\n\n return L\n\n\nclass UnitBoxWindow(BoxWindow):\n def __init__(self, center, dimension):\n \"\"\"[summary]a subclass of BoxWindow,represents the notion of \"unit square box\"\n\n Args:\n dimension ([int]): [dimension of the Unit Box]\n center ([numpy array list], optional): [center of the Box].\n \"\"\"\n # * exploit numpy vectors, use - or np.diff, and +\n self.bounds = np.array(\n [[center[i] - 0.5, center[i] + 0.5] for i in range(dimension)]\n )\n super().__init__(self.bounds) # * Nice call to super\n\n\n# todo write tests\nclass BallWindow:\n \"\"\"[summary]BoxWindow class representing a virtual n-dimensional bounded Box\"\"\"\n\n def __init__(self, center, radius, dimension):\n \"\"\"[summary]Initialization of Box's parameters\n\n Args:\n args ([numpy array list]): [this argument represents the bounds of the box]\n \"\"\"\n self.dim = dimension\n self.rad = radius\n self.cent = center\n\n def __contains__(self, args):\n \"\"\"[summary]This method tests if an element (args) is inside the ball\n\n Args:\n args ([numpy array list]): [the element to test]\n\n Returns:\n [bool]: [True if the element is inside the ball , False if not]\n \"\"\"\n # * same remarks as in BoxWindow.__contains__\n flag = True\n if len(args) != self.dim:\n return False\n else:\n if np.linalg.norm(args - self.center) <= self.rad:\n flag = True\n\n return flag\n\n def dimension(self):\n \"\"\"[summary]\n This method gives the dimension of the ball\n \"\"\"\n return self.dim\n\n def volume(self):\n r\"\"\"[summary]\n This method calculates the volume of the Ball using the formula :math:` V_{n+1} =\\int_{-r}^{r}V_{n}(\\sqrt{r^2 -x^2})dx`\n \"\"\"\n # * iteresting recursive try\n # todo test the method\n # * exploit numpy vectors, use - or np.diff, and np.prod\n v = 1\n for i in range(self.dimension()):\n integ = lambda x: v * np.sqrt(self.rad ** 2 - x ** 2)\n v = integrate.quad(integ, -self.rad, self.rad) # ! integrate is not defined\n\n return v\n\n def indicator_function(self, args):\n \"\"\"[summary]\n This method is similar to the method __contains__ described above\n\n Args:\n args ([numpy array list]): [the element to test]\n\n Returns:\n [bool]: [True if the element is inside the ball , False if not]\n \"\"\"\n # ? isn't it equivalent to return args in self\n if self.__contains__(args):\n return True\n else:\n return False\n\n def center(self):\n \"\"\"[summary] determinate the center of the ball\n\n Returns:\n [numpy array list]: [the center of the ball]\n \"\"\"\n # * interesting try\n # * exploit numpy vectorization power\n # ? how about np.mean(self.bounds)\n c = np.zeros(self.__len__())\n for i in range(self.__len__()):\n c[i] = np.mean(self.bounds[i])\n return c\n"
] |
[
[
"numpy.linalg.norm",
"numpy.sqrt",
"numpy.mean"
]
] |
anton-pershin/restools
|
[
"eb141f0989617db796d106de1b0824161ccaa0aa"
] |
[
"papers/jfm2022_optimizing_control_bayesian_method/views/sketches.py"
] |
[
"import os\nimport sys\nsys.path.append(os.getcwd())\n\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom scipy.stats import beta\n\nfrom restools.plotting import rasterise_and_save\nfrom papers.jfm2020_probabilistic_protocol.data import Summary as SummaryProbProto\nfrom papers.jfm2020_probabilistic_protocol.extensions import LaminarisationProbabilityFittingFunction2020JFM\nfrom comsdk.comaux import load_from_json\n\n\ndef plot_pretty_tick(ax, val, on_x=False, on_y=False):\n if on_x:\n ax.plot([val, val], [0.0, 0.025], 'k-', linewidth=2)\n if on_y:\n ax.plot([-0.002, -0.0018], [val, val], 'k-', linewidth=2)\n\n\ndef plot_pretty_annotation_on_axis(ax, val, up_lim, text='', on_x=False, on_y=False, shift=None):\n if on_x:\n ax.plot([val, val], [0.04, up_lim], 'k--', linewidth=1)\n shift = 0.0002 if shift is None else shift\n ax.text(val + shift, 0.03, text, fontsize=14)\n if on_y:\n ax.plot([-0.0016, up_lim], [val, val], 'k--', linewidth=1)\n shift = -0.05 if shift is None else shift\n ax.text(-0.0017, val + shift, text, fontsize=14)\n plot_pretty_tick(ax, val, on_x=on_x, on_y=on_y)\n\n\ndef plot_posterior_distribution(ax, N_lam, N_turb, obj_to_rasterize, simplified=False):\n a = N_lam + 1./2\n b = N_turb + 1./2\n ax.plot(x, beta.pdf(x, a, b), label=r'$N = ' + str(N_lam + N_turb) + '$\\n$l = ' + str(N_lam) + r'$',\n linewidth=4 if simplified else 2)\n ax.plot([beta.mean(a, b)], [beta.pdf(beta.mean(a, b), a, b)], 'ro',\n markersize=12 if simplified else 8)\n _, y_max = ax.get_ylim()\n ax.set_xticks([0.0, 0.2, 0.4, 0.6, 0.8, 1.0])\n if simplified:\n ax.set_xticklabels([])\n ax.set_yticklabels([])\n else:\n obj = ax.fill_between([beta.ppf(0.1, a, b), beta.ppf(0.9, a, b)], [0., 0.], [y_max, y_max], alpha=0.3)\n obj_to_rasterize.append(obj)\n ax.legend(fontsize=12)\n ax.set_xticks([0.0, 0.2, 0.4, 0.6, 0.8, 1.0])\n ax.set_xlabel(r'$p$')\n\n\nif __name__ == '__main__':\n plt.style.use('resources/default.mplstyle')\n\n # Plot fitting sketch\n\n summary_prob_proto = load_from_json(SummaryProbProto)\n energies = 0.5 * np.r_[[0.], summary_prob_proto.energy_levels]\n energies = energies[0:-20]\n print(summary_prob_proto.confs[1].description)\n p_lam = np.r_[[1.], summary_prob_proto.confs[1].p_lam]\n p_lam = p_lam[0:-20]\n\n fig, ax = plt.subplots(1, 1, figsize=(10, 5))\n bar_width = 0.0004\n # plot p_lam bars\n obj = ax.bar(energies, p_lam, 2*bar_width, alpha=0.75, color='lightpink', zorder=0)\n # plot fitting\n fitting = LaminarisationProbabilityFittingFunction2020JFM.from_data(energies, p_lam)\n e = np.linspace(energies[0], energies[-1], 200)\n ax.plot(e, fitting(e), color='blue', zorder=0, linewidth=3)\n E_99 = fitting.energy_with_99_lam_prob()\n E_flex = fitting.energy_at_inflection_point()\n E_a = fitting.energy_close_to_asymptote()\n ax.plot([E_99], [fitting(E_99)], 'ko', markersize=10)\n ax.plot([E_flex], [fitting(E_flex)], 'ko', markersize=10)\n ax.plot([E_a], [fitting(E_a)], 'ko', markersize=10)\n ax.set_xlim((-0.002, energies[-1]))\n ax.set_ylim((0, 1.05))\n energies_ticks = [None for _ in range(len(energies))]\n for i in range(3):\n energies_ticks[i] = r'$E^{(' + str(i + 1) + ')}$'\n energies_ticks[3] = r'...'\n energies_ticks[10] = r'$E^{(j)}$'\n# ax.annotate(r'$\\mathbb{E} P_{lam}(E^{(j)})$', xy=(energies[10], p_lam[10]), xytext=(energies[10] - 0.002, p_lam[10] + 0.2),\n# arrowprops=dict(arrowstyle='->'), fontsize=16)\n ax.annotate(r'$\\bar{P}_{lam}(E^{(j)})$', xy=(energies[10], p_lam[10]), xytext=(energies[10] - 0.002, p_lam[10] + 0.2),\n arrowprops=dict(arrowstyle='->'), fontsize=16)\n ax.annotate(r'$p(E)$', xy=(energies[4], fitting(energies[4])), xytext=(energies[4] + 0.001, fitting(energies[4]) + 0.2),\n arrowprops=dict(arrowstyle='->'), fontsize=16)\n\n col_labels = ['Definition']\n row_labels = [\n r'$E_{99\\%}$',\n r'$E_{flex}$',\n r'$E_{a}$',\n r'$a$'\n ]\n table_vals = [\n [r'$p(E_{99\\%})=0.99$'],\n [r'$E_{flex} = \\dfrac{\\alpha - 1}{\\beta}$'],\n [r'$|p(E_{a}) - a| = 0.01$'],\n [r'$a = \\lim_{E \\to \\infty} p(E)$']\n ]\n # the rectangle is where I want to place the table\n table = plt.table(cellText=table_vals,\n colWidths=[0.2]*3,\n rowLabels=row_labels,\n colLabels=col_labels,\n loc='upper right')\n #table.auto_set_font_size(False)\n #table.set_fontsize(16)\n table.scale(1, 3)\n ax.set_xticks(energies)\n ax.set_xticklabels(energies_ticks)\n\n plot_pretty_annotation_on_axis(ax, fitting.asymp, energies[-1], text=r'$a$', on_y=True)\n plot_pretty_annotation_on_axis(ax, 0.99, E_99, text=r'$0.99$', on_y=True)\n plot_pretty_annotation_on_axis(ax, E_99, 0.99, text=r'$E_{99\\%}$', on_x=True)\n plot_pretty_annotation_on_axis(ax, E_flex, fitting(E_flex), text=r'$E_{flex}$', on_x=True)\n plot_pretty_annotation_on_axis(ax, E_a, fitting(E_a), text=r'$E_{a}$', on_x=True)\n# ax_secondary_yaxis = ax.twinx()\n# ax_secondary_yaxis.tick_params(axis=\"y\", direction=\"in\", pad=-25.)\n# ax_secondary_yaxis.yaxis.tick_left()\n# #ax_secondary_yaxis = ax.secondary_yaxis(\"left\", xticks=[fitting.asymp, 0.99],\n# # xticklabels=[r'$a$', 0.99])\n# ax_secondary_yaxis.set_yticks([fitting.asymp, 0.99])\n# ax_secondary_yaxis.set_yticklabels([r'$a$', r'$0.99$'])\n# for ax_ in (ax, ax_secondary_yaxis):\n ax.spines['top'].set_color('none')\n ax.spines['right'].set_color('none')\n plt.tight_layout()\n plt.savefig('fitting_sketch.eps')\n plt.show()\n\n # Plot posterior distribution examples\n fig, axes = plt.subplots(1, 3, figsize=(12, 3.5))\n small_sample_cases = [\n (0, 10), # first number = number of lam events; second number = number of turb events\n (3, 7),\n (9, 1),\n ]\n large_sample_cases = [\n (0, 30), # first number = number of lam events; second number = number of turb events\n (9, 21),\n (27, 3),\n ]\n x = np.linspace(0., 1., 200)\n obj_to_rasterize = []\n for ax, (N_lam, N_turb) in zip(axes, small_sample_cases):\n plot_posterior_distribution(ax, N_lam, N_turb, obj_to_rasterize)\n for ax, (N_lam, N_turb) in zip(axes, large_sample_cases):\n plot_posterior_distribution(ax, N_lam, N_turb, obj_to_rasterize)\n for ax in axes:\n ax.grid()\n axes[0].set_ylabel(r'$f_{P_{lam}}(p | \\boldsymbol{S} = \\boldsymbol{s})$')\n plt.tight_layout()\n fname = 'posterior_examples.eps'\n rasterise_and_save(fname, rasterise_list=obj_to_rasterize, fig=fig, dpi=300)\n plt.show()\n\n # Plot small posterior distributions for large schema\n sample_cases = [\n (0, 10), # first number = number of lam events; second number = number of turb events\n (2, 8),\n (7, 3),\n ]\n for N_lam, N_turb in sample_cases:\n fig, ax = plt.subplots(1, 1, figsize=(3, 2.3))\n x = np.linspace(0., 1., 200)\n obj_to_rasterize = []\n plot_posterior_distribution(ax, N_lam, N_turb, obj_to_rasterize, simplified=True)\n ax.spines['top'].set_color('none')\n ax.spines['right'].set_color('none')\n plt.tight_layout()\n fname = 'posterior_example_{}_{}.eps'.format(N_lam, N_turb)\n rasterise_and_save(fname, rasterise_list=obj_to_rasterize, fig=fig, dpi=300)\n plt.show()\n\n # Plot fitting sketch\n\n fig, ax = plt.subplots(1, 1, figsize=(10, 3))\n bar_width = 0.0004\n # plot p_lam bars\n obj = ax.bar(energies, p_lam, 2*bar_width, alpha=0.75, color='lightpink', zorder=0)\n # plot fitting\n fitting = LaminarisationProbabilityFittingFunction2020JFM.from_data(energies, p_lam)\n e = np.linspace(energies[0], energies[-1], 200)\n ax.plot(e, fitting(e), color='blue', zorder=0, linewidth=3)\n ax.set_xlim((-0.002, energies[-1]))\n ax.set_ylim((0, 1.05))\n energies_ticks = [None for _ in range(len(energies))]\n for i in range(3):\n energies_ticks[i] = r'$E^{(' + str(i + 1) + ')}$'\n energies_ticks[3] = r'...'\n energies_ticks[10] = r'$E^{(j)}$'\n ax.set_xticks(energies)\n ax.set_xticklabels(energies_ticks)\n\n ax.spines['top'].set_color('none')\n ax.spines['right'].set_color('none')\n plt.tight_layout()\n plt.savefig('fitting_sketch_simplified.eps')\n plt.show()\n"
] |
[
[
"scipy.stats.beta.pdf",
"matplotlib.pyplot.savefig",
"matplotlib.pyplot.subplots",
"scipy.stats.beta.mean",
"scipy.stats.beta.ppf",
"matplotlib.pyplot.tight_layout",
"matplotlib.pyplot.style.use",
"matplotlib.pyplot.show",
"numpy.linspace",
"matplotlib.pyplot.table"
]
] |
Kleptobismol/scikit-bio
|
[
"3df95446558273034b884852f2b7bf6a1872f66d",
"3df95446558273034b884852f2b7bf6a1872f66d"
] |
[
"skbio/stats/ordination/_correspondence_analysis.py",
"skbio/diversity/alpha/_lladser.py"
] |
[
"# ----------------------------------------------------------------------------\n# Copyright (c) 2013--, scikit-bio development team.\n#\n# Distributed under the terms of the Modified BSD License.\n#\n# The full license is in the file COPYING.txt, distributed with this software.\n# ----------------------------------------------------------------------------\n\nfrom __future__ import absolute_import, division, print_function\n\nimport numpy as np\n\nfrom ._base import Ordination, OrdinationResults\nfrom ._utils import svd_rank\n\n\nclass CA(Ordination):\n r\"\"\"Compute correspondence analysis, a multivariate statistical\n technique for ordination.\n\n In general, rows in the data table will correspond to sites and\n columns to species, but the method is symmetric. In order to\n measure the correspondence between rows and columns, the\n :math:`\\chi^2` distance is used, and those distances are preserved\n in the transformed space. The :math:`\\chi^2` distance doesn't take\n double zeros into account, and so it is expected to produce better\n ordination that PCA when the data has lots of zero values.\n\n It is related to Principal Component Analysis (PCA) but it should\n be preferred in the case of steep or long gradients, that is, when\n there are many zeros in the input data matrix.\n\n Parameters\n ----------\n X : array_like\n Contingency table. It can be applied to different kinds of\n data tables but data must be non-negative and dimensionally\n homogeneous (quantitative or binary).\n\n Notes\n -----\n The algorithm is based on [1]_, \\S 9.4.1., and is expected to give\n the same results as ``cca(X)`` in R's package vegan.\n\n See Also\n --------\n CCA\n\n References\n ----------\n .. [1] Legendre P. and Legendre L. 1998. Numerical\n Ecology. Elsevier, Amsterdam.\n\n \"\"\"\n short_method_name = 'CA'\n long_method_name = 'Canonical Analysis'\n\n def __init__(self, X, row_ids, column_ids):\n self.X = np.asarray(X, dtype=np.float64)\n self._ca()\n self.row_ids = row_ids\n self.column_ids = column_ids\n\n def _ca(self):\n X = self.X\n r, c = X.shape\n\n if X.min() < 0:\n raise ValueError(\"Input matrix elements must be non-negative.\")\n\n # Step 1 (similar to Pearson chi-square statistic)\n grand_total = X.sum()\n Q = X / grand_total\n\n column_marginals = Q.sum(axis=0)\n row_marginals = Q.sum(axis=1)\n # Let's store them since they're needed to compute scores\n self.column_marginals = column_marginals\n self.row_marginals = row_marginals\n\n # Formula 9.32 in Lagrange & Lagrange (1998). Notice that it's\n # an scaled version of the contribution of each cell towards\n # Pearson chi-square statistic.\n expected = np.outer(row_marginals, column_marginals)\n Q_bar = (Q - expected) / np.sqrt(expected) # Eq. 9.32\n\n # Step 2 (Singular Value Decomposition)\n U_hat, W, Ut = np.linalg.svd(Q_bar, full_matrices=False)\n # Due to the centering, there are at most min(r, c) - 1 non-zero\n # eigenvalues (which are all positive)\n rank = svd_rank(Q_bar.shape, W)\n assert rank <= min(r, c) - 1\n self.U_hat = U_hat[:, :rank]\n self.W = W[:rank]\n self.U = Ut[:rank].T\n\n def scores(self, scaling):\n r\"\"\"Compute site and species scores for different scalings.\n\n Parameters\n ----------\n scaling : int\n\n For a more detailed explanation of the interpretation, check\n Legendre & Legendre 1998, section 9.4.3. The notes that\n follow are quick recommendations.\n\n Scaling type 1 maintains :math:`\\chi^2` distances between\n rows (sites): in the transformed space, the euclidean\n distances between rows are equal to the :math:`\\chi^2`\n distances between rows in the original space. It should be\n used when studying the ordination of sites. Rows (sites)\n that are near a column (species) have high contributions\n from it.\n\n Scaling type 2 preserves :math:`\\chi^2` distances between\n columns (species), so euclidean distance between columns\n after transformation is equal to :math:`\\chi^2` distance\n between columns in the original space. It is best used\n when we are interested in the ordination of species. A\n column (species) that is next to a row (site) means that\n it is more abundant there.\n\n Other types of scalings are currently not implemented, as\n they're less used by ecologists (Legendre & Legendre 1998,\n p. 456).\n\n In general, species appearing far from the center of the\n biplot and far from its edges will probably exhibit better\n relationships than species either in the center (may be\n multimodal species, not related to the shown ordination\n axes...) or the edges (sparse species...).\n\n Returns\n -------\n OrdinationResults\n Object that stores the computed eigenvalues, the\n proportion explained by each of them (per unit),\n transformed coordinates, etc.\n\n See Also\n --------\n OrdinationResults\n \"\"\"\n\n if scaling not in {1, 2}:\n raise NotImplementedError(\n \"Scaling {0} not implemented.\".format(scaling))\n # Both scalings are a bit intertwined, so we'll compute both and\n # then choose\n V = self.column_marginals[:, None]**-0.5 * self.U\n V_hat = self.row_marginals[:, None]**-0.5 * self.U_hat\n F = V_hat * self.W\n # According to Formula 9.43, this should hold\n # assert np.allclose(F, (row_marginals**-1)[:, None] * Q.dot(V))\n # but it doesn't (notice that W**2==Lambda):\n # (9.43a) F = V_hat W = D(p_i+)^{-1/2} U_hat W\n # = D(p_i+)^{-1/2} Q_bar U W^{-1} W (substituting 9.38)\n # = D(p_i+)^{-1/2} Q_bar U\n # (9.43b) F = D(p_i+)^{-1} Q V\n # = D(p_i+)^{-1} Q D(p_+j)^{-1/2} U (substituting 9.41)\n # = D(p_i+)^{-1/2} D(p_i+)^{-1/2} Q D(p_+j)^{-1/2} U\n # = D(p_i+)^{-1/2} Q_tilde U (using 9.40)\n # It holds if we replace Q in 9.43b with Q after centering, ie\n # assert np.allclose(\n # F,\n # (row_marginals**-1)[:, None] * (Q - expected).dot(V))\n # Comparing results with vegan and the examples in the book, 9.43a\n # is the right one. The same issue happens in 9.44, where also\n # 9.44a is the one that matches vegan's output.\n # (9.44a) F_hat = V W = D(p_+j)^{-1/2} U W\n # = D(p_+j)^{-1/2} Q_bar' U_hat W^{-1} W (using 9.39)\n # = D(p_+j)^{-1/2} Q_bar' U_hat\n # (9.44b) F_hat = D(p_+j)^{-1} Q' V_hat\n # = D(p_+j)^{-1/2} Q_tilde' U_hat (using 9.40 and 9.42)\n F_hat = V * self.W\n\n # Eigenvalues\n eigvals = self.W**2\n\n # Species scores\n species_scores = [V, F_hat][scaling - 1]\n # Site scores (weighted averages of species scores)\n site_scores = [F, V_hat][scaling - 1]\n return OrdinationResults(eigvals=eigvals, species=species_scores,\n site=site_scores, site_ids=self.row_ids,\n species_ids=self.column_ids)\n",
"#!/usr/bin/env python\nfrom __future__ import absolute_import, division, print_function\n\n# ----------------------------------------------------------------------------\n# Copyright (c) 2013--, scikit-bio development team.\n#\n# Distributed under the terms of the Modified BSD License.\n#\n# The full license is in the file COPYING.txt, distributed with this software.\n# ----------------------------------------------------------------------------\n\nimport numpy as np\n\nfrom ._base import _validate\n\n\ndef lladser_pe(counts, r=10):\n \"\"\"Calculate single point estimate of conditional uncovered probability.\n\n Parameters\n ----------\n counts : 1-D array_like, int\n Vector of counts.\n r : int, optional\n Number of new colors that are required for the next prediction.\n\n Returns\n -------\n double\n Single point estimate of the conditional uncovered probability. May be\n ``np.nan`` if a point estimate could not be computed.\n\n See Also\n --------\n lladser_ci\n\n Notes\n -----\n This function is just a wrapper around the full point estimator described\n in Theorem 2 (i) in [1]_, intended to be called for a single best estimate\n on a complete sample.\n\n References\n ----------\n .. [1] Lladser, Gouet, and Reeder, \"Extrapolation of Urn Models via\n Poissonization: Accurate Measurements of the Microbial Unknown\" PLoS\n 2011.\n\n \"\"\"\n counts = _validate(counts)\n sample = _expand_counts(counts)\n np.random.shuffle(sample)\n\n try:\n pe = list(_lladser_point_estimates(sample, r))[-1][0]\n except IndexError:\n pe = np.nan\n\n return pe\n\n\ndef lladser_ci(counts, r, alpha=0.95, f=10, ci_type='ULCL'):\n \"\"\"Calculate single CI of the conditional uncovered probability.\n\n Parameters\n ----------\n counts : 1-D array_like, int\n Vector of counts.\n r : int\n Number of new colors that are required for the next prediction.\n alpha : float, optional\n Desired confidence level.\n f : float, optional\n Ratio between upper and lower bound.\n ci_type : {'ULCL', 'ULCU', 'U', 'L'}\n Type of confidence interval. If ``'ULCL'``, upper and lower bounds with\n conservative lower bound. If ``'ULCU'``, upper and lower bounds with\n conservative upper bound. If ``'U'``, upper bound only, lower bound\n fixed to 0.0. If ``'L'``, lower bound only, upper bound fixed to 1.0.\n\n Returns\n -------\n tuple\n Confidence interval as ``(lower_bound, upper_bound)``.\n\n See Also\n --------\n lladser_pe\n\n Notes\n -----\n This function is just a wrapper around the full CI estimator described\n in Theorem 2 (iii) in [1]_, intended to be called for a single best CI\n estimate on a complete sample.\n\n References\n ----------\n .. [1] Lladser, Gouet, and Reeder, \"Extrapolation of Urn Models via\n Poissonization: Accurate Measurements of the Microbial Unknown\" PLoS\n 2011.\n\n \"\"\"\n counts = _validate(counts)\n sample = _expand_counts(counts)\n np.random.shuffle(sample)\n\n try:\n ci = list(_lladser_ci_series(sample, r, alpha, f, ci_type))[-1]\n except IndexError:\n ci = (np.nan, np.nan)\n\n return ci\n\n\ndef _expand_counts(counts):\n \"\"\"Convert vector of counts at each index to vector of indices.\"\"\"\n # From http://stackoverflow.com/a/22671394\n return np.repeat(np.arange(counts.size), counts)\n\n\ndef _lladser_point_estimates(sample, r=10):\n \"\"\"Series of point estimates of the conditional uncovered probability.\n\n Parameters\n ----------\n sample : 1-D array_like, int\n Series of random observations.\n r : int, optional\n Number of new colors that are required for the next prediction.\n\n Returns\n -------\n generator\n Each new color yields a tuple of three elements: the point estimate,\n position in sample of prediction, and random variable from Poisson\n process (mostly to make testing easier).\n\n Raises\n ------\n ValueError\n If `r` is less than or equal to 2.\n\n Notes\n -----\n This is the point estimator described in Theorem 2 (i) in [1]_.\n\n References\n ----------\n .. [1] Lladser, Gouet, and Reeder, \"Extrapolation of Urn Models via\n Poissonization: Accurate Measurements of the Microbial Unknown\" PLoS\n 2011.\n\n \"\"\"\n if r <= 2:\n raise ValueError(\"r must be greater than or equal to 3.\")\n\n for count, seen, cost, i in _get_interval_for_r_new_otus(sample, r):\n t = np.random.gamma(count, 1)\n point_est = (r - 1) / t\n yield point_est, i, t\n\n\ndef _get_interval_for_r_new_otus(seq, r):\n \"\"\"Compute interval between r new OTUs for seq of samples.\n\n Imagine an urn with colored balls. Given a drawing of balls from the urn,\n compute how many balls need to be looked at to discover r new colors.\n Colors can be repeated.\n\n Parameters\n ----------\n seq : sequence\n Series of observations (the actual sample, not the frequencies).\n r : int\n Number of new colors that need to be observed for a new interval.\n\n Returns\n -------\n generator\n For each new color seen for the first time, yields a tuple of four\n elements: the length of interval (i.e. number of observations looked\n at), the set of seen colors, position in seq after seeing last new\n color (end of interval), and position in seq where interval is started.\n\n \"\"\"\n seen = set()\n seq_len = len(seq)\n\n # note: first iteration is after looking at first char\n for i, curr in enumerate(seq):\n # bail out if there's nothing new\n if curr in seen:\n continue\n else:\n seen.add(curr)\n\n # otherwise, need to see distance to get k colors\n unseen = 0\n j = i + 1\n while unseen < r and j < seq_len:\n if seq[j] not in seen:\n unseen += 1\n # note: increments after termination condition\n j += 1\n\n # the interval to see r new colors\n count = j - i - 1\n # the position in seq after seeing r new ones\n cost = j\n\n # bail out if not enough unseen\n if not count or (unseen < r):\n raise StopIteration\n\n # make a copy of seen before yielding, as we'll continue to add to the\n # set in subsequent iterations\n yield count, set(seen), cost, i\n\n\ndef _lladser_ci_series(seq, r, alpha=0.95, f=10, ci_type='ULCL'):\n \"\"\"Construct r-color confidence intervals for uncovered conditional prob.\n\n Parameters\n ----------\n seq : sequence\n Sequence of colors (the actual sample, not the counts).\n r : int\n Number of new colors that are required for the next prediction.\n alpha : float, optional\n Desired confidence level.\n f : float, optional\n Ratio between upper and lower bound.\n ci_type : {'ULCL', 'ULCU', 'U', 'L'}\n Type of confidence interval. If ``'ULCL'``, upper and lower bounds with\n conservative lower bound. If ``'ULCU'``, upper and lower bounds with\n conservative upper bound. If ``'U'``, upper bound only, lower bound\n fixed to 0.0. If ``'L'``, lower bound only, upper bound fixed to 1.0.\n\n Returns\n -------\n generator\n Yields one CI prediction for each new color that is detected and where.\n\n \"\"\"\n for count, seen, cost, i in _get_interval_for_r_new_otus(seq, r):\n t = np.random.gamma(count, 1)\n yield _lladser_ci_from_r(r, t, alpha, f, ci_type)\n\n\ndef _lladser_ci_from_r(r, t, alpha=0.95, f=10, ci_type='ULCL'):\n \"\"\"Construct r-color confidence interval for uncovered conditional prob.\n\n Returns\n -------\n tuple\n Confidence interval that contains the true conditional uncovered\n probability with a probability of 100% * `alpha`.\n\n Raises\n ------\n ValueError\n For combinations of `r`, `f`, and `alpha` that do not have precomputed\n results.\n\n \"\"\"\n alpha = round(alpha, 2)\n\n if ci_type == 'U':\n if alpha != 0.95:\n raise ValueError(\"alpha must be 0.95 if ci_type is 'U'.\")\n if r not in _UPPER_CONFIDENCE_BOUND:\n raise ValueError(\"r must be between 1-25 or 50 if ci_type is 'U'.\")\n return 0.0, _UPPER_CONFIDENCE_BOUND[r] / t\n elif ci_type == 'L':\n if alpha != 0.95:\n raise ValueError(\"alpha must be 0.95 if ci_type is 'L'.\")\n if r not in _LOWER_CONFIDENCE_BOUND:\n raise ValueError(\"r must be between 1-25 if ci_type is 'L'.\")\n return _LOWER_CONFIDENCE_BOUND[r] / t, 1.0\n\n bound_params = _ul_confidence_bounds(f, r, alpha)\n if ci_type == 'ULCL':\n bound_param = bound_params[0]\n elif ci_type == 'ULCU':\n bound_param = bound_params[1]\n else:\n raise ValueError(\"Unknown ci_type '%s'.\" % ci_type)\n\n upper_bound = bound_param * f / t\n lower_bound = bound_param / t\n\n # make sure upper bound is at most 1\n if upper_bound > 1:\n upper_bound = 1.0\n\n return lower_bound, upper_bound\n\n\ndef _ul_confidence_bounds(f, r, alpha):\n \"\"\"Return confidence bounds based on ratio and alpha.\n\n This function is just a lookup of some precomputed values.\n\n Parameters\n ----------\n f : float\n Desired ratio of upper to lower bound.\n r : int\n Number of new colors.\n alpha : float\n Confidence interval (for 95% confidence use 0.95).\n\n Returns\n -------\n tuple\n Constants ``(c_1, c_2)`` such that the confidence interval is\n ``[c_1/T_r, c_1*f/T_r]`` for conservative lower bound intervals and\n ``[c_2/T_r, c_2*f/T_r]`` for conservative upper bound intervals.\n\n \"\"\"\n a = None\n b = None\n\n if (f, r, alpha) in _PRECOMPUTED_TABLE:\n return _PRECOMPUTED_TABLE[(f, r, alpha)]\n\n # all others combination are only computed for f=10\n # and alpha = 0.90, 0.95 and 0.99\n if f == 10 and r <= 50:\n if alpha in _CBS and r < len(_CBS[alpha]):\n a, b = _CBS[alpha][r]\n\n if a is None or b is None:\n raise ValueError(\"No constants are precomputed for the combination of \"\n \"f=%f, r=%d, and alpha=%.2f\" % (f, r, alpha))\n return a, b\n\n\n# Maps r to a constant c such that the 95% confidence interval with lower bound\n# fixed at 0 is [0, c/T_r]. This constant is constant b according to\n# Theorem 2 (iii) in the paper with a=0, aka c_0 from Table 3.\n_UPPER_CONFIDENCE_BOUND = {\n 1: 2.995732274,\n 2: 4.743864518,\n 3: 6.295793622,\n 4: 7.753656528,\n 5: 9.153519027,\n 6: 10.51303491,\n 7: 11.84239565,\n 8: 13.14811380,\n 9: 14.43464972,\n 10: 15.70521642,\n 11: 16.96221924,\n 12: 18.20751425,\n 13: 19.44256933,\n 14: 20.66856908,\n 15: 21.88648591,\n 16: 23.09712976,\n 17: 24.30118368,\n 18: 25.49923008,\n 19: 26.69177031,\n 20: 27.87923964,\n 21: 29.06201884,\n 22: 30.24044329,\n 23: 31.41481021,\n 24: 32.58538445,\n 25: 33.75240327,\n 50: 62.17105670\n}\n\n\n# Maps r to a constant c such that the 95% confidence interval with upper bound\n# fixed at 1 is [c/T_r, 1]. This constant is constant b according to\n# Theorem 2 (iii) in the paper with b=1, aka c_3 from Table 3.\n_LOWER_CONFIDENCE_BOUND = {\n 1: 0.051293294,\n 2: 0.355361510,\n 3: 0.817691447,\n 4: 1.366318397,\n 5: 1.970149568,\n 6: 2.613014744,\n 7: 3.285315692,\n 8: 3.980822786,\n 9: 4.695227540,\n 10: 5.425405697,\n 11: 6.169007289,\n 12: 6.924212514,\n 13: 7.689578292,\n 14: 8.463937522,\n 15: 9.246330491,\n 16: 10.03595673,\n 17: 10.83214036,\n 18: 11.63430451,\n 19: 12.44195219,\n 20: 13.25465160,\n 21: 14.07202475,\n 22: 14.89373854,\n 23: 15.71949763,\n 24: 16.54903871,\n 25: 17.38212584\n}\n\n\n# Hack in some special values we used for the paper.\n# Since Manuel needs to compute those semi-automatically\n# using Maple, we pre-calculate only a few common ones\n\n# precomputed table is {(f, r, alpha):(c_1, c_2)}\n_PRECOMPUTED_TABLE = {\n (2, 50, 0.95): (31.13026306, 38.94718565),\n (2, 33, 0.95): (22.3203508, 23.4487304),\n (1.5, 100, 0.95): (79.0424349, 83.22790086),\n (1.5, 94, 0.95): (75.9077267, 76.5492088),\n (2.5, 19, 0.95): (11.26109001, 11.96814857),\n\n # In the next block for each f, we report the smallest possible value\n # of r from table 4 in the paper\n (80, 2, 0.95): (0.0598276655, 0.355361510),\n (48, 2, 0.95): (0.1013728884, 0.355358676),\n (40, 2, 0.95): (0.1231379857, 0.355320458),\n (24, 2, 0.95): (0.226833483, 0.346045204),\n (20, 3, 0.95): (0.320984257, 0.817610455),\n (12, 3, 0.95): (0.590243030, 0.787721610),\n (10, 4, 0.95): (0.806026244, 1.360288674),\n (6, 6, 0.95): (1.8207383, 2.58658608),\n (5, 7, 0.95): (2.48303930, 3.22806682),\n (3, 14, 0.95): (7.17185045, 8.27008349),\n (2.5, 19, 0.95): (11.26109001, 11.96814857),\n (1.5, 94, 0.95): (75.9077267, 76.5492088),\n (1.25, 309, 0.95): (275.661191, 275.949782)\n}\n\n\n# Below are the values used for Theorem 3 iii\n# Values hand computed by Manuel Lladser using Maple. For each alpha (0.90,\n# 0.95, and 0.99), there is a list mapping r to (c_1, c_2), where r is used as\n# an index into the list.\n\n_CB_90 = [\n (None, None), # 0, makes indexing easier\n (None, None), # no feasible solution\n (None, None), # no feasible solution\n (.5635941995, 1.095834700),\n (.6764656264, 1.744588615),\n (.8018565594, 2.432587343),\n (.9282215025, 3.151897973),\n (1.053433716, 3.894766804),\n (1.177158858, 4.656118177),\n (1.299491033, 5.432468058),\n (1.420604842, 6.221304605), # 10\n (1.540665805, 7.020746595),\n (1.659812701, 7.829342026),\n (1.778158703, 8.645942495),\n (1.895796167, 9.469621185),\n (2.012801198, 10.29961731),\n (2.129237257, 11.13529724),\n (2.245157877, 11.97612664),\n (2.360608695, 12.82164994),\n (2.475628991, 13.67147502),\n (2.590252861, 14.52526147), # 20\n (2.704510123, 15.38271151),\n (2.818427036, 16.24356290),\n (2.932026869, 17.10758326),\n (3.045330351, 17.97456551),\n (3.158356050, 18.84432420),\n (None, None), # not computed\n (None, None),\n (None, None),\n (None, None),\n (3.719850286, 23.22944415), # 30\n (None, None),\n (None, None),\n (None, None),\n (None, None),\n (None, None),\n (None, None),\n (None, None),\n (None, None),\n (None, None),\n (4.828910181, 32.13892224), # 40\n (None, None),\n (None, None),\n (None, None),\n (None, None),\n (None, None),\n (None, None),\n (None, None),\n (None, None),\n (None, None),\n (5.924900191, 41.17906791) # 50\n]\n\n_CB_95 = [\n (None, None), # 0\n (None, None),\n (None, None),\n (None, None),\n (.8060262438, 1.360288674), # 4\n (.9240311584, 1.969902537),\n (1.053998892, 2.613007253),\n (1.185086998, 3.285315518),\n (1.315076337, 3.980822783),\n (4.695227540, 4.695227541),\n (1.570546801, 5.425405698), # 10\n (1.696229569, 6.169007289),\n (1.820753729, 6.924212513),\n (1.944257622, 7.689578291),\n (2.066857113, 8.463937522),\n (2.188648652, 9.246330491),\n (2.309712994, 10.03595673),\n (2.430118373, 10.83214036),\n (2.549923010, 11.63430451),\n (2.669177032, 12.44195219),\n (2.787923964, 13.25465160), # 20\n (2.906201884, 14.07202475),\n (3.024044329, 14.89373854),\n (3.141481020, 15.71949763),\n (3.258538445, 16.54903871),\n (3.375240327, 17.38212584),\n (None, None),\n (None, None),\n (None, None),\n (None, None),\n (3.954097220, 21.59397923), # 30\n (None, None),\n (None, None),\n (None, None),\n (None, None),\n (None, None),\n (None, None),\n (None, None),\n (None, None),\n (None, None),\n (5.093973695, 30.19573919), # 40\n (None, None),\n (None, None),\n (None, None),\n (None, None),\n (None, None),\n (None, None),\n (None, None),\n (None, None),\n (None, None),\n (6.217105673, 38.96473258) # 50\n]\n\n_CB_99 = [\n (None, None),\n (None, None),\n (None, None),\n (None, None),\n (None, None),\n (None, None),\n (1.360316290, 1.768978323),\n (1.470856924, 2.329171347),\n (1.604478487, 2.906049304),\n (1.741759456, 3.507452949),\n (1.878809285, 4.130199076), # 10\n (2.014632329, 4.771246173),\n (2.149044735, 5.428180734),\n (2.282101533, 6.099073460),\n (2.413917374, 6.782354878),\n (2.544610844, 7.476728267),\n (2.674289153, 8.181107778),\n (2.803045614, 8.894573463),\n (2.930960779, 9.616337916),\n (3.058104355, 10.34572103),\n (3.184536992, 11.08213063), # 20\n (3.310311816, 11.82504734),\n (3.435475649, 12.57401269),\n (3.560070013, 13.32861956),\n (3.684131925, 14.08850448),\n (3.807694563, 14.85334135),\n (None, None),\n (None, None),\n (None, None),\n (None, None),\n (4.41897094, 18.7424258), # 30\n (None, None),\n (None, None),\n (None, None),\n (None, None),\n (None, None),\n (None, None),\n (None, None),\n (None, None),\n (None, None),\n (5.61643962, 26.7700386), # 40\n (None, None),\n (None, None),\n (None, None),\n (None, None),\n (None, None),\n (None, None),\n (None, None),\n (None, None),\n (None, None),\n (6.79033616, 35.0324474) # 50\n]\n\n_CBS = {\n 0.90: _CB_90,\n 0.95: _CB_95,\n 0.99: _CB_99\n}\n"
] |
[
[
"numpy.outer",
"numpy.sqrt",
"numpy.asarray",
"numpy.linalg.svd"
],
[
"numpy.random.gamma",
"numpy.arange",
"numpy.random.shuffle"
]
] |
nadiahpk/niche-neutral-riau-birds
|
[
"83eeba57973d6912ad354592c84a03b5c24b3363"
] |
[
"scripts/summary_plots_stats/plot_tuned_area_v_m.py"
] |
[
"# plot how the fitted m for the tuned model varies with island size\n\nimport matplotlib.pyplot as plt\nimport pandas as pd\n\n\n# parameters\n# ---\n\n# which parameter set and archipelagos to sample\nsubset_name = 'survey_only'\nsuffix = '_3'\nrho = 1700\n\n# where results are stored\ndir_plot = '../../results/summary_stats/'\ndir_m = '../../results/neutral_data_fitmK/'\nfname_area = '../../data/processed/island_area.csv'\n\n\n# get migration parameter on all islands\n# ---\n\nfname_params = dir_m + 'archipelago_params' + suffix + '.csv'\ndf = pd.read_csv(fname_params)\ndf_sub = df[(df['subset_name'] == subset_name) & (df['rho'] == rho)]\nparams = df_sub.iloc[0]\nisland_names = [ v[2:] for v in df_sub.columns if v[:2] == 'm_' ]\n\n# migration probability\nmV = [ params['m_' + island_name] for island_name in island_names ]\n\n\n# get area of each island\n# ---\n\ndf_area = pd.read_csv(fname_area)\nareaV = [ df_area[df_area['island_name'] == island_name]['area_sq_km'].iloc[0] for island_name in island_names ]\n\n\n# plot area vs. m\n# ---\n\nplt.scatter(areaV, mV, color='blue')\n\nplt.xlabel(r'island area (km$^2$)', fontsize='xx-large')\nplt.ylabel(r'migration rate $m$', fontsize='xx-large')\nplt.xscale('log')\nplt.yscale('log')\nplt.tight_layout()\nplt.savefig(dir_plot + 'tuned_area_v_m' + suffix + '.pdf')\nplt.close()\n\n"
] |
[
[
"matplotlib.pyplot.xscale",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.savefig",
"matplotlib.pyplot.close",
"matplotlib.pyplot.tight_layout",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.scatter",
"pandas.read_csv",
"matplotlib.pyplot.yscale"
]
] |
gwanglee/OpenUnReID
|
[
"fa12430c5a4020c3d065edde21c9d1986c77afe3"
] |
[
"tools/UDA_TP/main.py"
] |
[
"import argparse\nimport shutil\nimport sys\nimport time\nfrom datetime import timedelta\nfrom pathlib import Path\n\nimport torch\n\nfrom openunreid.apis import BaseRunner, test_reid\nfrom openunreid.core.solvers import build_lr_scheduler, build_optimizer\nfrom openunreid.data import build_test_dataloader, build_train_dataloader\nfrom openunreid.models import build_model\nfrom openunreid.models.losses import build_loss\nfrom openunreid.utils.config import (\n cfg,\n cfg_from_list,\n cfg_from_yaml_file,\n log_config_to_file,\n)\nfrom openunreid.utils.dist_utils import init_dist, synchronize\nfrom openunreid.utils.file_utils import mkdir_if_missing\nfrom openunreid.utils.logger import Logger\n\n\ndef parge_config():\n parser = argparse.ArgumentParser(description=\"UDA_TP training\")\n parser.add_argument(\"config\", help=\"train config file path\")\n parser.add_argument(\n \"--work-dir\", help=\"the dir to save logs and models\", default=\"\"\n )\n parser.add_argument(\"--resume-from\", help=\"the checkpoint file to resume from\")\n parser.add_argument(\n \"--launcher\",\n type=str,\n choices=[\"none\", \"pytorch\", \"slurm\"],\n default=\"none\",\n help=\"job launcher\",\n )\n parser.add_argument(\"--tcp-port\", type=str, default=\"5017\")\n parser.add_argument(\n \"--set\",\n dest=\"set_cfgs\",\n default=None,\n nargs=argparse.REMAINDER,\n help=\"set extra config keys if needed\",\n )\n args = parser.parse_args()\n\n cfg_from_yaml_file(args.config, cfg)\n cfg.launcher = args.launcher\n cfg.tcp_port = args.tcp_port\n if not args.work_dir:\n args.work_dir = Path(args.config).stem\n cfg.work_dir = cfg.LOGS_ROOT / args.work_dir\n mkdir_if_missing(cfg.work_dir)\n if args.set_cfgs is not None:\n cfg_from_list(args.set_cfgs, cfg)\n\n shutil.copy(args.config, cfg.work_dir / \"config.yaml\")\n\n return args, cfg\n\n\ndef main():\n start_time = time.monotonic()\n\n # init distributed training\n args, cfg = parge_config()\n dist = init_dist(cfg)\n synchronize()\n\n # init logging file\n logger = Logger(cfg.work_dir / \"log.txt\", debug=False)\n sys.stdout = logger\n print(\"==========\\nArgs:{}\\n==========\".format(args))\n log_config_to_file(cfg)\n\n # build train loader\n train_loader, train_sets = build_train_dataloader(cfg)\n\n # build model\n model = build_model(cfg, 0, init=cfg.MODEL.source_pretrained)\n model.cuda()\n\n if dist:\n model = torch.nn.parallel.DistributedDataParallel(\n model,\n device_ids=[cfg.gpu],\n output_device=cfg.gpu,\n find_unused_parameters=True,\n )\n elif cfg.total_gpus > 1:\n model = torch.nn.DataParallel(model)\n\n # build optimizer\n optimizer = build_optimizer([model,], **cfg.TRAIN.OPTIM)\n\n # build lr_scheduler\n if cfg.TRAIN.SCHEDULER.lr_scheduler is not None:\n lr_scheduler = build_lr_scheduler(optimizer, **cfg.TRAIN.SCHEDULER)\n else:\n lr_scheduler = None\n\n # build loss functions\n criterions = build_loss(cfg.TRAIN.LOSS, triplet_key=\"feat\", cuda=True)\n\n # build runner\n runner = BaseRunner(\n cfg,\n model,\n optimizer,\n criterions,\n train_loader,\n train_sets=train_sets,\n lr_scheduler=lr_scheduler,\n meter_formats={\"Time\": \":.3f\"},\n reset_optim=False,\n )\n\n # resume\n if args.resume_from:\n runner.resume(args.resume_from)\n\n # start training\n runner.run()\n\n # load the best model\n runner.resume(cfg.work_dir / \"model_best.pth\")\n\n # final testing\n test_loaders, queries, galleries = build_test_dataloader(cfg)\n for i, (loader, query, gallery) in enumerate(zip(test_loaders, queries, galleries)):\n cmc, mAP = test_reid(\n cfg, model, loader, query, gallery, dataset_name=cfg.TEST.datasets[i]\n )\n\n # print time\n end_time = time.monotonic()\n print(\"Total running time: \", timedelta(seconds=end_time - start_time))\n\n\nif __name__ == \"__main__\":\n main()\n"
] |
[
[
"torch.nn.parallel.DistributedDataParallel",
"torch.nn.DataParallel"
]
] |
Saloed/PythonGenerator
|
[
"f567bbb007cc858d4e7be410d668fba680b07933"
] |
[
"model/rnn_with_dropout.py"
] |
[
"import tensorflow as tf\nfrom current_net_conf import *\n\n\nclass RnnDropoutPlaceholders:\n probability = tf.placeholder(tf.float32, [])\n\n @staticmethod\n def feed(prob=1.0):\n return {RnnDropoutPlaceholders.probability: prob}\n\n\nclass MultiRnnWithDropout(tf.nn.rnn_cell.DropoutWrapper):\n\n def __init__(self, num_layers, state_size):\n internal_cells = [tf.nn.rnn_cell.GRUCell(state_size) for _ in range(num_layers)]\n internal_cell = tf.nn.rnn_cell.MultiRNNCell(internal_cells)\n super(MultiRnnWithDropout, self).__init__(\n cell=internal_cell,\n output_keep_prob=RnnDropoutPlaceholders.probability,\n state_keep_prob=RnnDropoutPlaceholders.probability\n )\n\n def initial_state(self, first_layer_initial_state):\n initial_state = self.zero_state(BATCH_SIZE, tf.float32)\n initial_state = list(initial_state)\n initial_state[0] = first_layer_initial_state\n initial_state = tuple(initial_state)\n return initial_state\n\n @staticmethod\n def zero_initial_inputs(size):\n return tf.zeros([BATCH_SIZE, size], dtype=tf.float32)\n\n\nclass EncoderDropoutPlaceholders:\n probability = tf.placeholder(tf.float32, [])\n\n @staticmethod\n def feed(prob=1.0):\n return {EncoderDropoutPlaceholders.probability: prob}\n\n\ndef apply_dropout_to_encoder_rnn_cells(cells):\n return [\n tf.nn.rnn_cell.DropoutWrapper(\n cell=cell,\n output_keep_prob=EncoderDropoutPlaceholders.probability,\n state_keep_prob=EncoderDropoutPlaceholders.probability\n )\n for cell in cells\n ]\n"
] |
[
[
"tensorflow.zeros",
"tensorflow.nn.rnn_cell.GRUCell",
"tensorflow.placeholder",
"tensorflow.nn.rnn_cell.MultiRNNCell",
"tensorflow.nn.rnn_cell.DropoutWrapper"
]
] |
josh146/OpenFermion
|
[
"e64c17a8043b2ad0a60695b581293bf903ad91a3"
] |
[
"src/openfermion/ops/_binary_code.py"
] |
[
"# 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\"\"\" Binary code class for Fermion-qubit mappings (arXiv:1712.07067) \"\"\"\n\nimport copy\n\nimport numpy\nimport scipy\nimport scipy.sparse\n\nfrom openfermion.ops import BinaryPolynomial\n\n\ndef shift_decoder(decoder, shift_constant):\n \"\"\" Shifts the indices of a decoder by a constant.\n\n Args:\n decoder (iterable): list of BinaryPolynomial; the decoder\n shift_constant (int): the qubit index that corresponds to the offset.\n\n Returns (list): list of BinaryPolynomial shifted decoder\n \"\"\"\n decode_shifted = []\n if not isinstance(shift_constant, (numpy.int64, numpy.int32, int)):\n raise TypeError('the shift to the decoder must be integer. got {}'\n 'of type {}'.format(shift_constant,\n type(shift_constant)))\n for entry in decoder:\n tmp_entry = copy.deepcopy(entry)\n tmp_entry.shift(shift_constant)\n decode_shifted.append(tmp_entry)\n return decode_shifted\n\n\ndef double_decoding(decoder_1, decoder_2):\n \"\"\" Concatenates two decodings\n\n Args:\n decoder_1 (iterable): list of BinaryPolynomial\n decoding of the outer code layer\n decoder_2 (iterable): list of BinaryPolynomial\n decoding of the inner code layer\n\n Returns (list): list of BinaryPolynomial the decoding defined by\n w -> decoder_1( decoder_2(w) )\n \"\"\"\n doubled_decoder = []\n for entry in decoder_1:\n tmp_sum = 0\n for summand in entry.terms:\n tmp_term = BinaryPolynomial('1')\n for factor in summand:\n if isinstance(factor, (numpy.int32, numpy.int64, int)):\n tmp_term *= decoder_2[factor]\n tmp_sum = tmp_term + tmp_sum\n doubled_decoder += [tmp_sum]\n return doubled_decoder\n\n\nclass BinaryCodeError(Exception):\n pass\n\n\nclass BinaryCode(object):\n \"\"\"The BinaryCode class provides a representation of an encoding-decoding\n pair for binary vectors of different lengths, where the decoding is allowed\n to be non-linear.\n\n As the occupation number of fermionic mode is effectively binary,\n a length-N vector (v) of binary number can be utilized to describe\n a configuration of a many-body fermionic state on N modes.\n An n-qubit product state configuration \\|w0> \\|w1> \\|w2> ... \\|wn-1>,\n on the other hand is described by a length-n binary vector\n w=(w0, w1, ..., wn-1). To map a subset of N-Orbital Fermion states\n to n-qubit states we define a binary code, which consists of a\n (here: linear) encoding (e) and a (non-linear) decoding (d), such\n that for every v from that subset, w = e(v) is a length-n binary\n vector with d(w) = v. This can be used to save qubits given a\n Hamiltonian that dictates such a subset, otherwise n=N.\n\n Two binary codes (e,d) and (e',d') can construct a third code (e\",d\")\n by two possible operations:\n\n Concatenation: (e\",d\") = (e,d) * (e',d')\n which means e\": v\" -> e'( e(v\") ) and d\": w\" -> d( d'(w\") )\n where n\" = n' and N\" = N, with n = N' as necessary condition.\n\n Appendage: (e\",d\") = (e,d) + (e',d')\n which means e\": (v + v') -> e(v) + e'(v') and d\": (w + w') -> d(w) + d'(\n w')\n where the addition is to be understood as appending two vectors together,\n so N\" = N' + N and n\" = n + n'.\n\n Appending codes is particularly useful when considering segment codes or\n segmented transforms.\n\n A BinaryCode-instance is initialized by BinaryCode(A,d),\n given the encoding (e) as n x N array or matrix-like nested lists A,\n such that e(v) = (A v) mod 2. The decoding d is an array or a list\n input of length N, which has entries either of type BinaryPolynomial, or of\n valid type for an input of the BinaryPolynomial-constructor.\n\n The signs + and \\*, += and \\*= are overloaded to implement concatenation\n and appendage on BinaryCode-objects.\n\n NOTE: multiplication of a BinaryCode with an integer yields a\n multiple appending of the same code, the multiplication with another\n BinaryCode their concatenation.\n\n Attributes:\n decoder (list): list of BinaryPolynomial: Outputs the decoding\n functions as components.\n encoder (scipy.sparse.csc_matrix): Outputs A, the linear matrix that\n implements the encoding function.\n n_modes (int): Outputs the number of modes.\n n_qubits (int): Outputs the number of qubits.\n \"\"\"\n\n def __init__(self, encoding, decoding):\n \"\"\" Initialization of a binary code.\n\n Args:\n encoding (np.ndarray or list): nested lists or binary 2D-array\n decoding (array or list): list of BinaryPolynomial (list or str).\n\n Raises:\n TypeError: non-list, array like encoding or decoding, unsuitable\n BinaryPolynomial generators,\n BinaryCodeError: in case of decoder/encoder size mismatch or\n decoder size, qubits indexed mismatch\n \"\"\"\n if not isinstance(encoding, (numpy.ndarray, list)):\n raise TypeError('encoding must be a list or array.')\n\n if not isinstance(decoding, (numpy.ndarray, list)):\n raise TypeError('decoding must be a list or array.')\n\n self.encoder = scipy.sparse.csc_matrix(encoding)\n self.n_qubits, self.n_modes = numpy.shape(encoding)\n\n if self.n_modes != len(decoding):\n raise BinaryCodeError(\n 'size mismatch, decoder and encoder should have the same'\n ' first dimension')\n\n decoder_qubits = set()\n self.decoder = []\n\n for symbolic_binary in decoding:\n if isinstance(symbolic_binary, (tuple, list, str, int,\n numpy.int32, numpy.int64)):\n symbolic_binary = BinaryPolynomial(symbolic_binary)\n if isinstance(symbolic_binary, BinaryPolynomial):\n self.decoder.append(symbolic_binary)\n decoder_qubits = decoder_qubits | set(\n symbolic_binary.enumerate_qubits())\n else:\n raise TypeError(\n 'decoder component provided '\n 'is not a suitable for BinaryPolynomial',\n symbolic_binary)\n\n if len(decoder_qubits) != self.n_qubits:\n raise BinaryCodeError(\n 'decoder and encoder provided has different number of qubits')\n\n if max(decoder_qubits) + 1 > self.n_qubits:\n raise BinaryCodeError('decoder is not indexing some qubits. Qubits'\n 'indexed are: {}'.format(decoder_qubits))\n\n def __iadd__(self, appendix):\n \"\"\" In-place appending a binary code with +=.\n\n Args:\n appendix (BinaryCode): The code to append to the present one.\n\n Returns (BinaryCode): A global binary code with size\n (n_modes1 + n_modes2), (n_qubits1,n_qubits2)\n\n Raises:\n TypeError: Appendix must be a BinaryCode.\n \"\"\"\n if not isinstance(appendix, BinaryCode):\n raise TypeError('argument must be a BinaryCode.')\n\n self.decoder = numpy.append(self.decoder,\n shift_decoder(appendix.decoder,\n self.n_qubits)).tolist()\n self.encoder = scipy.sparse.bmat([[self.encoder, None],\n [None, appendix.encoder]])\n self.n_qubits, self.n_modes = numpy.shape(self.encoder)\n return self\n\n def __add__(self, appendix):\n \"\"\"Appends two binary codes via addition +.\n\n Args:\n appendix (BinaryCode): The code to append to the present one.\n\n Returns (BinaryCode): global binary code\n \"\"\"\n twin = copy.deepcopy(self)\n twin += appendix\n return twin\n\n def __imul__(self, factor):\n \"\"\"In-place code concatenation or appendage via *= .\n Multiplication with integer will yield appendage, otherwise\n concatenation.\n\n Args:\n factor (int or BinaryCode): the BinaryCode to concatenate. In case\n of int, it will append the code to itself factor times.\n\n Returns (BinaryCode): segmented or concatenated code\n\n Raises:\n TypeError: factor must be an integer or a BinaryCode\n BinaryCodeError: size mismatch between self and factor\n ValueError: in case of an integer factor that is < 1\n \"\"\"\n if not isinstance(factor, (BinaryCode, numpy.int32, numpy.int64, int)):\n raise TypeError('argument must be a BinaryCode or integer')\n\n if isinstance(factor, BinaryCode):\n if self.n_qubits != factor.n_modes:\n raise BinaryCodeError(\n 'size mismatch between inner and outer code layer')\n\n self.decoder = double_decoding(self.decoder, factor.decoder)\n self.encoder = factor.encoder.dot(self.encoder)\n self.n_qubits, self.n_modes = numpy.shape(self.encoder)\n return self\n\n elif isinstance(factor, (numpy.int32, numpy.int64, int)):\n if factor < 1:\n raise ValueError('integer factor has to be positive, '\n 'non-zero ')\n\n self.encoder = scipy.sparse.kron(\n scipy.sparse.identity(factor, format='csc', dtype=int),\n self.encoder, 'csc')\n tmp_decoder = self.decoder\n for index in numpy.arange(1, factor):\n self.decoder = numpy.append(self.decoder,\n shift_decoder(tmp_decoder,\n index *\n self.n_qubits))\n self.n_qubits *= factor\n self.n_modes *= factor\n return self\n\n def __mul__(self, factor):\n \"\"\" Concatenation of two codes or appendage the same code factor times\n in case of integer factor.\n\n Args:\n factor (int or BinaryCode): the BinaryCode to concatenate. In case\n of int, it will append the code to itself factor times.\n\n Returns (BinaryCode): segmented or concatenated code\n \"\"\"\n twin = copy.deepcopy(self)\n twin *= factor\n return twin\n\n def __rmul__(self, factor):\n \"\"\" Appending the same code factor times.\n\n Args:\n factor (int): integer defining number of appendages.\n\n Returns (BinaryCode): Segmented code.\n\n Raises:\n TypeError: factor must be an integer\n \"\"\"\n if isinstance(factor, (numpy.int32, numpy.int64, int)):\n return self * factor\n else:\n raise TypeError('the left multiplier must be an integer to a'\n 'BinaryCode. Was given {} of '\n 'type {}'.format(factor, type(factor)))\n\n def __str__(self):\n \"\"\" Return an easy-to-read string representation.\"\"\"\n string_return = [list(map(list, self.encoder.toarray()))]\n\n dec_str = '['\n for term in self.decoder:\n dec_str += term.__str__() + ','\n dec_str = dec_str[:-1]\n string_return.append(dec_str + ']')\n return str(string_return)\n\n def __repr__(self):\n return str(self)\n"
] |
[
[
"scipy.sparse.bmat",
"scipy.sparse.csc_matrix",
"numpy.shape",
"scipy.sparse.identity",
"numpy.arange"
]
] |
meteorspectroscopy/meteor-spectrum-calibration
|
[
"483335eda2776f73c95d08cfa40a63fafb037d5c"
] |
[
"myselect.py"
] |
[
"import numpy as np\r\nfrom skimage import io as ios\r\nimport PySimpleGUI as sg\r\nimport warnings\r\n\r\nimport m_specfun as m_fun\r\n\r\n\r\ndef select_lines(infile, contrast, lines, res_dict, fits_dict, wloc, outfil):\r\n \"\"\"\r\n displays new window with image infile + start + 'fit\r\n a rectangle around the selected line can be selected with dragging the mouse\r\n :param infile: filebase of image\r\n :param contrast: brightness of image\r\n :param lines: list of calibration wavelengths\r\n :param res_dict: dictionary\r\n :param fits_dict: \"\r\n :param wloc: location of displayed window for selection\r\n :param outfil: filename without extension (.txt) with results of line selection\r\n :return:\r\n x0, y0: center coordinates of selected rectangle (int)\r\n dx, dy: half width and height of selected rectangle (int)\r\n \"\"\"\r\n\r\n def fitgaussimage(image, xy0, dxy, lam):\r\n x0 = xy0[0]\r\n y0 = xy0[1]\r\n dx = dxy[0]\r\n dy = dxy[1]\r\n print(x0, y0, dx, dy)\r\n data = image[y0 - dy:y0 + dy, x0 - dx:x0 + dx] # x - y reversed\r\n params, success = m_fun.fit_gaussian_2d(data)\r\n if success in [1, 2, 3, 4]:\r\n (height, x, y, width_x, width_y) = params # x and y reversed\r\n width_x = 2 * np.sqrt(2 * np.log(2)) * np.abs(width_x) # FWHM\r\n width_y = 2 * np.sqrt(2 * np.log(2)) * np.abs(width_y) # FWHM\r\n x = x + y0 - dy # y and x reversed\r\n y = y + x0 - dx\r\n xyw = (y, x, width_y, width_x, lam) # x - y changed back\r\n return xyw\r\n else:\r\n return 0, 0, 0, 0, 0\r\n\r\n xyl = []\r\n dxy = [10, 10]\r\n i = i_plot = 0\r\n im, header = m_fun.get_fits_image(infile)\r\n if len(im.shape) == 3:\r\n imbw = np.sum(im, axis=2) # used for fitgaussian(data)\r\n else:\r\n imbw = im\r\n # (ymax, xmax) = im.shape\r\n # print (xmax,ymax)\r\n m_fun.get_fits_keys(header, fits_dict, res_dict, keyprint=False)\r\n # #===================================================================\r\n # new rect_plt\r\n # first get size of graph from tmp.png and size of image\r\n # graph coordinates are in image pixels!\r\n (imy, imx) = im.shape[:2]\r\n image_file = 'tmp.png' # scaled image\r\n imrescale = np.flipud(ios.imread(image_file)) # get shape\r\n (canvasy, canvasx) = imrescale.shape[:2]\r\n wlocw = (wloc[0], wloc[1])\r\n image_elem_sel = [sg.Graph(canvas_size=(canvasx, canvasy), graph_bottom_left=(0, 0),\r\n graph_top_right=(imx, imy), key='-GRAPH-', change_submits=True, drag_submits=True)]\r\n layout_select = [[sg.Ok(), sg.Cancel(), sg.Button('Skip Line'), sg.Button('Finish'),\r\n sg.Button('I'), sg.Button('D'), sg.Text(infile, size=(30, 1)),\r\n sg.Text(key='info', size=(40, 1))], image_elem_sel]\r\n winselect = sg.Window(f'select rectangle for fit size, click lines',\r\n layout_select, finalize=True, location=wlocw,\r\n keep_on_top=True, no_titlebar=False, resizable=True,\r\n disable_close=False, disable_minimize=True, element_padding=(2, 2))\r\n # get the graph element for ease of use later\r\n graph = winselect['-GRAPH-'] # type: sg.Graph\r\n # initialize interactive graphics\r\n winselect_active = True\r\n img = graph.draw_image(image_file, location=(0, imy))\r\n dragging = False\r\n start_point = end_point = prior_rect = None\r\n index = 0\r\n icircle = itext = None\r\n color = 'yellow'\r\n while winselect_active:\r\n event, values = winselect.read()\r\n if event == \"-GRAPH-\": # if there's a \"Graph\" event, then it's a mouse\r\n x, y = (values[\"-GRAPH-\"])\r\n if not dragging:\r\n start_point = (x, y)\r\n dragging = True\r\n else:\r\n end_point = (x, y)\r\n if prior_rect:\r\n graph.delete_figure(prior_rect)\r\n if None not in (start_point, end_point):\r\n prior_rect = graph.draw_rectangle(start_point,\r\n end_point, line_color='red')\r\n elif event is not None and event.endswith('+UP'):\r\n # The drawing has ended because mouse up\r\n xy0 = [int(0.5 * (start_point[0] + end_point[0])),\r\n int(0.5 * (start_point[1] + end_point[1]))]\r\n size = (abs(start_point[0] - end_point[0]),\r\n abs(start_point[1] - end_point[1]))\r\n info = winselect[\"info\"]\r\n info.update(value=f\"grabbed rectangle at {xy0} with size {size}\")\r\n start_point, end_point = None, None # enable grabbing a new rect\r\n dragging = False\r\n if min(size[0], size[1]) > 2: # rectangle\r\n info.update(value=f\"rectangle at {xy0} with size {size}\")\r\n dxy = size\r\n elif i < len(lines):\r\n if prior_rect:\r\n graph.delete_figure(prior_rect)\r\n print(xy0, lines[i])\r\n xyw = (fitgaussimage(imbw, xy0, dxy, lines[i]))\r\n if xyw[0]: # successful fit\r\n if 0 < xyw[0] < imx and 0 < xyw[1] < imy:\r\n print(np.float16(xyw))\r\n xyl.append(np.float32(xyw))\r\n # Draw the click just made\r\n r = (xyw[2] + xyw[3])/4\r\n icircle = graph.DrawCircle((xyw[0], xyw[1]), r, line_color=color, line_width=3)\r\n itext = graph.DrawText(' ' + str(lines[i]), location=(xyw[0], xyw[1]), color=color,\r\n font=('Arial', 12), angle=45, text_location=sg.TEXT_LOCATION_BOTTOM_LEFT)\r\n info.update(value=f\"line {lines[i]} at {np.float16(xyw)}\")\r\n graph.update()\r\n i += 1\r\n i_plot += 1\r\n else:\r\n info.update(value='bad fit, try again')\r\n print('bad fit, try again')\r\n else:\r\n info.update(value='Fit not successful, try again')\r\n print('Fit not successful, try again')\r\n else:\r\n info.update(value='all lines measured, press OK or Cancel')\r\n\r\n elif event == 'Ok':\r\n if np.array(xyl).shape[0] > 1:\r\n # minimum of two lines needed for fit\r\n xyl = np.array(xyl, dtype=np.float32) # for ordered output\r\n with open(m_fun.change_extension(outfil, '.txt'), 'ab+') as f:\r\n np.savetxt(f, xyl, fmt='%8.2f', header=str(index) + ' ' + str(infile) + '.fit')\r\n np.savetxt(f, np.zeros((1, 5)), fmt='%8.2f')\r\n index += 1\r\n color = 'red' if color == 'yellow' else 'yellow' # alternate colors for spectra\r\n elif icircle:\r\n graph.delete_figure(icircle) # last point\r\n graph.delete_figure(itext)\r\n graph.update()\r\n xyl = []\r\n i = i_plot = 0\r\n\r\n elif event == 'Cancel':\r\n for ind in range(i_plot):\r\n xyl = np.array(xyl, dtype=np.float32) # for ordered output\r\n rsq2 = (xyl[ind, 2] + xyl[ind, 3])/5.6\r\n drag_figures = graph.get_figures_at_location((xyl[ind, 0] + rsq2, xyl[ind, 1] + rsq2))\r\n for figure in drag_figures:\r\n if figure != img:\r\n graph.delete_figure(figure)\r\n graph.update()\r\n xyl = []\r\n i = i_plot = 0\r\n\r\n elif event == 'Skip Line':\r\n i += 1 # do not increment iplot!\r\n\r\n elif event in ('I', 'D'):\r\n if event == 'I':\r\n contrast *= 2\r\n else:\r\n contrast /= 2\r\n im_tmp = imrescale / np.max(imrescale) * 255 * contrast\r\n im_tmp = np.clip(im_tmp, 0.0, 255)\r\n with warnings.catch_warnings():\r\n warnings.simplefilter(\"ignore\")\r\n ios.imsave(image_file, np.flipud(im_tmp).astype(np.uint8))\r\n graph.delete_figure(img)\r\n img = graph.draw_image(image_file, location=(0, imy))\r\n graph.send_figure_to_back(img)\r\n\r\n elif event in ('Finish', None):\r\n if event == 'Finish':\r\n with open(outfil + '.txt', 'ab+') as f:\r\n np.savetxt(f, np.zeros((1, 5)), fmt='%8.2f')\r\n (x, y) = winselect.current_location()\r\n wlocw = (x, y)\r\n winselect.close()\r\n return wlocw\r\n\r\n\r\n"
] |
[
[
"numpy.max",
"numpy.array",
"numpy.float16",
"numpy.log",
"numpy.zeros",
"numpy.sum",
"numpy.flipud",
"numpy.float32",
"numpy.abs",
"numpy.clip"
]
] |
Carreau/phd-dissertation
|
[
"f283cf3819af019027a4e017141ec51029a0e46c",
"f283cf3819af019027a4e017141ec51029a0e46c"
] |
[
"src/systemidentification/control_parameters_vs_speed_plots.py",
"src/control/publication_historgram.py"
] |
[
"import numpy as np\nfrom scipy.optimize import curve_fit\nimport matplotlib.pyplot as plt\n\nfrom load_rider_id_results import df\n\n# Plot parameters for Latex output\nparams = {'backend': 'ps',\n 'axes.labelsize': 10,\n 'text.fontsize': 10,\n 'legend.fontsize': 8,\n 'xtick.labelsize': 8,\n 'ytick.labelsize': 8,\n 'text.usetex': True,\n 'figure.dpi': 200,\n }\nplt.rcParams.update(params)\n\n# Create a histogram of the speeds\nfig, ax = plt.subplots(1, 1, squeeze=True)\nfig.set_size_inches(5, 5)\nax.hist(df['speed'], bins=40, range=(0, 10), align='mid')\nax.set_xlabel('Speed m/s')\nax.set_ylabel('Runs')\nax.set_xticks(np.linspace(0, 10, 21))\nfig.savefig('../../figures/systemidentification/speed-hist-all.png')\nfig.savefig('../../figures/systemidentification/speed-hist-all.pdf')\n\n# plot the controller parameters versus speed\n\nfig, ax = plt.subplots(6, 1, sharex=True)\nfig.set_size_inches(6, 7.5)\n\nspeedBins = np.linspace(0.0, 10.0, num=41)\nparameters = ['kDelta', 'kPhiDot', 'kPhi', 'kPsi', 'kYQ', 'wnm']\nplotData = {k : [] for k in parameters}\nnums = []\nmeanFits = []\nfor v in speedBins:\n sbin = df[(v - 0.25 < df['speed']) & (df['speed'] < v + 0.25)]\n nums.append(len(sbin))\n meanFits.append(sbin['fit'].mean())\n for par in parameters:\n plotData[par].append(sbin[par])\n\nwidths = 0.25 * (np.sqrt(nums) / np.max(np.sqrt(nums)))\nline = lambda x, m, b: m * x + b\nconstant = lambda x, c: c\nylims = [(0, 100), (-8, 1), (1, 12), (-0.5, 3), (-0.5, 2), (0, 80)]\nfor i, par in enumerate(parameters):\n # Fit a weight line through the medians.\n y = np.array([sbin.median() for sbin in plotData[par]])\n x = speedBins\n weight = np.array([sbin.std() for sbin in plotData[par]])\n if par == 'wnm':\n b, cov = curve_fit(constant, x[~np.isnan(y)], y[~np.isnan(y)],\n sigma=1. / widths[~np.isnan(y)])\n m = 0.0\n else:\n (m, b), cov = curve_fit(line, x[~np.isnan(y)], y[~np.isnan(y)],\n sigma=1. / widths[~np.isnan(y)])\n ax[i].plot(np.linspace(0, 10), m * np.linspace(0, 10) + b, '-g')\n ax[i].boxplot(plotData[par], positions=speedBins, widths=widths)\n ax[i].set_ylim(ylims[i])\n ax[i].set_ylabel(par)\n #xts = ax[i].get_xticks()\n xticks = np.linspace(0.0, 10.0, num=21)\n ax[i].set_xticks(xticks)\n #ax[i].set_xticks(xts - 0.25)\n #ax[i].set_xticklabels(speedBins)\nax[-1].set_xlabel('Speed m/s')\n\nfig.savefig('../../figures/systemidentification/par-vs-speed-box-all.png')\nfig.savefig('../../figures/systemidentification/par-vs-speed-box-all.pdf')\n#top = ax[0].twiny()\n#top.set_xticks(ax[0].get_xticks() - 1.5)\n#top.set_xticklabels([''] + ['{}'.format(n) for n in nums])\n",
"#!/usr/bin/env python\n\nfrom pybtex.database.input import bibtex\nimport matplotlib.pyplot as plt\n\nparser = bibtex.Parser()\npath = '/media/Data/Documents/School/UC Davis/Bicycle Mechanics/Papers/bicycle.bib'\nbib_data = parser.parse_file(path)\nyears = []\nfor entry in bib_data.entries:\n try:\n years.append(int(bib_data.entries[entry].fields['year']))\n except:\n pass\n\nplt.hist(years, bins=40)\nplt.title('{} Total Publications'.format(len(years)))\nplt.xticks(range(1860, 2030, 10), fontsize=6, rotation=20.0)\nplt.yticks(range(0, 140, 20), fontsize=6)\nplt.ylabel('Number of Publications')\nplt.xlabel('Year')\nfig = plt.gcf()\nfig.set_size_inches(4.0, 4.0)\nfig.savefig('../../figures/control/pub-hist.png', dpi=200)\nfig.savefig('../../figures/control/pub-hist.pdf')\nplt.show()\n"
] |
[
[
"matplotlib.pyplot.rcParams.update",
"numpy.isnan",
"matplotlib.pyplot.subplots",
"numpy.sqrt",
"numpy.linspace"
],
[
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.hist",
"matplotlib.pyplot.gcf",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.show"
]
] |
dmsm/DeepParametricShapes
|
[
"2e0de365191b29c61796f7cd6cbd2bdf631eae2c"
] |
[
"dps_3d/interfaces.py"
] |
[
"import string\n\nimport numpy as np\nimport torch as th\n\nfrom ttools.training import ModelInterface\n\nfrom . import utils\n\n\nclass VectorizerInterface(ModelInterface):\n def __init__(self, model, lr, n_primitives, canvas_size, w_surface, w_alignment, csg, rounded, cuda=True):\n self.model = model\n self.cuda = cuda\n self.n_primitives = n_primitives\n self.canvas_size = canvas_size\n self.w_surface = w_surface\n self.w_alignment = w_alignment\n self.csg = csg\n self.rounded = rounded\n self._step = 0\n\n if self.cuda:\n self.model.cuda()\n\n self.optimizer = th.optim.Adam(self.model.parameters(), lr=lr)\n\n def forward(self, batch):\n df = batch['distance_fields']\n if self.cuda:\n df = df.cuda()\n\n params = self.model(df[:,None]).view(df.size(0), self.n_primitives, -1)\n params = th.cat([0.35*params[...,:3], params[...,3:]], dim=-1)\n\n df = utils.distance_to_rounded_cuboids if self.rounded else utils.distance_to_cuboids\n if self.csg:\n plus_params = params[:,:self.n_primitives//2]\n plus_distance_fields = utils.compute_distance_fields(plus_params, self.canvas_size, df=df)\n plus_distance_fields = plus_distance_fields.min(1)[0]\n\n minus_params = params[:,self.n_primitives//2:]\n minus_distance_fields = utils.compute_distance_fields(minus_params, self.canvas_size, df=df)\n minus_distance_fields = minus_distance_fields.min(1)[0]\n\n distance_fields = th.max(plus_distance_fields, -minus_distance_fields) ** 2\n else:\n distance_fields = utils.compute_distance_fields(params, self.canvas_size, df=df)\n distance_fields = distance_fields.min(1)[0] ** 2\n alignment_fields = utils.compute_alignment_fields(distance_fields)\n distance_fields = distance_fields[...,1:-1,1:-1,1:-1]\n occupancy_fields = utils.compute_occupancy_fields(distance_fields)\n\n return {\n 'distance_fields': distance_fields,\n 'alignment_fields': alignment_fields,\n 'occupancy_fields': occupancy_fields\n }\n\n def _compute_lossses(self, batch, fwd_data):\n ret = {}\n\n target_distance_fields = batch['distance_fields']\n target_alignment_fields = batch['alignment_fields']\n target_occupancy_fields = batch['occupancy_fields']\n if self.cuda:\n target_distance_fields = target_distance_fields.cuda()\n target_alignment_fields = target_alignment_fields.cuda()\n target_occupancy_fields = target_occupancy_fields.cuda()\n\n distance_fields = fwd_data['distance_fields']\n alignment_fields = fwd_data['alignment_fields']\n occupancy_fields = fwd_data['occupancy_fields']\n\n surfaceloss = th.mean(target_occupancy_fields*distance_fields + target_distance_fields*occupancy_fields)\n alignmentloss = th.mean(1 - th.sum(target_alignment_fields*alignment_fields, dim=-1)**2)\n ret['surfaceloss'] = surfaceloss\n ret['alignmentloss'] = alignmentloss\n\n loss = self.w_surface*surfaceloss + self.w_alignment*alignmentloss\n ret['loss'] = loss\n\n return ret\n\n def training_step(self, batch):\n self.model.train()\n fwd_data = self.forward(batch)\n\n self.optimizer.zero_grad()\n\n losses_dict = self._compute_lossses(batch, fwd_data)\n loss = losses_dict['loss']\n\n loss.backward()\n self.optimizer.step()\n self._step += 1\n\n return { k: v.item() for k, v in losses_dict.items() }\n\n def init_validation(self):\n losses = ['loss', 'surfaceloss', 'alignmentloss']\n ret = { l: 0 for l in losses }\n ret['count'] = 0\n return ret\n\n def validation_step(self, batch, running_data):\n self.model.eval()\n n = batch['distance_fields'].shape[0]\n count = running_data['count']\n\n fwd_data = self.forward(batch)\n losses_dict = self._compute_lossses(batch, fwd_data)\n loss = losses_dict['loss']\n surfaceloss = losses_dict['surfaceloss']\n alignmentloss = losses_dict['alignmentloss']\n return {\n 'loss': (running_data['loss']*count + loss.item()*n) / (count+n),\n 'surfaceloss': (running_data['surfaceloss']*count + surfaceloss.item()*n) / (count+n),\n 'alignmentloss': (running_data['alignmentloss']*count + alignmentloss.item()*n) / (count+n),\n 'count': count+n\n }\n"
] |
[
[
"torch.sum",
"torch.cat",
"torch.mean",
"torch.max"
]
] |
raufbhat-dev/Deep-Neural-Net-Numpy
|
[
"db347057c0763945b5a4852128b99cc64cc562a4"
] |
[
"neuralnetnumpy/neuralnet.py"
] |
[
"import numpy as np\n\nfrom neuralnetnumpy import layer, optimiser, loss\n\nclass NeuralNet:\n def __init__(self, loss_func, optimiser_method, learning_rate, epoch, partition_size, mode, network_arch):\n self.loss_func = loss_func\n self.optimiser = optimiser_method\n self.epoch_count = epoch\n self.partition_size = partition_size \n self.learning_rate = learning_rate\n self.mode = mode\n self.layers_list = []\n self.loss = loss.Loss(self.loss_func)\n self.network_arch = network_arch\n if optimiser_method == 'momentum':\n self.momentum = True\n self.optimiser = optimiser.GradientDescent(True,self.learning_rate,self.beta)\n else:\n self.optimiser = optimiser.GradientDescent(False,self.learning_rate)\n \n def createNetwork(self):\n network_layers = []\n for index, _layer in enumerate(self.network_arch):\n if _layer['layer_type'] != 'input':\n self.layers_list.append(layer.Layer(self.network_arch[index-1]['size'],_layer['size'], _layer['activation'],_layer['layer_type']))\n\n def forwardPass(self, inputs, output):\n layer_out = inputs\n for _layer in self.layers_list:\n layer_out = _layer(inputs)\n inputs = layer_out\n if self.mode.lower() == 'train':\n self.loss.getLoss()(layer_out,output)\n elif self.mode.lower() == 'test':\n return layer_out\n \n def backProp(self, inputs,**kwargs):\n upstream_gradient = self.loss.loss_derivative\n for index, _layer in enumerate(reversed(self.layers_list)):\n if _layer.layer_type == 'output':\n upstream_gradient = np.multiply(_layer.activation_derivative, upstream_gradient)\n upstream_gradient_w = np.matmul(self.layers_list[len(self.layers_list)-2].y_activation.T, upstream_gradient) \n if _layer.layer_type == 'hidden':\n upstream_gradient = np.matmul(upstream_gradient, self.layers_list[len(self.layers_list) -index].w.T)\n upstream_gradient = np.multiply(upstream_gradient,_layer.activation_derivative)\n if (len(self.layers_list)-index-1) != 0:\n upstream_gradient_w = np.matmul(self.layers_list[len(self.layers_list) -index -2].y_activation.T,upstream_gradient)\n else:\n upstream_gradient_w = np.matmul(inputs.T,upstream_gradient)\n upstream_gradient_b = np.sum(upstream_gradient,axis=0).T\n self.optimiser(_layer, upstream_gradient_w, upstream_gradient_b)\n\n for _layer_ in self.layers_list:\n _layer_.w = _layer_.w + _layer_.w_delta\n _layer_.b = _layer_.b + _layer_.b_delta\n \n def train(self, inputs, outputs):\n inputs = np.array_split(inputs, self.partition_size)\n Y = np.array_split(outputs, self.partition_size)\n for i in range(self.epoch_count):\n for inp_batch, out_batch in zip(inputs, Y): \n self.forwardPass(inp_batch, out_batch)\n self.backProp(inp_batch)\n if i%500 == 0:\n print('Epoch:{} Loss: {}'.format(i+1,self.loss.loss))\n"
] |
[
[
"numpy.multiply",
"numpy.sum",
"numpy.matmul",
"numpy.array_split"
]
] |
dineshsonachalam/deeplearning4nlp-tutorial
|
[
"2a36ecc39f13b683752483546441468fd7d734b3"
] |
[
"2017-07_Seminar/Session 3 - Relation CNN/code/preprocess.py"
] |
[
"\"\"\"\nThe file preprocesses the files/train.txt and files/test.txt files.\n\nI requires the dependency based embeddings by Levy et al.. Download them from his website and change \nthe embeddingsPath variable in the script to point to the unzipped deps.words file.\n\"\"\"\nfrom __future__ import print_function\nimport numpy as np\nimport gzip\nimport os\nimport sys\nif (sys.version_info > (3, 0)):\n import pickle as pkl\nelse: #Python 2.7 imports\n import cPickle as pkl\n\noutputFilePath = 'pkl/sem-relations.pkl.gz'\n\n\n#We download English word embeddings from here https://www.cs.york.ac.uk/nlp/extvec/\nembeddingsPath = 'embeddings/wiki_extvec.gz'\n\n\nfolder = 'files/'\nfiles = [folder+'train.txt', folder+'test.txt']\n\n#Mapping of the labels to integers\nlabelsMapping = {'Other':0, \n 'Message-Topic(e1,e2)':1, 'Message-Topic(e2,e1)':2, \n 'Product-Producer(e1,e2)':3, 'Product-Producer(e2,e1)':4, \n 'Instrument-Agency(e1,e2)':5, 'Instrument-Agency(e2,e1)':6, \n 'Entity-Destination(e1,e2)':7, 'Entity-Destination(e2,e1)':8,\n 'Cause-Effect(e1,e2)':9, 'Cause-Effect(e2,e1)':10,\n 'Component-Whole(e1,e2)':11, 'Component-Whole(e2,e1)':12, \n 'Entity-Origin(e1,e2)':13, 'Entity-Origin(e2,e1)':14,\n 'Member-Collection(e1,e2)':15, 'Member-Collection(e2,e1)':16,\n 'Content-Container(e1,e2)':17, 'Content-Container(e2,e1)':18}\n\n\n\n\nwords = {}\nmaxSentenceLen = [0,0]\n\n\ndistanceMapping = {'PADDING': 0, 'LowerMin': 1, 'GreaterMax': 2}\nminDistance = -30\nmaxDistance = 30\nfor dis in range(minDistance,maxDistance+1):\n distanceMapping[dis] = len(distanceMapping)\n\n\n\ndef createMatrices(file, word2Idx, maxSentenceLen=100):\n \"\"\"Creates matrices for the events and sentence for the given file\"\"\"\n labels = []\n positionMatrix1 = []\n positionMatrix2 = []\n tokenMatrix = []\n \n for line in open(file):\n splits = line.strip().split('\\t')\n \n label = splits[0]\n pos1 = splits[1]\n pos2 = splits[2]\n sentence = splits[3]\n tokens = sentence.split(\" \")\n \n \n \n \n tokenIds = np.zeros(maxSentenceLen)\n positionValues1 = np.zeros(maxSentenceLen)\n positionValues2 = np.zeros(maxSentenceLen)\n \n for idx in range(0, min(maxSentenceLen, len(tokens))):\n tokenIds[idx] = getWordIdx(tokens[idx], word2Idx)\n \n distance1 = idx - int(pos1)\n distance2 = idx - int(pos2)\n \n if distance1 in distanceMapping:\n positionValues1[idx] = distanceMapping[distance1]\n elif distance1 <= minDistance:\n positionValues1[idx] = distanceMapping['LowerMin']\n else:\n positionValues1[idx] = distanceMapping['GreaterMax']\n \n if distance2 in distanceMapping:\n positionValues2[idx] = distanceMapping[distance2]\n elif distance2 <= minDistance:\n positionValues2[idx] = distanceMapping['LowerMin']\n else:\n positionValues2[idx] = distanceMapping['GreaterMax']\n \n tokenMatrix.append(tokenIds)\n positionMatrix1.append(positionValues1)\n positionMatrix2.append(positionValues2)\n \n labels.append(labelsMapping[label])\n \n\n \n return np.array(labels, dtype='int32'), np.array(tokenMatrix, dtype='int32'), np.array(positionMatrix1, dtype='int32'), np.array(positionMatrix2, dtype='int32'),\n \n \n \n \ndef getWordIdx(token, word2Idx): \n \"\"\"Returns from the word2Idex table the word index for a given token\"\"\" \n if token in word2Idx:\n return word2Idx[token]\n elif token.lower() in word2Idx:\n return word2Idx[token.lower()]\n \n return word2Idx[\"UNKNOWN_TOKEN\"]\n\n\n\nfor fileIdx in range(len(files)):\n file = files[fileIdx]\n for line in open(file):\n splits = line.strip().split('\\t')\n \n label = splits[0]\n \n \n sentence = splits[3] \n tokens = sentence.split(\" \")\n maxSentenceLen[fileIdx] = max(maxSentenceLen[fileIdx], len(tokens))\n for token in tokens:\n words[token.lower()] = True\n \n\nprint(\"Max Sentence Lengths: \", maxSentenceLen)\n \n# :: Read in word embeddings ::\n# :: Read in word embeddings ::\nword2Idx = {}\nwordEmbeddings = []\n\n# :: Downloads the embeddings from the York webserver ::\nif not os.path.isfile(embeddingsPath):\n basename = os.path.basename(embeddingsPath)\n if basename == 'wiki_extvec.gz':\n print(\"Start downloading word embeddings for English using wget ...\")\n #os.system(\"wget https://www.cs.york.ac.uk/nlp/extvec/\"+basename+\" -P embeddings/\")\n os.system(\"wget https://public.ukp.informatik.tu-darmstadt.de/reimers/2017_english_embeddings/\"+basename+\" -P embeddings/\")\n else:\n print(embeddingsPath, \"does not exist. Please provide pre-trained embeddings\")\n exit()\n \n# :: Load the pre-trained embeddings file ::\nfEmbeddings = gzip.open(embeddingsPath, \"r\") if embeddingsPath.endswith('.gz') else open(embeddingsPath, encoding=\"utf8\")\n\t\nprint(\"Load pre-trained embeddings file\")\nfor line in fEmbeddings:\n split = line.decode('utf-8').strip().split(\" \")\n word = split[0]\n \n if len(word2Idx) == 0: #Add padding+unknown\n word2Idx[\"PADDING_TOKEN\"] = len(word2Idx)\n vector = np.zeros(len(split)-1) #Zero vector vor 'PADDING' word\n wordEmbeddings.append(vector)\n \n word2Idx[\"UNKNOWN_TOKEN\"] = len(word2Idx)\n vector = np.random.uniform(-0.25, 0.25, len(split)-1)\n wordEmbeddings.append(vector)\n\n if word.lower() in words:\n vector = np.array([float(num) for num in split[1:]])\n wordEmbeddings.append(vector)\n word2Idx[word] = len(word2Idx)\n \n \nwordEmbeddings = np.array(wordEmbeddings)\n\nprint(\"Embeddings shape: \", wordEmbeddings.shape)\nprint(\"Len words: \", len(words))\n\n\n\n# :: Create token matrix ::\ntrain_set = createMatrices(files[0], word2Idx, max(maxSentenceLen))\ntest_set = createMatrices(files[1], word2Idx, max(maxSentenceLen))\n\n\ndata = {'wordEmbeddings': wordEmbeddings, 'word2Idx': word2Idx, \n 'train_set': train_set, 'test_set': test_set}\n\nf = gzip.open(outputFilePath, 'wb')\npkl.dump(data, f)\nf.close()\n\n\n\nprint(\"Data stored in pkl folder\")\n\n \n "
] |
[
[
"numpy.array",
"numpy.zeros"
]
] |
Houchaoqun/ALiPy
|
[
"93aff0379db2a1994803d19026c434c2b12a2485"
] |
[
"alipy/query_strategy/noisy_oracles.py"
] |
[
"\"\"\"\nPre-defined query strategy for noisy oracles.\n\nIn reality, the labels given by human is not always correct. For one hand,\nthere are some inevitable noise comes from the instrumentation of experimental\nsetting. On the other hand, people can become distracted or fatigued over time,\nintroducing variability in the quality of their annotations.\n\nALiPy implements several strategies in noisy oracles settings.\nSome of then mainly evaluate the quality or expertise of each oracle,\nand the rest tries to obtain the accurate label for each instance\nwhose labels are provided by several noisy oracles.\n\nThere are 2 categories of methods.\n1. Query from a single selected oracle.\n 1.1 Always query from the best oracle\n 1.2 Query from the most appropriate oracle\n according to the selected instance and label.\n2. Query from multiple noisy oracles. Labels are obtained from multiple noisy oracles.\nAnd the algorithm tries to obtain the accurate label for each instance.\n\nImplement method:\n1: CEAL (IJCAI'17)\n2: IEthresh (KDD'09 Donmez)\nBaselines:\nMajority vote\nQuery from all oracles and majority vote\nRandom select an oracle\n\"\"\"\n# Authors: Ying-Peng Tang\n# License: BSD 3 clause\n\nfrom __future__ import division\n\nimport collections\nfrom abc import ABCMeta, abstractmethod\n\nimport copy\nimport numpy as np\nimport scipy.stats\nfrom sklearn.linear_model import LogisticRegression\nfrom sklearn.neighbors import NearestNeighbors\n\nfrom .base import BaseNoisyOracleQuery\nfrom .query_labels import QueryInstanceUncertainty\nfrom .query_labels import _get_proba_pred\nfrom ..oracle import Oracles, Oracle\n\n\ndef majority_vote(labels, weight=None):\n \"\"\"Perform majority vote to determine the true label from\n multiple noisy oracles.\n\n Parameters\n ----------\n labels: list\n A list with length=k, which contains the labels provided by\n k noisy oracles.\n\n weight: list, optional (default=None)\n The weights of each oracle. It should have the same length with\n labels.\n\n Returns\n -------\n vote_count: int\n The number of votes.\n\n vote_result: object\n The label of the selected_instance, produced by majority voting\n of the selected oracles.\n \"\"\"\n oracle_weight = np.ones(len(labels)) if weight is None else weight\n assert len(labels) == len(oracle_weight)\n\n vote_result = collections.Counter(labels)\n most_votes = vote_result.most_common(n=1)\n return most_votes[0][1], most_votes[0][0]\n\n\ndef get_query_results(selected_instance, oracles, names=None):\n \"\"\"Get the query results from oracles of the selected instance.\n\n Parameters\n ----------\n selected_instance: int\n The indexes of selected samples. Should be a member of unlabeled set.\n\n oracles: {list, alipy.oracle.Oracles}\n An alipy.oracle.Oracle object that contains all the\n available oracles or a list of oracles.\n Each oracle should be a alipy.oracle.Oracle object.\n\n names: list, optional (default=None)\n A list of str which contains the names of oracles to query from.\n If not provided, it will query from all oracles.\n Each name should in oracles.names().\n\n Returns\n -------\n query_labels: list\n The queried labels.\n\n query_costs: list\n The total cost of query.\n \"\"\"\n costs = []\n if isinstance(oracles, list):\n oracle_type = 'list'\n for oracle in oracles:\n assert isinstance(oracle, Oracle)\n elif isinstance(oracles, Oracles):\n oracle_type = 'oracles'\n else:\n raise TypeError(\"The type of parameter oracles must be a list or alipy.oracle.Oracles object.\")\n labeling_results = []\n if oracle_type == 'list':\n for i in oracles.names() if oracle_type == 'oracles' else range(len(oracles)):\n lab, co = oracles[i].query_by_index(selected_instance)\n labeling_results.append(lab[0])\n costs.append(np.sum(co))\n else:\n results = oracles.query_from_s(selected_instance, oracles_name=names)\n labeling_results = [res[0][0] for res in results]\n costs = [np.sum(res[1]) for res in results]\n return labeling_results, costs\n\ndef get_majority_vote(selected_instance, oracles, names=None):\n \"\"\"Get the majority vote results of the selected instance.\n\n Parameters\n ----------\n selected_instance: int\n The indexes of selected samples. Should be a member of unlabeled set.\n\n oracles: {list, alipy.oracle.Oracles}\n An alipy.oracle.Oracle object that contains all the\n available oracles or a list of oracles.\n Each oracle should be a alipy.oracle.Oracle object.\n\n names: list, optional (default=None)\n A list of str which contains the names of oracles to query from.\n If not provided, it will query from all oracles.\n Each name should in oracles.names().\n\n Returns\n -------\n vote_count: int\n The number of votes.\n\n vote_result: object\n The label of the selected_instance, produced by majority voting\n of the selected oracles.\n\n query_costs: int\n The total cost of query.\n \"\"\"\n labeling_results, cost = get_query_results(selected_instance, oracles, names)\n majority_vote_result = majority_vote(labeling_results)\n return majority_vote_result[0], majority_vote_result[1], np.sum(cost)\n\n\nclass QueryNoisyOraclesCEAL(BaseNoisyOracleQuery):\n \"\"\"Cost-Effective Active Learning from Diverse Labelers (CEAL) method assumes\n that different oracles have different expertise. Even the very noisy oracle\n may perform well on some kind of examples. The cost of a labeler is proportional\n to its overall labeling quality and it is thus necessary to query from the right oracle\n according to the selected instance.\n\n This method will select an instance-labeler pair (x, a), and queries the label of x\n from a, where the selection of both the instance and labeler is based on a\n evaluation function Q(x, a).\n\n The selection of instance is depend on its uncertainty. The selection of oracle is\n depend on the oracle's performance on the nearest neighbors of selected instance.\n The cost of each oracle is proportional to its overall labeling quality.\n\n Parameters\n ----------\n X: 2D array, optional (default=None)\n Feature matrix of the whole dataset. It is a reference which will not use additional memory.\n\n y: array-like, optional (default=None)\n Label matrix of the whole dataset. It is a reference which will not use additional memory.\n\n oracles: {list, alipy.oracle.Oracles}\n An alipy.oracle.Oracle object that contains all the\n available oracles or a list of oracles.\n Each oracle should be a alipy.oracle.Oracle object.\n\n initial_labeled_indexes: {list, np.ndarray, IndexCollection}\n The indexes of initially labeled samples. Used for initializing the scores of each oracle.\n\n References\n ----------\n [1] Sheng-Jun Huang, Jia-Lve Chen, Xin Mu, Zhi-Hua Zhou. 2017.\n Cost-Effective Active Learning from Diverse Labelers. In The\n Proceedings of the 26th International Joint Conference\n on Artificial Intelligence (IJCAI-17), 1879-1885.\n \"\"\"\n\n def __init__(self, X, y, oracles, initial_labeled_indexes):\n super(QueryNoisyOraclesCEAL, self).__init__(X, y, oracles=oracles)\n # ytype = type_of_target(self.y)\n # if 'multilabel' in ytype:\n # warnings.warn(\"This query strategy does not support multi-label.\",\n # category=FunctionWarning)\n assert (isinstance(initial_labeled_indexes, collections.Iterable))\n self._ini_ind = np.asarray(initial_labeled_indexes)\n # construct a nearest neighbor object implemented by scikit-learn\n self._nntree = NearestNeighbors(metric='euclidean')\n self._nntree.fit(self.X[self._ini_ind])\n\n def select(self, label_index, unlabel_index, eval_cost=False, model=None, **kwargs):\n \"\"\"Query from oracles. Return the index of selected instance and oracle.\n\n Parameters\n ----------\n label_index: {list, np.ndarray, IndexCollection}\n The indexes of labeled samples.\n\n unlabel_index: {list, np.ndarray, IndexCollection}\n The indexes of unlabeled samples.\n\n eval_cost: bool, optional (default=False)\n To evaluate the cost of oracles or use the cost provided by oracles.\n\n model: object, optional (default=None)\n Current classification model, should have the 'predict_proba' method for probabilistic output.\n If not provided, LogisticRegression with default parameters implemented by sklearn will be used.\n\n n_neighbors: int, optional (default=10)\n How many neighbors of the selected instance will be used\n to evaluate the oracles.\n\n Returns\n -------\n selected_instance: int\n The index of selected instance.\n\n selected_oracle: int or str\n The index of selected oracle.\n If a list is given, the index of oracle will be returned.\n If a Oracles object is given, the oracle name will be returned.\n \"\"\"\n\n if model is None:\n model = LogisticRegression(solver='liblinear')\n model.fit(self.X[label_index], self.y[label_index])\n pred_unlab, _ = _get_proba_pred(self.X[unlabel_index], model)\n\n n_neighbors = min(kwargs.pop('n_neighbors', 10), len(self._ini_ind) - 1)\n return self.select_by_prediction_mat(label_index, unlabel_index, pred_unlab,\n n_neighbors=n_neighbors, eval_cost=eval_cost)\n\n def select_by_prediction_mat(self, label_index, unlabel_index, predict, **kwargs):\n \"\"\"Query from oracles. Return the index of selected instance and oracle.\n\n Parameters\n ----------\n label_index: {list, np.ndarray, IndexCollection}\n The indexes of labeled samples.\n\n unlabel_index: {list, np.ndarray, IndexCollection}\n The indexes of unlabeled samples.\n\n predict: : 2d array, shape [n_samples, n_classes]\n The probabilistic prediction matrix for the unlabeled set.\n\n n_neighbors: int, optional (default=10)\n How many neighbors of the selected instance will be used\n to evaluate the oracles.\n\n eval_cost: bool, optional (default=False)\n To evaluate the cost of oracles or use the cost provided by oracles.\n\n Returns\n -------\n selected_instance: int\n The index of selected instance.\n\n selected_oracle: int or str\n The index of selected oracle.\n If a list is given, the index of oracle will be returned.\n If a Oracles object is given, the oracle name will be returned.\n \"\"\"\n n_neighbors = min(kwargs.pop('n_neighbors', 10), len(self._ini_ind)-1)\n eval_cost = kwargs.pop('n_neighbors', False)\n Q_table, oracle_ind_name_dict = self._calc_Q_table(label_index, unlabel_index, self._oracles, predict,\n n_neighbors=n_neighbors, eval_cost=eval_cost)\n # get the instance-oracle pair\n selected_pair = np.unravel_index(np.argmax(Q_table, axis=None), Q_table.shape)\n sel_ora = oracle_ind_name_dict[selected_pair[0]]\n if not isinstance(sel_ora, list):\n sel_ora = [sel_ora]\n return [unlabel_index[selected_pair[1]]], sel_ora\n\n def _calc_Q_table(self, label_index, unlabel_index, oracles, pred_unlab, n_neighbors=10, eval_cost=False):\n \"\"\"Query from oracles. Return the Q table and the oracle name/index of each row of Q_table.\n\n Parameters\n ----------\n label_index: {list, np.ndarray, IndexCollection}\n The indexes of labeled samples.\n\n unlabel_index: {list, np.ndarray, IndexCollection}\n The indexes of unlabeled samples.\n\n oracles: {list, alipy.oracle.Oracles}\n An alipy.oracle.Oracle object that contains all the\n available oracles or a list of oracles.\n Each oracle should be a alipy.oracle.Oracle object.\n\n predict: : 2d array, shape [n_samples, n_classes]\n The probabilistic prediction matrix for the unlabeled set.\n\n n_neighbors: int, optional (default=10)\n How many neighbors of the selected instance will be used\n to evaluate the oracles.\n\n eval_cost: bool, optional (default=False)\n To evaluate the cost of oracles or use the cost provided by oracles.\n\n Returns\n -------\n Q_table: 2D array\n The Q table.\n\n oracle_ind_name_dict: dict\n The oracle name/index of each row of Q_table.\n \"\"\"\n # Check parameter and initialize variables\n if self.X is None or self.y is None:\n raise Exception('Data matrix is not provided, use select_by_prediction_mat() instead.')\n assert (isinstance(unlabel_index, collections.Iterable))\n assert (isinstance(label_index, collections.Iterable))\n unlabel_index = np.asarray(unlabel_index)\n label_index = np.asarray(label_index)\n num_of_neighbors = n_neighbors\n if len(unlabel_index) <= 1:\n return unlabel_index\n\n Q_table = np.zeros((len(oracles), len(unlabel_index))) # row:oracle, col:ins\n spv = np.shape(pred_unlab)\n # calc least_confident\n rx = np.partition(pred_unlab, spv[1] - 1, axis=1)\n rx = 1 - rx[:, spv[1] - 1]\n for unlab_ind, unlab_ins_ind in enumerate(unlabel_index):\n # evaluate oracles for each instance\n nn_dist, nn_of_selected_ins = self._nntree.kneighbors(X=self.X[unlab_ins_ind].reshape(1, -1),\n n_neighbors=num_of_neighbors,\n return_distance=True)\n nn_dist = nn_dist[0]\n nn_of_selected_ins = nn_of_selected_ins[0]\n nn_of_selected_ins = self._ini_ind[nn_of_selected_ins] # map to the original population\n oracles_score = []\n for ora_ind, ora_name in enumerate(self._oracles_iterset):\n # calc q_i(x), expertise of this instance\n oracle = oracles[ora_name]\n labels, cost = oracle.query_by_index(nn_of_selected_ins)\n oracles_score.append(sum([nn_dist[i] * (labels[i] == self.y[nn_of_selected_ins[i]]) for i in\n range(num_of_neighbors)]) / num_of_neighbors)\n\n # calc c_i, cost of each labeler\n labels, cost = oracle.query_by_index(label_index)\n if eval_cost:\n oracles_cost = sum([labels[i] == self.y[label_index[i]] for i in range(len(label_index))]) / len(label_index)\n else:\n oracles_cost = cost[0]\n Q_table[ora_ind, unlab_ind] = oracles_score[ora_ind] * rx[unlab_ind] / max(oracles_cost, 0.0001)\n\n return Q_table, self._oracle_ind_name_dict\n\n\nclass QueryNoisyOraclesSelectInstanceUncertainty(BaseNoisyOracleQuery, metaclass=ABCMeta):\n \"\"\"This class implement select and select_by_prediction_mat by uncertainty.\"\"\"\n\n def __init__(self, X=None, y=None, oracles=None):\n super(QueryNoisyOraclesSelectInstanceUncertainty, self).__init__(X=X, y=y, oracles=oracles)\n\n def select(self, label_index, unlabel_index, model=None, **kwargs):\n \"\"\"Select an instance and a batch of oracles to label it.\n The instance is selected by uncertainty, the oracles is\n selected by the difference between their\n labeling results and the majority vote results.\n\n Parameters\n ----------\n label_index: {list, np.ndarray, IndexCollection}\n The indexes of labeled samples.\n\n unlabel_index: {list, np.ndarray, IndexCollection}\n The indexes of unlabeled samples.\n\n Returns\n -------\n selected_instance: int\n The index of selected instance. Selected by uncertainty.\n\n selected_oracles: list\n The selected oracles for querying.\n \"\"\"\n if model is None:\n model = LogisticRegression(solver='liblinear')\n model.fit(self.X[label_index], self.y[label_index])\n pred_unlab, _ = _get_proba_pred(self.X[unlabel_index], model)\n\n return self.select_by_prediction_mat(label_index, unlabel_index, pred_unlab)\n\n def select_by_prediction_mat(self, label_index, unlabel_index, predict):\n \"\"\"Query from oracles. Return the index of selected instance and oracle.\n\n Parameters\n ----------\n label_index: {list, np.ndarray, IndexCollection}\n The indexes of labeled samples.\n\n unlabel_index: {list, np.ndarray, IndexCollection}\n The indexes of unlabeled samples.\n\n predict: : 2d array, shape [n_samples, n_classes]\n The probabilistic prediction matrix for the unlabeled set.\n\n Returns\n -------\n selected_instance: int\n The index of selected instance. Selected by uncertainty.\n\n selected_oracles: list\n The selected oracles for querying.\n \"\"\"\n # Check parameter and initialize variables\n assert (isinstance(unlabel_index, collections.Iterable))\n assert (isinstance(label_index, collections.Iterable))\n unlabel_index = np.asarray(unlabel_index)\n label_index = np.asarray(label_index)\n if len(unlabel_index) <= 1:\n return unlabel_index\n\n # select instance and oracle\n unc = QueryInstanceUncertainty(measure='least_confident')\n selected_instance = unc.select_by_prediction_mat(unlabel_index=unlabel_index, predict=predict, batch_size=1)[0]\n return [selected_instance], self.select_by_given_instance(selected_instance)\n\n @abstractmethod\n def select_by_given_instance(self, selected_instance):\n pass\n\n\nclass QueryNoisyOraclesIEthresh(QueryNoisyOraclesSelectInstanceUncertainty):\n \"\"\"IEthresh will select a batch of oracles to label the selected instance.\n It will score for each oracle according to the difference between their\n labeling results and the majority vote results.\n\n At each iteration, a batch of oracles whose scores are larger than a threshold will be selected.\n Oracle with a higher score is more likely to be selected.\n\n Parameters\n ----------\n X: 2D array, optional (default=None)\n Feature matrix of the whole dataset. It is a reference which will not use additional memory.\n\n y: array-like, optional (default=None)\n Label matrix of the whole dataset. It is a reference which will not use additional memory.\n\n oracles: {list, alipy.oracle.Oracles}\n An alipy.oracle.Oracle object that contains all the\n available oracles or a list of oracles.\n Each oracle should be a alipy.oracle.Oracle object.\n\n initial_labeled_indexes: {list, np.ndarray, IndexCollection}\n The indexes of initially labeled samples. Used for initializing the scores of each oracle.\n\n epsilon: float, optional (default=0.1)\n The value to determine how many oracles will be selected.\n S_t = {a|UI(a) >= epsilon * max UI(a)}\n\n References\n ----------\n [1] Donmez P , Carbonell J G , Schneider J . Efficiently learning the accuracy of labeling\n sources for selective sampling.[C] ACM SIGKDD International Conference on\n Knowledge Discovery & Data Mining. ACM, 2009.\n \"\"\"\n\n def __init__(self, X, y, oracles, initial_labeled_indexes, **kwargs):\n super(QueryNoisyOraclesIEthresh, self).__init__(X, y, oracles=oracles)\n self._ini_ind = np.asarray(initial_labeled_indexes)\n # record the labeling history of each oracle\n self._oracles_history = dict()\n for i in range(len(self._oracles_iterset)):\n self._oracles_history[i] = dict()\n # record the results of majority vote\n self._majority_vote_results = dict()\n # calc initial QI(a) for each oracle a\n self._UI = np.ones(len(self._oracles_iterset))\n self.epsilon = kwargs.pop('epsilon', 0.8)\n\n def _calc_uia(self, oracle_history, majority_vote_result, alpha=0.05):\n \"\"\"Calculate the UI(a) by providing the labeling history and the majority vote results.\n\n Parameters\n ----------\n oracle_history: dict\n The labeling history of an oracle. The key is the index of instance, the value is the\n label given by the oracle.\n\n majority_vote_result: dict\n The results of majority vote of instances. The key is the index of instance,\n the value is the label given by the oracle.\n\n alpha: float, optional (default=0.05)\n Used for calculating the critical value for the Student’s t-distribution with n−1\n degrees of freedom at the alpha/2 confidence level.\n\n Returns\n -------\n uia: float\n The UI(a) value.\n \"\"\"\n n = len(self._oracles_iterset)\n t_crit_val = scipy.stats.t.isf([alpha / 2], n - 1)[0]\n reward_arr = []\n for ind in oracle_history.keys():\n if oracle_history[ind] == majority_vote_result[ind]:\n reward_arr.append(1)\n else:\n reward_arr.append(0)\n mean_a = np.mean(reward_arr)\n std_a = np.std(reward_arr)\n uia = mean_a + t_crit_val * std_a / np.sqrt(n)\n return uia\n\n def select_by_given_instance(self, selected_instance):\n \"\"\"Select oracle to query by providing the index of selected instance.\n\n Parameters\n ----------\n selected_instance: int\n The indexes of selected samples. Should be a member of unlabeled set.\n\n Returns\n -------\n selected_oracles: list\n The selected oracles for querying.\n \"\"\"\n selected_oracles = np.nonzero(self._UI >= self.epsilon * np.max(self._UI))\n selected_oracles = selected_oracles[0]\n\n # update UI(a) for each selected oracle\n labeling_results = []\n for i in selected_oracles:\n lab, _ = self._oracles[self._oracle_ind_name_dict[i]].query_by_index(selected_instance)\n labeling_results.append(lab[0])\n self._oracles_history[i][selected_instance] = copy.copy(lab[0])\n _, majority_vote_result = majority_vote(labeling_results)\n reward_arr = np.zeros(len(selected_oracles))\n same_ind = np.nonzero(labeling_results == majority_vote_result)[0]\n reward_arr[same_ind] = 1\n self._majority_vote_results[selected_instance] = majority_vote_result\n for i in selected_oracles:\n self._UI[i] = self._calc_uia(self._oracles_history[i], self._majority_vote_results)\n\n # return results\n return [self._oracle_ind_name_dict[i] for i in selected_oracles]\n\n\nclass QueryNoisyOraclesAll(QueryNoisyOraclesSelectInstanceUncertainty):\n \"\"\"This strategy will select instance by uncertainty and query from all\n oracles and return the majority vote result.\n\n Parameters\n ----------\n X: 2D array, optional (default=None)\n Feature matrix of the whole dataset. It is a reference which will not use additional memory.\n\n y: array-like, optional (default=None)\n Label matrix of the whole dataset. It is a reference which will not use additional memory.\n\n oracles: {list, alipy.oracle.Oracles}\n An alipy.oracle.Oracle object that contains all the\n available oracles or a list of oracles.\n Each oracle should be a alipy.oracle.Oracle object.\n \"\"\"\n\n def __init__(self, oracles, X=None, y=None):\n super(QueryNoisyOraclesAll, self).__init__(X=X, y=y, oracles=oracles)\n\n def select_by_given_instance(self, selected_instance):\n \"\"\"Select oracle to query by providing the index of selected instance.\n\n Parameters\n ----------\n selected_instance: int\n The indexes of selected samples. Should be a member of unlabeled set.\n\n Returns\n -------\n oracles_ind: list\n The indexes of selected oracles.\n \"\"\"\n return self._oracle_ind_name_dict.values()\n\n\nclass QueryNoisyOraclesRandom(QueryNoisyOraclesSelectInstanceUncertainty):\n \"\"\"Select a random oracle to query.\"\"\"\n\n def select_by_given_instance(self, selected_instance):\n \"\"\"Select oracle to query by providing the index of selected instance.\n\n Parameters\n ----------\n selected_instance: int\n The indexes of selected samples. Should be a member of unlabeled set.\n\n Returns\n -------\n oracles_ind: list\n The indexes of selected oracles.\n \"\"\"\n return [self._oracle_ind_name_dict[np.random.randint(0, len(self._oracles), 1)[0]]]\n"
] |
[
[
"numpy.max",
"numpy.asarray",
"numpy.sum",
"numpy.shape",
"numpy.mean",
"numpy.nonzero",
"numpy.std",
"sklearn.linear_model.LogisticRegression",
"numpy.argmax",
"numpy.sqrt",
"numpy.partition",
"sklearn.neighbors.NearestNeighbors"
]
] |
mattrogers1124/imagebot
|
[
"ed788c9dda85222b47e3b41ac2c4bfd50942cfd8"
] |
[
"imagebot/imagebot.py"
] |
[
"import os\nimport pandas\nimport numpy as np\nfrom numpy.random import default_rng\nimport cv2\nfrom time import time_ns\nfrom datetime import datetime, timedelta\nfrom PIL import Image\n\n\nclass Imagebot:\n\n def __init__(self, queue=\"./queue\", sourcedir=\"./source\", index=\"index.csv\",\n min_queue_length=240, images_to_autoadd=24):\n self.queue = queue\n self.sourcedir = sourcedir\n self.index = pandas.read_csv(index)\n self.min_queue_length = min_queue_length\n self.images_to_autoadd = images_to_autoadd\n\n def get_specific_image(self, key, frame):\n # 1. Find the first file in the source directory that matches the key\n # If none, go with the first file in the source directory\n files = os.listdir(self.sourcedir)\n file = files[0]\n for file_check in files:\n if key in file_check:\n file = file_check\n break\n\n filepath = os.path.join(self.sourcedir, file)\n\n # 2. Extract the frame\n video = cv2.VideoCapture(filepath)\n video.set(1, frame) # Set the frame\n ret, im = video.read()\n\n # 3. Return the result\n return im\n\n def get_random_image(self):\n # Returns the image data from a random clip in the source files\n # 1. Pick a clip (row) from the index\n clip = default_rng().integers(0, self.index.shape[0])\n\n # 2. Extract the data from the row\n key = self.index.iloc[clip][\"key\"]\n clip_start = self.index.iloc[clip][\"clip_start\"]\n clip_end = self.index.iloc[clip][\"clip_end\"]\n\n # 3. Pick a random frame from the clip\n frame = default_rng().integers(clip_start, clip_end+1)\n\n # 4. Return the result\n return self.get_specific_image(key, frame)\n\n @staticmethod\n def rgb_correction(im):\n # CV2 package switches the red and blue channels for some reason, correct them here\n b, g, r = Image.fromarray(im).split()\n image = Image.merge(\"RGB\", (r, g, b))\n return image\n\n def populate_queue(self, n=1):\n # Add n images to the queue\n print(\"Retreiving\", n, \"images\")\n start_time = time_ns()\n for i in np.arange(n)+1:\n im = self.get_random_image()\n image = self.rgb_correction(im)\n filename = \"New File - \" + str(time_ns()) + \".png\"\n filepath = os.path.join(self.queue, filename)\n image.save(filepath)\n print(i, filepath)\n end_time = time_ns()\n delta = (end_time - start_time) / 1e9\n avg = delta / n\n print(\"Retreived\", n, \"images\")\n print(\" Total time:\", np.round(delta, decimals=1), \"seconds\")\n print(\" Average time:\", np.round(avg, decimals=1), \"seconds per image\")\n\n def autopopulate_queue(self, min_queue_length=240, images_to_add=24):\n # Check the length of the queue, if it's below the specified threshold then run populate_queue()\n # Defaults are good for an hourly bot (Queue is at least 10 days long, add 24 images at a time)\n queue_length = len(os.listdir(self.queue))\n print(\"There are\", queue_length, \"images left in the queue.\")\n if queue_length < min_queue_length:\n print(\"Queue length is below threshold (min\", min_queue_length, \"images)\")\n self.populate_queue(images_to_add)\n\n def pop_from_queue(self, dryrun=False):\n # Return the raw image data from the first image in the queue & delete it\n # Use this method to post the data to Twitter or some other API\n files = os.listdir(self.queue)\n files.sort()\n file = files[0]\n filepath = os.path.join(self.queue, file)\n imagefile = open(filepath, \"rb\")\n imagedata = imagefile.read()\n print(\"Loaded data from\", filepath)\n if not dryrun:\n os.remove(filepath)\n print(\"Removed\", filepath)\n else:\n print(\"Dry run, did not remove\", filepath)\n return imagedata\n\n def organize_queue(self, start=datetime.now(), interval=60, dryrun=False):\n # Rename the files in the queue with timestamps of when they will be posted\n # Default settings: Items in the queue are posted an hour apart, starting now\n\n # Get the queue and sort it\n files = os.listdir(self.queue)\n files.sort()\n\n # Loop through and rename the files\n for i in range(len(files)):\n stamp = start + timedelta(minutes=i*interval)\n stamp_str = stamp.strftime(\"%Y-%m-%d %H:%M\")\n extension = os.path.splitext(files[i])[1]\n src = os.path.join(self.queue, files[i])\n dst = os.path.join(self.queue, stamp_str+extension)\n print(\"os.rename(\"+src+\", \"+dst+\")\")\n if not dryrun:\n os.rename(src, dst)\n"
] |
[
[
"numpy.round",
"pandas.read_csv",
"numpy.arange",
"numpy.random.default_rng"
]
] |
gbzan/algotom
|
[
"314f05b6a226e666a8ae4417b151d896606e7db4",
"314f05b6a226e666a8ae4417b151d896606e7db4"
] |
[
"tests/test_prep/test_filtering.py",
"tests/test_prep/test_calculation.py"
] |
[
"# ============================================================================\n# ============================================================================\n# Copyright (c) 2021 Nghia T. Vo. 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# Author: Nghia T. Vo\n# E-mail: \n# Description: Tests for the Algotom package.\n# Contributors:\n# ============================================================================\n\n\"\"\"\nTests for the methods in prep/filtering.py\n\n\"\"\"\n\nimport unittest\nimport numpy as np\nimport scipy.ndimage as ndi\nimport algotom.prep.filtering as filt\n\n\nclass FilteringMethods(unittest.TestCase):\n\n def setUp(self):\n self.eps = 10 ** (-6)\n\n def test_fresnel_filter(self):\n mat = np.random.rand(64, 64)\n mat1 = filt.fresnel_filter(mat, 10, dim=1)\n mat2 = filt.fresnel_filter(mat, 10, dim=2)\n num1 = np.sum(np.abs(mat - mat1))\n num2 = np.sum(np.abs(mat - mat2))\n num3 = np.sum(np.abs(mat1 - mat2))\n self.assertTrue(num1 > self.eps and num2 > self.eps and num3 > self.eps)\n\n def test_double_wedge_filter(self):\n size = 129\n idx1 = size // 2\n rad = size // 4\n num_proj = 73\n # Create a phantom and its sinogram.\n mat = np.zeros((size, size), dtype=np.float32)\n mat[idx1 - 10:idx1 + 5, idx1 + 10:idx1 + 20] = np.float32(1.0)\n mat = ndi.gaussian_filter(mat, 1.0)\n sino_360_std = np.zeros((num_proj, size), dtype=np.float32)\n angles = np.linspace(0.0, 360.0, len(sino_360_std), dtype=np.float32)\n for i, angle in enumerate(angles):\n sino_360_std[i] = np.sum(ndi.rotate(mat, angle, reshape=False),\n axis=0)\n sino_360_std = sino_360_std / size\n # Create a phantom with a feature larger than the crop FOV.\n mat = np.zeros((size, size), dtype=np.float32)\n mat[idx1 - 10:idx1 + 5, idx1 + 10:idx1 + 20] = np.float32(1.0)\n mat[5:25, 10:25] = np.float32(1.5)\n mat = ndi.gaussian_filter(mat, 1.0)\n sino_360 = np.zeros((num_proj, size), dtype=np.float32)\n angles = np.linspace(0.0, 360.0, len(sino_360), dtype=np.float32)\n for i, angle in enumerate(angles):\n sino_360[i] = np.sum(ndi.rotate(mat, angle, reshape=False), axis=0)\n sino_360 = sino_360 / size\n sino_360_crop0 = sino_360_std[:, idx1 - rad: idx1 + rad]\n sino_360_crop = sino_360[:, idx1 - rad: idx1 + rad]\n sino_180_crop0 = sino_360_crop0[:num_proj // 2 + 1]\n sino_180_crop = sino_360_crop[:num_proj // 2 + 1]\n sino_360_filt = filt.double_wedge_filter(sino_360_crop,\n sino_type=\"360\", iteration=10)\n sino_360_filt = sino_360_filt * (\n np.mean(sino_360_crop0) / np.mean(np.abs(sino_360_filt)))\n num1 = np.max(np.abs(sino_360_filt - sino_360_crop0))\n sino_180_filt = filt.double_wedge_filter(sino_180_crop, center=32.0,\n sino_type=\"180\", iteration=10)\n sino_180_filt = sino_180_filt * (\n np.mean(sino_180_crop0) / np.mean(np.abs(sino_180_filt)))\n num2 = np.max(np.abs(sino_180_filt - sino_180_crop0))\n self.assertTrue(num2 <= 0.1 and num2 <= 0.1)\n",
"# ============================================================================\n# ============================================================================\n# Copyright (c) 2021 Nghia T. Vo. 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# Author: Nghia T. Vo\n# E-mail: \n# Description: Tests for the Algotom package.\n# Contributors:\n# ============================================================================\n\"\"\"\nTests for methods in prep/calculation.py\n\"\"\"\n\nimport unittest\nimport numpy as np\nimport scipy.ndimage as ndi\nimport algotom.prep.calculation as calc\n\n\nclass CalculationMethods(unittest.TestCase):\n\n def setUp(self):\n self.error = 0.15\n self.size = 64\n\n def test_find_center_vo(self):\n center0 = 31.0\n mat = np.zeros((self.size, self.size), dtype=np.float32)\n mat[20:30, 35:42] = np.float32(1.0)\n sinogram = np.zeros((37, self.size), dtype=np.float32)\n angles = np.linspace(0.0, 180.0, len(sinogram), dtype=np.float32)\n for i, angle in enumerate(angles):\n sinogram[i] = np.sum(ndi.rotate(mat, angle, reshape=False), axis=0)\n center = calc.find_center_vo(sinogram)\n self.assertTrue(np.abs(center - center0) < self.error)\n\n def test_find_overlap(self):\n overlap = 20\n side = 1\n win_width = 10\n mat1 = np.zeros((self.size, self.size), dtype=np.float32)\n mat2 = np.copy(mat1)\n noise1 = np.float32(0.1 * np.random.rand(self.size, self.size))\n noise2 = np.float32(0.1 * np.random.rand(self.size, self.size))\n mat1 = mat1 + noise1\n mat2 = mat2 + noise2\n mat_cor = np.tile(np.sin(np.arange(overlap) / 3.0), (self.size, 1))\n mat1[:, self.size - overlap:] = np.float32(0.2) + mat_cor\n mat2[:, :overlap] = np.float32(0.2) + mat_cor\n (overlap1, side1, _) = calc.find_overlap(mat1, mat2, win_width)\n self.assertTrue(\n np.abs(overlap1 - overlap) < self.error and side1 == side)\n\n def test_find_overlap_multiple(self):\n overlap = 20\n side = 1\n win_width = 15\n mat1 = np.float32(0.1 * np.random.rand(self.size, self.size))\n mat2 = np.float32(0.1 * np.random.rand(self.size, self.size))\n mat3 = np.float32(0.1 * np.random.rand(self.size, self.size))\n mat_cor1 = np.tile(np.sin(np.arange(overlap) / 2.0), (self.size, 1))\n mat_cor2 = np.tile(np.sin(np.arange(overlap, 0, -1) / 3.0),\n (self.size, 1))\n mat1[:, self.size - overlap:] = np.float32(0.2) + np.abs(mat_cor1)\n mat2[:, :overlap] = np.float32(0.2) + np.abs(mat_cor1)\n mat2[:, self.size - overlap:] = np.float32(0.2) + np.abs(mat_cor2)\n mat3[:, :overlap] = np.float32(0.2) + np.abs(mat_cor2)\n results = calc.find_overlap_multiple([mat1, mat2, mat3], win_width)\n num1 = np.abs(results[0][0] - overlap)\n num2 = np.abs(results[1][0] - overlap)\n side1 = int(results[0][1])\n side2 = int(results[1][1])\n self.assertTrue((num1 < self.error) and (side1 == side) and (\n num2 < self.error) and (side2 == side))\n\n def test_find_center_360(self):\n mat = np.zeros((self.size, self.size), dtype=np.float32)\n mat[20:30, 35:42] = np.float32(1.0)\n sinogram = np.zeros((73, self.size), dtype=np.float32)\n angles = np.linspace(0.0, 360.0, len(sinogram), dtype=np.float32)\n for i, angle in enumerate(angles):\n sinogram[i] = np.sum(ndi.rotate(mat, angle, reshape=False), axis=0)\n sinogram = sinogram / np.max(sinogram)\n noise = 0.1 * np.random.rand(73, self.size)\n sinogram = np.pad(sinogram[:, 22:], ((0, 0), (0, 22)), mode='constant')\n sinogram = sinogram + noise\n (cor, _, side) = calc.find_center_360(sinogram, 6)[0:3]\n self.assertTrue(np.abs(cor - 9.0) < self.error and side == 0)\n\n def test_find_shift_based_phase_correlation(self):\n mat1 = np.zeros((self.size, self.size), dtype=np.float32)\n mat1[25:36, 25:36] = np.float32(1.0)\n xshift0 = 9\n yshift0 = -5\n mat2 = ndi.shift(mat1, (-yshift0, -xshift0))\n (yshift, xshift) = calc.find_shift_based_phase_correlation(mat1, mat2)\n num1 = np.abs(yshift - yshift0)\n num2 = np.abs(xshift - xshift0)\n self.assertTrue(num1 < self.error and num2 < self.error)\n\n def test_center_based_phase_correlation(self):\n mat1 = np.zeros((self.size, self.size), dtype=np.float32)\n mat1[25:36, 25:36] = np.float32(1.0)\n mat2 = np.fliplr(mat1)\n shift = -5\n mat1 = ndi.shift(mat1, (0, shift))\n mat2 = ndi.shift(mat2, (0, shift))\n center0 = (self.size - 1) / 2.0 + shift\n cor = calc.find_center_based_phase_correlation(mat1, mat2)\n self.assertTrue(np.abs(cor - center0) < self.error)\n\n def test_find_center_projection(self):\n mat1 = np.zeros((self.size, self.size), dtype=np.float32)\n mat1[26:36, 26:36] = np.tile(np.sin(np.arange(10) / 3.0), (10, 1))\n mat2 = np.fliplr(mat1)\n noise1 = np.float32(0.1 * np.random.rand(self.size, self.size))\n noise2 = np.float32(0.1 * np.random.rand(self.size, self.size))\n mat1 = mat1 + noise1\n mat2 = mat2 + noise2\n shift = -5\n mat1 = ndi.shift(mat1, (0, shift))\n mat2 = ndi.shift(mat2, (0, shift))\n center0 = (self.size - 1) / 2.0 + shift\n cor = calc.find_center_projection(mat1, mat2)\n self.assertTrue(np.abs(cor - center0) < self.error)\n\n def test_calculate_reconstructable_height(self):\n (y_s1, y_e1) = calc.calculate_reconstructable_height(5.0, 20.0, 4.0,\n scan_type=\"180\")\n (y_s2, y_e2) = calc.calculate_reconstructable_height(5.0, 20.0, 4.0,\n scan_type=\"360\")\n num1 = np.abs(y_s1 - 7.0)\n num2 = np.abs(y_e1 - 18.0)\n num3 = np.abs(y_s2 - 9.0)\n num4 = np.abs(y_e2 - 16.0)\n self.assertTrue((num1 < self.error) and (num2 < self.error)\n and (num3 < self.error) and (num4 < self.error))\n\n def test_calculate_maximum_index(self):\n idx1 = calc.calculate_maximum_index(5.0, 10.0, 2.0, 0.001, \"180\")\n idx2 = calc.calculate_maximum_index(5.0, 10.0, 2.0, 0.001, \"360\")\n self.assertTrue(idx1 == 3001 and idx2 == 1001)\n"
] |
[
[
"numpy.random.rand",
"scipy.ndimage.rotate",
"numpy.zeros",
"scipy.ndimage.gaussian_filter",
"numpy.mean",
"numpy.float32",
"numpy.abs"
],
[
"numpy.max",
"numpy.pad",
"numpy.random.rand",
"scipy.ndimage.rotate",
"numpy.zeros",
"scipy.ndimage.shift",
"numpy.copy",
"numpy.float32",
"numpy.arange",
"numpy.abs",
"numpy.fliplr"
]
] |
mingyuan-zhang/mmhuman3d
|
[
"0cb3236af31f968115c4316ee15686269d0bfe6c",
"0cb3236af31f968115c4316ee15686269d0bfe6c"
] |
[
"mmhuman3d/core/visualization/renderer/torch3d_renderer/render_runner.py",
"mmhuman3d/core/visualization/renderer/torch3d_renderer/segmentation_renderer.py"
] |
[
"import math\nimport os\nfrom pathlib import Path\nfrom typing import Iterable, Union\n\nimport mmcv\nimport torch\nfrom pytorch3d.structures.meshes import Meshes\nfrom tqdm import trange\n\nimport mmhuman3d\nfrom mmhuman3d.core.cameras import compute_orbit_cameras\nfrom mmhuman3d.core.conventions.cameras import convert_cameras\nfrom .builder import build_renderer\n\nosj = os.path.join\n\n\ndef render(\n output_path: str,\n device: Union[str, torch.device] = 'cpu',\n meshes: Meshes = None,\n render_choice: str = 'base',\n batch_size: int = 5,\n K: torch.Tensor = None,\n R: torch.Tensor = None,\n T: torch.Tensor = None,\n projection: str = 'perspective',\n orbit_speed: Union[Iterable[float], float] = 0.0,\n dist: float = 2.7,\n dist_speed=1.0,\n in_ndc: bool = True,\n resolution=[1024, 1024],\n convention: str = 'pytorch3d',\n no_grad: bool = False,\n return_tensor: bool = True,\n):\n RENDER_CONFIGS = mmcv.Config.fromfile(\n os.path.join(\n Path(mmhuman3d.__file__).parents[1],\n 'configs/render/smpl.py'))['RENDER_CONFIGS'][render_choice]\n renderer = build_renderer(\n dict(\n type=RENDER_CONFIGS['renderer_type'],\n device=device,\n resolution=resolution,\n projection=projection,\n output_path=output_path,\n return_type=['tensor'] if return_tensor else None,\n in_ndc=in_ndc,\n **RENDER_CONFIGS))\n\n num_frames = len(meshes)\n if K is None or R is None or T is None:\n K, R, T = compute_orbit_cameras(\n orbit_speed=orbit_speed,\n dist=dist,\n batch_size=num_frames,\n dist_speed=dist_speed)\n\n if projection in ['perspective', 'fovperspective']:\n is_perspective = True\n else:\n is_perspective = False\n\n K, R, T = convert_cameras(\n resolution_dst=resolution,\n resolution_src=resolution,\n in_ndc_dst=in_ndc,\n in_ndc_src=in_ndc,\n K=K,\n R=R,\n T=T,\n is_perspective=is_perspective,\n convention_src=convention,\n convention_dst='pytorch3d')\n\n tensors = []\n for i in trange(math.ceil(num_frames // batch_size)):\n indexes = list(\n range(i * batch_size, min((i + 1) * batch_size, len(meshes))))\n if no_grad:\n with torch.no_grad():\n images_batch = renderer(\n meshes=meshes[indexes],\n K=K[indexes],\n R=R[indexes],\n T=T[indexes],\n indexes=indexes)\n else:\n images_batch = renderer(\n meshes=meshes[indexes],\n K=K[indexes],\n R=R[indexes],\n T=T[indexes],\n indexes=indexes)\n tensors.append(images_batch['tensor'])\n\n tensors = torch.cat(tensors)\n renderer.export()\n return tensors\n",
"from typing import Iterable, List, Optional, Tuple, Union\n\nimport torch\nfrom pytorch3d.structures import Meshes\n\nfrom mmhuman3d.utils import get_different_colors\nfrom .base_renderer import MeshBaseRenderer\nfrom .builder import RENDERER\n\ntry:\n from typing import Literal\nexcept ImportError:\n from typing_extensions import Literal\n\n\n@RENDERER.register_module(name=[\n 'seg', 'segmentation', 'segmentation_renderer', 'Segmentation',\n 'SegmentationRenderer'\n])\nclass SegmentationRenderer(MeshBaseRenderer):\n \"\"\"Render segmentation map into a segmentation index tensor.\"\"\"\n\n def __init__(self,\n resolution: Tuple[int, int],\n device: Union[torch.device, str] = 'cpu',\n output_path: Optional[str] = None,\n return_type: Optional[List] = None,\n out_img_format: str = '%06d.png',\n projection: Literal['weakperspective', 'fovperspective',\n 'orthographics', 'perspective',\n 'fovorthographics'] = 'weakperspective',\n in_ndc: bool = True,\n **kwargs) -> None:\n \"\"\"Render vertex-color mesh into a segmentation map of a (B, H, W)\n tensor. For visualization, the output rgba image will be (B, H, W, 4),\n and the color palette comes from `get_different_colors`. The\n segmentation map is a tensor each pixel saves the classification index.\n Please make sure you have allocate each pixel a correct classification\n index by defining a textures of vertex color.\n\n [CrossEntropyLoss](https://pytorch.org/docs/stable/generated/torch.nn.\n CrossEntropyLoss.html)\n\n Args:\n resolution (Iterable[int]):\n (width, height) of the rendered images resolution.\n device (Union[torch.device, str], optional):\n You can pass a str or torch.device for cpu or gpu render.\n Defaults to 'cpu'.\n output_path (Optional[str], optional):\n Output path of the video or images to be saved.\n Defaults to None.\n return_type (Optional[Literal[, optional): the type of tensor to be\n returned. 'tensor' denotes return the determined tensor. E.g.,\n return silhouette tensor of (B, H, W) for SilhouetteRenderer.\n 'rgba' denotes the colorful RGBA tensor to be written.\n Will return a colorful segmentation image for 'rgba' and a\n segmentation map for 'tensor' (could be used as segmnentation\n GT).\n Defaults to None.\n out_img_format (str, optional): The image format string for\n saving the images.\n Defaults to '%06d.png'.\n projection (Literal[, optional): Projection type of the cameras.\n Defaults to 'weakperspective'.\n in_ndc (bool, optional): Whether defined in NDC.\n Defaults to True.\n num_class (int, optional): number of segmentation parts.\n Defaults to 1.\n\n Returns:\n None\n \"\"\"\n super().__init__(\n resolution=resolution,\n device=device,\n output_path=output_path,\n obj_path=None,\n return_type=return_type,\n out_img_format=out_img_format,\n projection=projection,\n in_ndc=in_ndc,\n **kwargs)\n\n def set_render_params(self, **kwargs):\n super().set_render_params(**kwargs)\n self.shader_type = 'nolight'\n self.num_class = kwargs.get('num_class', 1)\n\n def forward(self,\n meshes: Optional[Meshes] = None,\n K: Optional[torch.Tensor] = None,\n R: Optional[torch.Tensor] = None,\n T: Optional[torch.Tensor] = None,\n images: Optional[torch.Tensor] = None,\n indexes: Optional[Iterable[int]] = None,\n **kwargs):\n \"\"\"Render segmentation map.\n\n Args:\n meshes (Optional[Meshes], optional): meshes to be rendered.\n Require the textures type is `TexturesClosest`.\n The color indicates the class index of the triangle.\n Defaults to None.\n K (Optional[torch.Tensor], optional): Camera intrinsic matrixs.\n Defaults to None.\n R (Optional[torch.Tensor], optional): Camera rotation matrixs.\n Defaults to None.\n T (Optional[torch.Tensor], optional): Camera tranlastion matrixs.\n Defaults to None.\n images (Optional[torch.Tensor], optional): background images.\n Defaults to None.\n indexes (Optional[Iterable[int]], optional): indexes for images.\n Defaults to None.\n\n Returns:\n Union[torch.Tensor, None]: return tensor or None.\n \"\"\"\n # It is recommended that you use `TexturesClosest` to exclude\n # inappropriate interpolation among the faces, to make sure the\n # segmentation map is sharp.\n cameras = self.init_cameras(K=K, R=R, T=T)\n renderer = self.init_renderer(cameras, None)\n\n rendered_images = renderer(meshes)\n\n segmentation_map = rendered_images[..., 0].long()\n\n if self.output_path is not None or 'rgba' in self.return_type:\n valid_masks = (rendered_images[..., 3:] > 0) * 1.0\n color = torch.Tensor(get_different_colors(self.num_class))\n color = torch.cat([torch.zeros(1, 3), color]).to(self.device)\n rgbs = color[segmentation_map] * valid_masks\n if self.output_path is not None:\n self.write_images(rgbs, valid_masks, images, indexes)\n\n results = {}\n if 'tensor' in self.return_type:\n results.update(tensor=segmentation_map)\n if 'rgba' in self.return_type:\n results.update(rgba=torch.cat([rgbs, valid_masks], -1))\n return results\n"
] |
[
[
"torch.cat",
"torch.no_grad"
],
[
"torch.zeros",
"torch.cat"
]
] |
voidrank/SaccadeNet
|
[
"b24266c15a4fe999a0f1447e2ada127fe0bc136f"
] |
[
"src/compare_tool.py"
] |
[
"import os\nimport pickle\nimport argparse\nimport numpy as np\nfrom numpy import array as npa\n\nfrom IPython import embed\n\ndef create_argparse():\n parser = argparse.ArgumentParser(description='compare')\n parser.add_argument('src', type=str)\n parser.add_argument('dst', type=str)\n parser.add_argument('--box_fracs_scales', type=str, default='0,8,16,32,64,128,256,512',\n help='inner-box attribution for different scale')\n\n return parser\n\nif __name__ == '__main__':\n args_parser = create_argparse()\n opt = args_parser.parse_args()\n opt.box_fracs_scales = list(map(float, opt.box_fracs_scales.split(',')))\n\n with open(os.path.join('../exp', opt.src, 'box_fracs.pkl'), 'rb') as f:\n f_src_list = pickle.load(f)\n s_src = pickle.load(f)\n\n with open(os.path.join('../exp', opt.dst, 'box_fracs.pkl'), 'rb') as f:\n f_dst_list = pickle.load(f)\n s_dst = pickle.load(f)\n\n opt.box_fracs_scales.append(1e9)\n ratio_list = [0.5, 0.75, 1.0, 1.25, 1.5]\n for idx, box_size in enumerate(opt.box_fracs_scales[:-1]):\n for k in range(len(ratio_list)):\n ratio = ratio_list[k]\n pos, neg = 0, 0\n for i in range(len(f_src_list[0])):\n try:\n diff = np.array(f_src_list[i][k]) - np.array(f_dst_list[i][k])\n pos += ((diff > 0) * (npa(s_dst[i]).mean(1) > box_size) * (npa(s_dst[i]).mean(1) <= opt.box_fracs_scales[idx+1])).sum()\n neg += ((diff < 0) * (npa(s_src[i]).mean(1) > box_size) * (npa(s_src[i]).mean(1) <= opt.box_fracs_scales[idx+1])).sum()\n except Exception as e:\n continue\n print('size@{}~{}|ratio@{} - > : {}, < : {}'.format(box_size, opt.box_fracs_scales[idx+1], ratio, pos, neg))\n"
] |
[
[
"numpy.array"
]
] |
leaderj1001/Bag-of-MLP
|
[
"cfd9483245278a1814d55a4edc812663d436476e"
] |
[
"model.py"
] |
[
"import torch\nimport torch.nn as nn\nimport torch.nn.functional as F\n\n\nclass MLP(nn.Module):\n def __init__(self, dims, multiplxer=4):\n super(MLP, self).__init__()\n hidden = int(dims * multiplxer)\n\n self.out = nn.Sequential(\n nn.Linear(dims, hidden),\n nn.GELU(),\n nn.Linear(hidden, dims)\n )\n\n def forward(self, x):\n return self.out(x)\n\n\nclass MixerLayer(nn.Module):\n def __init__(self, seq, dims):\n super(MixerLayer, self).__init__()\n\n self.layer_norm1 = nn.LayerNorm(dims)\n self.mlp1 = MLP(seq, multiplxer=0.5)\n self.layer_norm2 = nn.LayerNorm(dims)\n self.mlp2 = MLP(dims)\n\n def forward(self, x):\n out = self.layer_norm1(x).transpose(1, 2)\n out = self.mlp1(out).transpose(1, 2)\n out += x\n\n out2 = self.layer_norm2(out)\n out2 = self.mlp2(out2)\n out2 += out\n\n return out2\n\n\nclass MLPMixer(nn.Module):\n def __init__(self, seq, in_dims, dims, patch=32, n_classes=10, N=12):\n super(MLPMixer, self).__init__()\n\n # self.embedding = nn.Linear(in_dims, dims)\n self.embedding = nn.Conv2d(3, dims, kernel_size=patch, stride=patch)\n\n self.layers = nn.ModuleList()\n for _ in range(N):\n self.layers.append(MixerLayer(seq, dims))\n\n self.gap = nn.AdaptiveAvgPool1d(1)\n self.fc = nn.Linear(dims, n_classes)\n self.dims = dims\n\n def forward(self, x):\n out = self.embedding(x)\n out = out.permute(0, 2, 3, 1).view(x.size(0), -1, self.dims)\n for layer in self.layers:\n out = layer(out)\n\n out = out.mean(dim=1)\n out = self.fc(out)\n\n return out\n\n\nclass Affine(nn.Module):\n def __init__(self, dims):\n super(Affine, self).__init__()\n\n self.alpha = nn.Parameter(torch.ones(dims))\n self.beta = nn.Parameter(torch.zeros(dims))\n\n def forward(self, x):\n return self.alpha * x + self.beta\n\n\nclass ResMLPBlock(nn.Module):\n def __init__(self, nb_patches, dims, layerscale_init):\n super(ResMLPBlock, self).__init__()\n self.affine1 = Affine(dims)\n self.affine2 = Affine(dims)\n self.linear_patches = nn.Linear(nb_patches, nb_patches)\n self.mlp_channels = MLP(dims)\n self.layerscale1 = nn.Parameter(layerscale_init * torch.ones(dims))\n self.layerscale2 = nn.Parameter(layerscale_init * torch.ones(dims))\n\n def forward(self, x):\n out1 = self.linear_patches(self.affine1(x).transpose(1, 2)).transpose(1, 2)\n x = x + self.layerscale1 * out1\n out2 = self.mlp_channels(self.affine2(x))\n x = x + self.layerscale2 * out2\n\n return x\n\n\nclass ResMLP(nn.Module):\n def __init__(self, dims, layerscale_init=1e-4, size=224, patch=32, num_classes=10, N=12):\n super(ResMLP, self).__init__()\n n = (size * size) // patch ** 2\n self.dims = dims\n self.embedding = nn.Conv2d(3, dims, kernel_size=patch, stride=patch)\n\n self.blocks = nn.ModuleList([ResMLPBlock(n, dims, layerscale_init) for _ in range(N)])\n self.affine = Affine(dims)\n self.out = nn.Linear(dims, num_classes)\n\n def forward(self, x):\n out = self.embedding(x).permute(0, 2, 3, 1).view(x.size(0), -1, self.dims)\n \n for layer in self.blocks:\n out = layer(out)\n\n out = self.affine(out).mean(dim=1)\n return self.out(out)\n\n\nclass TinyAttention(nn.Module):\n def __init__(self, d_ffn, d_attn=64):\n super(TinyAttention, self).__init__()\n self.qkv = nn.Linear(d_ffn, 3 * d_attn)\n self.d_attn = d_attn\n\n self.softmax = nn.Softmax(dim=-1)\n self.out = nn.Linear(d_attn, d_ffn // 2)\n\n def forward(self, x):\n qkv = self.qkv(x)\n q, k, v = torch.chunk(qkv, 3, dim=-1)\n energy = torch.bmm(q, k.transpose(1, 2)) / (self.d_attn ** 0.5)\n attn = self.softmax(energy)\n\n out = torch.bmm(attn, v)\n out = self.out(out)\n\n return out\n\n\nclass SpatialGatingUnit(nn.Module):\n def __init__(self, seq_len, d_model, attn=True):\n super(SpatialGatingUnit, self).__init__()\n self.layer_norm = nn.LayerNorm(d_model // 2)\n self.spatial = nn.Conv1d(seq_len, seq_len, kernel_size=1)\n self.is_attn = attn\n if self.is_attn:\n self.attn = TinyAttention(d_model)\n\n def forward(self, x):\n if self.is_attn:\n shortcut = x\n shortcut = self.attn(shortcut)\n u, v = torch.chunk(x, 2, dim=-1)\n v = self.layer_norm(v)\n v = self.spatial(v)\n if self.is_attn:\n v += shortcut\n\n return u * v\n\n\nclass gMLPBlock(nn.Module):\n def __init__(self, seq_len, d_model, d_ffn):\n super(gMLPBlock, self).__init__()\n self.layer_norm = nn.LayerNorm(d_model)\n\n self.channel1 = nn.Linear(d_model, d_ffn)\n self.sgu = SpatialGatingUnit(seq_len, d_ffn)\n self.channel2 = nn.Linear(d_ffn // 2, d_model)\n\n def forward(self, x):\n shortcut = x\n out = self.layer_norm(x)\n out = self.channel1(out)\n out = F.gelu(out)\n out = self.sgu(out)\n out = self.channel2(out)\n\n return out + shortcut\n\n\nclass gMLP(nn.Module):\n def __init__(self, seq_len, d_model, d_ffn, patch=32, N=12, n_classes=10):\n super(gMLP, self).__init__()\n self.d_model = d_model\n self.embedding = nn.Conv2d(3, d_model, kernel_size=patch, stride=patch)\n self.layers = nn.ModuleList([gMLPBlock(seq_len, d_model, d_ffn) for _ in range(N)])\n self.out = nn.Linear(d_model, n_classes)\n\n def forward(self, x):\n out = self.embedding(x).permute(0, 2, 3, 1).view(x.size(0), -1, self.d_model)\n for layer in self.layers:\n out = layer(out)\n\n out = out.mean(1)\n out = self.out(out)\n return out\n\n\ndef main():\n x = torch.randn(2, 12, 32)\n m = MLPMixer(12, 32, 32)\n m(x)\n\n\n# if __name__ == '__main__':\n# main()\n"
] |
[
[
"torch.nn.Linear",
"torch.zeros",
"torch.nn.LayerNorm",
"torch.nn.ModuleList",
"torch.nn.Softmax",
"torch.nn.Conv1d",
"torch.nn.functional.gelu",
"torch.bmm",
"torch.ones",
"torch.nn.AdaptiveAvgPool1d",
"torch.nn.Conv2d",
"torch.nn.GELU",
"torch.randn",
"torch.chunk"
]
] |
vkirilenko/FEDOT
|
[
"d287d899e47fe5aebf52c12733892e103b75842b"
] |
[
"test/unit/data_operations/test_data_operation_params.py"
] |
[
"import os\n\nimport numpy as np\nimport pandas as pd\n\nfrom fedot.core.data.data import InputData\nfrom fedot.core.pipelines.node import PrimaryNode, SecondaryNode\nfrom fedot.core.pipelines.pipeline import Pipeline\nfrom fedot.core.repository.dataset_types import DataTypesEnum\nfrom fedot.core.repository.tasks import Task, TaskTypesEnum, TsForecastingParams\nfrom fedot.core.utils import fedot_project_root\nfrom test.unit.tasks.test_regression import get_synthetic_regression_data\n\n\ndef get_ts_pipeline(window_size):\n \"\"\" Function return pipeline with lagged transformation in it \"\"\"\n node_lagged = PrimaryNode('lagged')\n node_lagged.custom_params = {'window_size': window_size}\n\n node_final = SecondaryNode('ridge', nodes_from=[node_lagged])\n pipeline = Pipeline(node_final)\n return pipeline\n\n\ndef get_ransac_pipeline():\n \"\"\" Function return pipeline with lagged transformation in it \"\"\"\n node_ransac = PrimaryNode('ransac_lin_reg')\n node_final = SecondaryNode('linear', nodes_from=[node_ransac])\n pipeline = Pipeline(node_final)\n return pipeline\n\n\ndef test_lagged_with_invalid_params_fit_correctly():\n \"\"\" The function define a pipeline with incorrect parameters in the lagged\n transformation. During the training of the pipeline, the parameter 'window_size'\n is corrected\n \"\"\"\n window_size = 600\n len_forecast = 50\n\n # The length of the time series is 500 elements\n project_root_path = str(fedot_project_root())\n file_path = os.path.join(project_root_path, 'test/data/short_time_series.csv')\n df = pd.read_csv(file_path)\n time_series = np.array(df['sea_height'])\n\n task = Task(TaskTypesEnum.ts_forecasting,\n TsForecastingParams(forecast_length=len_forecast))\n\n ts_input = InputData(idx=np.arange(0, len(time_series)), features=time_series,\n target=time_series, task=task, data_type=DataTypesEnum.ts)\n\n # Get pipeline with lagged transformation in it\n pipeline = get_ts_pipeline(window_size)\n\n # Fit it\n pipeline.fit(ts_input)\n\n # Get lagged node\n lagged_node = pipeline.nodes[1]\n fixed_params = lagged_node.custom_params\n\n assert pipeline.is_fitted\n assert fixed_params['window_size'] == 439\n\n\ndef test_ransac_with_invalid_params_fit_correctly():\n \"\"\" Check that on a small dataset the RANSAC anomaly search algorithm can\n adjust the values of hyperparameters\n\n As stated in the sklearn documentation, min_samples is determined by default\n based on how many features are in the dataset\n Therefore, problems can arise when there are more attributes in a dataset\n than the number of objects\n \"\"\"\n\n input_regression = get_synthetic_regression_data(n_samples=20, n_features=23)\n\n ransac_pipeline = get_ransac_pipeline()\n ransac_pipeline.fit(input_regression)\n predicted = ransac_pipeline.predict(input_regression)\n\n assert ransac_pipeline.is_fitted\n assert predicted is not None\n"
] |
[
[
"numpy.array",
"pandas.read_csv"
]
] |
michel4j/auto-process
|
[
"9c011cef3cdc2fc55df31f9cac88c3e1074aa366"
] |
[
"autoprocess/utils/ellipse.py"
] |
[
"# !/usr/bin/env python\n# -*- coding: utf-8 -*-\n#\n# Project: Azimuthal integration\n# https://github.com/silx-kit/pyFAI\n#\n# Copyright (C) European Synchrotron Radiation Facility, Grenoble, France\n#\n# Principal author: Jérôme Kieffer (Jerome.Kieffer@ESRF.eu)\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\n# all 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\n# THE SOFTWARE.\n\n\"\"\"This modules contains a function to fit without refinement an ellipse \non a set of points ....\n\"\"\"\n\n__author__ = \"Jerome Kieffer\"\n__contact__ = \"Jerome.Kieffer@ESRF.eu\"\n__license__ = \"MIT\"\n__copyright__ = \"European Synchrotron Radiation Facility, Grenoble, France\"\n__date__ = \"14/02/2017\"\n__status__ = \"production\"\n__docformat__ = 'restructuredtext'\n\nfrom collections import namedtuple\n\nimport numpy\n\nEllipse = namedtuple(\"Ellipse\", [\"cy\", \"cx\", \"angle\", \"half_long_axis\", \"half_short_axis\"])\n\n\ndef fit_ellipse(pty, ptx):\n \"\"\"Fit an\n \n inspired from \n http://nicky.vanforeest.com/misc/fitEllipse/fitEllipse.html\n \n :param pty: point coordinates in the slow dimension (y)\n :param ptx: point coordinates in the fast dimension (x)\n \"\"\"\n x = ptx[:, numpy.newaxis]\n y = pty[:, numpy.newaxis]\n D = numpy.hstack((x * x, x * y, y * y, x, y, numpy.ones_like(x)))\n S = numpy.dot(D.T, D)\n C = numpy.zeros([6, 6])\n C[0, 2] = C[2, 0] = 2\n C[1, 1] = -1\n E, V = numpy.linalg.eig(numpy.dot(numpy.linalg.inv(S), C))\n n = numpy.argmax(numpy.abs(E))\n res = V[:, n]\n b, c, d, f, g, a = res[1] / 2, res[2], res[3] / 2, res[4] / 2, res[5], res[0]\n num = b * b - a * c\n x0 = (c * d - b * f) / num\n y0 = (a * f - b * d) / num\n if b == 0:\n if a > c:\n angle = 0\n else:\n angle = numpy.pi / 2\n else:\n if a > c:\n angle = numpy.arctan2(2 * b, (a - c)) / 2\n else:\n angle = numpy.pi / 2 + numpy.arctan2(2 * b, (a - c)) / 2\n up = 2 * (a * f * f + c * d * d + g * b * b - 2 * b * d * f - a * c * g)\n down1 = (b * b - a * c) * ((c - a) * numpy.sqrt(1 + 4 * b * b / ((a - c) * (a - c))) - (c + a))\n down2 = (b * b - a * c) * ((a - c) * numpy.sqrt(1 + 4 * b * b / ((a - c) * (a - c))) - (c + a))\n res1 = numpy.sqrt(up / down1)\n res2 = numpy.sqrt(up / down2)\n return Ellipse(y0, x0, angle, max(res1, res2), min(res1, res2))\n"
] |
[
[
"numpy.dot",
"numpy.ones_like",
"numpy.zeros",
"numpy.arctan2",
"numpy.abs",
"numpy.sqrt",
"numpy.linalg.inv"
]
] |
anandsaha/cs231n.assignments
|
[
"d3a2d3a624bbc6335545a13508b28e977c8421c8"
] |
[
"2016winter/assignment2/cs231n/fast_layers.py"
] |
[
"import numpy as np\ntry:\n from cs231n.im2col_cython import col2im_cython, im2col_cython\n from cs231n.im2col_cython import col2im_6d_cython\nexcept ImportError:\n print ('run the following from the cs231n directory and try again:')\n print ('python setup.py build_ext --inplace')\n print ('You may also need to restart your iPython kernel')\n\nfrom cs231n.im2col import *\n\n\ndef conv_forward_im2col(x, w, b, conv_param):\n \"\"\"\n A fast implementation of the forward pass for a convolutional layer\n based on im2col and col2im.\n \"\"\"\n N, C, H, W = x.shape\n num_filters, _, filter_height, filter_width = w.shape\n stride, pad = conv_param['stride'], conv_param['pad']\n\n # Check dimensions\n assert (W + 2 * pad - filter_width) % stride == 0, 'width does not work'\n assert (H + 2 * pad - filter_height) % stride == 0, 'height does not work'\n\n # Create output\n out_height = (H + 2 * pad - filter_height) / stride + 1\n out_width = (W + 2 * pad - filter_width) / stride + 1\n out = np.zeros((N, num_filters, out_height, out_width), dtype=x.dtype)\n\n # x_cols = im2col_indices(x, w.shape[2], w.shape[3], pad, stride)\n x_cols = im2col_cython(x, w.shape[2], w.shape[3], pad, stride)\n res = w.reshape((w.shape[0], -1)).dot(x_cols) + b.reshape(-1, 1)\n\n out = res.reshape(w.shape[0], out.shape[2], out.shape[3], x.shape[0])\n out = out.transpose(3, 0, 1, 2)\n\n cache = (x, w, b, conv_param, x_cols)\n return out, cache\n\n\ndef conv_forward_strides(x, w, b, conv_param):\n N, C, H, W = x.shape\n F, _, HH, WW = w.shape\n stride, pad = conv_param['stride'], conv_param['pad']\n\n # Check dimensions\n assert (W + 2 * pad - WW) % stride == 0, 'width does not work'\n assert (H + 2 * pad - HH) % stride == 0, 'height does not work'\n\n # Pad the input\n p = pad\n x_padded = np.pad(x, ((0, 0), (0, 0), (p, p), (p, p)), mode='constant')\n \n # Figure out output dimensions\n H += 2 * pad\n W += 2 * pad\n out_h = (H - HH) / stride + 1\n out_w = (W - WW) / stride + 1\n\n # Perform an im2col operation by picking clever strides\n shape = (C, HH, WW, N, out_h, out_w)\n strides = (H * W, W, 1, C * H * W, stride * W, stride)\n strides = x.itemsize * np.array(strides)\n x_stride = np.lib.stride_tricks.as_strided(x_padded,\n shape=shape, strides=strides)\n x_cols = np.ascontiguousarray(x_stride)\n x_cols.shape = (C * HH * WW, N * out_h * out_w)\n\n # Now all our convolutions are a big matrix multiply\n res = w.reshape(F, -1).dot(x_cols) + b.reshape(-1, 1)\n\n # Reshape the output\n res.shape = (F, N, out_h, out_w)\n out = res.transpose(1, 0, 2, 3)\n\n # Be nice and return a contiguous array\n # The old version of conv_forward_fast doesn't do this, so for a fair\n # comparison we won't either\n out = np.ascontiguousarray(out)\n\n cache = (x, w, b, conv_param, x_cols)\n return out, cache\n \n\ndef conv_backward_strides(dout, cache):\n x, w, b, conv_param, x_cols = cache\n stride, pad = conv_param['stride'], conv_param['pad']\n\n N, C, H, W = x.shape\n F, _, HH, WW = w.shape\n _, _, out_h, out_w = dout.shape\n\n db = np.sum(dout, axis=(0, 2, 3))\n\n dout_reshaped = dout.transpose(1, 0, 2, 3).reshape(F, -1)\n dw = dout_reshaped.dot(x_cols.T).reshape(w.shape)\n\n dx_cols = w.reshape(F, -1).T.dot(dout_reshaped)\n dx_cols.shape = (C, HH, WW, N, out_h, out_w)\n dx = col2im_6d_cython(dx_cols, N, C, H, W, HH, WW, pad, stride)\n\n return dx, dw, db\n\n\ndef conv_backward_im2col(dout, cache):\n \"\"\"\n A fast implementation of the backward pass for a convolutional layer\n based on im2col and col2im.\n \"\"\"\n x, w, b, conv_param, x_cols = cache\n stride, pad = conv_param['stride'], conv_param['pad']\n\n db = np.sum(dout, axis=(0, 2, 3))\n\n num_filters, _, filter_height, filter_width = w.shape\n dout_reshaped = dout.transpose(1, 2, 3, 0).reshape(num_filters, -1)\n dw = dout_reshaped.dot(x_cols.T).reshape(w.shape)\n\n dx_cols = w.reshape(num_filters, -1).T.dot(dout_reshaped)\n # dx = col2im_indices(dx_cols, x.shape, filter_height, filter_width, pad, stride)\n dx = col2im_cython(dx_cols, x.shape[0], x.shape[1], x.shape[2], x.shape[3],\n filter_height, filter_width, pad, stride)\n\n return dx, dw, db\n\n\nconv_forward_fast = conv_forward_strides\nconv_backward_fast = conv_backward_strides\n\n\ndef max_pool_forward_fast(x, pool_param):\n \"\"\"\n A fast implementation of the forward pass for a max pooling layer.\n\n This chooses between the reshape method and the im2col method. If the pooling\n regions are square and tile the input image, then we can use the reshape\n method which is very fast. Otherwise we fall back on the im2col method, which\n is not much faster than the naive method.\n \"\"\"\n N, C, H, W = x.shape\n pool_height, pool_width = pool_param['pool_height'], pool_param['pool_width']\n stride = pool_param['stride']\n\n same_size = pool_height == pool_width == stride\n tiles = H % pool_height == 0 and W % pool_width == 0\n if same_size and tiles:\n out, reshape_cache = max_pool_forward_reshape(x, pool_param)\n cache = ('reshape', reshape_cache)\n else:\n out, im2col_cache = max_pool_forward_im2col(x, pool_param)\n cache = ('im2col', im2col_cache)\n return out, cache\n\n\ndef max_pool_backward_fast(dout, cache):\n \"\"\"\n A fast implementation of the backward pass for a max pooling layer.\n\n This switches between the reshape method an the im2col method depending on\n which method was used to generate the cache.\n \"\"\"\n method, real_cache = cache\n if method == 'reshape':\n return max_pool_backward_reshape(dout, real_cache)\n elif method == 'im2col':\n return max_pool_backward_im2col(dout, real_cache)\n else:\n raise ValueError('Unrecognized method \"%s\"' % method)\n\n\ndef max_pool_forward_reshape(x, pool_param):\n \"\"\"\n A fast implementation of the forward pass for the max pooling layer that uses\n some clever reshaping.\n\n This can only be used for square pooling regions that tile the input.\n \"\"\"\n N, C, H, W = x.shape\n pool_height, pool_width = pool_param['pool_height'], pool_param['pool_width']\n stride = pool_param['stride']\n assert pool_height == pool_width == stride, 'Invalid pool params'\n assert H % pool_height == 0\n assert W % pool_height == 0\n x_reshaped = x.reshape(N, C, H / pool_height, pool_height,\n W / pool_width, pool_width)\n out = x_reshaped.max(axis=3).max(axis=4)\n\n cache = (x, x_reshaped, out)\n return out, cache\n\n\ndef max_pool_backward_reshape(dout, cache):\n \"\"\"\n A fast implementation of the backward pass for the max pooling layer that\n uses some clever broadcasting and reshaping.\n\n This can only be used if the forward pass was computed using\n max_pool_forward_reshape.\n\n NOTE: If there are multiple argmaxes, this method will assign gradient to\n ALL argmax elements of the input rather than picking one. In this case the\n gradient will actually be incorrect. However this is unlikely to occur in\n practice, so it shouldn't matter much. One possible solution is to split the\n upstream gradient equally among all argmax elements; this should result in a\n valid subgradient. You can make this happen by uncommenting the line below;\n however this results in a significant performance penalty (about 40% slower)\n and is unlikely to matter in practice so we don't do it.\n \"\"\"\n x, x_reshaped, out = cache\n\n dx_reshaped = np.zeros_like(x_reshaped)\n out_newaxis = out[:, :, :, np.newaxis, :, np.newaxis]\n mask = (x_reshaped == out_newaxis)\n dout_newaxis = dout[:, :, :, np.newaxis, :, np.newaxis]\n dout_broadcast, _ = np.broadcast_arrays(dout_newaxis, dx_reshaped)\n dx_reshaped[mask] = dout_broadcast[mask]\n dx_reshaped /= np.sum(mask, axis=(3, 5), keepdims=True)\n dx = dx_reshaped.reshape(x.shape)\n\n return dx\n\n\ndef max_pool_forward_im2col(x, pool_param):\n \"\"\"\n An implementation of the forward pass for max pooling based on im2col.\n\n This isn't much faster than the naive version, so it should be avoided if\n possible.\n \"\"\"\n N, C, H, W = x.shape\n pool_height, pool_width = pool_param['pool_height'], pool_param['pool_width']\n stride = pool_param['stride']\n\n assert (H - pool_height) % stride == 0, 'Invalid height'\n assert (W - pool_width) % stride == 0, 'Invalid width'\n\n out_height = (H - pool_height) / stride + 1\n out_width = (W - pool_width) / stride + 1\n\n x_split = x.reshape(N * C, 1, H, W)\n x_cols = im2col(x_split, pool_height, pool_width, padding=0, stride=stride)\n x_cols_argmax = np.argmax(x_cols, axis=0)\n x_cols_max = x_cols[x_cols_argmax, np.arange(x_cols.shape[1])]\n out = x_cols_max.reshape(out_height, out_width, N, C).transpose(2, 3, 0, 1)\n\n cache = (x, x_cols, x_cols_argmax, pool_param)\n return out, cache\n\n\ndef max_pool_backward_im2col(dout, cache):\n \"\"\"\n An implementation of the backward pass for max pooling based on im2col.\n\n This isn't much faster than the naive version, so it should be avoided if\n possible.\n \"\"\"\n x, x_cols, x_cols_argmax, pool_param = cache\n N, C, H, W = x.shape\n pool_height, pool_width = pool_param['pool_height'], pool_param['pool_width']\n stride = pool_param['stride']\n\n dout_reshaped = dout.transpose(2, 3, 0, 1).flatten()\n dx_cols = np.zeros_like(x_cols)\n dx_cols[x_cols_argmax, np.arange(dx_cols.shape[1])] = dout_reshaped\n dx = col2im_indices(dx_cols, (N * C, 1, H, W), pool_height, pool_width,\n padding=0, stride=stride)\n dx = dx.reshape(x.shape)\n\n return dx\n"
] |
[
[
"numpy.pad",
"numpy.lib.stride_tricks.as_strided",
"numpy.zeros_like",
"numpy.array",
"numpy.zeros",
"numpy.broadcast_arrays",
"numpy.ascontiguousarray",
"numpy.sum",
"numpy.argmax",
"numpy.arange"
]
] |
ZAKAUDD/Segmentation-Networks
|
[
"7e006809a7345819ebc50326175df156beeca618"
] |
[
"model/FSSNet.py"
] |
[
"######################################################################################\n#FSSNet: Fast Semantic Segmentation for Scene Perception\n#Paper-Link: https://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=8392426\n######################################################################################\n\n\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom torchsummary import summary\nfrom utils.activations import NON_LINEARITY\n\n\n__all__ = [\"FSSNet\"]\n\n# NON_LINEARITY = {\n# 'ReLU': nn.ReLU(inplace=True),\n# 'PReLU': nn.PReLU(),\n# \t'ReLu6': nn.ReLU6(inplace=True)\n# }\n\nclass InitialBlock(nn.Module):\n def __init__(self, ninput, noutput, non_linear='ReLU'):\n super().__init__()\n\n self.conv = nn.Conv2d(ninput, noutput-ninput, (3, 3), stride=2, padding=1, bias=False)\n self.pool = nn.MaxPool2d(2, stride=2)\n self.bn = nn.BatchNorm2d(noutput-ninput, eps=1e-3)\n self.relu = NON_LINEARITY[non_linear]\n\n def forward(self, input):\n output = self.relu(self.bn(self.conv(input)))\n output = torch.cat([output, self.pool(input)], 1)\n\n return output\n\n\nclass DownsamplingBottleneck(nn.Module):\n def __init__(self, in_channels, out_channels, internal_ratio=4, kernel_size=3,\n padding=0, dropout_prob=0., bias=False, non_linear='ReLU'):\n super().__init__()\n # Store parameters that are needed later\n internal_channels = in_channels // internal_ratio\n\n # Main branch - max pooling followed by feature map (channels) padding\n self.main_max1 = nn.Sequential(\n nn.MaxPool2d(kernel_size=2, stride=2),\n nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=1, bias=bias),\n )\n\n # Extension branch - 2x2 convolution, followed by a regular, dilated or\n # asymmetric convolution, followed by another 1x1 convolution. Number\n # of channels is doubled.\n\n # 2x2 projection convolution with stride 2, no padding\n self.ext_conv1 = nn.Sequential(\n nn.Conv2d(in_channels, internal_channels, kernel_size=2, stride=2, bias=bias),\n nn.BatchNorm2d(internal_channels),\n NON_LINEARITY[non_linear]\n )\n # Convolution\n self.ext_conv2 = nn.Sequential(\n nn.Conv2d(internal_channels, internal_channels, kernel_size=kernel_size, stride=1, padding=padding,\n bias=bias),\n nn.BatchNorm2d(internal_channels),\n NON_LINEARITY[non_linear]\n )\n\n # 1x1 expansion convolution\n self.ext_conv3 = nn.Sequential(\n nn.Conv2d(internal_channels, out_channels, kernel_size=1, stride=1, bias=bias),\n nn.BatchNorm2d(out_channels),\n NON_LINEARITY[non_linear]\n )\n self.ext_regul = nn.Dropout2d(p=dropout_prob)\n # PReLU layer to apply after concatenating the branches\n self.out_prelu = NON_LINEARITY[non_linear]\n\n def forward(self, x):\n # Main branch shortcut\n main = self.main_max1(x)\n\n # Extension branch\n ext = self.ext_conv1(x)\n ext = self.ext_conv2(ext)\n ext = self.ext_conv3(ext)\n ext = self.ext_regul(ext)\n\n # Add main and extension branches\n out = self.out_prelu(main + ext)\n\n return out\n\n\nclass UpsamplingBottleneck(nn.Module):\n def __init__(self, in_channels, out_channels, internal_ratio=4, kernel_size=2,\n padding=0, dropout_prob=0., bias=False, non_linear='ReLU'):\n super().__init__()\n internal_channels = in_channels // internal_ratio\n\n # Main branch - max pooling followed by feature map (channels) padding\n self.main_conv1 = nn.Sequential(\n nn.Conv2d(in_channels, out_channels, kernel_size=1, bias=bias),\n nn.BatchNorm2d(out_channels))\n\n # Remember that the stride is the same as the kernel_size, just like\n # the max pooling layers\n # self.main_unpool1 = nn.MaxUnpool2d(kernel_size=2)\n\n # Extension branch - 1x1 convolution, followed by a regular, dilated or\n # asymmetric convolution, followed by another 1x1 convolution. Number\n # of channels is doubled.\n\n # 1x1 projection convolution with stride 1\n self.ext_conv1 = nn.Sequential(\n nn.Conv2d(in_channels, internal_channels, kernel_size=1, bias=bias),\n nn.BatchNorm2d(internal_channels),\n NON_LINEARITY[non_linear]\n )\n # Transposed convolution\n self.ext_conv2 = nn.Sequential(\n nn.ConvTranspose2d(internal_channels, internal_channels, kernel_size=kernel_size, stride=2, padding=padding,\n output_padding=0, bias=bias),\n nn.BatchNorm2d(internal_channels),\n NON_LINEARITY[non_linear]\n )\n # 1x1 expansion convolution\n self.ext_conv3 = nn.Sequential(\n nn.Conv2d(internal_channels, out_channels, kernel_size=1, bias=bias),\n nn.BatchNorm2d(out_channels),\n NON_LINEARITY[non_linear]\n )\n\n self.ext_regul = nn.Dropout2d(p=dropout_prob)\n\n # PReLU layer to apply after concatenating the branches\n self.out_prelu = NON_LINEARITY[non_linear]\n\n def forward(self, x, x_pre):\n # Main branch shortcut # here different origin paper, Fig 4 contradict to Fig 9\n main = x + x_pre\n\n main = self.main_conv1(main) # 2. conv first, follow up\n\n main = F.interpolate(main, scale_factor=2, mode=\"bilinear\", align_corners=True) # 1. up first, follow conv\n # main = self.main_conv1(main)\n\n # Extension branch\n ext = self.ext_conv1(x)\n ext = self.ext_conv2(ext)\n ext = self.ext_conv3(ext)\n ext = self.ext_regul(ext)\n\n # Add main and extension branches\n out = self.out_prelu(main + ext)\n\n return out\n\n\nclass DilatedBlock(nn.Module):\n def __init__(self, in_channels, out_channels, kernel_size=3, stride=1, dilation=1,\n dropout_prob=0., bias=False, non_linear='ReLU'):\n super(DilatedBlock, self).__init__()\n self.relu = NON_LINEARITY[non_linear]\n self.internal_channels = in_channels // 4\n # compress conv\n self.conv1 = nn.Conv2d(in_channels, self.internal_channels, 1, bias=bias)\n self.conv1_bn = nn.BatchNorm2d(self.internal_channels)\n # a relu\n self.conv2 = nn.Conv2d(self.internal_channels, self.internal_channels, kernel_size,\n stride, padding=int((kernel_size - 1) / 2 * dilation), dilation=dilation, groups=1,\n bias=bias)\n self.conv2_bn = nn.BatchNorm2d(self.internal_channels)\n # a relu\n self.conv4 = nn.Conv2d(self.internal_channels, out_channels, 1, bias=bias)\n self.conv4_bn = nn.BatchNorm2d(out_channels)\n self.regul = nn.Dropout2d(p=dropout_prob)\n\n def forward(self, x):\n residual = x\n main = self.relu(self.conv1_bn(self.conv1(x)))\n main = self.relu(self.conv2_bn(self.conv2(main)))\n main = self.conv4_bn(self.conv4(main))\n main = self.regul(main)\n out = self.relu(torch.add(main, residual))\n return out\n\n\nclass Factorized_Block(nn.Module):\n def __init__(self, in_channels, out_channels, kernel_size=3, stride=1, dilation=1,\n dropout_prob=0., bias=False, non_linear='ReLU'):\n super(Factorized_Block, self).__init__()\n self.relu = NON_LINEARITY[non_linear]\n self.internal_channels = in_channels // 4\n self.compress_conv1 = nn.Conv2d(in_channels, self.internal_channels, 1, padding=0, bias=bias)\n self.conv1_bn = nn.BatchNorm2d(self.internal_channels)\n # here is relu\n self.conv2_1 = nn.Conv2d(self.internal_channels, self.internal_channels, (kernel_size, 1), stride=(stride, 1),\n padding=(int((kernel_size - 1) / 2 * dilation), 0), dilation=(dilation, 1), bias=bias)\n self.conv2_1_bn = nn.BatchNorm2d(self.internal_channels)\n self.conv2_2 = nn.Conv2d(self.internal_channels, self.internal_channels, (1, kernel_size), stride=(1, stride),\n padding=(0, int((kernel_size - 1) / 2 * dilation)), dilation=(1, dilation), bias=bias)\n self.conv2_2_bn = nn.BatchNorm2d(self.internal_channels)\n # here is relu\n self.extend_conv3 = nn.Conv2d(self.internal_channels, out_channels, 1, padding=0, bias=bias)\n\n self.conv3_bn = nn.BatchNorm2d(out_channels)\n self.regul = nn.Dropout2d(p=dropout_prob)\n\n def forward(self, x):\n residual = x\n main = self.relu((self.conv1_bn(self.compress_conv1(x))))\n main = self.relu(self.conv2_1_bn(self.conv2_1(main)))\n main = self.relu(self.conv2_2_bn(self.conv2_2(main)))\n\n main = self.conv3_bn(self.extend_conv3(main))\n main = self.regul(main)\n out = self.relu((torch.add(residual, main)))\n return out\n\n\nclass FSSNet(nn.Module):\n def __init__(self, classes):\n super().__init__()\n\n self.initial_block = InitialBlock(3, 16)\n\n # Stage 1 - Encoder\n self.downsample1_0 = DownsamplingBottleneck(16, 64, padding=1, dropout_prob=0.03)\n self.factorized1_1 = Factorized_Block(64, 64, dropout_prob=0.03)\n self.factorized1_2 = Factorized_Block(64, 64, dropout_prob=0.03)\n self.factorized1_3 = Factorized_Block(64, 64, dropout_prob=0.03)\n self.factorized1_4 = Factorized_Block(64, 64, dropout_prob=0.03)\n\n # Stage 2 - Encoder\n self.downsample2_0 = DownsamplingBottleneck(64, 128, padding=1, dropout_prob=0.3)\n self.dilated2_1 = DilatedBlock(128, 128, dilation=2, dropout_prob=0.3)\n self.dilated2_2 = DilatedBlock(128, 128, dilation=5, dropout_prob=0.3)\n self.dilated2_3 = DilatedBlock(128, 128, dilation=9, dropout_prob=0.3)\n self.dilated2_4 = DilatedBlock(128, 128, dilation=2, dropout_prob=0.3)\n self.dilated2_5 = DilatedBlock(128, 128, dilation=5, dropout_prob=0.3)\n self.dilated2_6 = DilatedBlock(128, 128, dilation=9, dropout_prob=0.3)\n\n # Stage 4 - Decoder\n self.upsample4_0 = UpsamplingBottleneck(128, 64, dropout_prob=0.3)\n self.bottleneck4_1 = DilatedBlock(64, 64, dropout_prob=0.3)\n self.bottleneck4_2 = DilatedBlock(64, 64, dropout_prob=0.3)\n\n # Stage 5 - Decoder\n self.upsample5_0 = UpsamplingBottleneck(64, 16, dropout_prob=0.3)\n self.bottleneck5_1 = DilatedBlock(16, 16, dropout_prob=0.3)\n self.bottleneck5_2 = DilatedBlock(16, 16, dropout_prob=0.3)\n\n self.transposed_conv = nn.ConvTranspose2d(16, classes, kernel_size=3, stride=2, padding=1, output_padding=1, bias=False)\n\n def forward(self, x):\n # Initial block\n # Initial block\n x = self.initial_block(x)\n\n # Encoder - Block 1\n x_1= self.downsample1_0(x)\n x = self.factorized1_1(x_1)\n x = self.factorized1_2(x)\n x = self.factorized1_3(x)\n x = self.factorized1_4(x)\n\n # Encoder - Block 2\n x_2 = self.downsample2_0(x)\n # print(x_2.shape)\n x = self.dilated2_1(x_2)\n x = self.dilated2_2(x)\n x = self.dilated2_3(x)\n x = self.dilated2_4(x)\n x = self.dilated2_5(x)\n x = self.dilated2_6(x)\n # print(x.shape)\n\n # Decoder - Block 3\n x = self.upsample4_0(x, x_2)\n x = self.bottleneck4_1(x)\n x = self.bottleneck4_2(x)\n\n # Decoder - Block 4\n x = self.upsample5_0(x, x_1)\n x = self.bottleneck5_1(x)\n x = self.bottleneck5_2(x)\n\n # Fullconv - DeConv\n x = self.transposed_conv(x)\n\n return x\n\n\n\"\"\"print layers and params of network\"\"\"\nif __name__ == '__main__':\n device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n model = FSSNet(classes=19).to(device)\n summary(model,(3,512,1024))\n"
] |
[
[
"torch.nn.MaxPool2d",
"torch.nn.BatchNorm2d",
"torch.nn.functional.interpolate",
"torch.nn.ConvTranspose2d",
"torch.add",
"torch.nn.Conv2d",
"torch.cuda.is_available",
"torch.nn.Dropout2d"
]
] |
princeward/faster_rcnn_pytorch
|
[
"7ffb31afc3de10085a655a03282ab7d1e6002d87"
] |
[
"demo.py"
] |
[
"import cv2\nimport numpy as np\nfrom faster_rcnn import network\nfrom faster_rcnn.faster_rcnn import FasterRCNN\nfrom faster_rcnn.utils.timer import Timer\n\n\ndef test():\n import os\n im_file = 'demo/004545.jpg'\n # im_file = 'data/VOCdevkit2007/VOC2007/JPEGImages/009036.jpg'\n # im_file = '/media/longc/Data/data/2DMOT2015/test/ETH-Crossing/img1/000100.jpg'\n image = cv2.imread(im_file)\n\n model_file = '/home/zjwang/git/faster_rcnn_pytorch/VGGnet_fast_rcnn_iter_70000.h5'\n # model_file = '/media/longc/Data/models/faster_rcnn_pytorch3/faster_rcnn_100000.h5'\n # model_file = '/media/longc/Data/models/faster_rcnn_pytorch2/faster_rcnn_2000.h5'\n detector = FasterRCNN()\n network.load_net(model_file, detector)\n detector.cuda()\n detector.eval()\n print('load model successfully!')\n\n # network.save_net(r'/media/longc/Data/models/VGGnet_fast_rcnn_iter_70000.h5', detector)\n # print('save model succ')\n\n t = Timer()\n t.tic()\n # image = np.zeros(shape=[600, 800, 3], dtype=np.uint8) + 255\n dets, scores, classes = detector.detect(image, 0.7)\n runtime = t.toc()\n print('total spend: {}s'.format(runtime))\n\n im2show = np.copy(image)\n for i, det in enumerate(dets):\n det = tuple(int(x) for x in det)\n cv2.rectangle(im2show, det[0:2], det[2:4], (255, 205, 51), 2)\n cv2.putText(im2show, '%s: %.3f' % (classes[i], scores[i]), (det[0], det[1] + 15), cv2.FONT_HERSHEY_PLAIN,\n 1.0, (0, 0, 255), thickness=1)\n cv2.imwrite(os.path.join('demo', 'out.jpg'), im2show)\n cv2.imshow('demo', im2show)\n cv2.waitKey(0)\n\n\nif __name__ == '__main__':\n test()\n"
] |
[
[
"numpy.copy"
]
] |
MajesticKhan/Reinforcement-Learning
|
[
"c488e547afe571b47446be76abf6f5c80e8e6be5"
] |
[
"Simulation/play.py"
] |
[
"from env import lineFollower\nfrom stable_baselines import PPO2\nimport imageio\nimport numpy as np\n\n# Load separate environment for evaluation\nenv = lineFollower()\n\n# load model\nmodel = PPO2.load(\"model_final.zip\")\n\n# Store image\nimages = []\n\n# Set environment and get image\nobs = env.reset()\nimages.append(obs)\n\ndone = False\nwhile not done:\n action, _states = model.predict(obs, deterministic=True)\n obs, reward, done, info = env.step(action)\n images.append(obs)\n\n# shutdown environment\nenv.shutdown()\nimageio.mimsave('foundation.gif', [np.array(img) for i, img in enumerate(images) if i%4 == 0], fps=29)"
] |
[
[
"numpy.array"
]
] |
edwardyehuang/iDS
|
[
"36bde3a9e887eb7e1a8d88956cf041909ee84da4"
] |
[
"cocostuff.py"
] |
[
"# ================================================================\n# MIT License\n# Copyright (c) 2021 edwardyehuang (https://github.com/edwardyehuang)\n# ================================================================\n\nimport os\nimport tensorflow as tf\nimport numpy as np\nimport random\n\nINAGE_DIR = \"images\"\nLABEL_DIR = \"labels\"\n\nSEGMENTATION_TRAIN_FILENAME = \"train.txt\"\nSEGMENTATION_EVAL_FILENAME = \"val.txt\"\n\nIMAGE_FILE_EXTENSION = \".jpg\"\nLABEL_FILE_EXTENSION = \".png\"\n\nfrom .dataset import Dataset\n\n\nclass Cocostuff(Dataset):\n def __init__(self, dataset_dir):\n\n super().__init__(dataset_dir)\n\n self.ignore_label = 255\n self.num_class = 171\n self.val_image_count = 5000\n self.compress = True\n\n def load_data_paths(self, dataset_dir):\n\n image_dir = os.path.join(dataset_dir, INAGE_DIR)\n label_dir = os.path.join(dataset_dir, LABEL_DIR)\n\n train_list_path = os.path.join(dataset_dir, SEGMENTATION_TRAIN_FILENAME)\n val_list_path = os.path.join(dataset_dir, SEGMENTATION_EVAL_FILENAME)\n\n return (\n self.__get_data_paths(train_list_path, image_dir, label_dir),\n self.__get_data_paths(val_list_path, image_dir, label_dir),\n )\n\n def __get_data_paths(self, names_list_path, images_dir, labels_dir):\n\n with open(names_list_path, \"r\") as f:\n images_names = f.read().split()\n\n if self.shuffle_raw_image_paths:\n random.shuffle(images_names)\n\n images_paths = [os.path.join(images_dir, image_name + IMAGE_FILE_EXTENSION) for image_name in images_names]\n labels_paths = [os.path.join(labels_dir, image_name + LABEL_FILE_EXTENSION) for image_name in images_names]\n\n return images_paths, labels_paths\n\n def create_label_colormap(self):\n\n colormap = [\n (0, 0, 0),\n (128, 0, 0),\n (0, 128, 0),\n (128, 128, 0),\n (0, 0, 128),\n (128, 0, 128),\n (0, 128, 128),\n (128, 128, 128),\n (64, 0, 0),\n (192, 0, 0),\n (64, 128, 0),\n (192, 128, 0),\n (64, 0, 128),\n (192, 0, 128),\n (64, 128, 128),\n (192, 128, 128),\n (0, 64, 0),\n (128, 64, 0),\n (0, 192, 0),\n (128, 192, 0),\n (0, 64, 128),\n (128, 64, 128),\n (0, 192, 128),\n (128, 192, 128),\n (64, 64, 0),\n (192, 64, 0),\n (64, 192, 0),\n (192, 192, 0),\n (64, 64, 128),\n (192, 64, 128),\n (64, 192, 128),\n (192, 192, 128),\n (0, 0, 64),\n (128, 0, 64),\n (0, 128, 64),\n (128, 128, 64),\n (0, 0, 192),\n (128, 0, 192),\n (0, 128, 192),\n (128, 128, 192),\n (64, 0, 64),\n (192, 0, 64),\n (64, 128, 64),\n (192, 128, 64),\n (64, 0, 192),\n (192, 0, 192),\n (64, 128, 192),\n (192, 128, 192),\n (0, 64, 64),\n (128, 64, 64),\n (0, 192, 64),\n (128, 192, 64),\n (0, 64, 192),\n (128, 64, 192),\n (0, 192, 192),\n (128, 192, 192),\n (64, 64, 64),\n (192, 64, 64),\n (64, 192, 64),\n (192, 192, 64),\n ]\n\n colormap = np.array(colormap)\n\n return colormap\n"
] |
[
[
"numpy.array"
]
] |
tginart/competing-ai
|
[
"75c456854e4770adf8be7cd56e58177d50f74a24"
] |
[
"user.py"
] |
[
"from abc import ABC, abstractmethod\nimport random\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\n\n\nclass mab_user(ABC):\n def __init__(self, n_arms, lamb=1):\n super(mab_user, self).__init__()\n self.t = torch.tensor(1.0)\n self.r = torch.zeros(n_arms)\n self.n = torch.zeros(n_arms)\n self.id = -1\n self.returns = 0\n self.lamb = lamb\n\n @abstractmethod\n def choose(self):\n pass\n\n @abstractmethod\n def update(self, arm, reward):\n pass \n\nclass perfect_user(mab_user):\n # users that always make perfect decision -- can be paired with recEngines \n # in CF simulations\n def __init__(self, n_arms):\n super().__init__(n_arms)\n\n def setup_learners(self, learners):\n #this setup routine must be called before perfect_user can run\n self.learners = learners\n\n def choose(self):\n l_max = [0]*len(self.learners)\n for i,learner in enumerate(self.learners):\n l_max[i] = torch.max(learner.U[self.id] @ learner.V.t())\n return torch.argmax(torch.tensor(l_max))\n\n def update(self, arm, reward):\n pass \n\n\nclass ucb_user(mab_user):\n def __init__(self, n_arms):\n super().__init__(n_arms)\n\n def _ranking(self):\n return self.r + self.lamb*torch.sqrt(2*torch.log(self.t)/self.n)\n\n def choose(self):\n return torch.argmax(self._ranking())\n\n def update(self, arm, reward):\n self.r[arm] = self.r[arm]*(self.n[arm]) + reward\n self.n[arm] += 1\n self.r[arm] /= self.n[arm]\n self.t += 1\n self.returns += reward\n\nclass e_greedy_user(ucb_user):\n def __init__(self, n_arms, eps_scaling=0.333, r_tol=1e-20, eps0=1.0):\n super().__init__(n_arms)\n self.eps_scaling = eps_scaling\n self.eps = eps0\n self.eps0 = eps0\n self.n_arms = n_arms\n self.r_tol = r_tol\n\n def choose(self):\n if random.random() > self.eps:\n a = torch.argmax(self.r + self.r_tol*torch.randn(self.r.shape))\n else:\n a = random.randint(0,self.n_arms-1)\n return a\n\n def update(self, arm, reward):\n super().update(arm, reward)\n self.eps = self.eps0/(self.t**self.eps_scaling)\n\n\n\nclass sw_ucb_user(mab_user):\n\n def __init__(self, n_arms):\n super(ucb_user, self).__init__()\n self.n_arms = n_arms\n self.t = torch.tensor(1.0)\n self.tau\n self.sw_r = []\n self.sw_arms = []\n self.n = torch.zeros(self.n_arms)\n self.r = torch.zeros(self.n_arms)\n self.alpha = 0.9\n self.lamb = 1\n self.id = -1\n self.returns = 0\n\n def _ranking(self):\n return self.r/self.n + self.lamb*torch.sqrt(\n (1+self.alpha)*torch.log(self.t)/self.n)\n\n def update(self, arm, reward):\n self.sw_arm.append(arm)\n self.sw_r.append(reward)\n self.r[arm] += reward\n self.returns += reward\n self.n[arm] += 1\n tau_prime = torch.min(torch.ceil(self.lamb*(self.t**self.alpha)),self.t)\n delta_tau = tau_prime - self.tau\n if delta_tau < 1.0:\n arm = self.sw_arm.pop(0)\n self.r[arm] -= [self.sw_r.pop(0)]\n self.n[arm] -= 1\n self.tau = tau_prime\n\n\n"
] |
[
[
"torch.zeros",
"torch.ceil",
"torch.tensor",
"torch.log",
"torch.randn"
]
] |
dcf21/4most-4gp
|
[
"0421d76791315aa3ca8ff9e4bd2e37ad36c0141f"
] |
[
"src/pythonModules/fourgp_rv/fourgp_rv/templates_resample.py"
] |
[
"# -*- coding: utf-8 -*-\n\n\"\"\"\nCode to take template spectra, used for RV fitting, and pass them through 4FS to resample them to 4MOST's resolution.\nIt then further resamples each arm onto a fixed logarithmic stride.\n\"\"\"\n\nimport argparse\nimport hashlib\nimport logging\nimport numpy as np\nimport os\nfrom os import path as os_path\n\nfrom fourgp_fourfs import FourFS\nfrom fourgp_degrade.resample import SpectrumResampler\nfrom fourgp_degrade import SpectrumProperties\nfrom fourgp_speclib import SpectrumLibrarySqlite\n\n\ndef command_line_interface(root_path):\n \"\"\"\n A simple command-line interface for running a tool to resample a library of template spectra onto fixed\n logarithmic rasters representing each of the 4MOST arms.\n\n We use the python argparse module to build the interface, and return the inputs supplied by the user.\n\n :param root_path:\n The root path of this 4GP installation; the directory where we can find 4FS.\n\n :return:\n An object containing the arguments supplied by the user.\n \"\"\"\n # Read input parameters\n parser = argparse.ArgumentParser(description=__doc__.strip())\n parser.add_argument('--templates-in',\n required=False,\n default='turbospec_rv_templates',\n dest='templates_in',\n help=\"Library of spectra to use as templates for RV code\")\n parser.add_argument('--workspace', dest='workspace', default=\"\",\n help=\"Directory where we expect to find spectrum libraries\")\n parser.add_argument('--templates-out',\n required=False,\n default=\"rv_templates_resampled\",\n dest=\"templates_out\",\n help=\"Library into which to place resampled templates for RV code\")\n parser.add_argument('--binary-path',\n required=False,\n default=root_path,\n dest=\"binary_path\",\n help=\"Specify a directory where 4FS binary package is installed\")\n args = parser.parse_args()\n\n # Set up logger\n logging.basicConfig(level=logging.INFO, format='[%(asctime)s] %(levelname)s:%(filename)s:%(message)s',\n datefmt='%d/%m/%Y %H:%M:%S')\n logger = logging.getLogger(__name__)\n\n logger.info(\"Resampling template spectra\")\n\n return args\n\n\ndef logarithmic_raster(lambda_min, lambda_max, lambda_step):\n \"\"\"\n Create a logarithmic raster with a fixed logarithmic stride, based on a starting wavelength, finishing wavelength,\n and a mean wavelength step.\n\n :param lambda_min:\n Smallest wavelength in raster.\n :param lambda_max:\n Largest wavelength in raster.\n :param lambda_step:\n The approximate pixel size in the raster.\n :return:\n A numpy array containing a wavelength raster with fixed logarithmic stride.\n \"\"\"\n return np.exp(np.arange(\n np.log(lambda_min),\n np.log(lambda_max),\n np.log(1 + lambda_step / lambda_min)\n ))\n\n\ndef resample_templates(args, logger):\n \"\"\"\n Resample a spectrum library of templates onto a fixed logarithmic stride, representing each of the 4MOST arms in\n turn. We use 4FS to down-sample the templates to the resolution of 4MOST observations, and automatically detect\n the list of arms contained within each 4FS mock observation. We then resample the 4FS output onto a new raster\n with fixed logarithmic stride.\n\n :param args:\n Object containing arguments supplied by the used, for example the name of the spectrum libraries we use for\n input and output. The required fields are defined by the user interface above.\n :param logger:\n A python logging object.\n :return:\n None.\n \"\"\"\n # Set path to workspace where we expect to find libraries of spectra\n workspace = args.workspace if args.workspace else os_path.join(args.our_path, \"../../../workspace\")\n\n # Open input template spectra\n spectra = SpectrumLibrarySqlite.open_and_search(\n library_spec=args.templates_in,\n workspace=workspace,\n extra_constraints={\"continuum_normalised\": 0}\n )\n\n templates_library, templates_library_items, templates_spectra_constraints = \\\n [spectra[i] for i in (\"library\", \"items\", \"constraints\")]\n\n # Create new SpectrumLibrary to hold the resampled output templates\n library_path = os_path.join(workspace, args.templates_out)\n output_library = SpectrumLibrarySqlite(path=library_path, create=True)\n\n # Instantiate 4FS wrapper\n etc_wrapper = FourFS(\n path_to_4fs=os_path.join(args.binary_path, \"OpSys/ETC\"),\n snr_list=[250.],\n magnitude=13,\n snr_per_pixel=True\n )\n\n for input_spectrum_id in templates_library_items:\n logger.info(\"Working on <{}>\".format(input_spectrum_id['filename']))\n\n # Open Spectrum data from disk\n input_spectrum_array = templates_library.open(ids=input_spectrum_id['specId'])\n\n # Load template spectrum (flux normalised)\n template_flux_normalised = input_spectrum_array.extract_item(0)\n\n # Look up the unique ID of the star we've just loaded\n # Newer spectrum libraries have a uid field which is guaranteed unique; for older spectrum libraries use\n # Starname instead.\n\n # Work out which field we're using (uid or Starname)\n spectrum_matching_field = 'uid' if 'uid' in template_flux_normalised.metadata else 'Starname'\n\n # Look up the unique ID of this object\n object_name = template_flux_normalised.metadata[spectrum_matching_field]\n\n # Search for the continuum-normalised version of this same object (which will share the same uid / name)\n search_criteria = {\n spectrum_matching_field: object_name,\n 'continuum_normalised': 1\n }\n\n continuum_normalised_spectrum_id = templates_library.search(**search_criteria)\n\n # Check that continuum-normalised spectrum exists and is unique\n assert len(continuum_normalised_spectrum_id) == 1, \"Could not find continuum-normalised spectrum.\"\n\n # Load the continuum-normalised version\n template_continuum_normalised_arr = templates_library.open(\n ids=continuum_normalised_spectrum_id[0]['specId']\n )\n\n # Turn the SpectrumArray we got back into a single Spectrum\n template_continuum_normalised = template_continuum_normalised_arr.extract_item(0)\n\n # Now create a mock observation of this template using 4FS\n logger.info(\"Passing template through 4FS\")\n mock_observed_template = etc_wrapper.process_spectra(\n spectra_list=((template_flux_normalised, template_continuum_normalised),)\n )\n\n # Loop over LRS and HRS\n for mode in mock_observed_template:\n\n # Loop over the spectra we simulated (there was only one!)\n for index in mock_observed_template[mode]:\n\n # Loop over the various SNRs we simulated (there was only one!)\n for snr in mock_observed_template[mode][index]:\n\n # Create a unique ID for this arm's data\n unique_id = hashlib.md5(os.urandom(32)).hexdigest()[:16]\n\n # Import the flux- and continuum-normalised spectra separately, but give them the same ID\n for spectrum_type in mock_observed_template[mode][index][snr]:\n\n # Extract continuum-normalised mock observation\n logger.info(\"Resampling {} spectrum\".format(mode))\n mock_observed = mock_observed_template[mode][index][snr][spectrum_type]\n\n # Replace errors which are nans with a large value\n mock_observed.value_errors[np.isnan(mock_observed.value_errors)] = 1000.\n\n # Check for NaN values in spectrum itself\n if not np.all(np.isfinite(mock_observed.values)):\n print(\"Warning: NaN values in template <{}>\".format(template_flux_normalised.metadata['Starname']))\n mock_observed.value_errors[np.isnan(mock_observed.values)] = 1000.\n mock_observed.values[np.isnan(mock_observed.values)] = 1.\n\n # Resample template onto a logarithmic raster of fixed step\n resampler = SpectrumResampler(mock_observed)\n\n # Construct the raster for each wavelength arm\n wavelength_arms = SpectrumProperties(mock_observed.wavelengths).wavelength_arms()\n\n # Resample 4FS output for each arm onto a fixed logarithmic stride\n for arm_count, arm in enumerate(wavelength_arms[\"wavelength_arms\"]):\n arm_raster, mean_pixel_width = arm\n name = \"{}_{}\".format(mode, arm_count)\n\n arm_info = {\n \"lambda_min\": arm_raster[0],\n \"lambda_max\": arm_raster[-1],\n \"lambda_step\": mean_pixel_width\n }\n\n arm_raster = logarithmic_raster(lambda_min=arm_info['lambda_min'],\n lambda_max=arm_info['lambda_max'],\n lambda_step=arm_info['lambda_step']\n )\n\n # Resample 4FS output onto a fixed logarithmic step\n mock_observed_arm = resampler.onto_raster(arm_raster)\n\n # Save it into output spectrum library\n output_library.insert(spectra=mock_observed_arm,\n filenames=input_spectrum_id['filename'],\n metadata_list={\n \"uid\": unique_id,\n \"template_id\": object_name,\n \"mode\": mode,\n \"arm_name\": \"{}_{}\".format(mode,arm_count),\n \"lambda_min\": arm_raster[0],\n \"lambda_max\": arm_raster[-1],\n \"lambda_step\": mean_pixel_width\n })\n"
] |
[
[
"numpy.isnan",
"numpy.isfinite",
"numpy.log"
]
] |
liz-is/clodius
|
[
"aa31b3d90a5a9fec883c20cab31ad4d347cd52cd"
] |
[
"clodius/tiles/bigwig.py"
] |
[
"import bbi\nimport clodius.tiles.format as hgfo\nimport functools as ft\nimport logging\nimport numpy as np\nimport pandas as pd\nimport re\n\nfrom concurrent.futures import ThreadPoolExecutor\n\nMAX_THREADS = 4\nTILE_SIZE = 1024\n\nlogger = logging.getLogger(__name__)\n\naggregation_modes = {}\naggregation_modes['mean'] = {'name': 'Mean', 'value': 'mean'}\naggregation_modes['min'] = {'name': 'Min', 'value': 'min'}\naggregation_modes['max'] = {'name': 'Max', 'value': 'max'}\naggregation_modes['std'] = {'name': 'Standard Deviation', 'value': 'std'}\n\nrange_modes = {}\nrange_modes['minMax'] = {'name': 'Min-Max', 'value': 'minMax'}\nrange_modes['whisker'] = {'name': 'Whisker', 'value': 'whisker'}\n\ndef get_quadtree_depth(chromsizes):\n tile_size_bp = TILE_SIZE\n min_tile_cover = np.ceil(sum(chromsizes) / tile_size_bp)\n return int(np.ceil(np.log2(min_tile_cover)))\n\n\ndef get_zoom_resolutions(chromsizes):\n return [2**x for x in range(get_quadtree_depth(chromsizes) + 1)][::-1]\n\n\ndef natsort_key(s, _NS_REGEX=re.compile(r'(\\d+)', re.U)):\n return tuple(\n [int(x) if x.isdigit() else x for x in _NS_REGEX.split(s) if x]\n )\n\n\n\ndef natcmp(x, y):\n if x.find('_') >= 0:\n x_parts = x.split('_')\n if y.find('_') >= 0:\n # chr_1 vs chr_2\n y_parts = y.split('_')\n\n return natcmp(x_parts[1], y_parts[1])\n else:\n # chr_1 vs chr1\n # chr1 comes first\n return 1\n if y.find('_') >= 0:\n # chr1 vs chr_1\n # y comes second\n return -1\n\n _NS_REGEX = re.compile(r'(\\d+)', re.U)\n x_parts = tuple(\n [int(a) if a.isdigit() else a for a in _NS_REGEX.split(x) if a]\n )\n y_parts = tuple(\n [int(a) if a.isdigit() else a for a in _NS_REGEX.split(y) if a]\n )\n\n\n for key in ['m', 'y', 'x']: # order of these parameters is purposefully reverse how they should be ordered\n if key in y.lower():\n return -1\n if key in x.lower():\n return 1\n\n try:\n if x_parts < y_parts:\n return -1\n elif y_parts > x_parts:\n return 1\n else:\n return 0\n except TypeError:\n return 1\n\n\ndef natsorted(iterable):\n return sorted(iterable, key=ft.cmp_to_key(natcmp))\n\n\ndef get_chromsizes(bwpath):\n \"\"\"\n TODO: replace this with negspy\n\n Also, return NaNs from any missing chromosomes in bbi.fetch\n\n \"\"\"\n chromsizes = bbi.chromsizes(bwpath)\n chromosomes = natsorted(chromsizes.keys())\n chrom_series = pd.Series(chromsizes)[chromosomes]\n return chrom_series\n\n\ndef abs2genomic(chromsizes, start_pos, end_pos):\n abs_chrom_offsets = np.r_[0, np.cumsum(chromsizes.values)]\n cid_lo, cid_hi = np.searchsorted(abs_chrom_offsets,\n [start_pos, end_pos],\n side='right') - 1\n rel_pos_lo = start_pos - abs_chrom_offsets[cid_lo]\n rel_pos_hi = end_pos - abs_chrom_offsets[cid_hi]\n start = rel_pos_lo\n for cid in range(cid_lo, cid_hi):\n yield cid, start, chromsizes[cid]\n start = 0\n yield cid_hi, start, rel_pos_hi\n\n\ndef tileset_info(bwpath, chromsizes=None):\n '''\n Get the tileset info for a bigWig file\n\n Parameters\n ----------\n bwpath: string\n The path to the bigwig file from which to retrieve data\n chromsizes: [[chrom, size],...]\n A list of chromosome sizes associated with this tileset.\n Typically passed in to specify in what order data from\n the bigwig should be returned.\n\n Returns\n -------\n tileset_info: {'min_pos': [],\n 'max_pos': [],\n 'tile_size': 1024,\n 'max_zoom': 7\n }\n '''\n TILE_SIZE = 1024\n\n if chromsizes is None:\n chromsizes = get_chromsizes(bwpath)\n chromsizes_list = []\n\n for chrom, size in chromsizes.iteritems():\n chromsizes_list += [[chrom, int(size)]]\n else:\n chromsizes_list = chromsizes\n\n min_tile_cover = np.ceil(\n sum([int(c[1]) for c in chromsizes_list]) / TILE_SIZE\n )\n max_zoom = int(np.ceil(np.log2(min_tile_cover)))\n\n tileset_info = {\n 'min_pos': [0],\n 'max_pos': [TILE_SIZE * 2 ** max_zoom],\n 'max_width': TILE_SIZE * 2 ** max_zoom,\n 'tile_size': TILE_SIZE,\n 'max_zoom': max_zoom,\n 'chromsizes': chromsizes_list,\n 'aggregation_modes': aggregation_modes,\n 'range_modes': range_modes\n }\n return tileset_info\n\n\ndef fetch_data(a):\n (\n bwpath,\n binsize,\n chromsizes,\n aggregation_mode,\n range_mode,\n cid,\n start,\n end\n ) = a\n n_bins = int(np.ceil((end - start) / binsize))\n n_dim = 1\n\n if range_mode == 'minMax':\n n_dim = 2\n\n if range_mode == 'whisker':\n n_dim = 4\n\n x = np.zeros((n_bins, n_dim)) if n_dim > 1 else np.zeros(n_bins)\n\n try:\n chrom = chromsizes.index[cid]\n clen = chromsizes.values[cid]\n\n args = [bwpath, chrom, start, end]\n kwargs = {\"bins\": n_bins, \"missing\": np.nan}\n\n if range_mode == 'minMax':\n x[:, 0] = bbi.fetch(*args, **dict(kwargs, summary='min'))\n x[:, 1] = bbi.fetch(*args, **dict(kwargs, summary='max'))\n\n elif range_mode == 'whisker':\n x[:, 0] = bbi.fetch(*args, **dict(kwargs, summary='min'))\n x[:, 1] = bbi.fetch(*args, **dict(kwargs, summary='max'))\n x[:, 2] = bbi.fetch(*args, **dict(kwargs, summary='mean'))\n x[:, 3] = bbi.fetch(*args, **dict(kwargs, summary='std'))\n\n else:\n x[:] = bbi.fetch(*args, **dict(kwargs, summary=aggregation_mode))\n\n # drop the very last bin if it is smaller than the binsize\n if end == clen and clen % binsize != 0:\n x = x[:-1]\n except IndexError:\n # beyond the range of the available chromosomes\n # probably means we've requested a range of absolute\n # coordinates that stretch beyond the end of the genome\n x[:] = np.nan\n except KeyError:\n # probably requested a chromosome that doesn't exist (e.g. chrM)\n x[:] = np.nan\n\n return x\n\n\ndef get_bigwig_tile(\n bwpath,\n zoom_level,\n start_pos,\n end_pos,\n chromsizes=None,\n aggregation_mode='mean',\n range_mode=None\n ):\n\n if chromsizes is None:\n chromsizes = get_chromsizes(bwpath)\n\n resolutions = get_zoom_resolutions(chromsizes)\n binsize = resolutions[zoom_level]\n\n cids_starts_ends = list(abs2genomic(chromsizes, start_pos, end_pos))\n with ThreadPoolExecutor(max_workers=16) as e:\n arrays = list(\n e.map(\n fetch_data, [\n tuple([\n bwpath,\n binsize,\n chromsizes,\n aggregation_mode,\n range_mode\n ] + list(c)) for c in cids_starts_ends\n ]\n )\n )\n\n\n return np.concatenate(arrays)\n\n\ndef tiles(bwpath, tile_ids, chromsizes_map={}, chromsizes=None):\n '''\n Generate tiles from a bigwig file.\n\n Parameters\n ----------\n tileset: tilesets.models.Tileset object\n The tileset that the tile ids should be retrieved from\n tile_ids: [str,...]\n A list of tile_ids (e.g. xyx.0.0) identifying the tiles\n to be retrieved\n chromsizes_map: {uid: []}\n A set of chromsizes listings corresponding to the parameters of the\n tile_ids. To be used if a chromsizes id is passed in with the tile id\n with the `|cos:id` tag in the tile id\n chromsizes: [[chrom, size],...]\n A 2d array containing chromosome names and sizes. Overrides the\n chromsizes in chromsizes_map\n\n Returns\n -------\n tile_list: [(tile_id, tile_data),...]\n A list of tile_id, tile_data tuples\n '''\n TILE_SIZE = 1024\n generated_tiles = []\n for tile_id in tile_ids:\n tile_option_parts = tile_id.split('|')[1:]\n tile_no_options = tile_id.split('|')[0]\n tile_id_parts = tile_no_options.split('.')\n tile_position = list(map(int, tile_id_parts[1:3]))\n return_value = tile_id_parts[3] if len(tile_id_parts) > 3 else 'mean'\n\n aggregation_mode = (\n return_value if return_value in aggregation_modes else 'mean'\n )\n range_mode = return_value if return_value in range_modes else None\n\n tile_options = dict([o.split(':') for o in tile_option_parts])\n\n if chromsizes:\n chromnames = [c[0] for c in chromsizes]\n chromlengths = [int(c[1]) for c in chromsizes]\n chromsizes_to_use = pd.Series(chromlengths, index=chromnames)\n else:\n chromsizes_id = None\n if 'cos' in tile_options:\n chromsizes_id = tile_options['cos']\n if chromsizes_id in chromsizes_map:\n chromsizes_to_use = chromsizes_map[chromsizes_id]\n else:\n chromsizes_to_use = None\n\n zoom_level = tile_position[0]\n tile_pos = tile_position[1]\n\n # this doesn't combine multiple consequetive ids, which\n # would speed things up\n if chromsizes_to_use is None:\n chromsizes_to_use = get_chromsizes(bwpath)\n\n max_depth = get_quadtree_depth(chromsizes_to_use)\n tile_size = TILE_SIZE * 2 ** (max_depth - zoom_level)\n start_pos = tile_pos * tile_size\n end_pos = start_pos + tile_size\n dense = get_bigwig_tile(\n bwpath,\n zoom_level,\n start_pos,\n end_pos,\n chromsizes_to_use,\n aggregation_mode=aggregation_mode,\n range_mode=range_mode,\n )\n\n tile_value = hgfo.format_dense_tile(dense)\n\n generated_tiles += [(tile_id, tile_value)]\n return generated_tiles\n\n\ndef chromsizes(filename):\n '''\n Get a list of chromosome sizes from this [presumably] bigwig\n file.\n\n Parameters:\n -----------\n filename: string\n The filename of the bigwig file\n\n Returns\n -------\n chromsizes: [(name:string, size:int), ...]\n An ordered list of chromosome names and sizes\n '''\n try:\n chrom_series = get_chromsizes(filename)\n data = []\n for chrom, size in chrom_series.iteritems():\n data.append([chrom, size])\n return data\n except Exception as ex:\n logger.error(ex)\n raise Exception(\n 'Error loading chromsizes from bigwig file: {}'.format(ex)\n )\n"
] |
[
[
"numpy.concatenate",
"numpy.ceil",
"numpy.zeros",
"pandas.Series",
"numpy.cumsum",
"numpy.searchsorted",
"numpy.log2"
]
] |
dreiss/glow
|
[
"54c7625053bfb14955c4402ab8d9bca85195d53c",
"54c7625053bfb14955c4402ab8d9bca85195d53c"
] |
[
"torch_glow/tests/functionality/randomize_constants_test.py",
"torch_glow/tests/nodes/upsample_test.py"
] |
[
"# isort:skip_file\nfrom __future__ import absolute_import, division, print_function, unicode_literals\n\nimport unittest\n\nimport torch_glow\nfrom torch_glow import InputMeta, CompilationOptions, GlowCompileSpec\nimport torch\n\n\nclass Model(torch.nn.Module):\n def __init__(self):\n super(Model, self).__init__()\n self.linear = torch.nn.Linear(5, 10)\n\n def forward(self, x):\n return self.linear(x)\n\n\ndef run_model(m, input, randomize):\n torch_glow.disableFusionPass()\n traced_m = torch.jit.trace(m, input)\n\n input_meta = InputMeta()\n input_meta.set_same_as(input)\n inputs = [input_meta]\n options = CompilationOptions()\n options.backend = \"Interpreter\"\n options.randomize_constants = randomize\n spec = GlowCompileSpec()\n spec.set(inputs, options)\n\n glow_m = torch_glow.to_glow(traced_m, {\"forward\": spec})\n return glow_m.forward(input)\n\n\nclass TestRandomizeWeights(unittest.TestCase):\n def test_randomize_weights(self):\n m = Model()\n input = torch.randn(5)\n normal1 = run_model(m, input, False)\n normal2 = run_model(m, input, False)\n rand = run_model(m, input, True)\n\n assert torch.allclose(normal1, normal2)\n assert not torch.allclose(normal1, rand)\n",
"# isort:skip_file\nfrom __future__ import absolute_import, division, print_function, unicode_literals\n\nimport unittest\n\nimport torch_glow\nimport torch\nfrom tests.utils import jitVsGlow\n\n\nclass TestUpsample(unittest.TestCase):\n def test_upsample3d_2x_size(self):\n \"\"\"Test of the PyTorch upsample Node on Glow.\"\"\"\n\n def test_f(a):\n U = torch.nn.Upsample(size=(8, 10, 12))\n return U(a)\n\n x = torch.rand(2, 3, 4, 5, 6)\n\n jitVsGlow(test_f, x, expected_fused_ops={\"aten::upsample_nearest3d\"})\n\n def test_upsample3d_2x_scale_factor(self):\n \"\"\"Test of the PyTorch upsample Node on Glow.\"\"\"\n\n def test_f(a):\n U = torch.nn.Upsample(scale_factor=(2, 2, 2))\n return U(a)\n\n x = torch.rand(2, 3, 4, 5, 6)\n\n jitVsGlow(test_f, x, expected_fused_ops={\"aten::upsample_nearest3d\"})\n\n def test_upsample3d_2x_single_scale_factor(self):\n \"\"\"Test of the PyTorch upsample Node on Glow.\"\"\"\n\n def test_f(a):\n U = torch.nn.Upsample(scale_factor=2)\n return U(a)\n\n x = torch.rand(2, 3, 4, 5, 6)\n\n jitVsGlow(test_f, x, expected_fused_ops={\"aten::upsample_nearest3d\"})\n\n def test_upsample3d_not_2x_single_scale_factor(self):\n \"\"\"Test of the PyTorch upsample Node on Glow.\"\"\"\n\n def test_f(a):\n U = torch.nn.Upsample(scale_factor=5)\n return U(a)\n\n x = torch.rand(2, 3, 4, 5, 6)\n\n jitVsGlow(test_f, x, expected_fused_ops={\"aten::upsample_nearest3d\"})\n\n @unittest.skip(\n reason=\"breaks because of constants not being differentiated in CachingGraphRunner\"\n )\n def test_upsample3d_not_2x_scale_factor(self):\n \"\"\"Test of the PyTorch upsample Node on Glow.\"\"\"\n\n def test_f(a):\n U = torch.nn.Upsample(scale_factor=(1, 2, 3))\n return U(a)\n\n x = torch.rand(2, 2, 2, 2, 2)\n\n jitVsGlow(test_f, x, expected_fused_ops={\"aten::upsample_nearest3d\"})\n\n def test_upsample3d_not_2x_size(self):\n \"\"\"Test of the PyTorch upsample Node on Glow.\"\"\"\n\n def test_f(a):\n U = torch.nn.Upsample(size=(10, 12, 13))\n return U(a)\n\n x = torch.rand(2, 3, 4, 5, 6)\n\n jitVsGlow(test_f, x, expected_fused_ops={\"aten::upsample_nearest3d\"})\n"
] |
[
[
"torch.nn.Linear",
"torch.allclose",
"torch.randn",
"torch.jit.trace"
],
[
"torch.nn.Upsample",
"torch.rand"
]
] |
gbstack/PaddleDetection
|
[
"1a8dd826d7c35f2967ea04cf533d827cc9c80a42"
] |
[
"ppdet/modeling/post_process.py"
] |
[
"# Copyright (c) 2020 PaddlePaddle 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\nimport numpy as np\nimport paddle\nimport paddle.nn as nn\nimport paddle.nn.functional as F\nfrom ppdet.core.workspace import register\nfrom ppdet.modeling.bbox_utils import nonempty_bbox, rbox2poly\nfrom ppdet.modeling.layers import TTFBox\nfrom .transformers import bbox_cxcywh_to_xyxy\ntry:\n from collections.abc import Sequence\nexcept Exception:\n from collections import Sequence\n\n__all__ = [\n 'BBoxPostProcess', 'MaskPostProcess', 'FCOSPostProcess',\n 'S2ANetBBoxPostProcess', 'JDEBBoxPostProcess', 'CenterNetPostProcess',\n 'DETRBBoxPostProcess', 'SparsePostProcess'\n]\n\n\n@register\nclass BBoxPostProcess(nn.Layer):\n __shared__ = ['num_classes']\n __inject__ = ['decode', 'nms']\n\n def __init__(self, num_classes=80, decode=None, nms=None):\n super(BBoxPostProcess, self).__init__()\n self.num_classes = num_classes\n self.decode = decode\n self.nms = nms\n self.fake_bboxes = paddle.to_tensor(\n np.array(\n [[-1, 0.0, 0.0, 0.0, 0.0, 0.0]], dtype='float32'))\n self.fake_bbox_num = paddle.to_tensor(np.array([1], dtype='int32'))\n\n def forward(self, head_out, rois, im_shape, scale_factor):\n \"\"\"\n Decode the bbox and do NMS if needed. \n\n Args:\n head_out (tuple): bbox_pred and cls_prob of bbox_head output.\n rois (tuple): roi and rois_num of rpn_head output.\n im_shape (Tensor): The shape of the input image.\n scale_factor (Tensor): The scale factor of the input image.\n Returns:\n bbox_pred (Tensor): The output prediction with shape [N, 6], including\n labels, scores and bboxes. The size of bboxes are corresponding\n to the input image, the bboxes may be used in other branch.\n bbox_num (Tensor): The number of prediction boxes of each batch with\n shape [1], and is N.\n \"\"\"\n if self.nms is not None:\n bboxes, score = self.decode(head_out, rois, im_shape, scale_factor)\n bbox_pred, bbox_num, _ = self.nms(bboxes, score, self.num_classes)\n else:\n bbox_pred, bbox_num = self.decode(head_out, rois, im_shape,\n scale_factor)\n return bbox_pred, bbox_num\n\n def get_pred(self, bboxes, bbox_num, im_shape, scale_factor):\n \"\"\"\n Rescale, clip and filter the bbox from the output of NMS to \n get final prediction. \n \n Notes:\n Currently only support bs = 1.\n\n Args:\n bboxes (Tensor): The output bboxes with shape [N, 6] after decode\n and NMS, including labels, scores and bboxes.\n bbox_num (Tensor): The number of prediction boxes of each batch with\n shape [1], and is N.\n im_shape (Tensor): The shape of the input image.\n scale_factor (Tensor): The scale factor of the input image.\n Returns:\n pred_result (Tensor): The final prediction results with shape [N, 6]\n including labels, scores and bboxes.\n \"\"\"\n\n if bboxes.shape[0] == 0:\n bboxes = self.fake_bboxes\n bbox_num = self.fake_bbox_num\n\n origin_shape = paddle.floor(im_shape / scale_factor + 0.5)\n\n origin_shape_list = []\n scale_factor_list = []\n # scale_factor: scale_y, scale_x\n for i in range(bbox_num.shape[0]):\n expand_shape = paddle.expand(origin_shape[i:i + 1, :],\n [bbox_num[i], 2])\n scale_y, scale_x = scale_factor[i][0], scale_factor[i][1]\n scale = paddle.concat([scale_x, scale_y, scale_x, scale_y])\n expand_scale = paddle.expand(scale, [bbox_num[i], 4])\n origin_shape_list.append(expand_shape)\n scale_factor_list.append(expand_scale)\n\n self.origin_shape_list = paddle.concat(origin_shape_list)\n scale_factor_list = paddle.concat(scale_factor_list)\n\n # bboxes: [N, 6], label, score, bbox\n pred_label = bboxes[:, 0:1]\n pred_score = bboxes[:, 1:2]\n pred_bbox = bboxes[:, 2:]\n # rescale bbox to original image\n scaled_bbox = pred_bbox / scale_factor_list\n origin_h = self.origin_shape_list[:, 0]\n origin_w = self.origin_shape_list[:, 1]\n zeros = paddle.zeros_like(origin_h)\n # clip bbox to [0, original_size]\n x1 = paddle.maximum(paddle.minimum(scaled_bbox[:, 0], origin_w), zeros)\n y1 = paddle.maximum(paddle.minimum(scaled_bbox[:, 1], origin_h), zeros)\n x2 = paddle.maximum(paddle.minimum(scaled_bbox[:, 2], origin_w), zeros)\n y2 = paddle.maximum(paddle.minimum(scaled_bbox[:, 3], origin_h), zeros)\n pred_bbox = paddle.stack([x1, y1, x2, y2], axis=-1)\n # filter empty bbox\n keep_mask = nonempty_bbox(pred_bbox, return_mask=True)\n keep_mask = paddle.unsqueeze(keep_mask, [1])\n pred_label = paddle.where(keep_mask, pred_label,\n paddle.ones_like(pred_label) * -1)\n pred_result = paddle.concat([pred_label, pred_score, pred_bbox], axis=1)\n return pred_result\n\n def get_origin_shape(self, ):\n return self.origin_shape_list\n\n\n@register\nclass MaskPostProcess(object):\n \"\"\"\n refer to:\n https://github.com/facebookresearch/detectron2/layers/mask_ops.py\n\n Get Mask output according to the output from model\n \"\"\"\n\n def __init__(self, binary_thresh=0.5):\n super(MaskPostProcess, self).__init__()\n self.binary_thresh = binary_thresh\n\n def paste_mask(self, masks, boxes, im_h, im_w):\n \"\"\"\n Paste the mask prediction to the original image.\n \"\"\"\n x0, y0, x1, y1 = paddle.split(boxes, 4, axis=1)\n masks = paddle.unsqueeze(masks, [0, 1])\n img_y = paddle.arange(0, im_h, dtype='float32') + 0.5\n img_x = paddle.arange(0, im_w, dtype='float32') + 0.5\n img_y = (img_y - y0) / (y1 - y0) * 2 - 1\n img_x = (img_x - x0) / (x1 - x0) * 2 - 1\n img_x = paddle.unsqueeze(img_x, [1])\n img_y = paddle.unsqueeze(img_y, [2])\n N = boxes.shape[0]\n\n gx = paddle.expand(img_x, [N, img_y.shape[1], img_x.shape[2]])\n gy = paddle.expand(img_y, [N, img_y.shape[1], img_x.shape[2]])\n grid = paddle.stack([gx, gy], axis=3)\n img_masks = F.grid_sample(masks, grid, align_corners=False)\n return img_masks[:, 0]\n\n def __call__(self, mask_out, bboxes, bbox_num, origin_shape):\n \"\"\"\n Decode the mask_out and paste the mask to the origin image.\n\n Args:\n mask_out (Tensor): mask_head output with shape [N, 28, 28].\n bbox_pred (Tensor): The output bboxes with shape [N, 6] after decode\n and NMS, including labels, scores and bboxes.\n bbox_num (Tensor): The number of prediction boxes of each batch with\n shape [1], and is N.\n origin_shape (Tensor): The origin shape of the input image, the tensor\n shape is [N, 2], and each row is [h, w].\n Returns:\n pred_result (Tensor): The final prediction mask results with shape\n [N, h, w] in binary mask style.\n \"\"\"\n num_mask = mask_out.shape[0]\n origin_shape = paddle.cast(origin_shape, 'int32')\n # TODO: support bs > 1 and mask output dtype is bool\n pred_result = paddle.zeros(\n [num_mask, origin_shape[0][0], origin_shape[0][1]], dtype='int32')\n if bbox_num == 1 and bboxes[0][0] == -1:\n return pred_result\n\n # TODO: optimize chunk paste\n pred_result = []\n for i in range(bboxes.shape[0]):\n im_h, im_w = origin_shape[i][0], origin_shape[i][1]\n pred_mask = self.paste_mask(mask_out[i], bboxes[i:i + 1, 2:], im_h,\n im_w)\n pred_mask = pred_mask >= self.binary_thresh\n pred_mask = paddle.cast(pred_mask, 'int32')\n pred_result.append(pred_mask)\n pred_result = paddle.concat(pred_result)\n return pred_result\n\n\n@register\nclass FCOSPostProcess(object):\n __inject__ = ['decode', 'nms']\n\n def __init__(self, decode=None, nms=None):\n super(FCOSPostProcess, self).__init__()\n self.decode = decode\n self.nms = nms\n\n def __call__(self, fcos_head_outs, scale_factor):\n \"\"\"\n Decode the bbox and do NMS in FCOS.\n \"\"\"\n locations, cls_logits, bboxes_reg, centerness = fcos_head_outs\n bboxes, score = self.decode(locations, cls_logits, bboxes_reg,\n centerness, scale_factor)\n bbox_pred, bbox_num, _ = self.nms(bboxes, score)\n return bbox_pred, bbox_num\n\n\n@register\nclass S2ANetBBoxPostProcess(nn.Layer):\n __shared__ = ['num_classes']\n __inject__ = ['nms']\n\n def __init__(self, num_classes=15, nms_pre=2000, min_bbox_size=0, nms=None):\n super(S2ANetBBoxPostProcess, self).__init__()\n self.num_classes = num_classes\n self.nms_pre = paddle.to_tensor(nms_pre)\n self.min_bbox_size = min_bbox_size\n self.nms = nms\n self.origin_shape_list = []\n self.fake_pred_cls_score_bbox = paddle.to_tensor(\n np.array(\n [[-1, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]],\n dtype='float32'))\n self.fake_bbox_num = paddle.to_tensor(np.array([1], dtype='int32'))\n\n def forward(self, pred_scores, pred_bboxes):\n \"\"\"\n pred_scores : [N, M] score\n pred_bboxes : [N, 5] xc, yc, w, h, a\n im_shape : [N, 2] im_shape\n scale_factor : [N, 2] scale_factor\n \"\"\"\n pred_ploys0 = rbox2poly(pred_bboxes)\n pred_ploys = paddle.unsqueeze(pred_ploys0, axis=0)\n\n # pred_scores [NA, 16] --> [16, NA]\n pred_scores0 = paddle.transpose(pred_scores, [1, 0])\n pred_scores = paddle.unsqueeze(pred_scores0, axis=0)\n\n pred_cls_score_bbox, bbox_num, _ = self.nms(pred_ploys, pred_scores,\n self.num_classes)\n # Prevent empty bbox_pred from decode or NMS.\n # Bboxes and score before NMS may be empty due to the score threshold.\n if pred_cls_score_bbox.shape[0] <= 0 or pred_cls_score_bbox.shape[\n 1] <= 1:\n pred_cls_score_bbox = self.fake_pred_cls_score_bbox\n bbox_num = self.fake_bbox_num\n\n pred_cls_score_bbox = paddle.reshape(pred_cls_score_bbox, [-1, 10])\n return pred_cls_score_bbox, bbox_num\n\n def get_pred(self, bboxes, bbox_num, im_shape, scale_factor):\n \"\"\"\n Rescale, clip and filter the bbox from the output of NMS to\n get final prediction.\n Args:\n bboxes(Tensor): bboxes [N, 10]\n bbox_num(Tensor): bbox_num\n im_shape(Tensor): [1 2]\n scale_factor(Tensor): [1 2]\n Returns:\n bbox_pred(Tensor): The output is the prediction with shape [N, 8]\n including labels, scores and bboxes. The size of\n bboxes are corresponding to the original image.\n \"\"\"\n origin_shape = paddle.floor(im_shape / scale_factor + 0.5)\n\n origin_shape_list = []\n scale_factor_list = []\n # scale_factor: scale_y, scale_x\n for i in range(bbox_num.shape[0]):\n expand_shape = paddle.expand(origin_shape[i:i + 1, :],\n [bbox_num[i], 2])\n scale_y, scale_x = scale_factor[i][0], scale_factor[i][1]\n scale = paddle.concat([\n scale_x, scale_y, scale_x, scale_y, scale_x, scale_y, scale_x,\n scale_y\n ])\n expand_scale = paddle.expand(scale, [bbox_num[i], 8])\n origin_shape_list.append(expand_shape)\n scale_factor_list.append(expand_scale)\n\n origin_shape_list = paddle.concat(origin_shape_list)\n scale_factor_list = paddle.concat(scale_factor_list)\n\n # bboxes: [N, 10], label, score, bbox\n pred_label_score = bboxes[:, 0:2]\n pred_bbox = bboxes[:, 2:]\n\n # rescale bbox to original image\n pred_bbox = pred_bbox.reshape([-1, 8])\n scaled_bbox = pred_bbox / scale_factor_list\n origin_h = origin_shape_list[:, 0]\n origin_w = origin_shape_list[:, 1]\n\n bboxes = scaled_bbox\n zeros = paddle.zeros_like(origin_h)\n x1 = paddle.maximum(paddle.minimum(bboxes[:, 0], origin_w - 1), zeros)\n y1 = paddle.maximum(paddle.minimum(bboxes[:, 1], origin_h - 1), zeros)\n x2 = paddle.maximum(paddle.minimum(bboxes[:, 2], origin_w - 1), zeros)\n y2 = paddle.maximum(paddle.minimum(bboxes[:, 3], origin_h - 1), zeros)\n x3 = paddle.maximum(paddle.minimum(bboxes[:, 4], origin_w - 1), zeros)\n y3 = paddle.maximum(paddle.minimum(bboxes[:, 5], origin_h - 1), zeros)\n x4 = paddle.maximum(paddle.minimum(bboxes[:, 6], origin_w - 1), zeros)\n y4 = paddle.maximum(paddle.minimum(bboxes[:, 7], origin_h - 1), zeros)\n pred_bbox = paddle.stack([x1, y1, x2, y2, x3, y3, x4, y4], axis=-1)\n pred_result = paddle.concat([pred_label_score, pred_bbox], axis=1)\n return pred_result\n\n\n@register\nclass JDEBBoxPostProcess(nn.Layer):\n __shared__ = ['num_classes']\n __inject__ = ['decode', 'nms']\n\n def __init__(self, num_classes=1, decode=None, nms=None, return_idx=True):\n super(JDEBBoxPostProcess, self).__init__()\n self.num_classes = num_classes\n self.decode = decode\n self.nms = nms\n self.return_idx = return_idx\n\n self.fake_bbox_pred = paddle.to_tensor(\n np.array(\n [[-1, 0.0, 0.0, 0.0, 0.0, 0.0]], dtype='float32'))\n self.fake_bbox_num = paddle.to_tensor(np.array([1], dtype='int32'))\n self.fake_nms_keep_idx = paddle.to_tensor(\n np.array(\n [[0]], dtype='int32'))\n\n self.fake_yolo_boxes_out = paddle.to_tensor(\n np.array(\n [[[0.0, 0.0, 0.0, 0.0]]], dtype='float32'))\n self.fake_yolo_scores_out = paddle.to_tensor(\n np.array(\n [[[0.0]]], dtype='float32'))\n self.fake_boxes_idx = paddle.to_tensor(np.array([[0]], dtype='int64'))\n\n def forward(self, head_out, anchors):\n \"\"\"\n Decode the bbox and do NMS for JDE model. \n\n Args:\n head_out (list): Bbox_pred and cls_prob of bbox_head output.\n anchors (list): Anchors of JDE model.\n\n Returns:\n boxes_idx (Tensor): The index of kept bboxes after decode 'JDEBox'. \n bbox_pred (Tensor): The output is the prediction with shape [N, 6]\n including labels, scores and bboxes.\n bbox_num (Tensor): The number of prediction of each batch with shape [N].\n nms_keep_idx (Tensor): The index of kept bboxes after NMS. \n \"\"\"\n boxes_idx, yolo_boxes_scores = self.decode(head_out, anchors)\n\n if len(boxes_idx) == 0:\n boxes_idx = self.fake_boxes_idx\n yolo_boxes_out = self.fake_yolo_boxes_out\n yolo_scores_out = self.fake_yolo_scores_out\n else:\n yolo_boxes = paddle.gather_nd(yolo_boxes_scores, boxes_idx)\n # TODO: only support bs=1 now\n yolo_boxes_out = paddle.reshape(\n yolo_boxes[:, :4], shape=[1, len(boxes_idx), 4])\n yolo_scores_out = paddle.reshape(\n yolo_boxes[:, 4:5], shape=[1, 1, len(boxes_idx)])\n boxes_idx = boxes_idx[:, 1:]\n\n if self.return_idx:\n bbox_pred, bbox_num, nms_keep_idx = self.nms(\n yolo_boxes_out, yolo_scores_out, self.num_classes)\n if bbox_pred.shape[0] == 0:\n bbox_pred = self.fake_bbox_pred\n bbox_num = self.fake_bbox_num\n nms_keep_idx = self.fake_nms_keep_idx\n return boxes_idx, bbox_pred, bbox_num, nms_keep_idx\n else:\n bbox_pred, bbox_num, _ = self.nms(yolo_boxes_out, yolo_scores_out,\n self.num_classes)\n if bbox_pred.shape[0] == 0:\n bbox_pred = self.fake_bbox_pred\n bbox_num = self.fake_bbox_num\n return _, bbox_pred, bbox_num, _\n\n\n@register\nclass CenterNetPostProcess(TTFBox):\n \"\"\"\n Postprocess the model outputs to get final prediction:\n 1. Do NMS for heatmap to get top `max_per_img` bboxes.\n 2. Decode bboxes using center offset and box size.\n 3. Rescale decoded bboxes reference to the origin image shape.\n\n Args:\n max_per_img(int): the maximum number of predicted objects in a image,\n 500 by default.\n down_ratio(int): the down ratio from images to heatmap, 4 by default.\n regress_ltrb (bool): whether to regress left/top/right/bottom or\n width/height for a box, true by default.\n for_mot (bool): whether return other features used in tracking model.\n \"\"\"\n\n __shared__ = ['down_ratio', 'for_mot']\n\n def __init__(self,\n max_per_img=500,\n down_ratio=4,\n regress_ltrb=True,\n for_mot=False):\n super(TTFBox, self).__init__()\n self.max_per_img = max_per_img\n self.down_ratio = down_ratio\n self.regress_ltrb = regress_ltrb\n self.for_mot = for_mot\n\n def __call__(self, hm, wh, reg, im_shape, scale_factor):\n heat = self._simple_nms(hm)\n scores, inds, topk_clses, ys, xs = self._topk(heat)\n scores = paddle.tensor.unsqueeze(scores, [1])\n clses = paddle.tensor.unsqueeze(topk_clses, [1])\n\n reg_t = paddle.transpose(reg, [0, 2, 3, 1])\n # Like TTFBox, batch size is 1.\n # TODO: support batch size > 1\n reg = paddle.reshape(reg_t, [-1, paddle.shape(reg_t)[-1]])\n reg = paddle.gather(reg, inds)\n xs = paddle.cast(xs, 'float32')\n ys = paddle.cast(ys, 'float32')\n xs = xs + reg[:, 0:1]\n ys = ys + reg[:, 1:2]\n\n wh_t = paddle.transpose(wh, [0, 2, 3, 1])\n wh = paddle.reshape(wh_t, [-1, paddle.shape(wh_t)[-1]])\n wh = paddle.gather(wh, inds)\n\n if self.regress_ltrb:\n x1 = xs - wh[:, 0:1]\n y1 = ys - wh[:, 1:2]\n x2 = xs + wh[:, 2:3]\n y2 = ys + wh[:, 3:4]\n else:\n x1 = xs - wh[:, 0:1] / 2\n y1 = ys - wh[:, 1:2] / 2\n x2 = xs + wh[:, 0:1] / 2\n y2 = ys + wh[:, 1:2] / 2\n\n n, c, feat_h, feat_w = hm.shape[:]\n padw = (feat_w * self.down_ratio - im_shape[0, 1]) / 2\n padh = (feat_h * self.down_ratio - im_shape[0, 0]) / 2\n x1 = x1 * self.down_ratio\n y1 = y1 * self.down_ratio\n x2 = x2 * self.down_ratio\n y2 = y2 * self.down_ratio\n\n x1 = x1 - padw\n y1 = y1 - padh\n x2 = x2 - padw\n y2 = y2 - padh\n\n bboxes = paddle.concat([x1, y1, x2, y2], axis=1)\n scale_y = scale_factor[:, 0:1]\n scale_x = scale_factor[:, 1:2]\n scale_expand = paddle.concat(\n [scale_x, scale_y, scale_x, scale_y], axis=1)\n boxes_shape = paddle.shape(bboxes)\n boxes_shape.stop_gradient = True\n scale_expand = paddle.expand(scale_expand, shape=boxes_shape)\n bboxes = paddle.divide(bboxes, scale_expand)\n if self.for_mot:\n results = paddle.concat([bboxes, scores, clses], axis=1)\n return results, inds, topk_clses\n else:\n results = paddle.concat([clses, scores, bboxes], axis=1)\n return results, paddle.shape(results)[0:1], topk_clses\n\n\n@register\nclass DETRBBoxPostProcess(object):\n __shared__ = ['num_classes', 'use_focal_loss']\n __inject__ = []\n\n def __init__(self,\n num_classes=80,\n num_top_queries=100,\n use_focal_loss=False):\n super(DETRBBoxPostProcess, self).__init__()\n self.num_classes = num_classes\n self.num_top_queries = num_top_queries\n self.use_focal_loss = use_focal_loss\n\n def __call__(self, head_out, im_shape, scale_factor):\n \"\"\"\n Decode the bbox.\n\n Args:\n head_out (tuple): bbox_pred, cls_logit and masks of bbox_head output.\n im_shape (Tensor): The shape of the input image.\n scale_factor (Tensor): The scale factor of the input image.\n Returns:\n bbox_pred (Tensor): The output prediction with shape [N, 6], including\n labels, scores and bboxes. The size of bboxes are corresponding\n to the input image, the bboxes may be used in other branch.\n bbox_num (Tensor): The number of prediction boxes of each batch with\n shape [bs], and is N.\n \"\"\"\n bboxes, logits, masks = head_out\n\n bbox_pred = bbox_cxcywh_to_xyxy(bboxes)\n origin_shape = paddle.floor(im_shape / scale_factor + 0.5)\n img_h, img_w = origin_shape.unbind(1)\n origin_shape = paddle.stack(\n [img_w, img_h, img_w, img_h], axis=-1).unsqueeze(0)\n bbox_pred *= origin_shape\n\n scores = F.sigmoid(logits) if self.use_focal_loss else F.softmax(\n logits)[:, :, :-1]\n\n if not self.use_focal_loss:\n scores, labels = scores.max(-1), scores.argmax(-1)\n if scores.shape[1] > self.num_top_queries:\n scores, index = paddle.topk(\n scores, self.num_top_queries, axis=-1)\n labels = paddle.stack(\n [paddle.gather(l, i) for l, i in zip(labels, index)])\n bbox_pred = paddle.stack(\n [paddle.gather(b, i) for b, i in zip(bbox_pred, index)])\n else:\n scores, index = paddle.topk(\n scores.reshape([logits.shape[0], -1]),\n self.num_top_queries,\n axis=-1)\n labels = index % logits.shape[2]\n index = index // logits.shape[2]\n bbox_pred = paddle.stack(\n [paddle.gather(b, i) for b, i in zip(bbox_pred, index)])\n\n bbox_pred = paddle.concat(\n [\n labels.unsqueeze(-1).astype('float32'), scores.unsqueeze(-1),\n bbox_pred\n ],\n axis=-1)\n bbox_num = paddle.to_tensor(\n bbox_pred.shape[1], dtype='int32').tile([bbox_pred.shape[0]])\n bbox_pred = bbox_pred.reshape([-1, 6])\n return bbox_pred, bbox_num\n\n\n@register\nclass SparsePostProcess(object):\n __shared__ = ['num_classes']\n\n def __init__(self, num_proposals, num_classes=80):\n super(SparsePostProcess, self).__init__()\n self.num_classes = num_classes\n self.num_proposals = num_proposals\n\n def __call__(self, box_cls, box_pred, scale_factor_wh, img_whwh):\n \"\"\"\n Arguments:\n box_cls (Tensor): tensor of shape (batch_size, num_proposals, K).\n The tensor predicts the classification probability for each proposal.\n box_pred (Tensor): tensors of shape (batch_size, num_proposals, 4).\n The tensor predicts 4-vector (x,y,w,h) box\n regression values for every proposal\n scale_factor_wh (Tensor): tensors of shape [batch_size, 2] the scalor of per img\n img_whwh (Tensor): tensors of shape [batch_size, 4]\n Returns:\n bbox_pred (Tensor): tensors of shape [num_boxes, 6] Each row has 6 values:\n [label, confidence, xmin, ymin, xmax, ymax]\n bbox_num (Tensor): tensors of shape [batch_size] the number of RoIs in each image.\n \"\"\"\n assert len(box_cls) == len(scale_factor_wh) == len(img_whwh)\n\n img_wh = img_whwh[:, :2]\n\n scores = F.sigmoid(box_cls)\n labels = paddle.arange(0, self.num_classes). \\\n unsqueeze(0).tile([self.num_proposals, 1]).flatten(start_axis=0, stop_axis=1)\n\n classes_all = []\n scores_all = []\n boxes_all = []\n for i, (scores_per_image,\n box_pred_per_image) in enumerate(zip(scores, box_pred)):\n\n scores_per_image, topk_indices = scores_per_image.flatten(\n 0, 1).topk(\n self.num_proposals, sorted=False)\n labels_per_image = paddle.gather(labels, topk_indices, axis=0)\n\n box_pred_per_image = box_pred_per_image.reshape([-1, 1, 4]).tile(\n [1, self.num_classes, 1]).reshape([-1, 4])\n box_pred_per_image = paddle.gather(\n box_pred_per_image, topk_indices, axis=0)\n\n classes_all.append(labels_per_image)\n scores_all.append(scores_per_image)\n boxes_all.append(box_pred_per_image)\n\n bbox_num = paddle.zeros([len(scale_factor_wh)], dtype=\"int32\")\n boxes_final = []\n\n for i in range(len(scale_factor_wh)):\n classes = classes_all[i]\n boxes = boxes_all[i]\n scores = scores_all[i]\n\n boxes[:, 0::2] = paddle.clip(\n boxes[:, 0::2], min=0, max=img_wh[i][0]) / scale_factor_wh[i][0]\n boxes[:, 1::2] = paddle.clip(\n boxes[:, 1::2], min=0, max=img_wh[i][1]) / scale_factor_wh[i][1]\n boxes_w, boxes_h = (boxes[:, 2] - boxes[:, 0]).numpy(), (\n boxes[:, 3] - boxes[:, 1]).numpy()\n\n keep = (boxes_w > 1.) & (boxes_h > 1.)\n\n if (keep.sum() == 0):\n bboxes = paddle.zeros([1, 6]).astype(\"float32\")\n else:\n boxes = paddle.to_tensor(boxes.numpy()[keep]).astype(\"float32\")\n classes = paddle.to_tensor(classes.numpy()[keep]).astype(\n \"float32\").unsqueeze(-1)\n scores = paddle.to_tensor(scores.numpy()[keep]).astype(\n \"float32\").unsqueeze(-1)\n\n bboxes = paddle.concat([classes, scores, boxes], axis=-1)\n\n boxes_final.append(bboxes)\n bbox_num[i] = bboxes.shape[0]\n\n bbox_pred = paddle.concat(boxes_final)\n return bbox_pred, bbox_num\n\n\ndef nms(dets, thresh):\n \"\"\"Apply classic DPM-style greedy NMS.\"\"\"\n if dets.shape[0] == 0:\n return dets[[], :]\n scores = dets[:, 0]\n x1 = dets[:, 1]\n y1 = dets[:, 2]\n x2 = dets[:, 3]\n y2 = dets[:, 4]\n\n areas = (x2 - x1 + 1) * (y2 - y1 + 1)\n order = scores.argsort()[::-1]\n\n ndets = dets.shape[0]\n suppressed = np.zeros((ndets), dtype=np.int)\n\n # nominal indices\n # _i, _j\n # sorted indices\n # i, j\n # temp variables for box i's (the box currently under consideration)\n # ix1, iy1, ix2, iy2, iarea\n\n # variables for computing overlap with box j (lower scoring box)\n # xx1, yy1, xx2, yy2\n # w, h\n # inter, ovr\n\n for _i in range(ndets):\n i = order[_i]\n if suppressed[i] == 1:\n continue\n ix1 = x1[i]\n iy1 = y1[i]\n ix2 = x2[i]\n iy2 = y2[i]\n iarea = areas[i]\n for _j in range(_i + 1, ndets):\n j = order[_j]\n if suppressed[j] == 1:\n continue\n xx1 = max(ix1, x1[j])\n yy1 = max(iy1, y1[j])\n xx2 = min(ix2, x2[j])\n yy2 = min(iy2, y2[j])\n w = max(0.0, xx2 - xx1 + 1)\n h = max(0.0, yy2 - yy1 + 1)\n inter = w * h\n ovr = inter / (iarea + areas[j] - inter)\n if ovr >= thresh:\n suppressed[j] = 1\n keep = np.where(suppressed == 0)[0]\n dets = dets[keep, :]\n return dets\n"
] |
[
[
"numpy.where",
"numpy.array",
"numpy.zeros"
]
] |
kmwebnet/Audio-Effect-replicator-nnabla
|
[
"fc2724735f4d95b7d539e8035a698fa041695492"
] |
[
"predict.py"
] |
[
"import os\nfrom argparse import ArgumentParser\nfrom time import time\nimport yaml\nimport numpy as np\nfrom fx_replicator import (\n build_model, load_wave, save_wave, sliding_window, LossFunc\n)\nimport nnabla as nn\n#import nnabla_ext.cudnn\nimport nnabla.functions as F\nimport nnabla.parametric_functions as PF\nimport nnabla.solvers as S\nimport nnabla.utils.save\nimport tqdm\n\n\ndef main():\n\n args = parse_args()\n\n with open(args.config_file) as fp:\n config = yaml.safe_load(fp)\n\n input_timesteps = config[\"input_timesteps\"]\n output_timesteps = config[\"output_timesteps\"]\n batch_size = config[\"batch_size\"]\n\n data = load_wave(args.input_file)\n print(\"data.shape is:\", data.shape)\n print(\"data.len is:\", len(data))\n\n \"\"\"\n from nnabla.ext_utils import get_extension_context\n cuda_device_id = 0\n ctx = get_extension_context('cudnn', device_id=cuda_device_id)\n print(\"Context: {}\".format(ctx))\n nn.set_default_context(ctx) # Set CUDA as a default context.\n \"\"\"\n\n # padding and rounded up to the batch multiple\n block_size = output_timesteps * batch_size\n prepad = input_timesteps - output_timesteps\n postpad = len(data) % block_size\n print(\"postpad\", block_size - postpad)\n padded = np.concatenate((\n np.zeros(prepad, np.float32),\n data,\n np.zeros(block_size - postpad, np.float32)))\n x = sliding_window(padded, input_timesteps, output_timesteps)\n x = x[:, :, np.newaxis]\n y = np.zeros_like(x)\n\n batchlen = x.shape[0]\n print(\"x.length is:\",batchlen) \n\n xx = nn.Variable((batch_size , input_timesteps, 1))\n\n nn.load_parameters(\"best_result.h5\")\n\n print(\"xx.shape is:\", xx.shape)\n\n yy = build_model(xx)\n \n print(\"yy.shape is:\", yy.shape)\n\n print(\"x.shape in the loop is:\", x[32:32 + batch_size , : , : ].shape)\n\n start1 = time()\n\n for step in range(0, batchlen , batch_size):\n\n xx.d = x[step:step + batch_size , : , : ]\n\n yy.forward()\n\n y[step:step + batch_size , : , : ] = yy.d\n\n proc_time = time() - start1\n print(proc_time)\n print(step)\n \n\n y = y[:, -output_timesteps:, :].reshape(-1)[:len(data)]\n save_wave(y, args.output_file)\n\n print(\"finished\\n\")\n proc_time = time() - start1\n print(proc_time)\n\n\ndef parse_args():\n parser = ArgumentParser()\n parser.add_argument(\n \"--config_file\", \"-c\", default=\"./config.yml\",\n help=\"configuration file (*.yml)\")\n parser.add_argument(\n \"--input_file\", \"-i\",\n help=\"input wave file (48kHz/mono, *.wav)\")\n parser.add_argument(\n \"--output_file\", \"-o\", default=\"./predicted.wav\",\n help=\"output wave file (48kHz/mono, *.wav)\")\n parser.add_argument(\n \"--model_file\", \"-m\",\n help=\"input model file (*.h5)\")\n return parser.parse_args()\n\nif __name__ == '__main__':\n main()\n"
] |
[
[
"numpy.zeros_like",
"numpy.zeros"
]
] |
congnb/mypython
|
[
"893b3390b8d6cf803b8ae15bf5331e74e6faf04a"
] |
[
"ml.py"
] |
[
"import numpy\nimport matplotlib.pyplot as plt\nimport threading\nimport multiprocessing\nfrom scipy import stats\n\nclass TestHist:\n def hist(self, parameter_list):\n x = numpy.random.uniform(0.0, 5.0, 100000)\n\n plt.hist(x, 100)\n plt.show()\n\n y = numpy.random.normal(0.0, 5.0, 100000)\n\n plt.hist(y, 100)\n plt.show()\n\n\nclass TestScatter:\n def scatter(self, parameter_list):\n \n a = numpy.random.normal(5.0, 1.0, 1000)\n b = numpy.random.normal(10.0, 2.0, 1000)\n\n plt.scatter(a, b)\n plt.show()\n\n\nclass TestLinearRegression:\n def linear(self):\n \n a = numpy.random.uniform(5.0, 1.0, 1000)\n b = numpy.random.uniform(10.0, 2.0, 1000)\n\n slope, intercept, r, p, std_err = stats.linregress(a, b)\n\n print(slope, intercept, r, p, std_err )\n \n mymodel = list(map(lambda xa : self.myfunc(xa,slope,intercept),a))\n plt.scatter(a, b )\n plt.plot(a, mymodel) \n plt.show()\n\n def myfunc(self,x, slope, intercept):\n \"\"\"\n input, slope, intercept\n \"\"\"\n return slope * x + intercept \n \n\nlinear =TestLinearRegression()\nlinear.linear() \n\n# numpy.random.seed(12345678)\n# x = numpy.random.random(10)\n# y = 1.6*x + numpy.random.random(10)\n\n\n# from scipy import stats\n\n# x = [5,7,8,7,2,17,2,9,4,11,12,9,6]\n# y = [99,86,87,88,111,86,103,87,94,78,77,85,86]\n\n# slope, intercept, r, p, std_err = stats.linregress(x, y)\n\n# def myfunc(x):\n# return slope * x + intercept\n\n# speed = myfunc(10)\n# print(slope, intercept, r, p, std_err)\n# print(speed)"
] |
[
[
"numpy.random.normal",
"matplotlib.pyplot.plot",
"scipy.stats.linregress",
"matplotlib.pyplot.hist",
"numpy.random.uniform",
"matplotlib.pyplot.scatter",
"matplotlib.pyplot.show"
]
] |
shaoxin0801/scVI
|
[
"f439eeb7b696b01a281af2f0e2f49592318614cb"
] |
[
"tests/test_scvi.py"
] |
[
"import numpy as np\nimport tempfile\nimport os\nimport pytest\nimport torch\n\nfrom anndata import AnnData\n\nfrom scvi.dataset import (\n AnnDatasetFromAnnData,\n CortexDataset,\n SyntheticDataset,\n GeneExpressionDataset,\n Dataset10X,\n)\nfrom scvi.inference import (\n JointSemiSupervisedTrainer,\n AlternateSemiSupervisedTrainer,\n ClassifierTrainer,\n UnsupervisedTrainer,\n AdapterTrainer,\n TotalTrainer,\n TotalPosterior,\n)\nfrom scvi.inference.posterior import unsupervised_clustering_accuracy\nfrom scvi.inference.posterior_utils import load_posterior\nfrom scvi.inference.annotation import compute_accuracy_rf, compute_accuracy_svc\nfrom scvi.models import VAE, SCANVI, VAEC, LDVAE, TOTALVI, AutoZIVAE\nfrom scvi.models.distributions import ZeroInflatedNegativeBinomial, NegativeBinomial\nfrom scvi.models.classifier import Classifier\nfrom scvi.models.log_likelihood import log_zinb_positive, log_nb_positive\nfrom scvi import set_seed\n\nset_seed(0)\nuse_cuda = True\n\n\ndef test_cortex(save_path):\n cortex_dataset = CortexDataset(save_path=save_path)\n vae = VAE(cortex_dataset.nb_genes, cortex_dataset.n_batches)\n trainer_cortex_vae = UnsupervisedTrainer(\n vae, cortex_dataset, train_size=0.5, use_cuda=use_cuda\n )\n trainer_cortex_vae.train(n_epochs=1)\n trainer_cortex_vae.train_set.reconstruction_error()\n trainer_cortex_vae.train_set.differential_expression_stats()\n trainer_cortex_vae.train_set.generate_feature_correlation_matrix(\n n_samples=2, correlation_type=\"pearson\"\n )\n trainer_cortex_vae.train_set.generate_feature_correlation_matrix(\n n_samples=2, correlation_type=\"spearman\"\n )\n trainer_cortex_vae.train_set.imputation(n_samples=1)\n trainer_cortex_vae.test_set.imputation(n_samples=5)\n\n trainer_cortex_vae.corrupt_posteriors(corruption=\"binomial\")\n trainer_cortex_vae.corrupt_posteriors()\n trainer_cortex_vae.train(n_epochs=1)\n trainer_cortex_vae.uncorrupt_posteriors()\n\n trainer_cortex_vae.train_set.imputation_benchmark(\n n_samples=1, show_plot=False, title_plot=\"imputation\", save_path=save_path\n )\n trainer_cortex_vae.train_set.generate_parameters()\n\n n_cells, n_genes = (\n len(trainer_cortex_vae.train_set.indices),\n cortex_dataset.nb_genes,\n )\n n_samples = 3\n (dropout, means, dispersions) = trainer_cortex_vae.train_set.generate_parameters()\n assert dropout.shape == (n_cells, n_genes) and means.shape == (n_cells, n_genes)\n assert dispersions.shape == (n_cells, n_genes)\n (dropout, means, dispersions) = trainer_cortex_vae.train_set.generate_parameters(\n n_samples=n_samples\n )\n assert dropout.shape == (n_samples, n_cells, n_genes)\n assert means.shape == (n_samples, n_cells, n_genes)\n (dropout, means, dispersions) = trainer_cortex_vae.train_set.generate_parameters(\n n_samples=n_samples, give_mean=True\n )\n assert dropout.shape == (n_cells, n_genes) and means.shape == (n_cells, n_genes)\n\n full = trainer_cortex_vae.create_posterior(\n vae, cortex_dataset, indices=np.arange(len(cortex_dataset))\n )\n x_new, x_old = full.generate(n_samples=10)\n assert x_new.shape == (cortex_dataset.nb_cells, cortex_dataset.nb_genes, 10)\n assert x_old.shape == (cortex_dataset.nb_cells, cortex_dataset.nb_genes)\n\n trainer_cortex_vae.train_set.imputation_benchmark(\n n_samples=1, show_plot=False, title_plot=\"imputation\", save_path=save_path\n )\n\n svaec = SCANVI(\n cortex_dataset.nb_genes, cortex_dataset.n_batches, cortex_dataset.n_labels\n )\n trainer_cortex_svaec = JointSemiSupervisedTrainer(\n svaec, cortex_dataset, n_labelled_samples_per_class=3, use_cuda=use_cuda\n )\n trainer_cortex_svaec.train(n_epochs=1)\n trainer_cortex_svaec.labelled_set.accuracy()\n trainer_cortex_svaec.full_dataset.reconstruction_error()\n\n svaec = SCANVI(\n cortex_dataset.nb_genes, cortex_dataset.n_batches, cortex_dataset.n_labels\n )\n trainer_cortex_svaec = AlternateSemiSupervisedTrainer(\n svaec, cortex_dataset, n_labelled_samples_per_class=3, use_cuda=use_cuda\n )\n trainer_cortex_svaec.train(n_epochs=1, lr=1e-2)\n trainer_cortex_svaec.unlabelled_set.accuracy()\n data_train, labels_train = trainer_cortex_svaec.labelled_set.raw_data()\n data_test, labels_test = trainer_cortex_svaec.unlabelled_set.raw_data()\n compute_accuracy_svc(\n data_train,\n labels_train,\n data_test,\n labels_test,\n param_grid=[{\"C\": [1], \"kernel\": [\"linear\"]}],\n )\n compute_accuracy_rf(\n data_train,\n labels_train,\n data_test,\n labels_test,\n param_grid=[{\"max_depth\": [3], \"n_estimators\": [10]}],\n )\n\n cls = Classifier(cortex_dataset.nb_genes, n_labels=cortex_dataset.n_labels)\n cls_trainer = ClassifierTrainer(cls, cortex_dataset)\n cls_trainer.train(n_epochs=1)\n cls_trainer.train_set.accuracy()\n\n\ndef test_synthetic_1():\n synthetic_dataset = SyntheticDataset()\n synthetic_dataset.cell_types = np.array([\"A\", \"B\", \"C\"])\n svaec = SCANVI(\n synthetic_dataset.nb_genes,\n synthetic_dataset.n_batches,\n synthetic_dataset.n_labels,\n )\n trainer_synthetic_svaec = JointSemiSupervisedTrainer(\n svaec, synthetic_dataset, use_cuda=use_cuda\n )\n trainer_synthetic_svaec.train(n_epochs=1)\n trainer_synthetic_svaec.labelled_set.entropy_batch_mixing()\n\n with tempfile.TemporaryDirectory() as temp_dir:\n posterior_save_path = os.path.join(temp_dir, \"posterior_data\")\n original_post = trainer_synthetic_svaec.labelled_set.sequential()\n original_post.save_posterior(posterior_save_path)\n new_svaec = SCANVI(\n synthetic_dataset.nb_genes,\n synthetic_dataset.n_batches,\n synthetic_dataset.n_labels,\n )\n new_post = load_posterior(posterior_save_path, model=new_svaec, use_cuda=False)\n assert np.array_equal(new_post.indices, original_post.indices)\n assert np.array_equal(new_post.gene_dataset.X, original_post.gene_dataset.X)\n assert np.array_equal(\n new_post.gene_dataset.labels, original_post.gene_dataset.labels\n )\n\n trainer_synthetic_svaec.full_dataset.knn_purity()\n trainer_synthetic_svaec.labelled_set.show_t_sne(n_samples=5)\n trainer_synthetic_svaec.unlabelled_set.show_t_sne(n_samples=5, color_by=\"labels\")\n trainer_synthetic_svaec.labelled_set.show_t_sne(\n n_samples=5, color_by=\"batches and labels\"\n )\n trainer_synthetic_svaec.labelled_set.clustering_scores()\n trainer_synthetic_svaec.labelled_set.clustering_scores(prediction_algorithm=\"gmm\")\n trainer_synthetic_svaec.unlabelled_set.unsupervised_classification_accuracy()\n trainer_synthetic_svaec.unlabelled_set.differential_expression_score(\n synthetic_dataset.labels.ravel() == 1,\n synthetic_dataset.labels.ravel() == 2,\n n_samples=2,\n M_permutation=10,\n )\n trainer_synthetic_svaec.unlabelled_set.one_vs_all_degenes(\n n_samples=2, M_permutation=10\n )\n\n\ndef test_synthetic_2():\n synthetic_dataset = SyntheticDataset()\n vaec = VAEC(\n synthetic_dataset.nb_genes,\n synthetic_dataset.n_batches,\n synthetic_dataset.n_labels,\n )\n trainer_synthetic_vaec = JointSemiSupervisedTrainer(\n vaec,\n synthetic_dataset,\n use_cuda=use_cuda,\n frequency=1,\n early_stopping_kwargs={\n \"early_stopping_metric\": \"reconstruction_error\",\n \"on\": \"labelled_set\",\n \"save_best_state_metric\": \"reconstruction_error\",\n },\n )\n trainer_synthetic_vaec.train(n_epochs=2)\n\n\ndef base_benchmark(gene_dataset):\n vae = VAE(gene_dataset.nb_genes, gene_dataset.n_batches, gene_dataset.n_labels)\n trainer = UnsupervisedTrainer(vae, gene_dataset, train_size=0.5, use_cuda=use_cuda)\n trainer.train(n_epochs=1)\n return trainer\n\n\ndef ldvae_benchmark(dataset, n_epochs, use_cuda=True):\n ldvae = LDVAE(\n dataset.nb_genes, n_batch=dataset.n_batches, latent_distribution=\"normal\"\n )\n trainer = UnsupervisedTrainer(ldvae, dataset, use_cuda=use_cuda)\n trainer.train(n_epochs=n_epochs)\n trainer.test_set.reconstruction_error()\n trainer.test_set.marginal_ll()\n\n ldvae = LDVAE(dataset.nb_genes, n_batch=dataset.n_batches, latent_distribution=\"ln\")\n trainer = UnsupervisedTrainer(ldvae, dataset, use_cuda=use_cuda)\n trainer.train(n_epochs=n_epochs)\n trainer.test_set.reconstruction_error()\n\n ldvae.get_loadings()\n\n return trainer\n\n\ndef totalvi_benchmark(dataset, n_epochs, use_cuda=True):\n totalvae = TOTALVI(\n dataset.nb_genes, len(dataset.protein_names), n_batch=dataset.n_batches\n )\n trainer = TotalTrainer(\n totalvae, dataset, train_size=0.5, use_cuda=use_cuda, early_stopping_kwargs=None\n )\n trainer.train(n_epochs=n_epochs)\n trainer.test_set.reconstruction_error()\n trainer.test_set.marginal_ll()\n\n trainer.test_set.get_protein_background_mean()\n trainer.test_set.get_latent()\n trainer.test_set.generate()\n trainer.test_set.get_sample_dropout()\n trainer.test_set.get_normalized_denoised_expression(transform_batch=0)\n trainer.test_set.get_normalized_denoised_expression(transform_batch=0)\n trainer.test_set.imputation()\n trainer.test_set.get_protein_mean()\n trainer.test_set.one_vs_all_degenes(n_samples=2, M_permutation=10)\n trainer.test_set.generate_feature_correlation_matrix(n_samples=2)\n trainer.test_set.generate_feature_correlation_matrix(n_samples=2, transform_batch=0)\n\n return trainer\n\n\ndef test_synthetic_3():\n gene_dataset = SyntheticDataset()\n trainer = base_benchmark(gene_dataset)\n adapter_trainer = AdapterTrainer(\n trainer.model, gene_dataset, trainer.train_set, frequency=1\n )\n adapter_trainer.train(n_path=1, n_epochs=1)\n\n\ndef test_nb_not_zinb():\n synthetic_dataset = SyntheticDataset()\n svaec = SCANVI(\n synthetic_dataset.nb_genes,\n synthetic_dataset.n_batches,\n synthetic_dataset.n_labels,\n labels_groups=[0, 0, 1],\n reconstruction_loss=\"nb\",\n )\n trainer_synthetic_svaec = JointSemiSupervisedTrainer(\n svaec, synthetic_dataset, use_cuda=use_cuda\n )\n trainer_synthetic_svaec.train(n_epochs=1)\n\n\ndef test_poisson_not_zinb():\n synthetic_dataset = SyntheticDataset()\n svaec = SCANVI(\n synthetic_dataset.nb_genes,\n synthetic_dataset.n_batches,\n synthetic_dataset.n_labels,\n labels_groups=[0, 0, 1],\n reconstruction_loss=\"poisson\",\n )\n trainer_synthetic_svaec = JointSemiSupervisedTrainer(\n svaec, synthetic_dataset, use_cuda=use_cuda\n )\n trainer_synthetic_svaec.train(n_epochs=1)\n\n\ndef test_classifier_accuracy(save_path):\n cortex_dataset = CortexDataset(save_path=save_path)\n cls = Classifier(cortex_dataset.nb_genes, n_labels=cortex_dataset.n_labels)\n cls_trainer = ClassifierTrainer(\n cls,\n cortex_dataset,\n metrics_to_monitor=[\"accuracy\"],\n frequency=1,\n early_stopping_kwargs={\n \"early_stopping_metric\": \"accuracy\",\n \"save_best_state_metric\": \"accuracy\",\n },\n )\n cls_trainer.train(n_epochs=2)\n cls_trainer.train_set.accuracy()\n\n\ndef test_LDVAE(save_path):\n synthetic_datset_one_batch = SyntheticDataset(n_batches=1)\n ldvae_benchmark(synthetic_datset_one_batch, n_epochs=1, use_cuda=False)\n synthetic_datset_two_batches = SyntheticDataset(n_batches=2)\n ldvae_benchmark(synthetic_datset_two_batches, n_epochs=1, use_cuda=False)\n\n\ndef test_sampling_zl(save_path):\n cortex_dataset = CortexDataset(save_path=save_path)\n cortex_vae = VAE(cortex_dataset.nb_genes, cortex_dataset.n_batches)\n trainer_cortex_vae = UnsupervisedTrainer(\n cortex_vae, cortex_dataset, train_size=0.5, use_cuda=use_cuda\n )\n trainer_cortex_vae.train(n_epochs=2)\n\n cortex_cls = Classifier((cortex_vae.n_latent + 1), n_labels=cortex_dataset.n_labels)\n trainer_cortex_cls = ClassifierTrainer(\n cortex_cls, cortex_dataset, sampling_model=cortex_vae, sampling_zl=True\n )\n trainer_cortex_cls.train(n_epochs=2)\n trainer_cortex_cls.test_set.accuracy()\n\n\ndef test_annealing_procedures(save_path):\n cortex_dataset = CortexDataset(save_path=save_path)\n cortex_vae = VAE(cortex_dataset.nb_genes, cortex_dataset.n_batches)\n\n trainer_cortex_vae = UnsupervisedTrainer(\n cortex_vae,\n cortex_dataset,\n train_size=0.5,\n use_cuda=use_cuda,\n n_epochs_kl_warmup=1,\n )\n trainer_cortex_vae.train(n_epochs=2)\n assert trainer_cortex_vae.kl_weight >= 0.99, \"Annealing should be over\"\n\n trainer_cortex_vae = UnsupervisedTrainer(\n cortex_vae,\n cortex_dataset,\n train_size=0.5,\n use_cuda=use_cuda,\n n_epochs_kl_warmup=5,\n )\n trainer_cortex_vae.train(n_epochs=2)\n assert trainer_cortex_vae.kl_weight <= 0.99, \"Annealing should be proceeding\"\n\n # iter\n trainer_cortex_vae = UnsupervisedTrainer(\n cortex_vae,\n cortex_dataset,\n train_size=0.5,\n use_cuda=use_cuda,\n n_iter_kl_warmup=1,\n n_epochs_kl_warmup=None,\n )\n trainer_cortex_vae.train(n_epochs=2)\n assert trainer_cortex_vae.kl_weight >= 0.99, \"Annealing should be over\"\n\n\ndef test_differential_expression(save_path):\n dataset = CortexDataset(save_path=save_path)\n n_cells = len(dataset)\n all_indices = np.arange(n_cells)\n vae = VAE(dataset.nb_genes, dataset.n_batches)\n trainer = UnsupervisedTrainer(vae, dataset, train_size=0.5, use_cuda=use_cuda)\n trainer.train(n_epochs=2)\n post = trainer.create_posterior(vae, dataset, shuffle=False, indices=all_indices)\n\n with tempfile.TemporaryDirectory() as temp_dir:\n posterior_save_path = os.path.join(temp_dir, \"posterior_data\")\n post = post.sequential(batch_size=3)\n post.save_posterior(posterior_save_path)\n new_vae = VAE(dataset.nb_genes, dataset.n_batches)\n new_post = load_posterior(posterior_save_path, model=new_vae, use_cuda=False)\n assert new_post.data_loader.batch_size == 3\n assert np.array_equal(new_post.indices, post.indices)\n assert np.array_equal(new_post.gene_dataset.X, post.gene_dataset.X)\n\n # Sample scale example\n px_scales = post.scale_sampler(\n n_samples_per_cell=4, n_samples=None, selection=all_indices\n )[\"scale\"]\n assert (\n px_scales.shape[1] == dataset.nb_genes\n ), \"posterior scales should have shape (n_samples, n_genes)\"\n\n # Differential expression different models\n idx_1 = [1, 2, 3]\n idx_2 = [4, 5, 6, 7]\n de_dataframe = post.differential_expression_score(\n idx1=idx_1,\n idx2=idx_2,\n n_samples=10,\n mode=\"vanilla\",\n use_permutation=True,\n M_permutation=100,\n )\n\n de_dataframe = post.differential_expression_score(\n idx1=idx_1,\n idx2=idx_2,\n n_samples=10,\n mode=\"change\",\n use_permutation=True,\n M_permutation=100,\n cred_interval_lvls=[0.5, 0.95],\n )\n print(de_dataframe.keys())\n assert (\n de_dataframe[\"lfc_confidence_interval_0.5_min\"]\n <= de_dataframe[\"lfc_confidence_interval_0.5_max\"]\n ).all()\n assert (\n de_dataframe[\"lfc_confidence_interval_0.95_min\"]\n <= de_dataframe[\"lfc_confidence_interval_0.95_max\"]\n ).all()\n\n # DE estimation example\n de_probabilities = de_dataframe.loc[:, \"proba_de\"]\n assert ((0.0 <= de_probabilities) & (de_probabilities <= 1.0)).all()\n\n # Test totalVI DE\n sp = os.path.join(save_path, \"10X\")\n dataset = Dataset10X(dataset_name=\"pbmc_10k_protein_v3\", save_path=sp)\n n_cells = len(dataset)\n all_indices = np.arange(n_cells)\n vae = TOTALVI(\n dataset.nb_genes, len(dataset.protein_names), n_batch=dataset.n_batches\n )\n trainer = TotalTrainer(\n vae, dataset, train_size=0.5, use_cuda=use_cuda, early_stopping_kwargs=None\n )\n trainer.train(n_epochs=2)\n post = trainer.create_posterior(\n vae, dataset, shuffle=False, indices=all_indices, type_class=TotalPosterior\n )\n\n # Differential expression different models\n idx_1 = [1, 2, 3]\n idx_2 = [4, 5, 6, 7]\n de_dataframe = post.differential_expression_score(\n idx1=idx_1,\n idx2=idx_2,\n n_samples=10,\n mode=\"vanilla\",\n use_permutation=True,\n M_permutation=100,\n )\n\n de_dataframe = post.differential_expression_score(\n idx1=idx_1,\n idx2=idx_2,\n n_samples=10,\n mode=\"change\",\n use_permutation=True,\n M_permutation=100,\n )\n\n\ndef test_totalvi(save_path):\n synthetic_dataset_one_batch = SyntheticDataset(n_batches=1)\n totalvi_benchmark(synthetic_dataset_one_batch, n_epochs=1, use_cuda=use_cuda)\n synthetic_dataset_two_batches = SyntheticDataset(n_batches=2)\n totalvi_benchmark(synthetic_dataset_two_batches, n_epochs=1, use_cuda=use_cuda)\n\n # adversarial testing\n dataset = synthetic_dataset_two_batches\n totalvae = TOTALVI(\n dataset.nb_genes, len(dataset.protein_names), n_batch=dataset.n_batches\n )\n trainer = TotalTrainer(\n totalvae,\n dataset,\n train_size=0.5,\n use_cuda=use_cuda,\n early_stopping_kwargs=None,\n use_adversarial_loss=True,\n )\n trainer.train(n_epochs=1)\n\n with tempfile.TemporaryDirectory() as temp_dir:\n posterior_save_path = os.path.join(temp_dir, \"posterior_data\")\n original_post = trainer.create_posterior(\n totalvae,\n dataset,\n indices=np.arange(len(dataset)),\n type_class=TotalPosterior,\n )\n original_post.save_posterior(posterior_save_path)\n new_totalvae = TOTALVI(\n dataset.nb_genes, len(dataset.protein_names), n_batch=dataset.n_batches\n )\n new_post = load_posterior(\n posterior_save_path, model=new_totalvae, use_cuda=False\n )\n assert new_post.posterior_type == \"TotalPosterior\"\n assert np.array_equal(\n new_post.gene_dataset.protein_expression, dataset.protein_expression\n )\n\n\ndef test_autozi(save_path):\n data = SyntheticDataset(n_batches=1)\n\n for disp_zi in [\"gene\", \"gene-label\"]:\n autozivae = AutoZIVAE(\n n_input=data.nb_genes,\n dispersion=disp_zi,\n zero_inflation=disp_zi,\n n_labels=data.n_labels,\n )\n trainer_autozivae = UnsupervisedTrainer(\n model=autozivae, gene_dataset=data, train_size=0.5\n )\n trainer_autozivae.train(n_epochs=2, lr=1e-2)\n trainer_autozivae.test_set.elbo()\n trainer_autozivae.test_set.reconstruction_error()\n trainer_autozivae.test_set.marginal_ll()\n\n\ndef test_multibatches_features():\n data = [\n np.random.randint(1, 5, size=(20, 10)),\n np.random.randint(1, 10, size=(20, 10)),\n np.random.randint(1, 10, size=(20, 10)),\n np.random.randint(1, 10, size=(30, 10)),\n ]\n dataset = GeneExpressionDataset()\n dataset.populate_from_per_batch_list(data)\n vae = VAE(dataset.nb_genes, dataset.n_batches)\n trainer = UnsupervisedTrainer(vae, dataset, train_size=0.5, use_cuda=use_cuda)\n trainer.train(n_epochs=2)\n trainer.test_set.imputation(n_samples=2, transform_batch=0)\n trainer.train_set.imputation(n_samples=2, transform_batch=[0, 1, 2])\n\n\ndef test_deprecated_munkres():\n y = np.array([0, 1, 0, 1, 0, 1, 1, 1])\n y_pred = np.array([0, 0, 0, 0, 1, 1, 1, 1])\n reward, assignment = unsupervised_clustering_accuracy(y, y_pred)\n assert reward == 0.625\n assert (assignment == np.array([[0, 0], [1, 1]])).all()\n\n y = np.array([1, 1, 2, 2, 0, 0, 3, 3])\n y_pred = np.array([1, 1, 2, 2, 3, 3, 0, 0])\n reward, assignment = unsupervised_clustering_accuracy(y, y_pred)\n assert reward == 1.0\n assert (assignment == np.array([[0, 3], [1, 1], [2, 2], [3, 0]])).all()\n\n\ndef test_zinb_distribution():\n theta = 100.0 + torch.rand(size=(2,))\n mu = 15.0 * torch.ones_like(theta)\n pi = torch.randn_like(theta)\n x = torch.randint_like(mu, high=20)\n log_p_ref = log_zinb_positive(x, mu, theta, pi)\n\n dist = ZeroInflatedNegativeBinomial(mu=mu, theta=theta, zi_logits=pi)\n log_p_zinb = dist.log_prob(x)\n assert (log_p_ref - log_p_zinb).abs().max().item() <= 1e-8\n\n torch.manual_seed(0)\n s1 = dist.sample((100,))\n assert s1.shape == (100, 2)\n s2 = dist.sample(sample_shape=(4, 3))\n assert s2.shape == (4, 3, 2)\n\n log_p_ref = log_nb_positive(x, mu, theta)\n dist = NegativeBinomial(mu=mu, theta=theta)\n log_p_nb = dist.log_prob(x)\n assert (log_p_ref - log_p_nb).abs().max().item() <= 1e-8\n\n s1 = dist.sample((1000,))\n assert s1.shape == (1000, 2)\n assert (s1.mean(0) - mu).abs().mean() <= 1e0\n assert (s1.std(0) - (mu + mu * mu / theta) ** 0.5).abs().mean() <= 1e0\n\n size = (50, 3)\n theta = 100.0 + torch.rand(size=size)\n mu = 15.0 * torch.ones_like(theta)\n pi = torch.randn_like(theta)\n x = torch.randint_like(mu, high=20)\n dist1 = ZeroInflatedNegativeBinomial(mu=mu, theta=theta, zi_logits=pi)\n dist2 = NegativeBinomial(mu=mu, theta=theta)\n assert dist1.log_prob(x).shape == size\n assert dist2.log_prob(x).shape == size\n\n with pytest.raises(ValueError):\n ZeroInflatedNegativeBinomial(mu=-mu, theta=theta, zi_logits=pi)\n with pytest.warns(UserWarning):\n dist1.log_prob(-x) # ensures neg values raise warning\n with pytest.warns(UserWarning):\n dist2.log_prob(0.5 * x) # ensures float values raise warning\n\n\ndef test_anndata_loader():\n x = np.random.randint(low=0, high=100, size=(15, 4))\n batch_ids = np.random.randint(low=0, high=2, size=(15,))\n n_batches = 2\n adata = AnnData(X=x, obs=dict(batch=batch_ids))\n _ = AnnDatasetFromAnnData(adata, batch_label=\"batch\")\n dataset = AnnDatasetFromAnnData(adata, batch_label=\"batch\")\n assert (\n dataset.n_batches == n_batches\n ), \"AnnDatasetFromAnnData should not modify the anndata object\"\n"
] |
[
[
"torch.rand",
"numpy.array",
"numpy.array_equal",
"torch.manual_seed",
"torch.randn_like",
"numpy.arange",
"numpy.random.randint",
"torch.ones_like",
"torch.randint_like"
]
] |
vcristiani/galaxy-chop
|
[
"6a854ee8701001ab0f15d6b0112401c123d0c6b2"
] |
[
"tests/conftest.py"
] |
[
"# This file is part of\n# the galxy-chop project (https://github.com/vcristiani/galaxy-chop)\n# Copyright (c) 2020, Valeria Cristiani\n# License: MIT\n# Full Text: https://github.com/vcristiani/galaxy-chop/blob/master/LICENSE.txt\n\n\"\"\"Fixtures input data.\"\"\"\n\n# =============================================================================\n# IMPORTS\n# =============================================================================\n\nimport os\nfrom pathlib import Path\n\nimport astropy.units as u\n\nfrom galaxychop import core\n\nimport numpy as np\n\nimport pytest\n\n\n# =============================================================================\n# PATHS\n# =============================================================================\n\nPATH = Path(os.path.abspath(os.path.dirname(__file__)))\n\nTEST_DATA_PATH = PATH / \"test_data\"\n\nTEST_DATA_REAL_PATH = TEST_DATA_PATH / \"real\"\n\n# =============================================================================\n# Defining utility functions for mocking data\n# =============================================================================\n\n\ndef rot_matrix_xaxis(theta=0):\n \"\"\"\n Rotation matrix of a transformation around X axis.\n\n Parameters\n ----------\n theta : `float`\n Rotation angle in radians\n Returns\n -------\n A : `np.ndarray`\n Rotation matrix, with shape (3, 3)\n \"\"\"\n A = np.array(\n [\n [1, 0, 0],\n [0, np.cos(theta), -1 * np.sin(theta)],\n [0, np.sin(theta), np.cos(theta)],\n ]\n )\n return A\n\n\ndef rot_matrix_yaxis(theta=0):\n \"\"\"\n Rotation matrix of a transformation around Y axis.\n\n Parameters\n ----------\n theta : `float`\n Rotation angle in radians\n Returns\n -------\n A : `np.ndarray`\n Rotation matrix, with shape (3, 3)\n \"\"\"\n A = np.array(\n [\n [np.cos(theta), 0, np.sin(theta)],\n [0, 1, 0],\n [-1 * np.sin(theta), 0, np.cos(theta)],\n ]\n )\n return A\n\n\ndef rot_matrix_zaxis(theta=0):\n \"\"\"\n Rotation matrix of a transformation around Z axis.\n\n Parameters\n ----------\n theta : `float`\n Rotation angle in radians\n Returns\n -------\n A : `np.ndarray`\n Rotation matrix, with shape (3, 3)\n \"\"\"\n A = np.array(\n [\n [np.cos(theta), -1 * np.sin(theta), 0],\n [np.sin(theta), np.cos(theta), 0],\n [0, 0, 1],\n ]\n )\n return A\n\n\ndef rotate(pos, vel, matrix):\n \"\"\"\n Rotate.\n\n Applies the rotation `matrix` to a set of particles positions `pos` and\n velocities `vel`\n\n Parameters\n ----------\n pos : `np.ndarray`, shape = (N_part, 3)\n Positions of particles\n vel : `np.ndarray`, shape = (N_part, 3)\n Velocities of particles\n matrix : `np.ndarray`\n Rotation matrix, with shape (3, 3)\n\n Returns\n -------\n pos_rot : `np.ndarray`, shape = (N_part, 3)\n Rotated, positions of particles\n vel_rot : `np.ndarray`, shape = (N_part, 3)\n Rotated, velocities of particles\n \"\"\"\n pos_rot = pos @ matrix\n vel_rot = vel @ matrix\n\n return pos_rot, vel_rot\n\n\ndef distance(x, y, z, m):\n \"\"\"\n Distances calculator.\n\n Calculate distances beetween particles.\n\n Parameters\n ----------\n x, y, z: `np.ndarray`, shape = (N_part, 1)\n Positions\n m : `np.ndarray`, shape = (N_part, 1)\n Masses\n\n Returns\n -------\n dx, dy, dz: `np.ndarray`, shape = (N_part, N_part)\n Distances between particles.\n \"\"\"\n N_part = len(m)\n\n dx = np.zeros((N_part, N_part))\n dy = np.zeros((N_part, N_part))\n dz = np.zeros((N_part, N_part))\n\n for i in range(0, N_part - 1):\n for j in range(i + 1, N_part):\n dx[i, j] = x[j] - x[i]\n dy[i, j] = y[j] - y[i]\n dz[i, j] = z[j] - z[i]\n\n dx[j, i] = -dx[i, j]\n dy[j, i] = -dy[i, j]\n dz[j, i] = -dz[i, j]\n\n return dx, dy, dz\n\n\ndef epot(x, y, z, m, eps=0.0):\n \"\"\"\n Potential energy with python.\n\n Parameters\n ----------\n x, y, z: `np.ndarray`, shape = (N_part, 1)\n Positions\n m : `np.ndarray`, shape = (N_part, 1)\n Masses\n eps: `float`\n Softening radius\n\n Returns\n -------\n Upot: `np.ndarray`, shape = (N_part, 1)\n Potential energy of particles\n \"\"\"\n G = 4.299e-6\n N_part = len(m)\n\n U = np.zeros((N_part, N_part))\n\n dx, dy, dz = distance(x, y, z, m)\n\n dist = np.sqrt(dx ** 2 + dy ** 2 + dz ** 2 + eps ** 2)\n\n for i in range(N_part - 1):\n for j in range(i + 1, N_part):\n U[i, j] = G * m[j] * m[i] / dist[i, j]\n U[j, i] = U[i, j]\n\n Upot = np.sum(U / m, axis=0)\n return Upot\n\n\n# =============================================================================\n# Fixtures\n# =============================================================================\n@pytest.fixture\ndef random_galaxy_params():\n \"\"\"\n Galaxy parameter for test.\n\n This return a function of a dictionary with random params of a Galaxy\n object\n \"\"\"\n\n def make(stars, gas, dm, seed):\n\n random = np.random.default_rng(seed=seed)\n\n x_s = random.random(stars)\n y_s = random.random(stars)\n z_s = random.random(stars)\n vx_s = random.random(stars)\n vy_s = random.random(stars)\n vz_s = random.random(stars)\n m_s = random.random(stars)\n\n x_dm = random.random(dm)\n y_dm = random.random(dm)\n z_dm = random.random(dm)\n vx_dm = random.random(dm)\n vy_dm = random.random(dm)\n vz_dm = random.random(dm)\n m_dm = random.random(dm)\n\n x_g = random.random(gas)\n y_g = random.random(gas)\n z_g = random.random(gas)\n vx_g = random.random(gas)\n vy_g = random.random(gas)\n vz_g = random.random(gas)\n m_g = random.random(gas)\n\n params = {\n \"m_s\": m_s,\n \"x_s\": x_s,\n \"y_s\": y_s,\n \"z_s\": z_s,\n \"vx_s\": vx_s,\n \"vy_s\": vy_s,\n \"vz_s\": vz_s,\n \"m_dm\": m_dm,\n \"x_dm\": x_dm,\n \"y_dm\": y_dm,\n \"z_dm\": z_dm,\n \"vx_dm\": vx_dm,\n \"vy_dm\": vy_dm,\n \"vz_dm\": vz_dm,\n \"m_g\": m_g,\n \"x_g\": x_g,\n \"y_g\": y_g,\n \"z_g\": z_g,\n \"vx_g\": vx_g,\n \"vy_g\": vy_g,\n \"vz_g\": vz_g,\n }\n return params\n\n return make\n\n\n@pytest.fixture(scope=\"session\")\ndef solid_disk():\n \"\"\"\n Mock solid disk.\n\n Creates a mock solid disc of particles with masses\n and velocities.\n \"\"\"\n\n def make(N_part=100, rmax=30, rmin=2, omega=10, seed=42):\n\n random = np.random.RandomState(seed=seed)\n\n r = (rmax - rmin) * random.random_sample(size=N_part) + rmin\n phi0 = 2 * np.pi * random.random_sample(size=N_part)\n mass = 1.0e8 * np.ones_like(r)\n\n x = r * np.cos(phi0)\n y = r * np.sin(phi0)\n z = 1 * random.random_sample(size=N_part) - 0.5\n\n xdot = -1 * omega * r * np.sin(phi0)\n ydot = omega * r * np.cos(phi0)\n zdot = np.zeros_like(xdot)\n\n pos = np.array([x, y, z]).T\n vel = np.array([xdot, ydot, zdot]).T\n\n return mass, pos, vel\n\n return make\n\n\n@pytest.fixture(scope=\"session\")\ndef mock_dm_halo():\n \"\"\"\n Mock dark matter Halo.\n\n Creates a mock DM halo of particles with masses\n and velocities.\n \"\"\"\n\n def make(N_part=1000, rmax=100, seed=55):\n\n random = np.random.RandomState(seed=seed)\n\n r = random.random_sample(size=N_part) * rmax\n\n cos_t = random.random_sample(size=N_part) * 2.0 - 1\n phi0 = 2 * np.pi * random.random_sample(size=N_part)\n sin_t = np.sqrt(1 - cos_t ** 2)\n mass = 1.0e10 * np.ones_like(r)\n\n x = r * sin_t * np.cos(phi0)\n y = r * sin_t * np.sin(phi0)\n z = r * cos_t\n\n pos = np.array([x, y, z]).T\n\n return mass, pos\n\n return make\n\n\n@pytest.fixture\ndef disc_zero_angle(solid_disk):\n \"\"\"Disc with no angle of inclination.\"\"\"\n mass, pos, vel = solid_disk(N_part=1000)\n return mass, pos, vel\n\n\n@pytest.fixture\ndef disc_xrotation(solid_disk):\n \"\"\"Disc rotated over x axis.\"\"\"\n mass, pos, vel = solid_disk(N_part=1000)\n random = np.random.RandomState(seed=42)\n a = rot_matrix_xaxis(theta=0.3 * np.pi * random.random())\n\n return mass, pos @ a, vel @ a, a\n\n\n@pytest.fixture\ndef disc_yrotation(solid_disk):\n \"\"\"Disc rotated over y axis.\"\"\"\n mass, pos, vel = solid_disk(N_part=1000)\n random = np.random.RandomState(seed=42)\n a = rot_matrix_yaxis(theta=0.3 * np.pi * random.random())\n\n return mass, pos @ a, vel @ a, a\n\n\n@pytest.fixture\ndef disc_zrotation(solid_disk):\n \"\"\"Disc rotated over z axis.\"\"\"\n mass, pos, vel = solid_disk(N_part=1000)\n random = np.random.RandomState(seed=42)\n a = rot_matrix_zaxis(theta=0.3 * np.pi * random.random())\n\n return mass, pos @ a, vel @ a, a\n\n\n@pytest.fixture\ndef disc_particles(solid_disk):\n \"\"\"Solid disc without velocities.\"\"\"\n mass, pos, vel = solid_disk(N_part=100)\n return pos[:, 0], pos[:, 1], pos[:, 2], mass\n\n\n@pytest.fixture\ndef disc_particles_all(solid_disk):\n \"\"\"Solid disc with velocities.\"\"\"\n mass_s, pos_s, vel_s = solid_disk(N_part=100)\n mass_g, pos_g, vel_g = solid_disk(N_part=100)\n\n return mass_s, pos_s, vel_s, mass_g, pos_g, vel_g\n\n\n@pytest.fixture(scope=\"session\")\ndef halo_particles(mock_dm_halo):\n \"\"\"Spherical mock halo.\"\"\"\n\n def make(N_part=100, seed=None):\n random = np.random.RandomState(seed=seed)\n mass_dm, pos_dm = mock_dm_halo(N_part=N_part)\n vel_dm = random.random_sample(size=(N_part, 3))\n\n return mass_dm, pos_dm, vel_dm\n\n return make\n\n\n@pytest.fixture\ndef mock_galaxy(disc_particles_all, halo_particles):\n \"\"\"Mock galaxy.\"\"\"\n (mass_s, pos_s, vel_s, mass_g, pos_g, vel_g) = disc_particles_all\n\n mass_dm, pos_dm, vel_dm = halo_particles(N_part=100, seed=42)\n\n g = core.Galaxy(\n m_s=mass_s * u.M_sun,\n x_s=pos_s[:, 0] * u.kpc,\n y_s=pos_s[:, 1] * u.kpc,\n z_s=pos_s[:, 2] * u.kpc,\n vx_s=vel_s[:, 0] * (u.km / u.s),\n vy_s=vel_s[:, 1] * (u.km / u.s),\n vz_s=vel_s[:, 2] * (u.km / u.s),\n m_dm=mass_dm * u.M_sun,\n x_dm=pos_dm[:, 0] * u.kpc,\n y_dm=pos_dm[:, 1] * u.kpc,\n z_dm=pos_dm[:, 2] * u.kpc,\n vx_dm=vel_dm[:, 0] * (u.km / u.s),\n vy_dm=vel_dm[:, 1] * (u.km / u.s),\n vz_dm=vel_dm[:, 2] * (u.km / u.s),\n m_g=mass_g * u.M_sun,\n x_g=pos_g[:, 0] * u.kpc,\n y_g=pos_g[:, 1] * u.kpc,\n z_g=pos_g[:, 2] * u.kpc,\n vx_g=vel_g[:, 0] * (u.km / u.s),\n vy_g=vel_g[:, 1] * (u.km / u.s),\n vz_g=vel_g[:, 2] * (u.km / u.s),\n )\n\n return g\n\n\n@pytest.fixture\ndef mock_real_galaxy():\n \"\"\"Mock real galaxy.\"\"\"\n dm = np.loadtxt(TEST_DATA_REAL_PATH / \"dark.dat\")\n s = np.loadtxt(TEST_DATA_REAL_PATH / \"star.dat\")\n g = np.loadtxt(TEST_DATA_REAL_PATH / \"gas_.dat\")\n gal = core.Galaxy(\n m_s=s[:, 0] * 1e10 * u.M_sun,\n x_s=s[:, 1] * u.kpc,\n y_s=s[:, 2] * u.kpc,\n z_s=s[:, 3] * u.kpc,\n vx_s=s[:, 4] * (u.km / u.s),\n vy_s=s[:, 5] * (u.km / u.s),\n vz_s=s[:, 6] * (u.km / u.s),\n m_dm=dm[:, 0] * 1e10 * u.M_sun,\n x_dm=dm[:, 1] * u.kpc,\n y_dm=dm[:, 2] * u.kpc,\n z_dm=dm[:, 3] * u.kpc,\n vx_dm=dm[:, 4] * (u.km / u.s),\n vy_dm=dm[:, 5] * (u.km / u.s),\n vz_dm=dm[:, 6] * (u.km / u.s),\n m_g=g[:, 0] * 1e10 * u.M_sun,\n x_g=g[:, 1] * u.kpc,\n y_g=g[:, 2] * u.kpc,\n z_g=g[:, 3] * u.kpc,\n vx_g=g[:, 4] * (u.km / u.s),\n vy_g=g[:, 5] * (u.km / u.s),\n vz_g=g[:, 6] * (u.km / u.s),\n )\n\n return gal\n"
] |
[
[
"numpy.zeros_like",
"numpy.ones_like",
"numpy.sin",
"numpy.array",
"numpy.zeros",
"numpy.random.RandomState",
"numpy.sum",
"numpy.random.default_rng",
"numpy.loadtxt",
"numpy.sqrt",
"numpy.cos"
]
] |
mathieu-le-brun/EA-elective-NEAT
|
[
"71653793683bd26901f639a45179e47bf2041c37"
] |
[
"domain/hyperparameters.py"
] |
[
"from pprint import pprint\n\nfrom .task_gym import GymTask\nfrom .config import games\nimport json\nimport numpy as np\n\n\ndef loadHyp(pFileName, printHyp=False):\n \"\"\"Loads hyperparameters from .json file\n Args:\n pFileName - (string) - file name of hyperparameter file\n printHyp - (bool) - print contents of hyperparameter file to terminal?\n\n Note: see config/hypkey.txt for detailed hyperparameter description\n \"\"\"\n with open(pFileName) as data_file:\n hyp = json.load(data_file)\n\n # Task hyper parameters\n task = GymTask(games[hyp['task']], paramOnly=True)\n hyp['ann_nInput'] = task.nInput\n hyp['ann_nOutput'] = task.nOutput\n hyp['ann_initAct'] = task.activations[0]\n hyp['ann_absWCap'] = task.absWCap\n hyp['ann_mutSigma'] = task.absWCap * 0.2\n hyp['ann_layers'] = task.layers # if fixed toplogy is used\n\n if hyp['alg_act'] == 0:\n hyp['ann_actRange'] = task.actRange\n else:\n hyp['ann_actRange'] = np.full_like(task.actRange, hyp['alg_act'])\n\n # == EA-elective-NEAT ==============================================================================================\n if printHyp:\n print(pFileName)\n pprint(hyp)\n # ==================================================================================================================\n return hyp\n\n\ndef updateHyp(hyp, pFileName=None):\n \"\"\"Overwrites default hyperparameters with those from second .json file\n \"\"\"\n if pFileName is not None:\n print('\\t*** Running with hyperparameters: ', pFileName, '\\t***')\n with open(pFileName) as data_file:\n update = json.load(data_file)\n hyp.update(update)\n\n # Task hyper parameters\n task = GymTask(games[hyp['task']], paramOnly=True)\n hyp['ann_nInput'] = task.nInput\n hyp['ann_nOutput'] = task.nOutput\n hyp['ann_initAct'] = task.activations[0]\n hyp['ann_absWCap'] = task.absWCap\n hyp['ann_mutSigma'] = task.absWCap * 0.1\n hyp['ann_layers'] = task.layers # if fixed toplogy is used\n\n if hyp['alg_act'] == 0:\n hyp['ann_actRange'] = task.actRange\n else:\n hyp['ann_actRange'] = np.full_like(task.actRange, hyp['alg_act'])\n"
] |
[
[
"numpy.full_like"
]
] |
ncolomer/airflow
|
[
"cb7c67dea9cd9b9c5de10e355b63039446003149"
] |
[
"airflow/providers/amazon/aws/transfers/mysql_to_s3.py"
] |
[
"#\n# Licensed to the Apache Software Foundation (ASF) under one\n# or more contributor license agreements. See the NOTICE file\n# distributed with this work for additional information\n# regarding copyright ownership. The ASF licenses this file\n# to you under the Apache License, Version 2.0 (the\n# \"License\"); you may not use this file except in compliance\n# with the License. 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,\n# software distributed under the License is distributed on an\n# \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n# KIND, either express or implied. See the License for the\n# specific language governing permissions and limitations\n# under the License.\n\nimport os\nfrom tempfile import NamedTemporaryFile\nfrom typing import Optional, Union\n\nimport numpy as np\nimport pandas as pd\n\nfrom airflow.exceptions import AirflowException\nfrom airflow.models import BaseOperator\nfrom airflow.providers.amazon.aws.hooks.s3 import S3Hook\nfrom airflow.providers.mysql.hooks.mysql import MySqlHook\nfrom airflow.utils.decorators import apply_defaults\n\n\nclass MySQLToS3Operator(BaseOperator):\n \"\"\"\n Saves data from an specific MySQL query into a file in S3.\n\n :param query: the sql query to be executed. If you want to execute a file, place the absolute path of it,\n ending with .sql extension. (templated)\n :type query: str\n :param s3_bucket: bucket where the data will be stored. (templated)\n :type s3_bucket: str\n :param s3_key: desired key for the file. It includes the name of the file. (templated)\n :type s3_key: str\n :param mysql_conn_id: reference to a specific mysql database\n :type mysql_conn_id: str\n :param aws_conn_id: reference to a specific S3 connection\n :type aws_conn_id: str\n :param verify: Whether or not to verify SSL certificates for S3 connection.\n By default SSL certificates are verified.\n You can provide the following values:\n\n - ``False``: do not validate SSL certificates. SSL will still be used\n (unless use_ssl is False), but SSL certificates will not be verified.\n - ``path/to/cert/bundle.pem``: A filename of the CA cert bundle to uses.\n You can specify this argument if you want to use a different\n CA cert bundle than the one used by botocore.\n :type verify: bool or str\n :param pd_csv_kwargs: arguments to include in pd.to_csv (header, index, columns...)\n :type pd_csv_kwargs: dict\n :param index: whether to have the index or not in the dataframe\n :type index: str\n :param header: whether to include header or not into the S3 file\n :type header: bool\n \"\"\"\n\n template_fields = (\n 's3_bucket',\n 's3_key',\n 'query',\n )\n template_ext = ('.sql',)\n\n @apply_defaults\n def __init__(\n self,\n *,\n query: str,\n s3_bucket: str,\n s3_key: str,\n mysql_conn_id: str = 'mysql_default',\n aws_conn_id: str = 'aws_default',\n verify: Optional[Union[bool, str]] = None,\n pd_csv_kwargs: Optional[dict] = None,\n index: bool = False,\n header: bool = False,\n **kwargs,\n ) -> None:\n super().__init__(**kwargs)\n self.query = query\n self.s3_bucket = s3_bucket\n self.s3_key = s3_key\n self.mysql_conn_id = mysql_conn_id\n self.aws_conn_id = aws_conn_id\n self.verify = verify\n\n self.pd_csv_kwargs = pd_csv_kwargs or {}\n if \"path_or_buf\" in self.pd_csv_kwargs:\n raise AirflowException('The argument path_or_buf is not allowed, please remove it')\n if \"index\" not in self.pd_csv_kwargs:\n self.pd_csv_kwargs[\"index\"] = index\n if \"header\" not in self.pd_csv_kwargs:\n self.pd_csv_kwargs[\"header\"] = header\n\n def _fix_int_dtypes(self, df: pd.DataFrame) -> None:\n \"\"\"\n Mutate DataFrame to set dtypes for int columns containing NaN values.\"\n \"\"\"\n for col in df:\n if \"float\" in df[col].dtype.name and df[col].hasnans:\n # inspect values to determine if dtype of non-null values is int or float\n notna_series = df[col].dropna().values\n if np.isclose(notna_series, notna_series.astype(int)).all():\n # set to dtype that retains integers and supports NaNs\n df[col] = np.where(df[col].isnull(), None, df[col])\n df[col] = df[col].astype(pd.Int64Dtype())\n\n def execute(self, context) -> None:\n mysql_hook = MySqlHook(mysql_conn_id=self.mysql_conn_id)\n s3_conn = S3Hook(aws_conn_id=self.aws_conn_id, verify=self.verify)\n data_df = mysql_hook.get_pandas_df(self.query)\n self.log.info(\"Data from MySQL obtained\")\n\n self._fix_int_dtypes(data_df)\n with NamedTemporaryFile(mode='r+', suffix='.csv') as tmp_csv:\n data_df.to_csv(tmp_csv.name, **self.pd_csv_kwargs)\n s3_conn.load_file(filename=tmp_csv.name, key=self.s3_key, bucket_name=self.s3_bucket)\n\n if s3_conn.check_for_key(self.s3_key, bucket_name=self.s3_bucket):\n file_location = os.path.join(self.s3_bucket, self.s3_key)\n self.log.info(\"File saved correctly in %s\", file_location)\n"
] |
[
[
"pandas.Int64Dtype"
]
] |
alessandro-santini/Tensor-Network
|
[
"3f3c52d61a7ea3d2ceedb03d08f40ad4d153b56e"
] |
[
"tebd_floquet.py"
] |
[
"import MPS_class as MPS\nimport MPO_class as MPO\nfrom ncon import ncon\nimport numpy as np\nfrom scipy.linalg import expm\n#%%\ndef TEBD_evo(MPS_,Lx,Ly,J=1,epsilon=0.1,etrunc=0,chiMAX=256,chiMAXswap=256,info=True):\n L = Lx*Ly\n config = np.arange(0,L).reshape(Lx,Ly)\n \n theta = (np.pi+2*epsilon)\n flip_op = np.eye(2)*np.cos(theta/2) - 1j*np.sin(theta/2)*np.array([[0,1],[1,0]]) \n \n sigma_z = np.array([[1,0],[0,-1]])\n Uprop = expm(-1j*np.kron(sigma_z,-J*sigma_z)).reshape(2,2,2,2)\n nn_list_forward = [[] for x in range(L)]\n for x in range(L):\n i,j = np.where(config == x)\n if j != Ly-1: nn_list_forward[x].append( config[i,j+1])\n if i != Lx-1: nn_list_forward[x].append( config[i+1,j])\n nn_list_forward[x] = np.array(nn_list_forward[x]).ravel()\n nn_list_backward = [[] for x in range(L)] \n for x in reversed(range(L)):\n i,j = np.where(config == x)\n if j != 0: nn_list_backward[x].append( config[i,j-1])\n if i != 0: nn_list_backward[x].append( config[i-1,j])\n nn_list_backward[x] = np.array(nn_list_backward[x]).ravel()\n \n for x in range(L):\n for nn in nn_list_forward[x]:\n # If they are nearest neighbours\n if nn == x+1:\n shpM1,shpM2 = MPS_.M[x].shape, MPS_.M[nn].shape\n Theta = ncon([MPS_.M[x],MPS_.M[nn],Uprop],[[-1,2,1],[1,3,-4],[2,3,-2,-3]]) \n Theta = Theta.reshape(shpM1[0]*shpM1[1], shpM2[1]*shpM2[2])\n U,S,V = MPS.svdtruncate(Theta, etrunc, chiMAX,info=info)\n MPS_.M[x] = U.reshape(shpM1[0],shpM1[1],S.size)\n MPS_.M[nn] = (np.diag(S)@V).reshape(S.size,shpM2[1],shpM2[2])\n else:\n for index in range(x,nn-1):\n MPS_.swap(index,chiMAX=chiMAXswap,info=info)\n shpM1,shpM2 = MPS_.M[nn-1].shape, MPS_.M[nn].shape\n Theta = ncon([MPS_.M[nn-1],MPS_.M[nn],Uprop],[[-1,2,1],[1,3,-4],[2,3,-2,-3]]) \n Theta = Theta.reshape(shpM1[0]*shpM1[1], shpM2[1]*shpM2[2])\n U,S,V = MPS.svdtruncate(Theta, etrunc, chiMAX,info=info)\n MPS_.M[nn-1] = (U@np.diag(S)).reshape(shpM1[0],shpM1[1],S.size)\n MPS_.M[nn] = V.reshape(S.size,shpM2[1],shpM2[2]) \n for index in reversed(range(x,nn-1)):\n MPS_.swap(index,chiMAX=chiMAXswap,info=info)\n MPS_.M[x] = ncon([MPS_.M[x],flip_op],[[-1,1,-3],[1,-2]])\n \n for x in reversed(range(L)):\n for nn in nn_list_backward[x]:\n # If they are nearest neighbours\n if nn == x-1:\n shpM1,shpM2 = MPS_.M[nn].shape, MPS_.M[x].shape\n Theta = ncon([MPS_.M[nn],MPS_.M[x],Uprop],[[-1,2,1],[1,3,-4],[2,3,-2,-3]]) \n Theta = Theta.reshape(shpM1[0]*shpM1[1], shpM2[1]*shpM2[2])\n U,S,V = MPS.svdtruncate(Theta, etrunc, chiMAX,info=info)\n MPS_.M[nn] = (U@np.diag(S)).reshape(shpM1[0],shpM1[1],S.size)\n MPS_.M[x] = (V).reshape(S.size,shpM2[1],shpM2[2])\n else:\n for index in range(x-1,nn,-1):\n MPS_.swap(index,chiMAX=chiMAXswap,center='i',info=info)\n shpM1,shpM2 = MPS_.M[nn].shape, MPS_.M[nn+1].shape\n Theta = ncon([MPS_.M[nn],MPS_.M[nn+1],Uprop],[[-1,2,1],[1,3,-4],[2,3,-2,-3]]) \n Theta = Theta.reshape(shpM1[0]*shpM1[1], shpM2[1]*shpM2[2])\n U,S,V = MPS.svdtruncate(Theta, etrunc, chiMAX,info=info)\n MPS_.M[nn] = U.reshape(shpM1[0],shpM1[1],S.size)\n MPS_.M[nn+1] = (np.diag(S)@V).reshape(S.size,shpM2[1],shpM2[2]) \n for index in reversed(range(x-1,nn,-1)):\n MPS_.swap(index,chiMAX=chiMAXswap,center='i',info=info) \n MPS_.M[x] = ncon([MPS_.M[x],flip_op],[[-1,1,-3],[1,-2]])\n\nLx = 5\nLy = Lx\n\nL = Lx*Ly\npsi_state = MPS.getAllUp(L)\n\nmag = []\nerr = 0.\ninfo = True\nmag.append(MPO.return_LocalMz(psi_state).real.reshape(Lx,Ly))\nfor k in range(20):\n print('k',k,np.max(mag[k]-mag[k].T))\n for x in psi_state.M:\n print(x.shape)\n TEBD_evo(psi_state, Lx, Ly,J = -1j,chiMAX=256,chiMAXswap=256,etrunc=1e-12,info=info)\n mag.append(MPO.return_LocalMz(psi_state).real.reshape(Lx,Ly))\nmag = np.array(mag)\n#%%\n\nfrom scipy.sparse.linalg import expm_multiply\nimport scipy.sparse as sps\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nimport matplotlib as mpl\nimport seaborn as sns\n\n\ndef nested_tensor(lst):\n if len(lst) == 2:\n return sps.kron(lst[0],lst[1],format='csc')\n else:\n return sps.kron(lst[0], nested_tensor(lst[1:]),format='csc')\n\ndef spin_op_construct(sigma, j, L):\n before = [sps.eye(2) for _ in range(j)]\n mid = [sigma]\n after = [sps.eye(2) for _ in range(j+1,L)]\n return nested_tensor(before+mid+after)\ndef int_spin_op_construct(sigma1,sigma2,i1,i2,L):\n if i2 < i1:\n i1,i2 = i2,i1\n before1 = [sps.eye(2) for _ in range(i1)]\n mid1 = [sigma1]\n after1 = [sps.eye(2) for _ in range(i1+1,i2)]\n mid2 = [sigma2]\n after2 = [sps.eye(2) for _ in range(i2+1,L)]\n return nested_tensor(before1+mid1+after1+mid2+after2)\n\ndef H1(L, epsilon):\n sigma_x = sps.csc_matrix(np.array([[0,1],[1,0]]))\n op1 = 0\n for i in range(L):\n op1 += spin_op_construct(-sigma_x*(np.pi/2+epsilon),i,L)\n return op1\n \ndef H2(Lx, Ly, J=1):\n L = Lx*Ly\n sigma_z = sps.csc_matrix(np.array([[1,0],[0,-1]]))\n op2 = 0\n config = np.arange(L).reshape(Lx,Ly)\n for i in range(Lx):\n for j in range(Ly):\n nn = []\n if i != Lx-1:\n nn.append(config[i+1,j])\n if j != Ly-1:\n nn.append(config[i,j+1])\n op = 0\n for x in nn:\n op += int_spin_op_construct(-J*sigma_z,sigma_z,config[i,j],x,L)\n op2 += op\n return op2\n\ndef H2_pbc(Lx, Ly, J=1):\n L = Lx*Ly\n sigma_z = sps.csc_matrix(np.array([[1,0],[0,-1]]))\n op2 = 0\n config = np.arange(L).reshape(Lx,Ly)\n for i in range(Lx):\n for j in range(Ly):\n nn = []\n nn.append(config[(i+1)%(Lx-1),j])\n nn.append(config[i,(j+1)%(Ly-1)])\n op = 0\n for x in nn:\n op += int_spin_op_construct(-J*sigma_z,sigma_z,config[i,j],x,L)\n op2 += op\n return op2\n\n\ndef H2_pbc1D(L, J=1):\n sigma_z = sps.csc_matrix(np.array([[1,0],[0,-1]]))\n op2 = 0\n for i in range(L):\n op2 += int_spin_op_construct(-J*sigma_z,sigma_z,i,(i+1)%L,L)\n return op2\n\ndef H2_pbc1D_var(L, J=1):\n sigma_z = sps.csc_matrix(np.array([[1,0],[0,-1]]))\n op2 = 0\n for i in range(1,L-1):\n op2 += int_spin_op_construct(-J*sigma_z,sigma_z,i,(i+1),L)\n op2 += spin_op_construct(-J*0.5*np.eye(2), L-1, L) \n op2 += spin_op_construct(-J*0.5*np.eye(2), 0, L) \n return op2\n\nLx = 4;\nLy = Lx;\nL = Lx*Ly;\nD = 2**L\nen = []\n\nmz_config = np.zeros(D)\nfor i,state in enumerate(np.vectorize(np.binary_repr)(np.arange(2**L),L)):\n mz_config[i] = (L-2*state.count('1'))/L\n\nHdouble_1d = H2_pbc1D(L)\nHdouble_1dv = H2_pbc1D_var(L) \n\nepsilon = 0.1\n\nHsingle = H1(L,epsilon)\npsi0 = np.zeros(D)\npsi0[0] = 1\npsi1dv = [psi0]\npsi1d = [psi0]\nfor n in range(200):\n print(n,' ',end='')\n psi1dv.append(expm_multiply(-1j*Hsingle,expm_multiply(-1j*Hdouble_1dv,psi1dv[-1])))\n psi1d.append(expm_multiply(-1j*Hsingle,expm_multiply(-1j*Hdouble_1d,psi1d[-1])))\n#%%\npsi1dv = np.array(psi1dv)\npsi1d = np.array(psi1d)\n\nmag_ED = np.abs(psi1dv)**2@mz_config.reshape(D,1)\nmag_ED = mag_ED.reshape(mag_ED.size)\n\nmag_ED1d = np.abs(psi1d)**2@mz_config.reshape(D,1)\nmag_ED1d = mag_ED1d.reshape(mag_ED1d.size)\n\n\nplt.plot(np.abs(mag_ED))\nplt.plot(np.abs(mag_ED1d))\n#%%\n\nL1d = np.zeros(psi1d.shape[0])\nL2d = np.zeros(psi1d.shape[0])\nfor x in range(psi1d.shape[0]):\n if x%2 == 0: k = 0\n else: k=-1\n L1d[x] = np.abs(psi1d[x,k])**2\n L2d[x] = np.abs(psi[x,k])**2\n\n#%%\nK = (sps.eye(2**L)-1j*Hsingle)\nU = (sps.eye(2**L)-1j*Hdouble)\npsi_1 = []\npsi_1.append(psi0)\nfor n in range(100):\n print(n,' ',end='')\n psi_1.append(K.dot(U.dot(psi_1[-1])))\n psi_1[-1] /= np.linalg.norm(psi_1[-1])\npsi_1 = np.array(psi_1)\nmag_ED1 = np.abs(psi_1)**2@mz_config.reshape(D,1)\n\nplt.plot(mag_ED)\nplt.plot(mag_ED1)"
] |
[
[
"numpy.max",
"numpy.array",
"numpy.linalg.norm",
"numpy.sin",
"numpy.vectorize",
"numpy.zeros",
"scipy.sparse.linalg.expm_multiply",
"matplotlib.pyplot.plot",
"scipy.sparse.eye",
"numpy.eye",
"numpy.where",
"numpy.arange",
"numpy.abs",
"numpy.cos",
"numpy.diag",
"numpy.kron",
"scipy.sparse.kron"
]
] |
laurencejbelliott/Ensemble_DL_Ransomware_Detector
|
[
"0cae02c2425e787a810513537a47897f3a42e5b5"
] |
[
"bin-utf8-vec/truncateCorpus.py"
] |
[
"__author__ = \"Laurence Elliott - 16600748\"\n\nimport os, math\nimport numpy as np\n\n# sampleLens = []\n# count = 0\n# for file in os.listdir(\"corpus\"):\n# sample = np.load(\"corpus/\" + file)\n# zeroArr = [0]\n# try:\n# zerosInSample = np.isin(sample, zeroArr)\n# zerosIndexes = np.where(zerosInSample)\n# zerosStart = zerosIndexes[0][0]\n# sample = sample[:zerosStart]\n# sampleLen = len(sample)\n# print(count, sampleLen)\n# sampleLens.append(len(sample))\n# except:\n# sampleLen = len(sample)\n# print(count, sampleLen)\n# sampleLens.append(len(sample))\n# count += 1\n# # sample = np.concatenate((sample[0:200], sample[::-1][0:200]))\n#\n# minSampleLen = np.min(sampleLens)\n# print(minSampleLen)\n\n# Min sample length is 18 bytes D:\nmaxSequenceLen = 10000\nlenSqrt = int(math.sqrt(maxSequenceLen))\nprint(lenSqrt)\n\ncount = 0\nfor file in os.listdir(\"corpus\"):\n sample = np.load(\"corpus/\" + file)[:maxSequenceLen]\n sample = np.rint(((sample - np.min(sample)) /\n (np.max(sample) - np.min(sample))) * 255)\\\n .astype('int').reshape(lenSqrt, lenSqrt, 1)\n np.save(\"corpusTrunc/\" + file, sample)\n print(count)\n count += 1"
] |
[
[
"numpy.max",
"numpy.load",
"numpy.min",
"numpy.save"
]
] |
ALISCIFP/mmpose
|
[
"5c8ba2657b26ee9487451c45ba794823fa607cfd"
] |
[
"mmpose/datasets/datasets/top_down/topdown_coco_wholebody_dataset.py"
] |
[
"# Copyright (c) OpenMMLab. All rights reserved.\nimport os\nimport warnings\n\nimport numpy as np\nfrom mmcv import Config\nfrom xtcocotools.cocoeval import COCOeval\n\nfrom ...builder import DATASETS\nfrom .topdown_coco_dataset import TopDownCocoDataset\n\n\n@DATASETS.register_module()\nclass TopDownCocoWholeBodyDataset(TopDownCocoDataset):\n \"\"\"CocoWholeBodyDataset dataset for top-down pose estimation.\n\n \"Whole-Body Human Pose Estimation in the Wild\", ECCV'2020.\n More details can be found in the `paper\n <https://arxiv.org/abs/2007.11858>`__ .\n\n The dataset loads raw features and apply specified transforms\n to return a dict containing the image tensors and other information.\n\n COCO-WholeBody keypoint indexes::\n\n 0-16: 17 body keypoints,\n 17-22: 6 foot keypoints,\n 23-90: 68 face keypoints,\n 91-132: 42 hand keypoints\n\n In total, we have 133 keypoints for wholebody pose estimation.\n\n Args:\n ann_file (str): Path to the annotation file.\n img_prefix (str): Path to a directory where images are held.\n Default: None.\n data_cfg (dict): config\n pipeline (list[dict | callable]): A sequence of data transforms.\n dataset_info (DatasetInfo): A class containing all dataset info.\n test_mode (bool): Store True when building test or\n validation dataset. Default: False.\n \"\"\"\n\n def __init__(self,\n ann_file,\n img_prefix,\n data_cfg,\n pipeline,\n dataset_info=None,\n test_mode=False):\n\n if dataset_info is None:\n warnings.warn(\n 'dataset_info is missing. '\n 'Check https://github.com/open-mmlab/mmpose/pull/663 '\n 'for details.', DeprecationWarning)\n cfg = Config.fromfile('configs/_base_/datasets/coco_wholebody.py')\n dataset_info = cfg._cfg_dict['dataset_info']\n\n super(TopDownCocoDataset, self).__init__(\n ann_file,\n img_prefix,\n data_cfg,\n pipeline,\n dataset_info=dataset_info,\n test_mode=test_mode)\n\n self.use_gt_bbox = data_cfg['use_gt_bbox']\n self.bbox_file = data_cfg['bbox_file']\n self.det_bbox_thr = data_cfg.get('det_bbox_thr', 0.0)\n self.use_nms = data_cfg.get('use_nms', True)\n self.soft_nms = data_cfg['soft_nms']\n self.nms_thr = data_cfg['nms_thr']\n self.oks_thr = data_cfg['oks_thr']\n self.vis_thr = data_cfg['vis_thr']\n\n self.body_num = 17\n self.foot_num = 6\n self.face_num = 68\n self.left_hand_num = 21\n self.right_hand_num = 21\n\n self.db = self._get_db()\n\n print(f'=> num_images: {self.num_images}')\n print(f'=> load {len(self.db)} samples')\n\n def _load_coco_keypoint_annotation_kernel(self, img_id):\n \"\"\"load annotation from COCOAPI.\n\n Note:\n bbox:[x1, y1, w, h]\n Args:\n img_id: coco image id\n Returns:\n dict: db entry\n \"\"\"\n img_ann = self.coco.loadImgs(img_id)[0]\n width = img_ann['width']\n height = img_ann['height']\n num_joints = self.ann_info['num_joints']\n\n ann_ids = self.coco.getAnnIds(imgIds=img_id, iscrowd=False)\n objs = self.coco.loadAnns(ann_ids)\n\n # sanitize bboxes\n valid_objs = []\n for obj in objs:\n if 'bbox' not in obj:\n continue\n x, y, w, h = obj['bbox']\n x1 = max(0, x)\n y1 = max(0, y)\n x2 = min(width - 1, x1 + max(0, w - 1))\n y2 = min(height - 1, y1 + max(0, h - 1))\n if ('area' not in obj or obj['area'] > 0) and x2 > x1 and y2 > y1:\n obj['clean_bbox'] = [x1, y1, x2 - x1, y2 - y1]\n valid_objs.append(obj)\n objs = valid_objs\n\n rec = []\n bbox_id = 0\n for obj in objs:\n if 'keypoints' not in obj:\n continue\n if max(obj['keypoints']) == 0:\n continue\n joints_3d = np.zeros((num_joints, 3), dtype=np.float32)\n joints_3d_visible = np.zeros((num_joints, 3), dtype=np.float32)\n\n keypoints = np.array(obj['keypoints'] + obj['foot_kpts'] +\n obj['face_kpts'] + obj['lefthand_kpts'] +\n obj['righthand_kpts']).reshape(-1, 3)\n joints_3d[:, :2] = keypoints[:, :2]\n joints_3d_visible[:, :2] = np.minimum(1, keypoints[:, 2:3] > 0)\n\n center, scale = self._xywh2cs(*obj['clean_bbox'][:4])\n\n image_file = os.path.join(self.img_prefix, self.id2name[img_id])\n rec.append({\n 'image_file': image_file,\n 'center': center,\n 'scale': scale,\n 'rotation': 0,\n 'joints_3d': joints_3d,\n 'joints_3d_visible': joints_3d_visible,\n 'dataset': self.dataset_name,\n 'bbox_score': 1,\n 'bbox_id': bbox_id\n })\n bbox_id = bbox_id + 1\n\n return rec\n\n def _coco_keypoint_results_one_category_kernel(self, data_pack):\n \"\"\"Get coco keypoint results.\"\"\"\n cat_id = data_pack['cat_id']\n keypoints = data_pack['keypoints']\n cat_results = []\n\n for img_kpts in keypoints:\n if len(img_kpts) == 0:\n continue\n\n _key_points = np.array(\n [img_kpt['keypoints'] for img_kpt in img_kpts])\n key_points = _key_points.reshape(-1,\n self.ann_info['num_joints'] * 3)\n\n cuts = np.cumsum([\n 0, self.body_num, self.foot_num, self.face_num,\n self.left_hand_num, self.right_hand_num\n ]) * 3\n\n result = [{\n 'image_id': img_kpt['image_id'],\n 'category_id': cat_id,\n 'keypoints': key_point[cuts[0]:cuts[1]].tolist(),\n 'foot_kpts': key_point[cuts[1]:cuts[2]].tolist(),\n 'face_kpts': key_point[cuts[2]:cuts[3]].tolist(),\n 'lefthand_kpts': key_point[cuts[3]:cuts[4]].tolist(),\n 'righthand_kpts': key_point[cuts[4]:cuts[5]].tolist(),\n 'score': float(img_kpt['score']),\n 'center': img_kpt['center'].tolist(),\n 'scale': img_kpt['scale'].tolist()\n } for img_kpt, key_point in zip(img_kpts, key_points)]\n\n cat_results.extend(result)\n\n return cat_results\n\n def _do_python_keypoint_eval(self, res_file):\n \"\"\"Keypoint evaluation using COCOAPI.\"\"\"\n coco_det = self.coco.loadRes(res_file)\n\n cuts = np.cumsum([\n 0, self.body_num, self.foot_num, self.face_num, self.left_hand_num,\n self.right_hand_num\n ])\n\n coco_eval = COCOeval(\n self.coco,\n coco_det,\n 'keypoints_body',\n self.sigmas[cuts[0]:cuts[1]],\n use_area=True)\n coco_eval.params.useSegm = None\n coco_eval.evaluate()\n coco_eval.accumulate()\n coco_eval.summarize()\n\n coco_eval = COCOeval(\n self.coco,\n coco_det,\n 'keypoints_foot',\n self.sigmas[cuts[1]:cuts[2]],\n use_area=True)\n coco_eval.params.useSegm = None\n coco_eval.evaluate()\n coco_eval.accumulate()\n coco_eval.summarize()\n\n coco_eval = COCOeval(\n self.coco,\n coco_det,\n 'keypoints_face',\n self.sigmas[cuts[2]:cuts[3]],\n use_area=True)\n coco_eval.params.useSegm = None\n coco_eval.evaluate()\n coco_eval.accumulate()\n coco_eval.summarize()\n\n coco_eval = COCOeval(\n self.coco,\n coco_det,\n 'keypoints_lefthand',\n self.sigmas[cuts[3]:cuts[4]],\n use_area=True)\n coco_eval.params.useSegm = None\n coco_eval.evaluate()\n coco_eval.accumulate()\n coco_eval.summarize()\n\n coco_eval = COCOeval(\n self.coco,\n coco_det,\n 'keypoints_righthand',\n self.sigmas[cuts[4]:cuts[5]],\n use_area=True)\n coco_eval.params.useSegm = None\n coco_eval.evaluate()\n coco_eval.accumulate()\n coco_eval.summarize()\n\n coco_eval = COCOeval(\n self.coco,\n coco_det,\n 'keypoints_wholebody',\n self.sigmas,\n use_area=True)\n coco_eval.params.useSegm = None\n coco_eval.evaluate()\n coco_eval.accumulate()\n coco_eval.summarize()\n\n stats_names = [\n 'AP', 'AP .5', 'AP .75', 'AP (M)', 'AP (L)', 'AR', 'AR .5',\n 'AR .75', 'AR (M)', 'AR (L)'\n ]\n\n info_str = list(zip(stats_names, coco_eval.stats))\n\n return info_str\n"
] |
[
[
"numpy.minimum",
"numpy.array",
"numpy.zeros",
"numpy.cumsum"
]
] |
GabrielTourinho/dlnd-teach-a-quadcopter-how-to-fly
|
[
"6af874491752cf7d7caf6d9a5421fdb090b006f2"
] |
[
"home/agents/agent.py"
] |
[
"# TODO: your agent here!\n\nimport numpy as np\n\nfrom agents.actor import Actor\nfrom agents.critic import Critic\nfrom agents.buffer import ReplayBuffer\nfrom agents.ou_noise import OUNoise\n\nclass DDPG():\n \"\"\"Reinforcement Learning agent that learns using DDPG.\"\"\"\n def __init__(self, task):\n self.task = task\n self.state_size = task.state_size\n self.action_size = task.action_size\n self.action_low = task.action_low\n self.action_high = task.action_high\n\n # Actor (Policy) Model\n self.actor_local = Actor(self.state_size, self.action_size, self.action_low, self.action_high)\n self.actor_target = Actor(self.state_size, self.action_size, self.action_low, self.action_high)\n\n # Critic (Value) Model\n self.critic_local = Critic(self.state_size, self.action_size)\n self.critic_target = Critic(self.state_size, self.action_size)\n\n # Initialize target model parameters with local model parameters\n self.critic_target.model.set_weights(self.critic_local.model.get_weights())\n self.actor_target.model.set_weights(self.actor_local.model.get_weights())\n\n # Noise process\n self.exploration_mu = 0\n self.exploration_theta = 0.15\n self.exploration_sigma = 0.2\n self.noise = OUNoise(self.action_size, self.exploration_mu, self.exploration_theta, self.exploration_sigma)\n\n # Replay memory\n self.buffer_size = 100000\n self.batch_size = 64\n self.memory = ReplayBuffer(self.buffer_size, self.batch_size)\n\n # Algorithm parameters\n self.gamma = 0.99 # discount factor\n self.tau = 0.001 # for soft update of target parameters\n \n # Reward tracking\n self.reward_total = 0\n self.best_reward = -np.Inf\n self.score = 0\n self.count = 0\n\n def reset_episode_vars(self):\n self.noise.reset()\n state = self.task.reset()\n self.last_state = state\n \n # Reward tracking\n self.reward_total = 0\n self.score = 0\n self.count = 0\n self.max_z = 0\n \n return state\n\n def step(self, action, reward, next_state, done):\n # Save experience / reward\n self.memory.add(self.last_state, action, reward, next_state, done)\n \n # Track the reward: Compute the total reward for this episode\n self.reward_total += reward\n self.count += 1\n \n if done:\n self.score = self.reward_total / self.count if self.count > 0 else 0\n self.score_best = max(self.best_reward, self.reward_total)\n\n # Learn, if enough samples are available in memory\n if len(self.memory) > self.batch_size:\n experiences = self.memory.sample()\n self.learn(experiences)\n\n # Roll over last state and action\n self.last_state = next_state\n\n def act(self, state):\n \"\"\"Returns actions for given state(s) as per current policy.\"\"\"\n state = np.reshape(state, [-1, self.state_size])\n action = self.actor_local.model.predict(state)[0]\n return list(action + self.noise.sample()) # add some noise for exploration\n\n def learn(self, experiences):\n \"\"\"Update policy and value parameters using given batch of experience tuples.\"\"\"\n # Convert experience tuples to separate arrays for each element (states, actions, rewards, etc.)\n states = np.vstack([e.state for e in experiences if e is not None])\n actions = np.array([e.action for e in experiences if e is not None]).astype(np.float32).reshape(-1, self.action_size)\n rewards = np.array([e.reward for e in experiences if e is not None]).astype(np.float32).reshape(-1, 1)\n dones = np.array([e.done for e in experiences if e is not None]).astype(np.uint8).reshape(-1, 1)\n next_states = np.vstack([e.next_state for e in experiences if e is not None])\n\n # Get predicted next-state actions and Q values from target models\n # Q_targets_next = critic_target(next_state, actor_target(next_state))\n actions_next = self.actor_target.model.predict_on_batch(next_states)\n Q_targets_next = self.critic_target.model.predict_on_batch([next_states, actions_next])\n\n # Compute Q targets for current states and train critic model (local)\n Q_targets = rewards + self.gamma * Q_targets_next * (1 - dones)\n self.critic_local.model.train_on_batch(x=[states, actions], y=Q_targets)\n\n # Train actor model (local)\n action_gradients = np.reshape(self.critic_local.get_action_gradients([states, actions, 0]), (-1, self.action_size))\n self.actor_local.train_fn([states, action_gradients, 1]) # custom training function\n\n # Soft-update target models\n self.soft_update(self.critic_local.model, self.critic_target.model)\n self.soft_update(self.actor_local.model, self.actor_target.model) \n\n def soft_update(self, local_model, target_model):\n \"\"\"Soft update model parameters.\"\"\"\n local_weights = np.array(local_model.get_weights())\n target_weights = np.array(target_model.get_weights())\n\n assert len(local_weights) == len(target_weights), \"Local and target model parameters must have the same size\"\n\n new_weights = self.tau * local_weights + (1 - self.tau) * target_weights\n target_model.set_weights(new_weights)"
] |
[
[
"numpy.array",
"numpy.reshape",
"numpy.vstack"
]
] |
zhangfazhan/text_clustering
|
[
"e867887e87c41006c4828a1313d6154c448a164a"
] |
[
"Single_Pass/single_pass_cluster.py"
] |
[
"# -*- coding: UTF-8 -*-\n\nimport os\nimport sys\nimport jieba\nimport json\nimport numpy as np\nfrom sklearn.feature_extraction.text import TfidfVectorizer\nfrom sklearn.metrics.pairwise import cosine_similarity\n\nclass SinglePassCluster():\n def __init__(self, stopWords_path=\"../data/stop_words.txt\", my_stopwords=None,\n max_df=0.5, max_features=1000,\n simi_threshold=0.5, res_save_path=\"./cluster_res.json\"):\n self.stopwords = self.load_stopwords(stopWords_path)\n if isinstance(my_stopwords, list):\n self.stopwords += my_stopwords\n self.tfidf = TfidfVectorizer(stop_words=self.stopwords, max_df=max_df, max_features=max_features)\n self.simi_thr = simi_threshold\n self.cluster_center_vec = [] # [cluster_center_vec, ]\n self.idx_2_text = {} # {文本id: text, }\n self.cluster_2_idx = {} # {cluster_id: [text_id, ]}\n self.res_path = res_save_path # save self.cluster_2_idx\n\n def load_stopwords(self, path):\n stopwords = []\n with open(path, 'r', encoding=\"utf-8\") as f:\n for line in f:\n stopwords.append(line.strip())\n return stopwords\n\n def cut_sentences(self, texts):\n if isinstance(texts, str):\n if not os.path.exists(texts):\n print(\"path: {} is not exist !!!\".format(texts))\n sys.exit()\n else:\n _texts = []\n with open(texts, 'r', encoding=\"utf-8\") as f:\n for line in f:\n _texts.append(line.strip())\n texts = _texts\n texts_cut = [\" \".join(jieba.lcut(t)) for t in texts]\n self.idx_2_text = {idx: text for idx, text in enumerate(texts)}\n return texts_cut\n\n\n def get_tfidf(self, texts_cut):\n tfidf = self.tfidf.fit_transform(texts_cut)\n return tfidf.todense().tolist()\n\n def cosion_simi(self, vec):\n simi = cosine_similarity(np.array([vec]), np.array(self.cluster_center_vec))\n max_idx = np.argmax(simi, arixs=1)[0]\n max_val = simi[0][max_idx]\n return max_val, max_idx\n\n def single_pass(self, texts):\n texts_cut = self.cut_sentences(texts)\n tfidf = self.get_tfidf(texts_cut)\n # print(len(tfidf), len(tfidf[0]))\n\n # 开始遍历\n for idx, vec in enumerate(tfidf):\n # 初始化，没有中心生成\n if not self.cluster_center_vec:\n self.cluster_center_vec.append(vec)\n self.cluster_2_idx[0] = [idx]\n # 存在簇\n else:\n max_simi, max_idx = self.cosion_simi(vec)\n if max_simi >= self.simi_thr:\n self.cluster_2_idx[max_idx].append(idx)\n else:\n self.cluster_center_vec.append(vec)\n self.cluster_2_idx[len(self.cluster_2_idx)] = [idx]\n\n with open(self.res_path, \"w\", encoding=\"utf-8\") as f:\n json.dump(self.cluster_2_idx, f, ensure_ascii=False)\n\n\n\nif __name__ == \"__main__\":\n test_data = \"../data/test_data.txt\"\n cluster = SinglePassCluster(max_features=100, simi_threshold=0.1)\n cluster.single_pass(test_data)\n\n\n\n\n\n"
] |
[
[
"numpy.array",
"numpy.argmax",
"sklearn.feature_extraction.text.TfidfVectorizer"
]
] |
yellowdolphin/SIIM-COVID19-Detection
|
[
"31e8653b467ac35a8b1d92330ad5f15a12622676"
] |
[
"src/detection_efffdet/predict_test.py"
] |
[
"import argparse\nimport pandas as pd\nfrom tqdm import tqdm\nimport torch\nimport torch.nn.parallel\nfrom contextlib import suppress\nimport os\n\nfrom effdet import create_model, create_loader\nfrom effdet.data import resolve_input_config\nfrom timm.utils import setup_default_logging\nfrom timm.models.layers import set_layer_config\n\nfrom dataset import SiimCovidDataset\nfrom utils import seed_everything, refine_det\n\nhas_apex = False\ntry:\n from apex import amp\n has_apex = True\nexcept ImportError:\n pass\n\nhas_native_amp = False\ntry:\n if getattr(torch.cuda.amp, 'autocast') is not None:\n has_native_amp = True\nexcept AttributeError:\n pass\n\ntorch.backends.cudnn.benchmark = True\n\ndef add_bool_arg(parser, name, default=False, help=''): # FIXME move to utils\n dest_name = name.replace('-', '_')\n group = parser.add_mutually_exclusive_group(required=False)\n group.add_argument('--' + name, dest=dest_name, action='store_true', help=help)\n group.add_argument('--no-' + name, dest=dest_name, action='store_false', help=help)\n parser.set_defaults(**{dest_name: default})\n\nparser = argparse.ArgumentParser(description='PyTorch ImageNet Validation')\nparser.add_argument(\"--folds\", default=[0,1,2,3,4], nargs=\"+\", type=int)\nparser.add_argument(\"--frac\", default=1.0, type=float)\nparser.add_argument('--image-size', type=int, default=None)\nparser.add_argument('--model', '-m', metavar='MODEL', default='tf_efficientdet_d7',\n help='model architecture (default: tf_efficientdet_d7)')\nadd_bool_arg(parser, 'redundant-bias', default=None,\n help='override model config for redundant bias layers')\nadd_bool_arg(parser, 'soft-nms', default=None, help='override model config for soft-nms')\nparser.add_argument('--num-classes', type=int, default=None, metavar='N',\n help='Override num_classes in model config if set. For fine-tuning from pretrained.')\nparser.add_argument('-j', '--workers', default=4, type=int, metavar='N',\n help='number of data loading workers (default: 4)')\nparser.add_argument('-b', '--batch-size', default=128, type=int,\n metavar='N', help='mini-batch size (default: 128)')\nparser.add_argument('--mean', type=float, nargs='+', default=None, metavar='MEAN',\n help='Override mean pixel value of dataset')\nparser.add_argument('--std', type=float, nargs='+', default=None, metavar='STD',\n help='Override std deviation of of dataset')\nparser.add_argument('--interpolation', default='bilinear', type=str, metavar='NAME',\n help='Image resize interpolation type (overrides model)')\nparser.add_argument('--fill-color', default=None, type=str, metavar='NAME',\n help='Image augmentation fill (background) color (\"mean\" or int)')\nparser.add_argument('--pretrained', dest='pretrained', action='store_true',\n help='use pre-trained model')\nparser.add_argument('--no-prefetcher', action='store_true', default=False,\n help='disable fast prefetcher')\nparser.add_argument('--pin-mem', action='store_true', default=False,\n help='Pin CPU memory in DataLoader for more efficient (sometimes) transfer to GPU.')\nparser.add_argument('--use-ema', dest='use_ema', action='store_true',\n help='use ema version of weights if present')\nparser.add_argument('--amp', action='store_true', default=False,\n help='Use AMP mixed precision. Defaults to Apex, fallback to native Torch AMP.')\nparser.add_argument('--apex-amp', action='store_true', default=False,\n help='Use NVIDIA Apex AMP mixed precision')\nparser.add_argument('--native-amp', action='store_true', default=False,\n help='Use Native Torch AMP mixed precision')\nparser.add_argument('--torchscript', dest='torchscript', action='store_true',\n help='convert model torchscript for inference')\nargs = parser.parse_args()\n\nSEED = 123\nseed_everything(SEED)\n\nif __name__ == \"__main__\":\n os.makedirs('predictions', exist_ok = True)\n\n setup_default_logging()\n\n if args.amp:\n if has_apex:\n args.apex_amp = True\n elif has_native_amp:\n args.native_amp = True\n assert not args.apex_amp or not args.native_amp, \"Only one AMP mode should be set.\"\n args.prefetcher = not args.no_prefetcher\n\n test_df = pd.read_csv('../../dataset/siim-covid19-detection/test_meta.csv')\n if args.frac != 1:\n test_df = test_df.sample(frac=args.frac).reset_index(drop=True)\n\n models = {}\n for fold in args.folds:\n print('*'*20, 'Fold {}'.format(fold), '*'*20)\n CHECKPOINT = 'checkpoints/{}_{}_fold{}/model_best.pth.tar'.format(args.model, args.image_size, fold)\n\n # create model\n with set_layer_config(scriptable=args.torchscript):\n extra_args = {}\n bench = create_model(\n args.model,\n bench_task='predict',\n image_size=args.image_size,\n num_classes=args.num_classes,\n pretrained=args.pretrained,\n redundant_bias=args.redundant_bias,\n soft_nms=args.soft_nms,\n checkpoint_path=CHECKPOINT,\n checkpoint_ema=args.use_ema,\n **extra_args,\n )\n model_config = bench.config\n\n param_count = sum([m.numel() for m in bench.parameters()])\n print('Model %s created, param count: %d' % (args.model, param_count))\n\n bench = bench.cuda()\n\n amp_autocast = suppress\n if args.apex_amp:\n bench = amp.initialize(bench, opt_level='O1')\n print('Using NVIDIA APEX AMP. Validating in mixed precision.')\n elif args.native_amp:\n amp_autocast = torch.cuda.amp.autocast\n print('Using native Torch AMP. Validating in mixed precision.')\n else:\n print('AMP not enabled. Validating in float32.')\n input_config = resolve_input_config(args, model_config)\n bench.eval()\n\n models[fold] = bench\n\n dataset = SiimCovidDataset(df=test_df, images_dir='../../dataset/siim-covid19-detection/images/test', image_size=args.image_size)\n \n loader = create_loader(\n dataset,\n input_size=input_config['input_size'],\n batch_size=args.batch_size,\n use_prefetcher=args.prefetcher,\n interpolation=input_config['interpolation'],\n fill_color=input_config['fill_color'],\n mean=input_config['mean'],\n std=input_config['std'],\n num_workers=args.workers,\n pin_mem=args.pin_mem)\n\n predict_dict = {}\n for input, target in tqdm(loader):\n image_idxs = target['img_idx'].data.cpu().numpy().tolist()\n image_sizes = target['img_size'].data.cpu().numpy().tolist()\n\n with amp_autocast(), torch.no_grad():\n for fold in args.folds:\n dets = models[fold](input, img_info=target).data.cpu().numpy()\n flip_dets = models[fold](torch.flip(input, dims=(3,)).contiguous(), img_info=target).data.cpu().numpy()\n for idx, det_pred, flip_det_pred, img_size in zip(image_idxs, dets, flip_dets, image_sizes):\n imageid = test_df.loc[idx, 'imageid']\n if imageid not in list(predict_dict.keys()):\n predict_dict[imageid] = [[],[],[], img_size[0], img_size[1]]\n \n box_pred = det_pred[:,:4].astype(float)\n box_pred[:,[0,2]] = box_pred[:,[0,2]]/float(img_size[0])\n box_pred[:,[1,3]] = box_pred[:,[1,3]]/float(img_size[1])\n score_pred = det_pred[:,4]\n label_pred = det_pred[:,5].astype(int) - 1\n box_pred, label_pred, score_pred = refine_det(box_pred, label_pred, score_pred)\n\n flip_box_pred = flip_det_pred[:,:4].astype(float)\n flip_box_pred[:,[0,2]] = flip_box_pred[:,[0,2]]/float(img_size[0])\n flip_box_pred[:,[1,3]] = flip_box_pred[:,[1,3]]/float(img_size[1])\n flip_box_pred[:,[0,2]] = 1 - flip_box_pred[:,[0,2]]\n flip_score_pred = flip_det_pred[:,4]\n flip_label_pred = flip_det_pred[:,5].astype(int) - 1\n flip_box_pred, flip_label_pred, flip_score_pred = refine_det(flip_box_pred, flip_label_pred, flip_score_pred)\n\n predict_dict[imageid][0] += [box_pred, flip_box_pred]\n predict_dict[imageid][1] += [score_pred, flip_score_pred]\n predict_dict[imageid][2] += [label_pred, flip_label_pred]\n \n pred_dict_path = 'predictions/{}_{}_fold{}_test_pred.pth'.format(args.model, args.image_size, '_'.join(str(x) for x in args.folds))\n torch.save(predict_dict, pred_dict_path)\n"
] |
[
[
"pandas.read_csv",
"torch.flip",
"torch.save",
"torch.no_grad"
]
] |
levindabhi/SieveNet
|
[
"a5e2263acf28b52a551d4e139328957cf454e7e8"
] |
[
"gmm.py"
] |
[
"import torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom torch.nn import init\nfrom torchvision import models\n\nimport numpy as np\n\n\ndevice = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n\n\ndef weights_init_normal(m):\n classname = m.__class__.__name__\n if classname.find('Conv') != -1:\n init.normal_(m.weight.data, 0.0, 0.02)\n elif classname.find('Linear') != -1:\n init.normal(m.weight.data, 0.0, 0.02)\n elif classname.find('BatchNorm2d') != -1:\n init.normal_(m.weight.data, 1.0, 0.02)\n init.constant_(m.bias.data, 0.0)\n\n\ndef weights_init_xavier(m):\n classname = m.__class__.__name__\n if classname.find('Conv') != -1:\n init.xavier_normal_(m.weight.data, gain=0.02)\n elif classname.find('Linear') != -1:\n init.xavier_normal_(m.weight.data, gain=0.02)\n elif classname.find('BatchNorm2d') != -1:\n init.normal_(m.weight.data, 1.0, 0.02)\n init.constant_(m.bias.data, 0.0)\n\n\ndef weights_init_kaiming(m):\n classname = m.__class__.__name__\n if classname.find('Conv') != -1:\n init.kaiming_normal_(m.weight.data, a=0, mode='fan_in')\n elif classname.find('Linear') != -1:\n init.kaiming_normal_(m.weight.data, a=0, mode='fan_in')\n elif classname.find('BatchNorm2d') != -1:\n init.normal_(m.weight.data, 1.0, 0.02)\n init.constant_(m.bias.data, 0.0)\n\n\ndef init_weights(net, init_type='normal'):\n print('initialization method [%s]' % init_type)\n if init_type == 'normal':\n net.apply(weights_init_normal)\n elif init_type == 'xavier':\n net.apply(weights_init_xavier)\n elif init_type == 'kaiming':\n net.apply(weights_init_kaiming)\n else:\n raise NotImplementedError('initialization method [%s] is not implemented' % init_type)\n\n \n \nclass FeatureExtraction(nn.Module):\n def __init__(self, input_nc, ngf=64, n_layers=3, norm_layer=nn.BatchNorm2d, use_dropout=False):\n super(FeatureExtraction, self).__init__()\n downconv = nn.Conv2d(input_nc, ngf, kernel_size=4, stride=2, padding=1)\n model = [downconv, nn.ReLU(True), norm_layer(ngf)]\n for i in range(n_layers):\n in_ngf = 2**i * ngf if 2**i * ngf < 512 else 512\n out_ngf = 2**(i+1) * ngf if 2**i * ngf < 512 else 512\n downconv = nn.Conv2d(in_ngf, out_ngf, kernel_size=4, stride=2, padding=1)\n model += [downconv, nn.ReLU(True)]\n model += [norm_layer(out_ngf)]\n model += [nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1), nn.ReLU(True)]\n model += [norm_layer(512)]\n model += [nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1), nn.ReLU(True)]\n \n self.model = nn.Sequential(*model)\n init_weights(self.model, init_type='normal')\n\n def forward(self, x):\n return self.model(x)\n \n \n \nclass FeatureL2Norm(torch.nn.Module):\n def __init__(self):\n super(FeatureL2Norm, self).__init__()\n\n def forward(self, feature):\n epsilon = 1e-6\n norm = torch.pow(torch.sum(torch.pow(feature,2),1)+epsilon,0.5).unsqueeze(1).expand_as(feature)\n return torch.div(feature,norm)\n \n \n \nclass FeatureCorrelation(nn.Module):\n def __init__(self):\n super(FeatureCorrelation, self).__init__()\n \n def forward(self, feature_A, feature_B):\n b,c,h,w = feature_A.size()\n # reshape features for matrix multiplication\n feature_A = feature_A.transpose(2,3).contiguous().view(b,c,h*w)\n feature_B = feature_B.view(b,c,h*w).transpose(1,2)\n # perform matrix mult.\n feature_mul = torch.bmm(feature_B,feature_A)\n correlation_tensor = feature_mul.view(b,h,w,h*w).transpose(2,3).transpose(1,2)\n return correlation_tensor\n \n \n \nclass FeatureRegression(nn.Module):\n def __init__(self, input_nc=512,output_dim=6):\n super(FeatureRegression, self).__init__()\n self.conv = nn.Sequential(\n nn.Conv2d(input_nc, 512, kernel_size=4, stride=2, padding=1),\n nn.BatchNorm2d(512),\n nn.ReLU(inplace=True),\n nn.Conv2d(512, 256, kernel_size=4, stride=2, padding=1),\n nn.BatchNorm2d(256),\n nn.ReLU(inplace=True),\n nn.Conv2d(256, 128, kernel_size=3, padding=1),\n nn.BatchNorm2d(128),\n nn.ReLU(inplace=True),\n nn.Conv2d(128, 64, kernel_size=3, padding=1),\n nn.BatchNorm2d(64),\n nn.ReLU(inplace=True),\n )\n self.linear = nn.Linear(64 * 4 * 3, output_dim)\n self.tanh = nn.Tanh()\n '''self.conv.to(device)\n self.linear.to(device)\n self.tanh.to(device)'''\n\n def forward(self, x):\n x = self.conv(x)\n x = x.reshape(x.size(0), -1)\n x = self.linear(x)\n x = self.tanh(x)\n return x\n \n \n \nclass TpsGridGen(nn.Module):\n def __init__(self, out_h=256, out_w=192, use_regular_grid=True, grid_size=3, reg_factor=0):\n super(TpsGridGen, self).__init__()\n self.out_h, self.out_w = out_h, out_w\n self.reg_factor = reg_factor\n\n # create grid in numpy\n self.grid = np.zeros( [self.out_h, self.out_w, 3], dtype=np.float32)\n # sampling grid with dim-0 coords (Y)\n self.grid_X,self.grid_Y = np.meshgrid(np.linspace(-1,1,out_w),np.linspace(-1,1,out_h))\n # grid_X,grid_Y: size [1,H,W,1,1]\n self.grid_X = torch.FloatTensor(self.grid_X).unsqueeze(0).unsqueeze(3)\n self.grid_Y = torch.FloatTensor(self.grid_Y).unsqueeze(0).unsqueeze(3)\n \n self.grid_X = self.grid_X.to(device)\n self.grid_Y = self.grid_Y.to(device)\n\n # initialize regular grid for control points P_i\n if use_regular_grid:\n axis_coords = np.linspace(-1,1,grid_size)\n self.N = grid_size*grid_size\n P_Y,P_X = np.meshgrid(axis_coords,axis_coords)\n P_X = np.reshape(P_X,(-1,1)) # size (N,1)\n P_Y = np.reshape(P_Y,(-1,1)) # size (N,1)\n P_X = torch.FloatTensor(P_X)\n P_X = P_X.to(device)\n P_Y = torch.FloatTensor(P_Y)\n P_Y = P_Y.to(device)\n self.P_X_base = P_X.clone()\n self.P_X_base = self.P_X_base.to(device)\n self.P_Y_base = P_Y.clone()\n self.P_Y_base = self.P_Y_base.to(device)\n self.Li = self.compute_L_inverse(P_X,P_Y).unsqueeze(0)\n self.P_X = P_X.unsqueeze(2).unsqueeze(3).unsqueeze(4).transpose(0,4)\n self.P_Y = P_Y.unsqueeze(2).unsqueeze(3).unsqueeze(4).transpose(0,4)\n \n\n \n def forward(self, theta):\n warped_grid = self.apply_transformation(theta,torch.cat((self.grid_X,self.grid_Y),3))\n \n return warped_grid\n \n def compute_L_inverse(self,X,Y):\n N = X.size()[0] # num of points (along dim 0)\n # construct matrix K\n Xmat = X.expand(N,N)\n Ymat = Y.expand(N,N)\n P_dist_squared = torch.pow(Xmat-Xmat.transpose(0,1),2)+torch.pow(Ymat-Ymat.transpose(0,1),2)\n P_dist_squared[P_dist_squared==0]=1 # make diagonal 1 to avoid NaN in log computation\n K = torch.mul(P_dist_squared,torch.log(P_dist_squared))\n # construct matrix L\n O = torch.FloatTensor(N,1).fill_(1)\n O = O.to(device)\n Z = torch.FloatTensor(3,3).fill_(0)\n Z = Z.to(device)\n P = torch.cat((O,X,Y),1)\n L = torch.cat((torch.cat((K,P),1),torch.cat((P.transpose(0,1),Z),1)),0)\n Li = torch.inverse(L)\n Li = Li.to(device)\n return Li\n \n def apply_transformation(self,theta,points):\n if theta.dim()==2:\n theta = theta.unsqueeze(2).unsqueeze(3)\n # points should be in the [B,H,W,2] format,\n # where points[:,:,:,0] are the X coords \n # and points[:,:,:,1] are the Y coords \n \n # input are the corresponding control points P_i\n batch_size = theta.size()[0]\n # split theta into point coordinates\n Q_X=theta[:,:self.N,:,:].squeeze(3)\n Q_Y=theta[:,self.N:,:,:].squeeze(3)\n Q_X = Q_X + self.P_X_base.expand_as(Q_X)\n Q_Y = Q_Y + self.P_Y_base.expand_as(Q_Y)\n \n # get spatial dimensions of points\n points_b = points.size()[0]\n points_h = points.size()[1]\n points_w = points.size()[2]\n \n # repeat pre-defined control points along spatial dimensions of points to be transformed\n P_X = self.P_X.expand((1,points_h,points_w,1,self.N))\n P_Y = self.P_Y.expand((1,points_h,points_w,1,self.N))\n \n # compute weigths for non-linear part\n W_X = torch.bmm(self.Li[:,:self.N,:self.N].expand((batch_size,self.N,self.N)),Q_X)\n W_Y = torch.bmm(self.Li[:,:self.N,:self.N].expand((batch_size,self.N,self.N)),Q_Y)\n # reshape\n # W_X,W,Y: size [B,H,W,1,N]\n W_X = W_X.unsqueeze(3).unsqueeze(4).transpose(1,4).repeat(1,points_h,points_w,1,1)\n W_Y = W_Y.unsqueeze(3).unsqueeze(4).transpose(1,4).repeat(1,points_h,points_w,1,1)\n # compute weights for affine part\n A_X = torch.bmm(self.Li[:,self.N:,:self.N].expand((batch_size,3,self.N)),Q_X)\n A_Y = torch.bmm(self.Li[:,self.N:,:self.N].expand((batch_size,3,self.N)),Q_Y)\n # reshape\n # A_X,A,Y: size [B,H,W,1,3]\n A_X = A_X.unsqueeze(3).unsqueeze(4).transpose(1,4).repeat(1,points_h,points_w,1,1)\n A_Y = A_Y.unsqueeze(3).unsqueeze(4).transpose(1,4).repeat(1,points_h,points_w,1,1)\n \n # compute distance P_i - (grid_X,grid_Y)\n # grid is expanded in point dim 4, but not in batch dim 0, as points P_X,P_Y are fixed for all batch\n points_X_for_summation = points[:,:,:,0].unsqueeze(3).unsqueeze(4).expand(points[:,:,:,0].size()+(1,self.N))\n points_Y_for_summation = points[:,:,:,1].unsqueeze(3).unsqueeze(4).expand(points[:,:,:,1].size()+(1,self.N))\n \n if points_b==1:\n delta_X = points_X_for_summation-P_X\n delta_Y = points_Y_for_summation-P_Y\n else:\n # use expanded P_X,P_Y in batch dimension\n delta_X = points_X_for_summation-P_X.expand_as(points_X_for_summation)\n delta_Y = points_Y_for_summation-P_Y.expand_as(points_Y_for_summation)\n \n dist_squared = torch.pow(delta_X,2)+torch.pow(delta_Y,2)\n # U: size [1,H,W,1,N]\n dist_squared[dist_squared==0]=1 # avoid NaN in log computation\n U = torch.mul(dist_squared,torch.log(dist_squared)) \n \n # expand grid in batch dimension if necessary\n points_X_batch = points[:,:,:,0].unsqueeze(3)\n points_Y_batch = points[:,:,:,1].unsqueeze(3)\n if points_b==1:\n points_X_batch = points_X_batch.expand((batch_size,)+points_X_batch.size()[1:])\n points_Y_batch = points_Y_batch.expand((batch_size,)+points_Y_batch.size()[1:])\n \n points_X_prime = A_X[:,:,:,:,0]+ \\\n torch.mul(A_X[:,:,:,:,1],points_X_batch) + \\\n torch.mul(A_X[:,:,:,:,2],points_Y_batch) + \\\n torch.sum(torch.mul(W_X,U.expand_as(W_X)),4)\n \n points_Y_prime = A_Y[:,:,:,:,0]+ \\\n torch.mul(A_Y[:,:,:,:,1],points_X_batch) + \\\n torch.mul(A_Y[:,:,:,:,2],points_Y_batch) + \\\n torch.sum(torch.mul(W_Y,U.expand_as(W_Y)),4)\n \n return torch.cat((points_X_prime,points_Y_prime),3)\n \n \n \nclass GMM(nn.Module):\n '''Geometric matching module\n '''\n \n def __init__(self, opt):\n super(GMM, self).__init__()\n self.extraction_agnostic = FeatureExtraction(22, ngf=64, n_layers=3, norm_layer=nn.BatchNorm2d)#.to(device)\n self.extraction_cloth = FeatureExtraction(3, ngf=64, n_layers=3, norm_layer=nn.BatchNorm2d)#.to(device)\n self.l2norm = FeatureL2Norm()#.to(device)\n self.correlation = FeatureCorrelation()#.to(device)\n self.regression_zero = FeatureRegression(input_nc=192, output_dim=2*opt.grid_size**2)#.to(device)\n self.gridGen = TpsGridGen(opt.fine_height, opt.fine_width, grid_size=opt.grid_size)#.to(device)\n self.extraction_warped_cloth = FeatureExtraction(3, ngf=64, n_layers=3, norm_layer=nn.BatchNorm2d)#.to(device)\n self.regression_one = FeatureRegression(input_nc=192, output_dim=2*opt.grid_size**2)#.to(device)\n \n \n def forward(self, agn, clt):\n feature_agn = self.extraction_agnostic(agn)\n feature_clt = self.extraction_cloth(clt)\n feature_agn = self.l2norm(feature_agn)\n feature_clt = self.l2norm(feature_clt)\n \n coorelation_0 = self.correlation(feature_agn, feature_clt)\n theta = self.regression_zero(coorelation_0)\n grid_zero = self.gridGen(theta)\n \n warped_coarse_cloth = F.grid_sample(clt, grid_zero, padding_mode='border')\n feature_wc = self.extraction_warped_cloth(warped_coarse_cloth)\n feature_wc = self.l2norm(feature_wc)\n \n coorelation_1 = self.correlation(feature_agn, feature_wc)\n delta_theta = self.regression_one(coorelation_1)\n #here in original paper there is not much details of theta + delta theta\n #so I have done element-wise addition\n grid_one = self.gridGen(theta.add(delta_theta))\n \n return grid_zero, theta, grid_one, delta_theta\n "
] |
[
[
"torch.nn.Linear",
"torch.cat",
"torch.nn.BatchNorm2d",
"torch.nn.init.kaiming_normal_",
"torch.inverse",
"torch.bmm",
"torch.cuda.is_available",
"torch.mul",
"torch.nn.init.constant_",
"torch.FloatTensor",
"torch.nn.init.normal_",
"torch.div",
"torch.nn.init.xavier_normal_",
"numpy.reshape",
"numpy.zeros",
"torch.nn.Sequential",
"torch.nn.Tanh",
"torch.nn.ReLU",
"torch.nn.Conv2d",
"torch.nn.init.normal",
"torch.log",
"torch.pow",
"torch.nn.functional.grid_sample",
"numpy.linspace",
"numpy.meshgrid"
]
] |
araffin/aae-train-donkeycar
|
[
"0fb11c558271be53f1b0b9d5c85625a933367faf"
] |
[
"ae/enjoy_latent.py"
] |
[
"# Original code from https://github.com/araffin/robotics-rl-srl\n# Authors: Antonin Raffin, René Traoré, Ashley Hill\nimport argparse\n\nimport cv2 # pytype: disable=import-error\nimport numpy as np\n\nfrom ae.autoencoder import Autoencoder\n\n\ndef create_figure_and_sliders(name, state_dim):\n \"\"\"\n Creating a window for the latent space visualization,\n and another one for the sliders to control it.\n\n :param name: name of model (str)\n :param state_dim: (int)\n :return:\n \"\"\"\n # opencv gui setup\n cv2.namedWindow(name, cv2.WINDOW_NORMAL)\n cv2.resizeWindow(name, 500, 500)\n cv2.namedWindow(\"slider for \" + name)\n # add a slider for each component of the latent space\n for i in range(state_dim):\n # the sliders MUST be between 0 and max, so we placed max at 100, and start at 50\n # So that when we substract 50 and divide 10 we get [-5,5] for each component\n cv2.createTrackbar(str(i), \"slider for \" + name, 50, 100, (lambda a: None))\n\n\ndef main():\n parser = argparse.ArgumentParser(description=\"latent space enjoy\")\n parser.add_argument(\"--log-dir\", default=\"\", type=str, help=\"directory to load model\")\n parser.add_argument(\"-ae\", \"--ae-path\", help=\"Path to saved AE\", type=str, default=\"\")\n\n args = parser.parse_args()\n\n autoencoder = Autoencoder.load(args.ae_path)\n\n fig_name = \"Decoder for the AE\"\n\n # TODO: load data to infer bounds\n bound_min = -10\n bound_max = 10\n\n create_figure_and_sliders(fig_name, autoencoder.z_size)\n\n should_exit = False\n while not should_exit:\n # stop if escape is pressed\n k = cv2.waitKey(1) & 0xFF\n if k == 27:\n break\n\n state = []\n for i in range(autoencoder.z_size):\n state.append(cv2.getTrackbarPos(str(i), \"slider for \" + fig_name))\n # Rescale the values to fit the bounds of the representation\n state = (np.array(state) / 100) * (bound_max - bound_min) + bound_min\n\n reconstructed_image = autoencoder.decode(state[None])[0]\n\n # stop if user closed a window\n if (cv2.getWindowProperty(fig_name, 0) < 0) or (cv2.getWindowProperty(\"slider for \" + fig_name, 0) < 0):\n should_exit = True\n break\n cv2.imshow(fig_name, reconstructed_image)\n\n # gracefully close\n cv2.destroyAllWindows()\n\n\nif __name__ == \"__main__\":\n main()\n"
] |
[
[
"numpy.array"
]
] |
izaid/vispy
|
[
"402cf95bfef88d70c9c45bb27c532ed72944e14a"
] |
[
"vispy/util/tests/test_transforms.py"
] |
[
"# -*- coding: utf-8 -*-\n# Copyright (c) 2014, Vispy Development Team.\n# Distributed under the (new) BSD License. See LICENSE.txt for more info.\nimport numpy as np\nfrom numpy.testing import assert_allclose\n\nfrom vispy.util.transforms import (translate, scale, rotate, ortho, frustum,\n perspective)\nfrom vispy.testing import run_tests_if_main, assert_equal\n\n\ndef test_transforms():\n \"\"\"Test basic transforms\"\"\"\n xfm = np.random.randn(4, 4).astype(np.float32)\n\n # Do a series of rotations that should end up into the same orientation\n # again, to ensure the order of computation is all correct\n # i.e. if rotated would return the transposed matrix this would not work\n # out (the translation part would be incorrect)\n new_xfm = xfm.dot(rotate(180, (1, 0, 0)).dot(rotate(-90, (0, 1, 0))))\n new_xfm = new_xfm.dot(rotate(90, (0, 0, 1)).dot(rotate(90, (0, 1, 0))))\n new_xfm = new_xfm.dot(rotate(90, (1, 0, 0)))\n assert_allclose(xfm, new_xfm)\n\n new_xfm = translate((1, -1, 1)).dot(translate((-1, 1, -1))).dot(xfm)\n assert_allclose(xfm, new_xfm)\n\n new_xfm = scale((1, 2, 3)).dot(scale((1, 1. / 2., 1. / 3.))).dot(xfm)\n assert_allclose(xfm, new_xfm)\n\n # These could be more complex...\n xfm = ortho(-1, 1, -1, 1, -1, 1)\n assert_equal(xfm.shape, (4, 4))\n\n xfm = frustum(-1, 1, -1, 1, -1, 1)\n assert_equal(xfm.shape, (4, 4))\n\n xfm = perspective(1, 1, -1, 1)\n assert_equal(xfm.shape, (4, 4))\n\n\nrun_tests_if_main()\n"
] |
[
[
"numpy.testing.assert_allclose",
"numpy.random.randn"
]
] |
Faizullah877/compression
|
[
"82111a7ec61c3478f38c152ae7ec3fa61b21a530"
] |
[
"models/hific/archs.py"
] |
[
"# Copyright 2020 Google LLC. 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\"\"\"Implement the components needed for HiFiC.\n\nFor more details, see the paper: https://arxiv.org/abs/2006.09965\n\nThe default values for all constructors reflect what was used in the paper.\n\"\"\"\n\nimport collections\nfrom compare_gan.architectures import abstract_arch\nfrom compare_gan.architectures import arch_ops\nimport numpy as np\nimport tensorflow.compat.v1 as tf\n\nimport tensorflow_compression as tfc\n\nfrom hific.helpers import ModelMode\n\nSCALES_MIN = 0.11\nSCALES_MAX = 256\nSCALES_LEVELS = 64\n\n\n# Output of discriminator, where real and fake are merged into single tensors.\nDiscOutAll = collections.namedtuple(\n \"DiscOutAll\",\n [\"d_all\", \"d_all_logits\"])\n\n\n# Split each tensor in a DiscOutAll into 2.\nDiscOutSplit = collections.namedtuple(\n \"DiscOutSplit\",\n [\"d_real\", \"d_fake\",\n \"d_real_logits\", \"d_fake_logits\"])\n\n\nEntropyInfo = collections.namedtuple(\n \"EntropyInfo\",\n \"noisy quantized nbits nbpp qbits qbpp\",\n)\n\nFactorizedPriorInfo = collections.namedtuple(\n \"FactorizedPriorInfo\",\n \"decoded latent_shape total_nbpp total_qbpp bitstring\",\n)\n\nHyperInfo = collections.namedtuple(\n \"HyperInfo\",\n \"decoded latent_shape hyper_latent_shape \"\n \"nbpp side_nbpp total_nbpp qbpp side_qbpp total_qbpp \"\n \"bitstream_tensors\",\n)\n\n\nclass Encoder(tf.keras.Sequential):\n \"\"\"Encoder architecture.\"\"\"\n\n def __init__(self,\n name=\"Encoder\",\n num_down=4,\n num_filters_base=60,\n num_filters_bottleneck=220):\n \"\"\"Instantiate model.\n\n Args:\n name: Name of the layer.\n num_down: How many downsampling layers to use.\n num_filters_base: Num filters to base multiplier on.\n num_filters_bottleneck: Num filters to output for bottleneck (latent).\n \"\"\"\n self._num_down = num_down\n\n model = [\n tf.keras.layers.Conv2D(\n filters=num_filters_base, kernel_size=7, padding=\"same\"),\n ChannelNorm(),\n tf.keras.layers.ReLU()\n ]\n\n for i in range(num_down):\n model.extend([\n tf.keras.layers.Conv2D(\n filters=num_filters_base * 2 ** (i + 1),\n kernel_size=3, padding=\"same\", strides=2),\n ChannelNorm(),\n tf.keras.layers.ReLU()])\n\n model.append(\n tf.keras.layers.Conv2D(\n filters=num_filters_bottleneck,\n kernel_size=3, padding=\"same\"))\n\n super(Encoder, self).__init__(layers=model, name=name)\n\n @property\n def num_downsampling_layers(self):\n return self._num_down\n\n\nclass Decoder(tf.keras.layers.Layer):\n \"\"\"Decoder/generator architecture.\"\"\"\n\n def __init__(self,\n name=\"Decoder\",\n num_up=4,\n num_filters_base=60,\n num_residual_blocks=9,\n ):\n \"\"\"Instantiate layer.\n\n Args:\n name: name of the layer.\n num_up: how many upsampling layers.\n num_filters_base: base number of filters.\n num_residual_blocks: number of residual blocks.\n \"\"\"\n head = [ChannelNorm(),\n tf.keras.layers.Conv2D(\n filters=num_filters_base * (2 ** num_up),\n kernel_size=3, padding=\"same\"),\n ChannelNorm()]\n\n residual_blocks = []\n for block_idx in range(num_residual_blocks):\n residual_blocks.append(\n ResidualBlock(\n filters=num_filters_base * (2 ** num_up),\n kernel_size=3,\n name=\"block_{}\".format(block_idx),\n activation=\"relu\",\n padding=\"same\"))\n\n tail = []\n for scale in reversed(range(num_up)):\n filters = num_filters_base * (2 ** scale)\n tail += [\n tf.keras.layers.Conv2DTranspose(\n filters=filters,\n kernel_size=3, padding=\"same\",\n strides=2),\n ChannelNorm(),\n tf.keras.layers.ReLU()]\n\n # Final conv layer.\n tail.append(\n tf.keras.layers.Conv2D(\n filters=3,\n kernel_size=7,\n padding=\"same\"))\n\n self._head = tf.keras.Sequential(head)\n self._residual_blocks = tf.keras.Sequential(residual_blocks)\n self._tail = tf.keras.Sequential(tail)\n\n super(Decoder, self).__init__(name=name)\n\n def call(self, inputs):\n after_head = self._head(inputs)\n after_res = self._residual_blocks(after_head)\n after_res += after_head # Skip connection\n return self._tail(after_res)\n\n\nclass ResidualBlock(tf.keras.layers.Layer):\n \"\"\"Implement a residual block.\"\"\"\n\n def __init__(\n self,\n filters,\n kernel_size,\n name=None,\n activation=\"relu\",\n **kwargs_conv2d):\n \"\"\"Instantiate layer.\n\n Args:\n filters: int, number of filters, passed to the conv layers.\n kernel_size: int, kernel_size, passed to the conv layers.\n name: str, name of the layer.\n activation: function or string, resolved with keras.\n **kwargs_conv2d: Additional arguments to be passed directly to Conv2D.\n E.g. 'padding'.\n \"\"\"\n super(ResidualBlock, self).__init__()\n\n kwargs_conv2d[\"filters\"] = filters\n kwargs_conv2d[\"kernel_size\"] = kernel_size\n\n block = [\n tf.keras.layers.Conv2D(**kwargs_conv2d),\n ChannelNorm(),\n tf.keras.layers.Activation(activation),\n tf.keras.layers.Conv2D(**kwargs_conv2d),\n ChannelNorm()]\n\n self.block = tf.keras.Sequential(name=name, layers=block)\n\n def call(self, inputs, **kwargs):\n return inputs + self.block(inputs, **kwargs)\n\n\nclass ChannelNorm(tf.keras.layers.Layer):\n \"\"\"Implement ChannelNorm.\n\n Based on this paper and keras' InstanceNorm layer:\n Ba, Jimmy Lei, Jamie Ryan Kiros, and Geoffrey E. Hinton.\n \"Layer normalization.\"\n arXiv preprint arXiv:1607.06450 (2016).\n \"\"\"\n\n def __init__(self,\n epsilon: float = 1e-3,\n center: bool = True,\n scale: bool = True,\n beta_initializer=\"zeros\",\n gamma_initializer=\"ones\",\n **kwargs):\n \"\"\"Instantiate layer.\n\n Args:\n epsilon: For stability when normalizing.\n center: Whether to create and use a {beta}.\n scale: Whether to create and use a {gamma}.\n beta_initializer: Initializer for beta.\n gamma_initializer: Initializer for gamma.\n **kwargs: Passed to keras.\n \"\"\"\n super(ChannelNorm, self).__init__(**kwargs)\n\n self.axis = -1\n self.epsilon = epsilon\n self.center = center\n self.scale = scale\n self.beta_initializer = tf.keras.initializers.get(beta_initializer)\n self.gamma_initializer = tf.keras.initializers.get(gamma_initializer)\n\n def build(self, input_shape):\n self._add_gamma_weight(input_shape)\n self._add_beta_weight(input_shape)\n self.built = True\n super().build(input_shape)\n\n def call(self, inputs, modulation=None):\n mean, variance = self._get_moments(inputs)\n # inputs = tf.Print(inputs, [mean, variance, self.beta, self.gamma], \"NORM\")\n return tf.nn.batch_normalization(\n inputs, mean, variance, self.beta, self.gamma, self.epsilon,\n name=\"normalize\")\n\n def _get_moments(self, inputs):\n # Like tf.nn.moments but unbiased sample std. deviation.\n # Reduce over channels only.\n mean = tf.reduce_mean(inputs, [self.axis], keepdims=True, name=\"mean\")\n variance = tf.reduce_sum(\n tf.squared_difference(inputs, tf.stop_gradient(mean)),\n [self.axis], keepdims=True, name=\"variance_sum\")\n # Divide by N-1\n inputs_shape = tf.shape(inputs)\n counts = tf.reduce_prod([inputs_shape[ax] for ax in [self.axis]])\n variance /= (tf.cast(counts, tf.float32) - 1)\n return mean, variance\n\n def _add_gamma_weight(self, input_shape):\n dim = input_shape[self.axis]\n shape = (dim,)\n\n if self.scale:\n self.gamma = self.add_weight(\n shape=shape,\n name=\"gamma\",\n initializer=self.gamma_initializer)\n else:\n self.gamma = None\n\n def _add_beta_weight(self, input_shape):\n dim = input_shape[self.axis]\n shape = (dim,)\n\n if self.center:\n self.beta = self.add_weight(\n shape=shape,\n name=\"beta\",\n initializer=self.beta_initializer)\n else:\n self.beta = None\n\n\nclass _PatchDiscriminatorCompareGANImpl(abstract_arch.AbstractDiscriminator):\n \"\"\"PatchDiscriminator architecture.\n\n Implemented as a compare_gan layer. This has the benefit that we can use\n spectral_norm from that framework.\n \"\"\"\n\n def __init__(self,\n name,\n num_filters_base=64,\n num_layers=3,\n ):\n \"\"\"Instantiate discriminator.\n\n Args:\n name: Name of the layer.\n num_filters_base: Number of base filters. will be multiplied as we\n go down in resolution.\n num_layers: Number of downscaling convolutions.\n \"\"\"\n\n super(_PatchDiscriminatorCompareGANImpl, self).__init__(\n name, batch_norm_fn=None, layer_norm=False, spectral_norm=True)\n\n self._num_layers = num_layers\n self._num_filters_base = num_filters_base\n\n def __call__(self, x):\n \"\"\"Overwriting compare_gan's __call__ as we only need `x`.\"\"\"\n with tf.variable_scope(self.name, reuse=tf.AUTO_REUSE):\n return self.apply(x)\n\n def apply(self, x):\n \"\"\"Overwriting compare_gan's apply as we only need `x`.\"\"\"\n if not isinstance(x, tuple) or len(x) != 2:\n raise ValueError(\"Expected 2-tuple, got {}\".format(x))\n x, latent = x\n x_shape = tf.shape(x)\n\n # Upscale and fuse latent.\n latent = arch_ops.conv2d(latent, 12, 3, 3, 1, 1,\n name=\"latent\", use_sn=self._spectral_norm)\n latent = arch_ops.lrelu(latent, leak=0.2)\n latent = tf.image.resize(latent, [x_shape[1], x_shape[2]],\n tf.image.ResizeMethod.NEAREST_NEIGHBOR)\n x = tf.concat([x, latent], axis=-1)\n\n # The discriminator:\n k = 4\n net = arch_ops.conv2d(x, self._num_filters_base, k, k, 2, 2,\n name=\"d_conv_head\", use_sn=self._spectral_norm)\n net = arch_ops.lrelu(net, leak=0.2)\n\n num_filters = self._num_filters_base\n for i in range(self._num_layers - 1):\n num_filters = min(num_filters * 2, 512)\n net = arch_ops.conv2d(net, num_filters, k, k, 2, 2,\n name=f\"d_conv_{i}\", use_sn=self._spectral_norm)\n net = arch_ops.lrelu(net, leak=0.2)\n\n num_filters = min(num_filters * 2, 512)\n net = arch_ops.conv2d(net, num_filters, k, k, 1, 1,\n name=\"d_conv_a\", use_sn=self._spectral_norm)\n net = arch_ops.lrelu(net, leak=0.2)\n\n # Final 1x1 conv that maps to 1 Channel\n net = arch_ops.conv2d(net, 1, k, k, 1, 1,\n name=\"d_conv_b\", use_sn=self._spectral_norm)\n\n out_logits = tf.reshape(net, [-1, 1]) # Reshape all into batch dimension.\n out = tf.nn.sigmoid(out_logits)\n\n return DiscOutAll(out, out_logits)\n\n\nclass _CompareGANLayer(tf.keras.layers.Layer):\n \"\"\"Base class for wrapping compare_gan classes as keras layers.\n\n The main task of this class is to provide a keras-like interface, which\n includes a `trainable_variables`. This is non-trivial however, as\n compare_gan uses tf.get_variable. So we try to use the name scope to find\n these variables.\n \"\"\"\n\n def __init__(self,\n name,\n compare_gan_cls,\n **compare_gan_kwargs):\n \"\"\"Constructor.\n\n Args:\n name: Name of the layer. IMPORTANT: Setting this to the same string\n for two different layers will cause unexpected behavior since variables\n are found using this name.\n compare_gan_cls: A class from compare_gan, which should inherit from\n either AbstractGenerator or AbstractDiscriminator.\n **compare_gan_kwargs: keyword arguments passed to compare_gan_cls to\n construct it.\n \"\"\"\n super(_CompareGANLayer, self).__init__(name=name)\n compare_gan_kwargs[\"name\"] = name\n self._name = name\n self._model = compare_gan_cls(**compare_gan_kwargs)\n\n def call(self, x):\n return self._model(x)\n\n @property\n def trainable_variables(self):\n \"\"\"Get trainable variables.\"\"\"\n # Note: keras only returns something if self.training is true, but we\n # don't have training as a flag to the constructor, so we always return.\n # However, we only call trainable_variables when we are training.\n return tf.get_collection(\n tf.GraphKeys.TRAINABLE_VARIABLES, scope=self._model.name)\n\n\nclass Discriminator(_CompareGANLayer):\n\n def __init__(self):\n super(Discriminator, self).__init__(\n name=\"Discriminator\",\n compare_gan_cls=_PatchDiscriminatorCompareGANImpl)\n\n\nclass Hyperprior(tf.keras.layers.Layer):\n \"\"\"Hyperprior architecture (probability model).\"\"\"\n\n def __init__(self,\n num_chan_bottleneck=220,\n num_filters=320,\n name=\"Hyperprior\"):\n super(Hyperprior, self).__init__(name=name)\n\n self._num_chan_bottleneck = num_chan_bottleneck\n self._num_filters = num_filters\n self._analysis = tf.keras.Sequential([\n tfc.SignalConv2D(\n num_filters, (3, 3), name=f\"layer_{name}_0\",\n corr=True,\n padding=\"same_zeros\", use_bias=True,\n activation=tf.nn.relu),\n tfc.SignalConv2D(\n num_filters, (5, 5), name=f\"layer_{name}_1\",\n corr=True, strides_down=2,\n padding=\"same_zeros\", use_bias=True,\n activation=tf.nn.relu),\n tfc.SignalConv2D(\n num_filters, (5, 5), name=f\"layer_{name}_2\",\n corr=True, strides_down=2,\n padding=\"same_zeros\", use_bias=True,\n activation=None)], name=\"HyperAnalysis\")\n\n def _make_synthesis(syn_name):\n return tf.keras.Sequential([\n tfc.SignalConv2D(\n num_filters, (5, 5), name=f\"layer_{syn_name}_0\",\n corr=False, strides_up=2,\n padding=\"same_zeros\", use_bias=True,\n kernel_parameterizer=None,\n activation=tf.nn.relu),\n tfc.SignalConv2D(\n num_filters, (5, 5), name=f\"layer_{syn_name}_1\",\n corr=False, strides_up=2,\n padding=\"same_zeros\", use_bias=True,\n kernel_parameterizer=None,\n activation=tf.nn.relu),\n tfc.SignalConv2D(\n num_chan_bottleneck, (3, 3), name=f\"layer_{syn_name}_2\",\n corr=False,\n padding=\"same_zeros\", use_bias=True,\n kernel_parameterizer=None,\n activation=None),\n ], name=\"HyperSynthesis\")\n\n self._synthesis_scale = _make_synthesis(\"scale\")\n self._synthesis_mean = _make_synthesis(\"mean\")\n\n self._side_entropy_model = FactorizedPriorLayer()\n\n @property\n def losses(self):\n return self._side_entropy_model.losses\n\n @property\n def updates(self):\n return self._side_entropy_model.updates\n\n @property\n def transform_layers(self):\n return [self._analysis, self._synthesis_scale, self._synthesis_mean]\n\n @property\n def entropy_layers(self):\n return [self._side_entropy_model]\n\n def call(self, latents, image_shape, mode: ModelMode) -> HyperInfo:\n \"\"\"Apply this layer to code `latents`.\n\n Args:\n latents: Tensor of latent values to code.\n image_shape: The [height, width] of a reference frame.\n mode: The training, evaluation or validation mode of the model.\n\n Returns:\n A HyperInfo tuple.\n \"\"\"\n training = (mode == ModelMode.TRAINING)\n validation = (mode == ModelMode.VALIDATION)\n\n latent_shape = tf.shape(latents)[1:-1]\n hyper_latents = self._analysis(latents, training=training)\n\n # Model hyperprior distributions and entropy encode/decode hyper-latents.\n side_info = self._side_entropy_model(\n hyper_latents, image_shape=image_shape, mode=mode, training=training)\n hyper_decoded = side_info.decoded\n\n scale_table = np.exp(np.linspace(\n np.log(SCALES_MIN), np.log(SCALES_MAX), SCALES_LEVELS))\n\n latent_scales = self._synthesis_scale(\n hyper_decoded, training=training)\n latent_means = self._synthesis_mean(\n tf.cast(hyper_decoded, tf.float32), training=training)\n\n if not (training or validation):\n latent_scales = latent_scales[:, :latent_shape[0], :latent_shape[1], :]\n latent_means = latent_means[:, :latent_shape[0], :latent_shape[1], :]\n\n conditional_entropy_model = tfc.GaussianConditional(\n latent_scales, scale_table, mean=latent_means,\n name=\"conditional_entropy_model\")\n\n entropy_info = estimate_entropy(\n conditional_entropy_model, latents, spatial_shape=image_shape)\n\n compressed = None\n if training:\n latents_decoded = _ste_quantize(latents, latent_means)\n elif validation:\n latents_decoded = entropy_info.quantized\n else:\n compressed = conditional_entropy_model.compress(latents)\n latents_decoded = conditional_entropy_model.decompress(compressed)\n\n info = HyperInfo(\n decoded=latents_decoded,\n latent_shape=latent_shape,\n hyper_latent_shape=side_info.latent_shape,\n nbpp=entropy_info.nbpp,\n side_nbpp=side_info.total_nbpp,\n total_nbpp=entropy_info.nbpp + side_info.total_nbpp,\n qbpp=entropy_info.qbpp,\n side_qbpp=side_info.total_qbpp,\n total_qbpp=entropy_info.qbpp + side_info.total_qbpp,\n # We put everything that's needed for real arithmetic coding into\n # the bistream_tensors tuple.\n bitstream_tensors=(compressed, side_info.bitstring,\n image_shape, latent_shape, side_info.latent_shape))\n\n tf.summary.scalar(\"bpp/total/noisy\", info.total_nbpp)\n tf.summary.scalar(\"bpp/total/quantized\", info.total_qbpp)\n\n tf.summary.scalar(\"bpp/latent/noisy\", entropy_info.nbpp)\n tf.summary.scalar(\"bpp/latent/quantized\", entropy_info.qbpp)\n\n tf.summary.scalar(\"bpp/side/noisy\", side_info.total_nbpp)\n tf.summary.scalar(\"bpp/side/quantized\", side_info.total_qbpp)\n\n return info\n\n\ndef _ste_quantize(inputs, mean):\n \"\"\"Calculates quantize(inputs - mean) + mean, sets straight-through grads.\"\"\"\n half = tf.constant(.5, dtype=tf.float32)\n outputs = inputs\n outputs -= mean\n # Rounding latents for the forward pass (straight-through).\n outputs = outputs + tf.stop_gradient(tf.math.floor(outputs + half) - outputs)\n outputs += mean\n return outputs\n\n\nclass FactorizedPriorLayer(tf.keras.layers.Layer):\n \"\"\"Factorized prior to code a discrete tensor.\"\"\"\n\n def __init__(self):\n \"\"\"Instantiate layer.\"\"\"\n super(FactorizedPriorLayer, self).__init__(name=\"FactorizedPrior\")\n self._entropy_model = tfc.EntropyBottleneck(\n name=\"entropy_model\")\n\n def compute_output_shape(self, input_shape):\n batch_size = input_shape[0]\n shapes = (\n input_shape, # decoded\n [2], # latent_shape = [height, width]\n [], # total_nbpp\n [], # total_qbpp\n [batch_size], # bitstring\n )\n return tuple(tf.TensorShape(x) for x in shapes)\n\n @property\n def losses(self):\n return self._entropy_model.losses\n\n @property\n def updates(self):\n return self._entropy_model.updates\n\n def call(self, latents, image_shape, mode: ModelMode) -> FactorizedPriorInfo:\n \"\"\"Apply this layer to code `latents`.\n\n Args:\n latents: Tensor of latent values to code.\n image_shape: The [height, width] of a reference frame.\n mode: The training, evaluation or validation mode of the model.\n\n Returns:\n A FactorizedPriorInfo tuple\n \"\"\"\n training = (mode == ModelMode.TRAINING)\n validation = (mode == ModelMode.VALIDATION)\n latent_shape = tf.shape(latents)[1:-1]\n\n with tf.name_scope(\"factorized_entropy_model\"):\n noisy, quantized, _, nbpp, _, qbpp = estimate_entropy(\n self._entropy_model, latents, spatial_shape=image_shape)\n\n compressed = None\n if training:\n latents_decoded = noisy\n elif validation:\n latents_decoded = quantized\n else:\n compressed = self._entropy_model.compress(latents)\n\n # Decompress using the spatial shape tensor and get tensor coming out of\n # range decoder.\n num_channels = latents.shape[-1].value\n latents_decoded = self._entropy_model.decompress(\n compressed, shape=tf.concat([latent_shape, [num_channels]], 0))\n\n return FactorizedPriorInfo(\n decoded=latents_decoded,\n latent_shape=latent_shape,\n total_nbpp=nbpp,\n total_qbpp=qbpp,\n bitstring=compressed)\n\n\ndef estimate_entropy(entropy_model, inputs, spatial_shape=None) -> EntropyInfo:\n \"\"\"Compresses `inputs` with the given entropy model and estimates entropy.\n\n Args:\n entropy_model: An `EntropyModel` instance.\n inputs: The input tensor to be fed to the entropy model.\n spatial_shape: Shape of the input image (HxW). Must be provided for\n `valid == False`.\n\n Returns:\n The 'noisy' and quantized inputs, as well as differential and discrete\n entropy estimates, as an `EntropyInfo` named tuple.\n \"\"\"\n # We are summing over the log likelihood tensor, so we need to explicitly\n # divide by the batch size.\n batch = tf.cast(tf.shape(inputs)[0], tf.float32)\n\n # Divide by this to flip sign and convert from nats to bits.\n quotient = tf.constant(-np.log(2), dtype=tf.float32)\n\n num_pixels = tf.cast(tf.reduce_prod(spatial_shape), tf.float32)\n\n # Compute noisy outputs and estimate differential entropy.\n noisy, likelihood = entropy_model(inputs, training=True)\n log_likelihood = tf.log(likelihood)\n nbits = tf.reduce_sum(log_likelihood) / (quotient * batch)\n nbpp = nbits / num_pixels\n\n # Compute quantized outputs and estimate discrete entropy.\n quantized, likelihood = entropy_model(inputs, training=False)\n log_likelihood = tf.log(likelihood)\n qbits = tf.reduce_sum(log_likelihood) / (quotient * batch)\n qbpp = qbits / num_pixels\n\n return EntropyInfo(noisy, quantized, nbits, nbpp, qbits, qbpp)\n"
] |
[
[
"tensorflow.compat.v1.log",
"tensorflow.compat.v1.reduce_prod",
"tensorflow.compat.v1.shape",
"tensorflow.compat.v1.keras.layers.Conv2DTranspose",
"tensorflow.compat.v1.reduce_sum",
"tensorflow.compat.v1.constant",
"tensorflow.compat.v1.reshape",
"tensorflow.compat.v1.keras.layers.ReLU",
"tensorflow.compat.v1.name_scope",
"numpy.log",
"tensorflow.compat.v1.keras.Sequential",
"tensorflow.compat.v1.TensorShape",
"tensorflow.compat.v1.reduce_mean",
"tensorflow.compat.v1.cast",
"tensorflow.compat.v1.keras.layers.Conv2D",
"tensorflow.compat.v1.stop_gradient",
"tensorflow.compat.v1.variable_scope",
"tensorflow.compat.v1.nn.batch_normalization",
"tensorflow.compat.v1.summary.scalar",
"tensorflow.compat.v1.math.floor",
"tensorflow.compat.v1.keras.layers.Activation",
"tensorflow.compat.v1.get_collection",
"tensorflow.compat.v1.concat",
"tensorflow.compat.v1.nn.sigmoid",
"tensorflow.compat.v1.image.resize",
"tensorflow.compat.v1.keras.initializers.get"
]
] |
hnlab/can-ai-do
|
[
"090cbb835bdaf4af33523bd11c3e73fc7f1ed954"
] |
[
"pdbbind/props_random_forest.py"
] |
[
"\"\"\"A fingerprint + random forest model.\nTry to generate independent and identically distributed figerprint as decoy.\n\"\"\"\nimport os\nimport sys\nimport json\nimport argparse\nimport numpy as np\nfrom pathlib import Path\nfrom tqdm import tqdm\n\nimport scipy.sparse as sp\nfrom scipy.spatial import distance\nfrom multiprocessing import Pool\n\nfrom rdkit import Chem\nfrom rdkit.Chem import AllChem\nfrom rdkit import DataStructs\nfrom rdkit.Chem import Descriptors\n\nfrom sklearn import metrics\nfrom sklearn.ensemble import RandomForestClassifier\nfrom sklearn.ensemble import RandomForestRegressor\n\nimport matplotlib\nmatplotlib.use('Agg')\nimport matplotlib.pyplot as plt\n\nparser = argparse.ArgumentParser(description=__doc__)\nparser.add_argument('-i', '--index', required=True)\nparser.add_argument(\n '-d', '--datadir', required=True, help=\"pdbbind datadir, like v2018\")\nparser.add_argument(\n '-u', '--uclust', help=\"uclust output, format: https://www.drive5.com/usearch/manual/opt_uc.html\")\nargs = parser.parse_args()\n\nDATADIR = Path(args.datadir)\n\ndef read_index(index_file):\n codes = []\n pKs = []\n with open(index_file) as f:\n for i in f:\n if i[0] == '#': continue\n code, reso, year, pK, *others = i.split()\n codes.append(code)\n pKs.append(float(pK))\n return codes, pKs\n\ndef getProp(mol):\n mw = Descriptors.ExactMolWt(mol)\n logp = Descriptors.MolLogP(mol)\n rotb = Descriptors.NumRotatableBonds(mol)\n hbd = Descriptors.NumHDonors(mol)\n hba = Descriptors.NumHAcceptors(mol)\n q = Chem.GetFormalCharge(mol)\n return tuple([mw, logp, rotb, hbd, hba, q])\n\ndef load_fps(codes):\n print(\"Loading ligand fingerprint\")\n fps = []\n for i, code in tqdm(enumerate(codes), total=len(codes)):\n # already converted ligand.mol2 to ligand.pdb by babel\n path = DATADIR / code / (code + '_ligand.pdb')\n if not path.exists():\n fps.append(None)\n continue\n mol = Chem.MolFromPDBFile(str(path))\n if mol is None:\n fps.append(None)\n continue\n # fp = AllChem.GetMorganFingerprintAsBitVect(mol, 2, nBits=512)\n fp = getProp(mol)\n fps.append(fp)\n notNone = sum([1 for i in fps if i is not None])\n print('succeed loaded {}/{}'.format(notNone, len(codes)))\n return fps\n\n\ndef load_clust(uclust_file, codes):\n clust_nums = [None for i in codes]\n all_clust_nums = []\n labels = []\n with open(uclust_file) as f:\n for line in f:\n fields = line.split()\n all_clust_nums.append( int(fields[1]))\n labels.append(fields[8])\n for i, code in enumerate(codes):\n try:\n idx = labels.index(code)\n clust_nums[i] = all_clust_nums[idx]\n except ValueError:\n continue\n return clust_nums\n\ncodes, pKs = read_index(args.index)\nfps = load_fps(codes)\nNones = [i for i in range(len(codes)) if fps[i] is None]\nfps = [j for i,j in enumerate(fps) if i not in Nones]\npKs = [j for i,j in enumerate(pKs) if i not in Nones]\ncodes = [j for i,j in enumerate(codes) if i not in Nones]\nX = np.array(fps)\n\nif args.uclust:\n clust_nums = load_clust(args.uclust, codes)\n Nones.extend([i for i in range(len(codes)) if clust_nums[i] is None])\n Nones = set(Nones)\n fps = [j for i,j in enumerate(fps) if i not in Nones]\n pKs = [j for i,j in enumerate(pKs) if i not in Nones]\n codes = [j for i,j in enumerate(codes) if i not in Nones]\n clust_nums = [j for i,j in enumerate(clust_nums) if i not in Nones]\n clust_nums = np.array(clust_nums, dtype=int)\n join_clust = np.zeros_like(clust_nums)\n for i, num in enumerate(set(clust_nums)):\n mask = clust_nums == num\n # all cluster smaller than 5 will set as cluster 0\n if sum(mask) >= 10:\n join_clust[mask] = i+1\n nb_clust = max(join_clust) + 1\n print(join_clust)\n one_hot = np.eye(nb_clust, dtype=int)[join_clust]\n X = np.hstack((one_hot, fps))\n X = one_hot\n print(X.shape)\n\n\npKs = np.array(pKs)\n# filter None\nfor seed in (111, 222, 333):\n np.random.seed(seed)\n N = len(codes)\n perm = np.random.permutation(N)\n train_idx = perm[:int(N*0.8)]\n valid_idx = perm[int(N*0.8):int(N*0.9)]\n test_idx = perm[int(N*0.9):]\n train_X = X[train_idx]\n test_X = X[test_idx]\n train_pKs = pKs[train_idx]\n test_pKs = pKs[test_idx]\n\n clf = RandomForestRegressor(\n n_estimators=10,\n max_depth=15,\n # min_samples_split=10,\n min_samples_split=5,\n min_samples_leaf=1,\n random_state=0,\n n_jobs=8,\n )\n clf.fit(train_X, train_pKs)\n pred_pKs = clf.predict(test_X)\n r2 = np.corrcoef(test_pKs, pred_pKs)[0,1] ** 2\n print('seed {} r2: {}'.format(seed, r2))\n"
] |
[
[
"matplotlib.use",
"numpy.zeros_like",
"numpy.array",
"numpy.random.seed",
"numpy.random.permutation",
"numpy.eye",
"sklearn.ensemble.RandomForestRegressor",
"numpy.corrcoef",
"numpy.hstack"
]
] |
pvsnp9/audio_classification_using_deep_learning
|
[
"e9c5e0c81a4b331483acb4b2508843c6d4acf247"
] |
[
"predict.py"
] |
[
"#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Mon Mar 23 18:18:48 2020\n\n@author: tsuyogbasnet\n\"\"\"\n\nimport os\nimport sys\nimport pickle\nfrom tqdm import tqdm\nfrom scipy.io import wavfile\nfrom python_speech_features import mfcc\nfrom keras.models import load_model\nimport pandas as pd\nfrom sklearn.metrics import accuracy_score\nimport numpy as np\n\ndef build_predictions(audio_dir):\n y_true = []\n y_pred = []\n fn_prob = {}\n \n if len(os.listdir(audio_dir)) == 0:\n print(\"No files found for classification\")\n return False, False, False\n\n print(\"Extracting feature from audio files\")\n for file in tqdm(os.listdir(audio_dir)):\n try:\n rate, signal = wavfile.read(os.path.join(audio_dir, file))\n label = filename_to_class[file]\n c = classes.index(label)\n y_prob = []\n\n print(\"Classifying audio files\")\n for i in tqdm(range(0, signal.shape[0]-config.step, config.step)):\n sample = signal[i:i+config.step]\n x = mfcc(sample, rate, numcep=config.nfeat, nfilt=config.nfilt, nfft=config.nfft)\n x = (x-config._min) / (config._max - config._min)\n \n if config.mode == 'conv':\n x = x.reshape(1, x.shape[0], x.shape[1], 1)\n elif config.mode == 'time':\n x = np.expand_dims(x, axis=0)\n \n y_hat = model.predict(x)\n y_prob.append(y_hat)\n y_pred.append(np.argmax(y_hat))\n y_true.append(c)\n \n fn_prob[file] = np.mean(y_prob, axis=0).flatten()\n except:\n print(\"Something went wrong some files\", sys.exc_info()[0])\n return y_true, y_pred, fn_prob\n \n \ndata_frame = pd.read_csv('instruments.csv')\nclasses = list(np.unique(data_frame.label))\nfilename_to_class = dict(zip(data_frame.fname,data_frame.label))\n\np_path = os.path.join('pickles','conv.p')\nwith open(p_path, 'rb') as handle:\n config = pickle.load(handle)\n \nmodel = load_model(config.model_path)\ny_true, y_pred, fn_prob = build_predictions('testcleanfiles')\n\nif(y_true and y_pred and fn_prob):\n acc_score = accuracy_score(y_true=y_true, y_pred=y_pred)\n y_probs = []\n\n for i, row in data_frame.iterrows():\n y_prob = fn_prob[row.fname]\n y_probs.append(y_prob)\n \n for c, p in zip(classes, y_prob):\n data_frame.at[i,c] = p\n \n\n y_pred = [classes[np.argmax(y)] for y in y_probs]\n data_frame['y_pred'] = y_pred \n\n data_frame.to_csv('prediction.csv', index=False)\n\n\n\n\n\n\n\n"
] |
[
[
"numpy.mean",
"sklearn.metrics.accuracy_score",
"numpy.argmax",
"numpy.expand_dims",
"pandas.read_csv",
"numpy.unique"
]
] |
shensheng27/py-motmetrics
|
[
"5055bd3e1db5377c33706d2949fced39ecd4c3dc"
] |
[
"motmetrics/tests/test_mot.py"
] |
[
"# py-motmetrics - Metrics for multiple object tracker (MOT) benchmarking.\n# https://github.com/cheind/py-motmetrics/\n#\n# MIT License\n# Copyright (c) 2017-2020 Christoph Heindl, Jack Valmadre and others.\n# See LICENSE file for terms.\n\n\"\"\"Tests behavior of MOTAccumulator.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport numpy as np\nimport pandas as pd\nimport pytest\n\nimport motmetrics as mm\n\n\ndef test_events():\n \"\"\"Tests that expected events are created by MOTAccumulator.update().\"\"\"\n acc = mm.MOTAccumulator()\n\n # All FP\n acc.update([], [1, 2], [], frameid=0)\n # All miss\n acc.update([1, 2], [], [], frameid=1)\n # Match\n acc.update([1, 2], [1, 2], [[1, 0.5], [0.3, 1]], frameid=2)\n # Switch\n acc.update([1, 2], [1, 2], [[0.2, np.nan], [np.nan, 0.1]], frameid=3)\n # Match. Better new match is available but should prefer history\n acc.update([1, 2], [1, 2], [[5, 1], [1, 5]], frameid=4)\n # No data\n acc.update([], [], [], frameid=5)\n\n expect = mm.MOTAccumulator.new_event_dataframe()\n expect.loc[(0, 0), :] = ['RAW', np.nan, np.nan, np.nan]\n expect.loc[(0, 1), :] = ['RAW', np.nan, 1, np.nan]\n expect.loc[(0, 2), :] = ['RAW', np.nan, 2, np.nan]\n expect.loc[(0, 3), :] = ['FP', np.nan, 1, np.nan]\n expect.loc[(0, 4), :] = ['FP', np.nan, 2, np.nan]\n\n expect.loc[(1, 0), :] = ['RAW', np.nan, np.nan, np.nan]\n expect.loc[(1, 1), :] = ['RAW', 1, np.nan, np.nan]\n expect.loc[(1, 2), :] = ['RAW', 2, np.nan, np.nan]\n expect.loc[(1, 3), :] = ['MISS', 1, np.nan, np.nan]\n expect.loc[(1, 4), :] = ['MISS', 2, np.nan, np.nan]\n\n expect.loc[(2, 0), :] = ['RAW', np.nan, np.nan, np.nan]\n expect.loc[(2, 1), :] = ['RAW', 1, 1, 1.0]\n expect.loc[(2, 2), :] = ['RAW', 1, 2, 0.5]\n expect.loc[(2, 3), :] = ['RAW', 2, 1, 0.3]\n expect.loc[(2, 4), :] = ['RAW', 2, 2, 1.0]\n expect.loc[(2, 5), :] = ['MATCH', 1, 2, 0.5]\n expect.loc[(2, 6), :] = ['MATCH', 2, 1, 0.3]\n\n expect.loc[(3, 0), :] = ['RAW', np.nan, np.nan, np.nan]\n expect.loc[(3, 1), :] = ['RAW', 1, 1, 0.2]\n expect.loc[(3, 2), :] = ['RAW', 2, 2, 0.1]\n expect.loc[(3, 3), :] = ['TRANSFER', 1, 1, 0.2]\n expect.loc[(3, 4), :] = ['SWITCH', 1, 1, 0.2]\n expect.loc[(3, 5), :] = ['TRANSFER', 2, 2, 0.1]\n expect.loc[(3, 6), :] = ['SWITCH', 2, 2, 0.1]\n\n expect.loc[(4, 0), :] = ['RAW', np.nan, np.nan, np.nan]\n expect.loc[(4, 1), :] = ['RAW', 1, 1, 5.]\n expect.loc[(4, 2), :] = ['RAW', 1, 2, 1.]\n expect.loc[(4, 3), :] = ['RAW', 2, 1, 1.]\n expect.loc[(4, 4), :] = ['RAW', 2, 2, 5.]\n expect.loc[(4, 5), :] = ['MATCH', 1, 1, 5.]\n expect.loc[(4, 6), :] = ['MATCH', 2, 2, 5.]\n\n expect.loc[(5, 0), :] = ['RAW', np.nan, np.nan, np.nan]\n\n pd.util.testing.assert_frame_equal(acc.events, expect)\n\n\ndef test_max_switch_time():\n \"\"\"Tests max_switch_time option.\"\"\"\n acc = mm.MOTAccumulator(max_switch_time=1)\n acc.update([1, 2], [1, 2], [[1, 0.5], [0.3, 1]], frameid=1) # 1->a, 2->b\n frameid = acc.update([1, 2], [1, 2], [[0.5, np.nan], [np.nan, 0.5]], frameid=2) # 1->b, 2->a\n\n df = acc.events.loc[frameid]\n assert ((df.Type == 'SWITCH') | (df.Type == 'RAW') | (df.Type == 'TRANSFER')).all()\n\n acc = mm.MOTAccumulator(max_switch_time=1)\n acc.update([1, 2], [1, 2], [[1, 0.5], [0.3, 1]], frameid=1) # 1->a, 2->b\n frameid = acc.update([1, 2], [1, 2], [[0.5, np.nan], [np.nan, 0.5]], frameid=5) # Later frame 1->b, 2->a\n\n df = acc.events.loc[frameid]\n assert ((df.Type == 'MATCH') | (df.Type == 'RAW') | (df.Type == 'TRANSFER')).all()\n\n\ndef test_auto_id():\n \"\"\"Tests auto_id option.\"\"\"\n acc = mm.MOTAccumulator(auto_id=True)\n acc.update([1, 2, 3, 4], [], [])\n acc.update([1, 2, 3, 4], [], [])\n assert acc.events.index.levels[0][-1] == 1\n acc.update([1, 2, 3, 4], [], [])\n assert acc.events.index.levels[0][-1] == 2\n\n with pytest.raises(AssertionError):\n acc.update([1, 2, 3, 4], [], [], frameid=5)\n\n acc = mm.MOTAccumulator(auto_id=False)\n with pytest.raises(AssertionError):\n acc.update([1, 2, 3, 4], [], [])\n\n\ndef test_merge_dataframes():\n \"\"\"Tests merge_event_dataframes().\"\"\"\n # pylint: disable=too-many-statements\n acc = mm.MOTAccumulator()\n\n acc.update([], [1, 2], [], frameid=0)\n acc.update([1, 2], [], [], frameid=1)\n acc.update([1, 2], [1, 2], [[1, 0.5], [0.3, 1]], frameid=2)\n acc.update([1, 2], [1, 2], [[0.2, np.nan], [np.nan, 0.1]], frameid=3)\n\n r, mappings = mm.MOTAccumulator.merge_event_dataframes([acc.events, acc.events], return_mappings=True)\n\n expect = mm.MOTAccumulator.new_event_dataframe()\n\n expect.loc[(0, 0), :] = ['RAW', np.nan, np.nan, np.nan]\n expect.loc[(0, 1), :] = ['RAW', np.nan, mappings[0]['hid_map'][1], np.nan]\n expect.loc[(0, 2), :] = ['RAW', np.nan, mappings[0]['hid_map'][2], np.nan]\n expect.loc[(0, 3), :] = ['FP', np.nan, mappings[0]['hid_map'][1], np.nan]\n expect.loc[(0, 4), :] = ['FP', np.nan, mappings[0]['hid_map'][2], np.nan]\n\n expect.loc[(1, 0), :] = ['RAW', np.nan, np.nan, np.nan]\n expect.loc[(1, 1), :] = ['RAW', mappings[0]['oid_map'][1], np.nan, np.nan]\n expect.loc[(1, 2), :] = ['RAW', mappings[0]['oid_map'][2], np.nan, np.nan]\n expect.loc[(1, 3), :] = ['MISS', mappings[0]['oid_map'][1], np.nan, np.nan]\n expect.loc[(1, 4), :] = ['MISS', mappings[0]['oid_map'][2], np.nan, np.nan]\n\n expect.loc[(2, 0), :] = ['RAW', np.nan, np.nan, np.nan]\n expect.loc[(2, 1), :] = ['RAW', mappings[0]['oid_map'][1], mappings[0]['hid_map'][1], 1]\n expect.loc[(2, 2), :] = ['RAW', mappings[0]['oid_map'][1], mappings[0]['hid_map'][2], 0.5]\n expect.loc[(2, 3), :] = ['RAW', mappings[0]['oid_map'][2], mappings[0]['hid_map'][1], 0.3]\n expect.loc[(2, 4), :] = ['RAW', mappings[0]['oid_map'][2], mappings[0]['hid_map'][2], 1.0]\n expect.loc[(2, 5), :] = ['MATCH', mappings[0]['oid_map'][1], mappings[0]['hid_map'][2], 0.5]\n expect.loc[(2, 6), :] = ['MATCH', mappings[0]['oid_map'][2], mappings[0]['hid_map'][1], 0.3]\n\n expect.loc[(3, 0), :] = ['RAW', np.nan, np.nan, np.nan]\n expect.loc[(3, 1), :] = ['RAW', mappings[0]['oid_map'][1], mappings[0]['hid_map'][1], 0.2]\n expect.loc[(3, 2), :] = ['RAW', mappings[0]['oid_map'][2], mappings[0]['hid_map'][2], 0.1]\n expect.loc[(3, 3), :] = ['TRANSFER', mappings[0]['oid_map'][1], mappings[0]['hid_map'][1], 0.2]\n expect.loc[(3, 4), :] = ['SWITCH', mappings[0]['oid_map'][1], mappings[0]['hid_map'][1], 0.2]\n expect.loc[(3, 5), :] = ['TRANSFER', mappings[0]['oid_map'][2], mappings[0]['hid_map'][2], 0.1]\n expect.loc[(3, 6), :] = ['SWITCH', mappings[0]['oid_map'][2], mappings[0]['hid_map'][2], 0.1]\n\n # Merge duplication\n expect.loc[(4, 0), :] = ['RAW', np.nan, np.nan, np.nan]\n expect.loc[(4, 1), :] = ['RAW', np.nan, mappings[1]['hid_map'][1], np.nan]\n expect.loc[(4, 2), :] = ['RAW', np.nan, mappings[1]['hid_map'][2], np.nan]\n expect.loc[(4, 3), :] = ['FP', np.nan, mappings[1]['hid_map'][1], np.nan]\n expect.loc[(4, 4), :] = ['FP', np.nan, mappings[1]['hid_map'][2], np.nan]\n\n expect.loc[(5, 0), :] = ['RAW', np.nan, np.nan, np.nan]\n expect.loc[(5, 1), :] = ['RAW', mappings[1]['oid_map'][1], np.nan, np.nan]\n expect.loc[(5, 2), :] = ['RAW', mappings[1]['oid_map'][2], np.nan, np.nan]\n expect.loc[(5, 3), :] = ['MISS', mappings[1]['oid_map'][1], np.nan, np.nan]\n expect.loc[(5, 4), :] = ['MISS', mappings[1]['oid_map'][2], np.nan, np.nan]\n\n expect.loc[(6, 0), :] = ['RAW', np.nan, np.nan, np.nan]\n expect.loc[(6, 1), :] = ['RAW', mappings[1]['oid_map'][1], mappings[1]['hid_map'][1], 1]\n expect.loc[(6, 2), :] = ['RAW', mappings[1]['oid_map'][1], mappings[1]['hid_map'][2], 0.5]\n expect.loc[(6, 3), :] = ['RAW', mappings[1]['oid_map'][2], mappings[1]['hid_map'][1], 0.3]\n expect.loc[(6, 4), :] = ['RAW', mappings[1]['oid_map'][2], mappings[1]['hid_map'][2], 1.0]\n expect.loc[(6, 5), :] = ['MATCH', mappings[1]['oid_map'][1], mappings[1]['hid_map'][2], 0.5]\n expect.loc[(6, 6), :] = ['MATCH', mappings[1]['oid_map'][2], mappings[1]['hid_map'][1], 0.3]\n\n expect.loc[(7, 0), :] = ['RAW', np.nan, np.nan, np.nan]\n expect.loc[(7, 1), :] = ['RAW', mappings[1]['oid_map'][1], mappings[1]['hid_map'][1], 0.2]\n expect.loc[(7, 2), :] = ['RAW', mappings[1]['oid_map'][2], mappings[1]['hid_map'][2], 0.1]\n expect.loc[(7, 3), :] = ['TRANSFER', mappings[1]['oid_map'][1], mappings[1]['hid_map'][1], 0.2]\n expect.loc[(7, 4), :] = ['SWITCH', mappings[1]['oid_map'][1], mappings[1]['hid_map'][1], 0.2]\n expect.loc[(7, 5), :] = ['TRANSFER', mappings[1]['oid_map'][2], mappings[1]['hid_map'][2], 0.1]\n expect.loc[(7, 6), :] = ['SWITCH', mappings[1]['oid_map'][2], mappings[1]['hid_map'][2], 0.1]\n\n pd.util.testing.assert_frame_equal(r, expect)\n"
] |
[
[
"pandas.util.testing.assert_frame_equal"
]
] |
Semere-Gr/PyTorchProjectFramework
|
[
"c2e2e9d391060a11f9151f021adc96c27ad8a894"
] |
[
"models/segmentation_model.py"
] |
[
"from collections import OrderedDict\nfrom models.base_model import BaseModel\nfrom optimizers.radam import RAdam\nimport random\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom sklearn.metrics import accuracy_score\nimport sys\n\nclass double_conv(nn.Module):\n def __init__(self, in_ch, out_ch):\n super(double_conv, self).__init__()\n self.conv = nn.Sequential(\n nn.Conv2d(in_ch, out_ch, 3, padding=1),\n nn.BatchNorm2d(out_ch),\n nn.ReLU(inplace=True),\n nn.Conv2d(out_ch, out_ch, 3, padding=1),\n nn.BatchNorm2d(out_ch),\n nn.ReLU(inplace=True)\n )\n\n def forward(self, x):\n x = self.conv(x)\n return x\n\nclass inconv(nn.Module):\n def __init__(self, in_ch, out_ch):\n super(inconv, self).__init__()\n self.conv = double_conv(in_ch, out_ch)\n\n def forward(self, x):\n x = self.conv(x)\n return x\n\nclass down(nn.Module):\n def __init__(self, in_ch, out_ch):\n super(down, self).__init__()\n self.mpconv = nn.Sequential(\n nn.MaxPool2d(2),\n double_conv(in_ch, out_ch)\n )\n\n def forward(self, x):\n x = self.mpconv(x)\n return x\n\nclass up(nn.Module):\n def __init__(self, in_ch, out_ch, bilinear=True):\n super(up, self).__init__()\n\n self.convtrans = nn.ConvTranspose2d(in_ch//2, in_ch//2, 2, stride=2)\n self.bilinear = bilinear\n\n self.conv = double_conv(in_ch, out_ch)\n\n def forward(self, x1, x2):\n if self.bilinear:\n x1 = nn.functional.interpolate(x1, scale_factor=2, mode='bilinear', align_corners=True)\n else:\n x1 = self.convtrans(x1)\n \n # input is CHW\n diffY = x2.size()[2] - x1.size()[2]\n diffX = x2.size()[3] - x1.size()[3]\n\n x1 = F.pad(x1, (diffX // 2, diffX - diffX//2,\n diffY // 2, diffY - diffY//2))\n\n x = torch.cat([x2, x1], dim=1)\n x = self.conv(x)\n return x\n\nclass outconv(nn.Module):\n def __init__(self, in_ch, out_ch):\n super(outconv, self).__init__()\n self.conv = nn.Conv2d(in_ch, out_ch, 1)\n\n def forward(self, x):\n x = self.conv(x)\n return x\n\n\n\nclass UNet(nn.Module):\n \"\"\"Standard U-Net architecture network.\n \n Input params:\n n_channels: Number of input channels (usually 1 for a grayscale image).\n n_classes: Number of output channels (2 for binary segmentation).\n \"\"\"\n def __init__(self, n_channels, n_classes):\n super().__init__()\n self.inc = inconv(n_channels, 64)\n self.down1 = down(64, 128)\n self.down2 = down(128, 256)\n self.down3 = down(256, 512)\n self.down4 = down(512, 512)\n self.up1 = up(1024, 256)\n self.up2 = up(512, 128)\n self.up3 = up(256, 64)\n self.up4 = up(128, 64)\n self.outc = outconv(64, n_classes)\n\n def forward(self, x):\n x1 = self.inc(x)\n x2 = self.down1(x1)\n x3 = self.down2(x2)\n x4 = self.down3(x3)\n x5 = self.down4(x4)\n x = self.up1(x5, x4)\n x = self.up2(x, x3)\n x = self.up3(x, x2)\n x = self.up4(x, x1)\n x = self.outc(x)\n return x\n\n\nclass Segmentation2DModel(BaseModel):\n def __init__(self, configuration):\n \"\"\"Initialize the model.\n \"\"\"\n super().__init__(configuration)\n\n self.loss_names = ['segmentation']\n self.network_names = ['unet']\n\n self.netunet = UNet(1, 2)\n self.netunet = self.netunet.to(self.device)\n if self.is_train: # only defined during training time\n self.criterion_loss = torch.nn.CrossEntropyLoss()\n self.optimizer = torch.optim.Adam(self.netunet.parameters(), lr=configuration['lr'])\n self.optimizers = [self.optimizer]\n\n # storing predictions and labels for validation\n self.val_predictions = []\n self.val_labels = []\n self.val_images = []\n\n\n def forward(self):\n \"\"\"Run forward pass.\n \"\"\"\n self.output = self.netunet(self.input)\n\n\n def backward(self):\n \"\"\"Calculate losses; called in every training iteration.\n \"\"\"\n self.loss_segmentation = self.criterion_loss(self.output, self.label)\n\n\n def optimize_parameters(self):\n \"\"\"Calculate gradients and update network weights.\n \"\"\"\n self.loss_segmentation.backward() # calculate gradients\n self.optimizer.step()\n self.optimizer.zero_grad()\n torch.cuda.empty_cache()\n\n\n def test(self):\n super().test() # run the forward pass\n\n # save predictions and labels as flat tensors\n self.val_images.append(self.input)\n self.val_predictions.append(self.output)\n self.val_labels.append(self.label)\n\n\n def post_epoch_callback(self, epoch, visualizer):\n self.val_predictions = torch.cat(self.val_predictions, dim=0)\n predictions = torch.argmax(self.val_predictions, dim=1)\n predictions = torch.flatten(predictions).cpu()\n\n self.val_labels = torch.cat(self.val_labels, dim=0)\n labels = torch.flatten(self.val_labels).cpu()\n\n self.val_images = torch.squeeze(torch.cat(self.val_images, dim=0)).cpu()\n\n # Calculate and show accuracy\n val_accuracy = accuracy_score(labels, predictions)\n\n metrics = OrderedDict()\n metrics['accuracy'] = val_accuracy\n\n visualizer.plot_current_validation_metrics(epoch, metrics)\n print('Validation accuracy: {0:.3f}'.format(val_accuracy))\n\n # Here you may do something else with the validation data such as\n # displaying the validation images or calculating the ROC curve\n\n self.val_images = []\n self.val_predictions = []\n self.val_labels = []"
] |
[
[
"torch.cat",
"torch.flatten",
"torch.nn.MaxPool2d",
"torch.nn.BatchNorm2d",
"torch.nn.ConvTranspose2d",
"torch.nn.functional.interpolate",
"torch.nn.CrossEntropyLoss",
"sklearn.metrics.accuracy_score",
"torch.nn.ReLU",
"torch.cuda.empty_cache",
"torch.nn.Conv2d",
"torch.nn.functional.pad",
"torch.argmax"
]
] |
Dqirvin/msticpy
|
[
"9c9f54b755bf4f2b917f30b41ab2336caf102f3e"
] |
[
"msticpy/nbtools/timeline.py"
] |
[
"# -------------------------------------------------------------------------\n# Copyright (c) Microsoft Corporation. All rights reserved.\n# Licensed under the MIT License. See License.txt in the project root for\n# license information.\n# --------------------------------------------------------------------------\n\"\"\"Module for common display functions.\"\"\"\nfrom datetime import datetime\nfrom typing import Any, Union, Set, Dict, Tuple\n\nimport pandas as pd\nfrom bokeh.io import output_notebook, show\nfrom bokeh.models import (\n ColumnDataSource,\n DatetimeTickFormatter,\n HoverTool,\n Label,\n Legend,\n RangeTool,\n Title,\n)\n\n# pylint: disable=no-name-in-module\nfrom bokeh.palettes import viridis\n\n# pylint: enable=no-name-in-module\nfrom bokeh.plotting import figure, reset_output\nfrom bokeh.layouts import column\n\nfrom .._version import VERSION\nfrom .utility import export\n\n__version__ = VERSION\n__author__ = \"Ian Hellen\"\n\n\n# Constants\n_WRAP = 50\n_WRAP_CMDL = \"WrapCmdl\"\n\n\n@export\ndef display_timeline(\n data: Union[pd.DataFrame, dict],\n time_column: str = \"TimeGenerated\",\n source_columns: list = None,\n **kwargs,\n) -> figure:\n \"\"\"\n Display a timeline of events.\n\n Parameters\n ----------\n data : Union[dict, pd.DataFrame]\n Either\n dict of data sets to plot on the timeline with the following structure::\n\n Key (str) - Name of data set to be displayed in legend\n Value (Dict[str, Any]) - containing:\n data (pd.DataFrame) - Data to plot\n time_column (str, optional) - Name of the timestamp column\n source_columns (list[str], optional) - source columns to use\n in tooltips\n color (str, optional) - color of datapoints for this data\n If any of the last values are omitted, they default to the values\n supplied as parameters to the function (see below)\n\n Or\n DataFrame as a single data set or grouped into individual\n plot series using the `group_by` parameter\n time_column : str, optional\n Name of the timestamp column\n (the default is 'TimeGenerated')\n source_columns : list, optional\n List of default source columns to use in tooltips\n (the default is None)\n\n Other Parameters\n ----------------\n title : str, optional\n Title to display (the default is None)\n alert : SecurityAlert, optional\n Add a reference line/label using the alert time (the default is None)\n ref_event : Any, optional\n Add a reference line/label using the alert time (the default is None)\n ref_time : datetime, optional\n Add a reference line/label using `ref_time` (the default is None)\n group_by : str\n (where `data` is a DataFrame)\n The column to group timelines on\n legend: str, optional\n \"left\", \"right\", \"inline\" or \"none\"\n (the default is to show a legend when plotting multiple series\n and not to show one when plotting a single series)\n yaxis : bool, optional\n Whether to show the yaxis and labels (default is False)\n ygrid : bool, optional\n Whether to show the yaxis grid (default is False)\n xgrid : bool, optional\n Whether to show the xaxis grid (default is True)\n range_tool : bool, optional\n Show the the range slider tool (default is True)\n height : int, optional\n The height of the plot figure\n (the default is auto-calculated height)\n width : int, optional\n The width of the plot figure (the default is 900)\n color : str\n Default series color (default is \"navy\")\n overlay_color : str\n Overlay series color (default is \"green\")\n\n Returns\n -------\n figure\n The bokeh plot figure.\n\n \"\"\"\n # Get args\n overlay_data: pd.DataFrame = kwargs.pop(\"overlay_data\", None)\n overlay_columns: list = kwargs.pop(\"overlay_columns\", source_columns)\n color: str = kwargs.get(\"color\", \"navy\") # don't remove this from kwargs\n overlay_color: str = kwargs.pop(\"overlay_color\", \"green\")\n\n kwargs_sub = kwargs.copy()\n kwargs_sub[\"time_column\"] = time_column\n kwargs_sub[\"source_columns\"] = source_columns\n kwargs_sub[\"ref_time\"], kwargs_sub[\"ref_label\"] = _get_ref_event_time(**kwargs)\n\n if isinstance(data, pd.DataFrame):\n if overlay_data is not None:\n aggr_data = {\n \"Primary\": {\n \"data\": data,\n \"time_column\": time_column,\n \"source_columns\": source_columns,\n \"color\": color,\n },\n \"Secondary\": {\n \"data\": overlay_data,\n \"time_column\": time_column,\n \"source_columns\": overlay_columns,\n \"color\": overlay_color,\n },\n }\n return _display_timeline_dict(data=aggr_data, **kwargs_sub)\n\n # Create a dictionary from a grouped or simple series\n series_dict = _create_dict_from_grouping(\n data=data,\n source_columns=source_columns,\n time_column=time_column,\n group_by=kwargs.get(\"group_by\", None),\n color=kwargs.get(\"color\", \"navy\"),\n )\n return _display_timeline_dict(data=series_dict, **kwargs_sub)\n\n if isinstance(data, dict):\n return _display_timeline_dict(data, **kwargs_sub)\n return None\n\n\n# pylint: disable=invalid-name, too-many-locals, too-many-statements, too-many-branches\n@export # noqa: C901, MC0001\ndef display_timeline_values(\n data: pd.DataFrame,\n y: str,\n time_column: str = \"TimeGenerated\",\n source_columns: list = None,\n **kwargs,\n) -> figure:\n \"\"\"\n Display a timeline of events.\n\n Parameters\n ----------\n data : pd.DataFrame\n DataFrame as a single data set or grouped into individual\n plot series using the `group_by` parameter\n time_column : str, optional\n Name of the timestamp column\n (the default is 'TimeGenerated')\n y : str\n The column name holding the value to plot vertically\n source_columns : list, optional\n List of default source columns to use in tooltips\n (the default is None)\n\n Other Parameters\n ----------------\n x : str, optional\n alias of `time_column`\n title : str, optional\n Title to display (the default is None)\n ref_event : Any, optional\n Add a reference line/label using the alert time (the default is None)\n ref_time : datetime, optional\n Add a reference line/label using `ref_time` (the default is None)\n group_by : str\n (where `data` is a DataFrame)\n The column to group timelines on\n legend_column : str, optional\n (where `data` is a DataFrame)\n Name of the column used to generate the legend labels if a legend is\n to be displayed. Default is `group_by` parameter.\n yaxis : bool, optional\n Whether to show the yaxis and labels\n range_tool : bool, optional\n Show the the range slider tool (default is True)\n height : int, optional\n The height of the plot figure\n (the default is auto-calculated height)\n width : int, optional\n The width of the plot figure (the default is 900)\n color : str\n Default series color (default is \"navy\"). This is overridden by\n automatic color assignments if plotting a grouped chart\n kind : Union[str, List[str]]\n one or more glyph types to plot., optional\n Supported types are \"circle\", \"line\" and \"vbar\" (default is \"vbar\")\n\n Returns\n -------\n figure\n The bokeh plot figure.\n\n \"\"\"\n reset_output()\n output_notebook()\n\n height: int = kwargs.pop(\"height\", None)\n width: int = kwargs.pop(\"width\", 900)\n title: str = kwargs.pop(\"title\", None)\n time_column = kwargs.get(\"x\", time_column)\n group_by: str = kwargs.get(\"group_by\", None)\n show_yaxis: bool = kwargs.pop(\"yaxis\", True)\n show_range: bool = kwargs.pop(\"range_tool\", True)\n color: str = kwargs.get(\"color\", \"navy\")\n legend_pos: str = kwargs.pop(\"legend\", None)\n kind: Any = kwargs.pop(\"kind\", [\"vbar\"])\n plot_kinds = kind if isinstance(kind, list) else [kind]\n\n ref_time, ref_label = _get_ref_event_time(**kwargs)\n\n graph_df, group_count_df, tool_tip_columns, series_count = _create_data_grouping(\n data, source_columns, time_column, group_by, color\n )\n\n # build the tool tips from columns (excluding these)\n tool_tip_items = [(f\"{col}\", f\"@{col}\") for col in tool_tip_columns]\n hover = HoverTool(tooltips=tool_tip_items, formatters={\"Tooltip\": \"printf\"})\n\n # Create the Plot figure\n title = title if title else \"Timeline\"\n min_time = graph_df[time_column].min()\n max_time = graph_df[time_column].max()\n start_range = min_time - ((max_time - min_time) * 0.1)\n end_range = max_time + ((max_time - min_time) * 0.1)\n height = height if height else _calc_auto_plot_height(series_count)\n\n plot = figure(\n x_range=(start_range, end_range),\n min_border_left=50,\n plot_height=height,\n plot_width=width,\n x_axis_label=\"Event Time\",\n x_axis_type=\"datetime\",\n x_minor_ticks=10,\n y_axis_label=y,\n tools=[hover, \"xwheel_zoom\", \"box_zoom\", \"reset\", \"save\", \"xpan\"],\n toolbar_location=\"above\",\n title=title,\n )\n plot.yaxis.visible = show_yaxis\n plot.ygrid.minor_grid_line_color = \"navy\"\n plot.ygrid.minor_grid_line_alpha = 0.1\n plot.ygrid.grid_line_color = \"navy\"\n plot.ygrid.grid_line_alpha = 0.3\n plot.xgrid.minor_grid_line_color = \"navy\"\n plot.xgrid.minor_grid_line_alpha = 0.1\n plot.xgrid.grid_line_color = \"navy\"\n plot.xgrid.grid_line_alpha = 0.3\n\n # set the tick datetime formatter\n plot.xaxis[0].formatter = _get_tick_formatter()\n\n # plot groups individually so that we can create an interactive legend\n if group_by:\n legend_items = []\n for _, group_id in group_count_df[group_by].items():\n first_group_item = graph_df[graph_df[group_by] == group_id].iloc[0]\n legend_label = str(first_group_item[group_by])\n inline_legend = str(group_id) if legend_pos == \"inline\" else None\n group_color = first_group_item[\"color\"]\n row_source = ColumnDataSource(graph_df[graph_df[group_by] == group_id])\n p_series = []\n # create default plot args\n plot_args: Dict[str, Any] = dict(\n x=time_column,\n alpha=0.7,\n source=row_source,\n legend_label=str(inline_legend),\n )\n if \"vbar\" in plot_kinds:\n p_series.append(plot.vbar(top=y, width=4, color=\"color\", **plot_args))\n if \"circle\" in plot_kinds:\n p_series.append(plot.circle(y=y, size=4, color=\"color\", **plot_args))\n if \"line\" in plot_kinds:\n p_series.append(\n plot.line(y=y, line_width=1, line_color=group_color, **plot_args)\n )\n if not inline_legend:\n legend_items.append((legend_label, p_series))\n\n if legend_pos == \"inline\":\n # Position the inline legend\n plot.legend.location = \"top_left\"\n plot.legend.click_policy = \"hide\"\n elif legend_pos in [\"left\", \"right\"]:\n # Create the legend box outside of the plot area\n ext_legend = Legend(\n items=legend_items,\n location=\"center\",\n click_policy=\"hide\",\n label_text_font_size=\"8pt\",\n )\n plot.add_layout(ext_legend, legend_pos)\n else:\n plot_args = dict(\n x=time_column, color=\"color\", alpha=0.7, source=ColumnDataSource(graph_df)\n )\n if \"vbar\" in plot_kinds:\n plot.vbar(top=y, width=4, **plot_args)\n if \"circle\" in plot_kinds:\n plot.circle(y=y, size=4, **plot_args)\n if \"line\" in plot_kinds:\n plot.line(y=y, line_width=4, **plot_args)\n\n # if we have a reference, plot the time as a line\n if ref_time is not None:\n _add_ref_line(plot, ref_time, ref_label, series_count)\n\n if show_range:\n rng_select = _create_range_tool(\n data=graph_df,\n min_time=min_time,\n max_time=max_time,\n plot_range=plot.x_range,\n width=width,\n height=height,\n time_column=time_column,\n )\n show(column(plot, rng_select))\n else:\n show(plot)\n return plot\n\n\n# pylint: enable=invalid-name,too-many-locals, too-many-statements, too-many-branches\n\n\n# pylint: disable=too-many-locals, too-many-statements, too-many-branches\ndef _display_timeline_dict(data: dict, **kwargs) -> figure: # noqa: C901, MC0001\n \"\"\"\n Display a timeline of events.\n\n Parameters\n ----------\n data : dict\n Data points to plot on the timeline.\n Need to contain:\n Key - Name of data type to be displayed in legend\n Value - dict of data containing:\n data : pd.DataFrame\n Data to plot\n time_column : str\n Name of the timestamp column\n source_columns : list\n List of source columns to use in tooltips\n color: str\n Color of datapoints for this data\n Other Parameters\n ----------------\n ref_time : datetime, optional\n Input reference line to display (the default is None)\n title : str, optional\n Title to display (the default is None)\n time_column : str, optional\n Name of the timestamp column\n (the default is 'TimeGenerated')\n legend: str, optional\n Where to position the legend\n None, left, right or inline (default is None)\n yaxis : bool, optional\n Whether to show the yaxis and labels\n range_tool : bool, optional\n Show the the range slider tool (default is True)\n source_columns : list, optional\n List of default source columns to use in tooltips\n (the default is None)\n height : int, optional\n The height of the plot figure\n (the default is auto-calculated height)\n width : int, optional\n The width of the plot figure (the default is 900)\n\n Returns\n -------\n figure\n The bokeh plot figure.\n\n \"\"\"\n reset_output()\n output_notebook()\n\n height: int = kwargs.pop(\"height\", None)\n width: int = kwargs.pop(\"width\", 900)\n ref_time: Any = kwargs.pop(\"ref_time\", None)\n ref_label: str = kwargs.pop(\"ref_label\", None)\n title: str = kwargs.pop(\"title\", None)\n legend_pos: str = kwargs.pop(\"legend\", None)\n show_yaxis: bool = kwargs.pop(\"yaxis\", False)\n show_range: bool = kwargs.pop(\"range_tool\", True)\n xgrid: bool = kwargs.pop(\"xgrid\", True)\n ygrid: bool = kwargs.pop(\"ygrid\", False)\n\n tool_tip_columns, min_time, max_time = _unpack_data_series_dict(data, **kwargs)\n series_count = len(data)\n\n # build the tool tips from all specified columns\n tool_tip_items = [(f\"{col}\", f\"@{col}\") for col in tool_tip_columns]\n hover = HoverTool(tooltips=tool_tip_items, formatters={\"Tooltip\": \"printf\"})\n\n title = f\"Timeline: {title}\" if title else \"Event Timeline\"\n start_range = min_time - ((max_time - min_time) * 0.1)\n end_range = max_time + ((max_time - min_time) * 0.1)\n height = height if height else _calc_auto_plot_height(len(data))\n y_range = ((-1 / series_count), series_count - 1 + (1 / series_count))\n plot = figure(\n x_range=(start_range, end_range),\n y_range=y_range,\n min_border_left=50,\n plot_height=height,\n plot_width=width,\n x_axis_label=\"Event Time\",\n x_axis_type=\"datetime\",\n x_minor_ticks=10,\n tools=[hover, \"xwheel_zoom\", \"box_zoom\", \"reset\", \"save\", \"xpan\"],\n title=title,\n )\n plot.yaxis.visible = show_yaxis\n if show_yaxis:\n if data:\n y_labels = {ser_def[\"y_index\"]: str(lbl) for lbl, ser_def in data.items()}\n plot.yaxis.major_label_overrides = y_labels\n if ygrid:\n plot.ygrid.minor_grid_line_color = \"navy\"\n plot.ygrid.minor_grid_line_alpha = 0.1\n plot.ygrid.grid_line_color = \"navy\"\n plot.ygrid.grid_line_alpha = 0.3\n else:\n plot.ygrid.grid_line_color = None\n if xgrid:\n plot.xgrid.minor_grid_line_color = \"navy\"\n plot.xgrid.minor_grid_line_alpha = 0.3\n else:\n plot.xgrid.grid_line_color = None\n\n # Create plot bar to act as as range selector\n rng_select = _create_range_tool(\n data=data,\n min_time=min_time,\n max_time=max_time,\n plot_range=plot.x_range,\n width=width,\n height=height,\n )\n\n # set the tick datetime formatter\n plot.xaxis[0].formatter = _get_tick_formatter()\n\n if series_count > 1 and not legend_pos:\n legend_pos = \"left\"\n\n # plot groups individually so that we can create an interactive legend\n # if legend_pos is \"inline\", we add add the normal legend inside the plot\n # if legend_pos is \"left\" or \"right\", we add the legend to the side\n legend_items = []\n for ser_name, series_def in data.items():\n if legend_pos == \"inline\":\n p_series = plot.diamond(\n x=series_def[\"time_column\"],\n y=\"y_index\",\n color=series_def[\"color\"],\n alpha=0.5,\n size=10,\n source=series_def[\"source\"],\n legend_label=str(ser_name),\n )\n else:\n p_series = plot.diamond(\n x=series_def[\"time_column\"],\n y=\"y_index\",\n color=series_def[\"color\"],\n alpha=0.5,\n size=10,\n source=series_def[\"source\"],\n )\n if legend_pos in [\"left\", \"right\"]:\n legend_items.append((str(ser_name), [p_series]))\n\n if legend_pos == \"inline\":\n # Position the inline legend\n plot.legend.location = \"center_left\"\n plot.legend.click_policy = \"hide\"\n elif legend_pos in [\"left\", \"right\"]:\n # Create the legend box outside of the plot area\n ext_legend = Legend(\n items=legend_items,\n location=\"center\",\n click_policy=\"hide\",\n label_text_font_size=\"8pt\",\n )\n plot.add_layout(ext_legend, legend_pos)\n\n if ref_time is not None:\n _add_ref_line(plot, ref_time, ref_label, len(data))\n\n if show_range:\n show(column(plot, rng_select))\n else:\n show(plot)\n return plot\n\n\n# pylint: enable=too-many-locals, too-many-statements, too-many-branches\n\n\n# pylint: disable=too-many-locals\ndef _unpack_data_series_dict(data, **kwargs):\n time_column: str = kwargs.pop(\"time_column\", \"TimeGenerated\")\n source_columns: list = kwargs.pop(\"source_columns\", None)\n\n if not source_columns:\n source_columns = [\"NewProcessName\", \"EventID\", \"CommandLine\"]\n def_source_columns = set(source_columns) if source_columns else set()\n\n # Process the input dictionary\n # Take each item that is passed and fill in blanks and add a y_index\n tool_tip_columns: Set[str] = set()\n min_time = pd.Timestamp(pd.Timestamp.max)\n max_time = pd.Timestamp(pd.Timestamp.min)\n y_index = 0\n\n # Create a color map in case colors have not been specified\n # (Shift the Viridis palatte so we lose the top, harder-to-see colors)\n series_count = len(data)\n colors, palette_size = _get_color_palette(series_count)\n\n for series_def in data.values():\n data_columns: Set[str] = set()\n series_data = series_def[\"data\"]\n\n # if the series has source columns, use those\n src_cols = series_def.get(\"source_columns\", def_source_columns)\n data_columns.update(src_cols if src_cols else def_source_columns)\n\n # add these columns to the tool tip column set\n tool_tip_columns.update(data_columns)\n\n time_col = series_def.get(\"time_column\", None)\n if not time_col:\n time_col = time_column\n series_def[\"time_column\"] = time_col\n\n min_time = min(min_time, series_data[time_col].min())\n max_time = max(max_time, series_data[time_col].max())\n data_columns.update([time_col])\n # Create the Column data source to plot\n graph_df = series_data[list(data_columns)].copy()\n graph_df[\"y_index\"] = y_index\n series_def[\"y_index\"] = y_index\n ser_color = series_def.get(\"color\", None)\n if not ser_color:\n ser_color = colors[y_index % palette_size]\n series_def[\"color\"] = ser_color\n # Wrap tooltip lines longer than 50 chars\n _wrap_df_columns(graph_df, 50)\n series_def[\"source\"] = ColumnDataSource(graph_df)\n y_index += 1\n\n return tool_tip_columns, min_time, max_time\n\n\n# pylint: enable=too-many-locals\n\n\ndef _create_data_grouping(data, source_columns, time_column, group_by, color):\n if not source_columns:\n data_columns = set([\"NewProcessName\", \"EventID\", \"CommandLine\"])\n else:\n data_columns = set(source_columns)\n tool_tip_columns = data_columns.copy()\n # If the time column not explicity specified in source_columns, add it\n data_columns.add(time_column)\n # create group frame so that we can color each group separately\n if group_by:\n group_count_df = (\n data[[group_by, time_column]]\n .groupby(group_by)\n .count()\n .reset_index()\n .rename(columns={time_column: \"count\"})\n )\n group_count_df[\"y_index\"] = group_count_df.index\n\n # Shift the Viridis palatte so we lose the top, harder-to-see colors\n series_count = len(group_count_df)\n colors, palette_size = _get_color_palette(series_count)\n group_count_df[\"color\"] = group_count_df.apply(\n lambda x: colors[x.y_index % palette_size], axis=1\n )\n # re-join with the original data\n data_columns.update([group_by, \"y_index\", \"color\"])\n clean_data = data.drop(columns=[\"y_index\", \"color\"], errors=\"ignore\")\n graph_df = clean_data.merge(group_count_df, on=group_by)[list(data_columns)]\n else:\n graph_df = data[list(data_columns)].copy()\n graph_df[\"color\"] = color\n graph_df[\"y_index\"] = 1\n series_count = 1\n group_count_df = None\n return graph_df, group_count_df, tool_tip_columns, series_count\n\n\n# pylint: enable=too-many-arguments\n\n\ndef _create_dict_from_grouping(data, source_columns, time_column, group_by, color):\n if not source_columns:\n data_columns = set([\"NewProcessName\", \"EventID\", \"CommandLine\"])\n else:\n data_columns = set(source_columns)\n # If the time column not explicitly specified in source_columns, add it\n data_columns.add(time_column)\n\n series_dict: Dict[str, Dict] = {}\n # create group frame so that we can color each group separately\n if group_by:\n data_columns.add(group_by)\n grouped_data = data[list(data_columns)].groupby(group_by)\n\n series_count = len(grouped_data)\n colors, palette_size = _get_color_palette(series_count)\n color_index = 0\n for group_name, group_df in grouped_data:\n series_dict[str(group_name)] = dict(\n data=group_df,\n time_column=time_column,\n source_columns=source_columns,\n color=colors[color_index % palette_size],\n )\n color_index += 1\n\n else:\n group_df = data[list(data_columns)].copy()\n series_dict[\"unnamed series\"] = dict(\n data=group_df,\n time_column=time_column,\n source_columns=source_columns,\n color=color,\n )\n\n return series_dict\n\n\ndef _get_ref_event_time(**kwargs) -> Tuple[datetime, str]:\n \"\"\"Extract the reference time from kwargs.\"\"\"\n ref_alert = kwargs.get(\"alert\", None)\n if ref_alert is not None:\n ref_event = ref_alert\n ref_label = \"Alert time\"\n else:\n ref_event = kwargs.get(\"ref_event\", None)\n ref_label = \"Event time\"\n\n if ref_event is not None:\n ref_time = getattr(ref_event, \"StartTimeUtc\", None)\n if not ref_time:\n ref_time = getattr(ref_event, \"TimeGenerated\", None)\n else:\n ref_time = kwargs.get(\"ref_time\", None)\n ref_label = \"Ref time\"\n return ref_time, kwargs.get(\"ref_label\", ref_label)\n\n\ndef _get_color_palette(series_count):\n palette_size = min(256, series_count + int(series_count / 5))\n return viridis(palette_size), palette_size\n\n\ndef _plot_dict_series(data, plot, legend_pos):\n \"\"\"Plot series from dict.\"\"\"\n # If legend_pos is outside the graph we need to create the legend\n # seperately.\n # We plot groups individually so that we can create an interactive legend.\n legend_items = []\n for ser_name, series_def in data.items():\n if legend_pos == \"inline\":\n p_series = plot.diamond(\n x=series_def[\"time_column\"],\n y=\"y_index\",\n color=series_def[\"color\"],\n alpha=0.5,\n size=10,\n source=series_def[\"source\"],\n legend_label=str(ser_name),\n )\n else:\n p_series = plot.diamond(\n x=series_def[\"time_column\"],\n y=\"y_index\",\n color=series_def[\"color\"],\n alpha=0.5,\n size=10,\n source=series_def[\"source\"],\n )\n if legend_pos in [\"left\", \"right\"]:\n legend_items.append((ser_name, [p_series]))\n\n if legend_pos == \"inline\":\n # Position the inline legend\n plot.legend.location = \"top_left\"\n plot.legend.click_policy = \"hide\"\n elif legend_pos in [\"left\", \"right\"]:\n # Create the legend box outside of the plot area\n ext_legend = Legend(\n items=legend_items,\n location=\"center\",\n click_policy=\"hide\",\n label_text_font_size=\"8pt\",\n )\n plot.add_layout(ext_legend, legend_pos)\n\n\ndef _wrap_df_columns(data: pd.DataFrame, wrap_len: int = 50):\n \"\"\"Wrap any string columns.\"\"\"\n if not data.empty:\n for col in data.columns:\n if isinstance(data[col].iloc[0], str):\n data[col] = data[col].str.wrap(wrap_len)\n\n\ndef _get_tick_formatter() -> DatetimeTickFormatter:\n \"\"\"Return tick formatting for different zoom levels.\"\"\"\n # '%H:%M:%S.%3Nms\n tick_format = DatetimeTickFormatter()\n tick_format.days = [\"%m-%d %H:%M\"]\n tick_format.hours = [\"%H:%M:%S\"]\n tick_format.minutes = [\"%H:%M:%S\"]\n tick_format.seconds = [\"%H:%M:%S\"]\n tick_format.milliseconds = [\"%H:%M:%S.%3N\"]\n return tick_format\n\n\ndef _calc_auto_plot_height(group_count):\n \"\"\"Dynamic calculation of plot height.\"\"\"\n ht_per_row = 40\n if group_count > 15:\n ht_per_row = 25\n return max(ht_per_row * group_count, 300)\n\n\n# pylint: disable=too-many-arguments\ndef _create_range_tool(\n data, min_time, max_time, plot_range, width, height, time_column: str = None\n):\n \"\"\"Create plot bar to act as as range selector.\"\"\"\n ext_min = min_time - ((max_time - min_time) * 0.15)\n ext_max = max_time + ((max_time - min_time) * 0.15)\n plot_height = max(120, int(height * 0.20))\n rng_select = figure(\n x_range=(ext_min, ext_max),\n title=\"Range Selector\",\n plot_height=plot_height,\n plot_width=width,\n x_axis_type=\"datetime\",\n y_axis_type=None,\n tools=\"\",\n toolbar_location=None,\n )\n help_str = (\n \"Drag the middle or edges of the selection box to change \"\n + \"the range in the main chart\"\n )\n rng_select.add_layout(\n Title(text=help_str, align=\"right\", text_font_size=\"10px\"), \"below\"\n )\n rng_select.xaxis[0].formatter = _get_tick_formatter()\n if isinstance(data, dict):\n for _, series_def in data.items():\n rng_select.circle(\n x=series_def[\"time_column\"],\n y=\"y_index\",\n color=series_def[\"color\"],\n source=series_def[\"source\"],\n )\n elif isinstance(data, pd.DataFrame):\n rng_select.circle(\n x=time_column, y=\"y_index\", color=\"blue\", source=ColumnDataSource(data)\n )\n\n range_tool = RangeTool(x_range=plot_range)\n range_tool.overlay.fill_color = \"navy\"\n range_tool.overlay.fill_alpha = 0.2\n rng_select.ygrid.grid_line_color = None\n rng_select.add_tools(range_tool)\n rng_select.toolbar.active_multi = range_tool\n return rng_select\n\n\n# pylint: enable=too-many-arguments\n\n\ndef _add_ref_line(plot, ref_time, ref_text=\"Ref time\", series_count=1):\n \"\"\"Add a reference marker line and label at `ref_time`.\"\"\"\n ref_label_tm = pd.Timestamp(ref_time)\n plot.line(x=[ref_label_tm, ref_label_tm], y=[0, series_count])\n ref_label = Label(\n x=ref_label_tm,\n y=0,\n y_offset=10,\n x_units=\"data\",\n y_units=\"data\",\n text=f\"< {ref_text}\",\n text_font_size=\"8pt\",\n render_mode=\"css\",\n border_line_color=\"red\",\n border_line_alpha=1.0,\n background_fill_color=\"white\",\n background_fill_alpha=0.5,\n )\n\n plot.add_layout(ref_label)\n"
] |
[
[
"pandas.Timestamp"
]
] |
awsl-dbq/sqlflow
|
[
"6684ac4b4f26774bd10e437bc52080fdbae5ce49"
] |
[
"python/runtime/step/xgboost/evaluate.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 os\n\nimport numpy as np\nimport six\nimport sklearn.metrics\n\nimport runtime.temp_file as temp_file\nimport xgboost as xgb\nfrom runtime import db\nfrom runtime.dbapi.paiio import PaiIOConnection\nfrom runtime.feature.compile import compile_ir_feature_columns\nfrom runtime.feature.derivation import get_ordered_field_descs\nfrom runtime.feature.field_desc import DataType\nfrom runtime.model import EstimatorType\nfrom runtime.model.model import Model\nfrom runtime.pai.pai_distributed import define_tf_flags\nfrom runtime.step.xgboost.predict import _calc_predict_result\nfrom runtime.xgboost.dataset import xgb_dataset\n# TODO(typhoonzero): remove runtime.xgboost\nfrom runtime.xgboost.feature_column import ComposedColumnTransformer\n\nFLAGS = define_tf_flags()\n\nSKLEARN_METRICS = [\n 'accuracy_score',\n 'average_precision_score',\n 'balanced_accuracy_score',\n 'brier_score_loss',\n 'cohen_kappa_score',\n 'explained_variance_score',\n 'f1_score',\n 'fbeta_score',\n 'hamming_loss',\n 'hinge_loss',\n 'log_loss',\n 'mean_absolute_error',\n 'mean_squared_error',\n 'mean_squared_log_error',\n 'median_absolute_error',\n 'precision_score',\n 'r2_score',\n 'recall_score',\n 'roc_auc_score',\n 'zero_one_loss',\n]\n\n\ndef evaluate(datasource,\n select,\n result_table,\n model,\n label_name=None,\n model_params=None,\n result_column_names=[],\n pai_table=None):\n \"\"\"TBD\n \"\"\"\n if model_params is None:\n model_params = {}\n validation_metrics = model_params.get(\"validation.metrics\",\n \"accuracy_score\")\n validation_metrics = [m.strip() for m in validation_metrics.split(\",\")]\n\n bst = xgb.Booster()\n if isinstance(model, six.string_types):\n with temp_file.TemporaryDirectory(as_cwd=True):\n model = Model.load_from_db(datasource, model)\n bst.load_model(\"my_model\")\n else:\n assert isinstance(model,\n Model), \"not supported model type %s\" % type(model)\n bst.load_model(\"my_model\")\n\n model_params = model.get_meta(\"attributes\")\n fc_map_ir = model.get_meta(\"features\")\n train_label = model.get_meta(\"label\")\n train_label_desc = train_label.get_field_desc()[0]\n\n if label_name:\n train_label_desc.name = label_name\n\n feature_columns = compile_ir_feature_columns(fc_map_ir,\n EstimatorType.XGBOOST)\n field_descs = get_ordered_field_descs(fc_map_ir)\n feature_column_names = [fd.name for fd in field_descs]\n feature_metas = dict([(fd.name, fd.to_dict(dtype_to_string=True))\n for fd in field_descs])\n transform_fn = ComposedColumnTransformer(\n feature_column_names, *feature_columns[\"feature_columns\"])\n\n is_pai = True if pai_table else False\n if is_pai:\n conn = PaiIOConnection.from_table(pai_table)\n else:\n conn = db.connect_with_data_source(datasource)\n\n with temp_file.TemporaryDirectory() as tmp_dir_name:\n pred_fn = os.path.join(tmp_dir_name, \"predict.txt\")\n\n dpred = xgb_dataset(\n datasource=datasource,\n fn=pred_fn,\n dataset_sql=select,\n feature_metas=feature_metas,\n feature_column_names=feature_column_names,\n label_meta=train_label_desc.to_dict(dtype_to_string=True),\n cache=True,\n batch_size=10000,\n transform_fn=transform_fn,\n is_pai=is_pai,\n pai_table=pai_table,\n pai_single_file=True,\n feature_column_code=fc_map_ir)\n\n for i, pred_dmatrix in enumerate(dpred):\n if is_pai:\n feature_file_name = pred_fn\n else:\n feature_file_name = pred_fn + \"_%d\" % i\n preds = _calc_predict_result(bst, pred_dmatrix, model_params)\n _store_evaluate_result(preds, feature_file_name, train_label_desc,\n result_table, result_column_names,\n validation_metrics, conn)\n\n conn.close()\n\n\ndef _store_evaluate_result(preds, feature_file_name, label_desc, result_table,\n result_column_names, validation_metrics, conn):\n \"\"\"\n Save the evaluation result in the table.\n\n Args:\n preds: the prediction result.\n feature_file_name (str): the file path where the feature dumps.\n label_desc (FieldDesc): the label FieldDesc object.\n result_table (str): the result table name.\n result_column_names (list[str]): the result column names.\n validation_metrics (list[str]): the evaluation metric names.\n conn: the database connection object.\n\n Returns:\n None.\n \"\"\"\n y_test = []\n with open(feature_file_name, 'r') as f:\n for line in f.readlines():\n row = [i for i in line.strip().split(\"\\t\")]\n # DMatrix store label in the first column\n if label_desc.dtype == DataType.INT64:\n y_test.append(int(row[0]))\n elif label_desc.dtype == DataType.FLOAT32:\n y_test.append(float(row[0]))\n else:\n raise TypeError(\"unsupported data type {}\".format(\n label_desc.dtype))\n\n y_test = np.array(y_test)\n\n evaluate_results = dict()\n for metric_name in validation_metrics:\n metric_name = metric_name.strip()\n if metric_name not in SKLEARN_METRICS:\n raise ValueError(\"unsupported metrics %s\" % metric_name)\n metric_func = getattr(sklearn.metrics, metric_name)\n metric_value = metric_func(y_test, preds)\n evaluate_results[metric_name] = metric_value\n\n # write evaluation result to result table\n with db.buffered_db_writer(conn, result_table, result_column_names) as w:\n row = [\"0.0\"]\n for mn in validation_metrics:\n row.append(str(evaluate_results[mn]))\n w.write(row)\n"
] |
[
[
"numpy.array"
]
] |
fpernice-google/data
|
[
"049b6c0c42364aa59af1966bc270521208cfdab7"
] |
[
"scripts/world_bank/worldbank.py"
] |
[
"# Copyright 2020 Google LLC\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# https://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\"\"\" Fetches, cleans, outputs TMCFs and CSVs for all World Bank development\n indicator codes provided in WorldBankIndicators.csv for all years and for\n all countries provided in WorldBankCountries.csv. \"\"\"\n\nfrom absl import app\nimport pandas as pd\nimport itertools\nimport requests\nimport zipfile\nimport io\nimport re\n\n# Remaps the columns provided by World Bank API.\nWORLDBANK_COL_REMAP = {\n 'Country Name': 'CountryName',\n 'Country Code': 'CountryCode',\n 'Indicator Name': 'IndicatorName',\n 'Indicator Code': 'IndicatorCode'\n}\n\nTEMPLATE_TMCF = \"\"\"\nNode: E:WorldBank->E0\ntypeOf: dcs:StatVarObservation\nvariableMeasured: C:WorldBank->StatisticalVariable\nobservationDate: C:WorldBank->Year\nobservationPeriod: \"P1Y\"\nobservationAbout: C:WorldBank->ISO3166Alpha3\nvalue: C:WorldBank->Value\n\"\"\"\n\nTEMPLATE_STAT_VAR = \"\"\"\nNode: dcid:WorldBank/{INDICATOR}\nname: \"{NAME}\"\ndescription: \"{DESCRIPTION}\"\ntypeOf: dcs:StatisticalVariable\npopulationType: dcs:{populationType}\nstatType: dcs:{statType}\nmeasuredProperty: dcs:{measuredProperty}\nmeasurementDenominator: dcs:{measurementDenominator}\n{CONSTRAINTS}\n\"\"\"\n\n\ndef read_worldbank(iso3166alpha3):\n \"\"\" Fetches and tidies all ~1500 World Bank indicators\n for a given ISO 3166 alpha 3 code.\n\n For a particular alpha 3 code, this function fetches the entire ZIP\n file for that particular country for all World Bank indicators in a\n wide format where years are columns. The dataframe is changed into a\n narrow format so that year becomes a single column with each row\n representing a different year for a single indicator.\n\n Args:\n iso3166alpha3: ISO 3166 alpha 3 for a country, as a string.\n\n Returns:\n A tidied pandas dataframe with all indicator codes for a particular\n country in the format of (country, indicator, year, value).\n\n Notes:\n Takes approximately 10 seconds to download and\n tidy one country in a Jupyter notebook.\n \"\"\"\n country_zip = (\"http://api.worldbank.org/v2/en/country/\" + iso3166alpha3 +\n \"?downloadformat=csv\")\n r = requests.get(country_zip)\n filebytes = io.BytesIO(r.content)\n myzipfile = zipfile.ZipFile(filebytes)\n\n # We need to select the data file which starts with \"API\",\n # but does not have an otherwise regular filename structure.\n file_to_open = None\n for file in myzipfile.namelist():\n if file.startswith(\"API\"):\n file_to_open = file\n break\n assert file_to_open is not None, \\\n \"Failed to find data for\" + iso3166alpha3\n\n df = None\n # Captures any text contained in double quotatations.\n line_match = re.compile(r\"\\\"([^\\\"]*)\\\"\")\n\n for line in myzipfile.open(file_to_open).readlines():\n # Cells are contained in quotations and comma separated.\n cols = line_match.findall(line.decode(\"utf-8\"))\n\n # CSVs include header informational lines which should be ignored.\n if len(cols) > 2:\n # Use first row as the header.\n if df is None:\n df = pd.DataFrame(columns=cols)\n else:\n df = df.append(pd.DataFrame([cols], columns=df.columns),\n ignore_index=True)\n\n df = df.rename(columns=WORLDBANK_COL_REMAP)\n\n # Turn each year into its own row.\n df = df.set_index(\n ['CountryName', 'CountryCode', 'IndicatorName', 'IndicatorCode'])\n df = df.stack()\n df.index = df.index.rename('year', level=4)\n df.name = \"Value\"\n df = df.reset_index()\n\n # Convert to numeric and drop empty values.\n df['Value'] = pd.to_numeric(df['Value'])\n df = df.dropna()\n return df\n\n\ndef build_stat_vars_from_indicator_list(row):\n \"\"\" Generates World Bank StatVar for a row in the indicators dataframe. \"\"\"\n\n def row_to_constraints(row):\n \"\"\" Helper to generate list of constraints. \"\"\"\n constraints_text = \"\"\n next_constraint = 1\n while (f\"p{next_constraint}\" in row and\n not pd.isna(row[f\"p{next_constraint}\"])):\n variable = row[f'p{next_constraint}']\n constraint = row[f'v{next_constraint}']\n constraints_text += f\"{variable}: dcs:{constraint}\\n\"\n next_constraint += 1\n return constraints_text\n\n # yapf: disable\n # Input all required statistical variable fields.\n new_stat_var = (TEMPLATE_STAT_VAR\n .replace(\"{INDICATOR}\", row['IndicatorCode'].replace(\".\", \"_\"))\n .replace(\"{NAME}\", row['IndicatorName'])\n .replace(\"{DESCRIPTION}\", row['SourceNote'])\n .replace(\"{measuredProperty}\", row['measuredProp'])\n .replace(\"{CONSTRAINTS}\", row_to_constraints(row))\n )\n # yapf: enable\n # Include or remove option fields.\n for optional_col in ([\n 'populationType', 'statType', 'measurementDenominator'\n ]):\n if not pd.isna(row[optional_col]):\n new_stat_var = new_stat_var.replace(f\"{{{optional_col}}}\",\n row[optional_col])\n else:\n new_stat_var = new_stat_var.replace(\n f\"{optional_col}: dcs:{{{optional_col}}}\\n\", \"\")\n return new_stat_var\n\n\ndef group_stat_vars_by_observation_properties(indicator_codes):\n \"\"\" Groups stat vars by their observation schemas.\n\n Groups Stat Vars by their inclusion of StatVar Observation\n properties like measurementMethod or Unit.\n The current template MCF schema does not support optional values in the\n CSV so we must place these stat vars into\n different template MCFs and CSVs.\n\n Args:\n indicator_codes: List of World Bank indicator codes with\n their Data Commons mappings, as a pandas dataframe.\n\n Returns:\n Array of tuples for each statistical variable grouping.\n 1) template MCF, as a string.\n 2) columns to include in exported csv, as a list of strings.\n 3) indicator codes in this grouping, as a list of strings.\n \"\"\"\n # All the statistical observation properties that we included.\n properties_of_stat_var_observation = ([\n 'measurementMethod', 'scalingFactor', 'sourceScalingFactor', 'unit'\n ])\n # List of tuples to return.\n tmcfs_for_stat_vars = []\n # Dataframe that tracks which values are null.\n null_status = indicator_codes.notna()\n\n # Iterates over all permutations of stat var properties being included.\n for permutation in list(\n itertools.product([False, True],\n repeat=len(properties_of_stat_var_observation))):\n codes_that_match = null_status.copy()\n base_template_mcf = TEMPLATE_TMCF\n cols_to_include_in_csv = ['IndicatorCode']\n\n # Loop over each obs column and whether to include it.\n for include_col, column in (zip(permutation,\n properties_of_stat_var_observation)):\n # Filter the dataframe by this observation.\n codes_that_match = codes_that_match.query(\n f\"{column} == {include_col}\")\n # Include the column in TMCF and column list.\n if include_col:\n base_template_mcf += f\"{column}: C:WorldBank->{column}\\n\"\n cols_to_include_in_csv.append(f\"{column}\")\n\n tmcfs_for_stat_vars.append(\n (base_template_mcf, cols_to_include_in_csv,\n list(\n indicator_codes.loc[codes_that_match.index]['IndicatorCode'])))\n return tmcfs_for_stat_vars\n\n\ndef download_indicator_data(worldbank_countries, indicator_codes):\n \"\"\" Downloads World Bank country data for all countries and\n indicators provided.\n\n Retains only the unique indicator codes provided.\n\n Args:\n worldbank_countries: Dataframe with ISO 3166 alpha 3 code for each\n country.\n indicator_code: Dataframe with INDICATOR_CODES to include.\n\n Returns:\n worldbank_dataframe: A tidied pandas dataframe where each row has\n the format (indicator code, ISO 3166 alpha 3, year, value)\n for all countries and all indicators provided.\n \"\"\"\n worldbank_dataframe = pd.DataFrame()\n indicators_to_keep = list(indicator_codes['IndicatorCode'].unique())\n\n for index, country_code in enumerate(worldbank_countries['ISO3166Alpha3']):\n print(f\"Downloading {country_code}\")\n country_df = read_worldbank(country_code)\n\n # Remove unneccessary indicators.\n country_df = country_df[country_df['IndicatorCode'].isin(\n indicators_to_keep)]\n\n # Map country codes to ISO.\n country_df['ISO3166Alpha3'] = country_code\n\n # Add new row to main datframe.\n worldbank_dataframe = worldbank_dataframe.append(country_df)\n\n # Map indicator codes to unique Statistical Variable.\n worldbank_dataframe['StatisticalVariable'] = (\n worldbank_dataframe['IndicatorCode'].apply(\n lambda code: f\"WorldBank/{code.replace('.', '_')}\"))\n return worldbank_dataframe.rename({'year': 'Year'}, axis=1)\n\n\ndef output_csv_and_tmcf_by_grouping(worldbank_dataframe, tmcfs_for_stat_vars,\n indicator_codes):\n \"\"\" Outputs TMCFs and CSVs for each grouping of stat vars.\n\n Args:\n worldbank_dataframe: Dataframe containing all indicators for all\n countries.\n tmcfs_for_stat_vars: Array of tuples of template MCF,\n columns on stat var observations,\n indicator codes for that template.\n indicator_codes -> Dataframe with INDICATOR_CODES to include.\n \"\"\"\n # Only include a subset of columns in the final csv\n output_csv = worldbank_dataframe[[\n 'StatisticalVariable', 'IndicatorCode', 'ISO3166Alpha3', 'Year', 'Value'\n ]]\n\n # Output tmcf and csv for each unique World Bank grouping.\n for index, enum in enumerate(tmcfs_for_stat_vars):\n tmcf, stat_var_obs_cols, stat_vars_in_group = enum\n if len(stat_vars_in_group) != 0:\n with open(f\"output/WorldBank_{index}.tmcf\", 'w',\n newline='') as f_out:\n f_out.write(tmcf)\n\n # Output only the indicator codes in that grouping.\n matching_csv = output_csv[output_csv['IndicatorCode'].isin(\n stat_vars_in_group)]\n\n # Include the Stat Observation columns in the output CSV.\n if len(stat_var_obs_cols) > 1:\n matching_csv = pd.merge(matching_csv,\n indicator_codes[stat_var_obs_cols],\n on=\"IndicatorCode\")\n\n # Format to decimals.\n matching_csv = matching_csv.round(10)\n matching_csv.drop(\"IndicatorCode\",\n axis=1).to_csv(f\"output/WorldBank_{index}.csv\",\n float_format='%.10f',\n index=False)\n\n\ndef source_scaling_remap(row, scaling_factor_lookup, existing_stat_var_lookup):\n \"\"\" Scales values by sourceScalingFactor and inputs exisiting stat vars.\n\n First, this function converts all values to per capita. Some measures\n in the World Bank dataset are per thousand or per hundred thousand, but\n we need to scale these to the common denomination format. Secondly,\n some statistical variables such as Count_Person_InLaborForce are not\n World Bank specific and need to be replaced. Both of these are imputted\n from the following two lists in args.\n\n Args:\n scaling_factor_lookup: A dictionary of a mapping between World Bank\n indicator code to the respective numeric scaling factor.\n existing_stat_var_lookup: A dictionary of a mapping between all\n indicator to be replaced with the exisiting stat var to replace it.\n \"\"\"\n indicator_code = row['IndicatorCode']\n if indicator_code in scaling_factor_lookup:\n row['Value'] = (row['Value'] /\n int(scaling_factor_lookup[indicator_code]))\n\n if indicator_code in existing_stat_var_lookup:\n row['StatisticalVariable'] = (\"dcid:\" +\n existing_stat_var_lookup[indicator_code])\n return row\n\n\ndef main(_):\n # Load statistical variable configuration file.\n indicator_codes = pd.read_csv(\"WorldBankIndicators.csv\")\n\n # Add source description to note.\n def add_source_to_description(row):\n if not pd.isna(row['Source']):\n return row['SourceNote'] + \" \" + str(row['Source'])\n else:\n return row['SourceNote']\n\n indicator_codes['SourceNote'] = indicator_codes.apply(\n add_source_to_description, axis=1)\n\n # Generate stat vars\n with open(\"output/WorldBank_StatisticalVariables.mcf\", \"w+\") as f_out:\n # Generate StatVars for fields that don't exist. Some fields such as\n # Count_Person_Unemployed are already statistical variables so we do\n # not need to recreate them.\n for _, row in indicator_codes[\n indicator_codes['ExistingStatVar'].isna()].iterrows():\n f_out.write(build_stat_vars_from_indicator_list(row))\n\n # Create template MCFs for each grouping of stat vars.\n tmcfs_for_stat_vars = (\n group_stat_vars_by_observation_properties(indicator_codes))\n\n # Download data for all countries.\n worldbank_countries = pd.read_csv(\"WorldBankCountries.csv\")\n worldbank_dataframe = download_indicator_data(worldbank_countries,\n indicator_codes)\n\n # Remap columns to match expected format.\n worldbank_dataframe['Value'] = pd.to_numeric(worldbank_dataframe['Value'])\n worldbank_dataframe['ISO3166Alpha3'] = (\n worldbank_dataframe['ISO3166Alpha3'].apply(\n lambda code: \"dcs:country/\" + code))\n worldbank_dataframe['StatisticalVariable'] = \\\n worldbank_dataframe['StatisticalVariable'].apply(\n lambda code: \"dcs:\" + code)\n\n # Scale values by scaling factor and replace exisiting StatVars.\n scaling_factor_lookup = (indicator_codes.set_index(\"IndicatorCode\")\n ['sourceScalingFactor'].dropna().to_dict())\n existing_stat_var_lookup = (indicator_codes.set_index(\"IndicatorCode\")\n ['ExistingStatVar'].dropna().to_dict())\n worldbank_dataframe = worldbank_dataframe.apply(\n lambda row: source_scaling_remap(row, scaling_factor_lookup,\n existing_stat_var_lookup),\n axis=1)\n\n # Convert integer columns.\n int_cols = (list(indicator_codes[indicator_codes['ConvertToInt'] == True]\n ['IndicatorCode'].unique()))\n worldbank_subset = worldbank_dataframe[\n worldbank_dataframe['IndicatorCode'].isin(int_cols)].index\n worldbank_dataframe.loc[worldbank_subset, \"Value\"] = (pd.to_numeric(\n worldbank_dataframe.loc[worldbank_subset, \"Value\"], downcast=\"integer\"))\n\n # Output final CSVs and variables.\n output_csv_and_tmcf_by_grouping(worldbank_dataframe, tmcfs_for_stat_vars,\n indicator_codes)\n\n\nif __name__ == '__main__':\n app.run(main)\n"
] |
[
[
"pandas.isna",
"pandas.merge",
"pandas.DataFrame",
"pandas.read_csv",
"pandas.to_numeric"
]
] |
super-resolution/Locan
|
[
"94ed7759f7d7ceddee7c7feaabff80010cfedf30"
] |
[
"locan/tests/data/test_alpha_shape_2d.py"
] |
[
"import numpy as np\nimport pytest\nfrom scipy.spatial import Delaunay\n\nfrom locan.data.hulls.alpha_shape_2d import _circumcircle, _half_distance\n\n\ndef test__circumcircle_2d(locdata_2d):\n points = np.array([(0, 0), (1, 1 + np.sqrt(2)), (1 + np.sqrt(2), 1)])\n center, radius = _circumcircle(points, [2, 1, 0])\n assert radius == np.sqrt(2)\n assert np.array_equal(center, [1, 1])\n\n points = locdata_2d.coordinates\n triangulation = Delaunay(points)\n center, radius = _circumcircle(points, triangulation.simplices[0])\n assert radius == pytest.approx(1.8210786221487993)\n assert center[0] == pytest.approx(3.357142857142857)\n\n\ndef test__half_distance():\n points = np.array([(0, 0), (0, 1)])\n radius = _half_distance(points)\n assert radius == 0.5\n"
] |
[
[
"numpy.array",
"numpy.array_equal",
"scipy.spatial.Delaunay",
"numpy.sqrt"
]
] |
AndrewWilliams3142/cmip6_preprocessing
|
[
"8cdd02de9fa35b373be5a66da9bc481ca3a6aaa8"
] |
[
"cmip6_preprocessing/preprocessing.py"
] |
[
"# Preprocessing for CMIP6 models\nimport xarray as xr\nimport pandas as pd\nimport numpy as np\nimport warnings\n\n\ndef cmip6_renaming_dict():\n \"\"\"a universal renaming dict. Keys correspond to source id (model name)\n and valuse are a dict of target name (key) and a list of variables that\n should be renamed into the target.\"\"\"\n rename_dict = {\n # dim labels (order represents the priority when checking for the dim labels)\n \"x\": [\"x\", \"i\", \"ni\", \"xh\", \"nlon\", \"lon\", \"longitude\"],\n \"y\": [\"y\", \"j\", \"nj\", \"yh\", \"nlat\", \"lat\", \"latitude\"],\n \"lev\": [\"lev\", \"deptht\", \"olevel\", \"zlev\", \"olev\", \"depth\"],\n \"bnds\": [\"bnds\", \"axis_nbounds\", \"d2\"],\n \"vertex\": [\"vertex\", \"nvertex\", \"vertices\"],\n # coordinate labels\n \"lon\": [\"lon\", \"longitude\", \"nav_lon\"],\n \"lat\": [\"lat\", \"latitude\", \"nav_lat\"],\n \"lev_bounds\": [\n \"lev_bounds\",\n \"deptht_bounds\",\n \"lev_bnds\",\n \"olevel_bounds\",\n \"zlev_bnds\",\n ],\n \"lon_bounds\": [\n \"bounds_lon\",\n \"bounds_nav_lon\",\n \"lon_bnds\",\n \"x_bnds\",\n \"vertices_longitude\",\n ],\n \"lat_bounds\": [\n \"bounds_lat\",\n \"bounds_nav_lat\",\n \"lat_bnds\",\n \"y_bnds\",\n \"vertices_latitude\",\n ],\n \"time_bounds\": [\"time_bounds\", \"time_bnds\"],\n }\n return rename_dict\n\n\ndef rename_cmip6(ds, rename_dict=None):\n \"\"\"Homogenizes cmip6 dadtasets to common naming\"\"\"\n ds = ds.copy()\n source_id = ds.attrs[\"source_id\"]\n\n if rename_dict is None:\n rename_dict = cmip6_renaming_dict()\n\n # rename variables\n if len(rename_dict) == 0:\n warnings.warn(\n \"input dictionary empty.\",\n UserWarning,\n )\n else:\n for di in rename_dict.keys():\n\n # make sure the input is a list\n if isinstance(rename_dict[di], str):\n rename_dict[di] = [rename_dict[di]]\n\n if di not in ds.variables:\n\n # For now just stop in the list if the dimension is already there, or one 'hit'\n # was already encountered.\n trigger = False\n for wrong in rename_dict[di]:\n if wrong in ds.variables or wrong in ds.dims:\n if not trigger:\n ds = ds.rename({wrong: di})\n trigger = True\n\n return ds\n\n\ndef promote_empty_dims(ds):\n \"\"\"Convert empty dimensions to actual coordinates\"\"\"\n ds = ds.copy()\n for di in ds.dims:\n if di not in ds.coords:\n ds = ds.assign_coords({di: ds[di]})\n # ds.coords[di] = ds[di]\n return ds\n\n\n# some of the models do not have 2d lon lats, correct that.\ndef broadcast_lonlat(ds, verbose=True):\n \"\"\"Some models (all `gr` grid_labels) have 1D lon lat arrays\n This functions broadcasts those so lon/lat are always 2d arrays.\"\"\"\n if \"lon\" not in ds.variables:\n ds.coords[\"lon\"] = ds[\"x\"]\n if \"lat\" not in ds.variables:\n ds.coords[\"lat\"] = ds[\"y\"]\n\n if len(ds[\"lon\"].dims) < 2:\n ds.coords[\"lon\"] = ds[\"lon\"] * xr.ones_like(ds[\"lat\"])\n if len(ds[\"lat\"].dims) < 2:\n ds.coords[\"lat\"] = xr.ones_like(ds[\"lon\"]) * ds[\"lat\"]\n\n return ds\n\n\ndef replace_x_y_nominal_lat_lon(ds):\n \"\"\"Approximate the dimensional values of x and y with mean lat and lon at the equator\"\"\"\n ds = ds.copy()\n\n def maybe_fix_non_unique(data, pad=False):\n \"\"\"remove duplicate values by linear interpolation\n if values are non-unique. `pad` if the last two points are the same\n pad with -90 or 90. This is only applicable to lat values\"\"\"\n if len(data) == len(np.unique(data)):\n return data\n else:\n # pad each end with the other end.\n if pad:\n if len(np.unique([data[0:2]])) < 2:\n data[0] = -90\n if len(np.unique([data[-2:]])) < 2:\n data[-1] = 90\n\n ii_range = np.arange(len(data))\n _, indicies = np.unique(data, return_index=True)\n double_idx = np.array([ii not in indicies for ii in ii_range])\n # print(f\"non-unique values found at:{ii_range[double_idx]})\")\n data[double_idx] = np.interp(\n ii_range[double_idx], ii_range[~double_idx], data[~double_idx]\n )\n return data\n\n if \"x\" in ds.dims and \"y\" in ds.dims:\n\n # pick the nominal lon/lat values from the eastern\n # and southern edge, and eliminate non unique values\n # these occour e.g. in \"MPI-ESM1-2-HR\"\n max_lat_idx = ds.lat.isel(y=-1).argmax(\"x\").load().data\n nominal_y = maybe_fix_non_unique(ds.isel(x=max_lat_idx).lat.load().data)\n eq_idx = len(ds.y) // 2\n nominal_x = maybe_fix_non_unique(ds.isel(y=eq_idx).lon.load().data)\n\n ds = ds.assign_coords(x=nominal_x, y=nominal_y)\n ds = ds.sortby(\"x\")\n ds = ds.sortby(\"y\")\n\n # do one more interpolation for the x values, in case the boundary values were\n # affected\n ds = ds.assign_coords(\n x=maybe_fix_non_unique(ds.x.load().data),\n y=maybe_fix_non_unique(ds.y.load().data, pad=True),\n )\n\n else:\n warnings.warn(\n \"No x and y found in dimensions for source_id:%s. This likely means that you forgot to rename the dataset or this is the German unstructured model\"\n % ds.attrs[\"source_id\"]\n )\n return ds\n\n\ndef unit_conversion_dict():\n \"\"\"Units conversion database\"\"\"\n unit_dict = {\"m\": {\"centimeters\": 1 / 100}}\n return unit_dict\n\n\ndef correct_units(ds, verbose=False, stric=False):\n \"Converts coordinates into SI units using `unit_conversion_dict`\"\n unit_dict = unit_conversion_dict()\n ds = ds.copy()\n # coordinate conversions\n for co, expected_unit in [(\"lev\", \"m\")]:\n if co in ds.coords:\n if \"units\" in ds.coords[co].attrs.keys():\n unit = ds.coords[co].attrs[\"units\"]\n if unit != expected_unit:\n print(\n \"%s: Unexpected unit (%s) for coordinate `%s` detected.\"\n % (ds.attrs[\"source_id\"], unit, co)\n )\n if unit in unit_dict[expected_unit].keys():\n factor = unit_dict[expected_unit][unit]\n ds.coords[co] = ds.coords[co] * factor\n ds.coords[co].attrs[\"units\"] = expected_unit\n print(\"\\t Converted to `m`\")\n else:\n print(\"No conversion found in unit_dict\")\n else:\n print(\"%s: No units found\" % ds.attrs[\"source_id\"])\n\n else:\n if verbose:\n print(\"`%s` not found as coordinate\" % co)\n return ds\n\n\ndef correct_coordinates(ds, verbose=False):\n \"\"\"converts wrongly assigned data_vars to coordinates\"\"\"\n ds = ds.copy()\n for co in [\n \"x\",\n \"y\",\n \"lon\",\n \"lat\",\n \"lev\",\n \"bnds\",\n \"lev_bounds\",\n \"lon_bounds\",\n \"lat_bounds\",\n \"time_bounds\",\n \"lat_verticies\",\n \"lon_verticies\",\n ]:\n if co in ds.variables:\n if verbose:\n print(\"setting %s as coord\" % (co))\n ds = ds.set_coords(co)\n return ds\n\n\ndef correct_lon(ds):\n \"\"\"Wraps negative x and lon values around to have 0-360 lons.\n longitude names expected to be corrected with `rename_cmip6`\"\"\"\n ds = ds.copy()\n\n # remove out of bounds values found in some\n # models as missing values\n ds[\"lon\"] = ds[\"lon\"].where(abs(ds[\"lon\"]) <= 1e35)\n ds[\"lat\"] = ds[\"lat\"].where(abs(ds[\"lat\"]) <= 1e35)\n\n # adjust lon convention\n lon = ds[\"lon\"].where(ds[\"lon\"] > 0, 360 + ds[\"lon\"])\n ds = ds.assign_coords(lon=lon)\n\n if \"lon_bounds\" in ds.variables:\n lon_b = ds[\"lon_bounds\"].where(ds[\"lon_bounds\"] > 0, 360 + ds[\"lon_bounds\"])\n ds = ds.assign_coords(lon_bounds=lon_b)\n\n return ds\n\n\ndef parse_lon_lat_bounds(ds):\n \"\"\"both `regular` 2d bounds and vertex bounds are parsed as `*_bounds`.\n This function renames them to `*_verticies` if the vertex dimension is found.\n Also removes time dimension from static bounds as found in e.g. `SAM0-UNICON` model.\n \"\"\"\n if \"source_id\" in ds.attrs.keys():\n if ds.attrs[\"source_id\"] == \"FGOALS-f3-L\":\n warnings.warn(\"`FGOALS-f3-L` does not provide lon or lat bounds.\")\n\n ds = ds.copy()\n\n if \"lat_bounds\" in ds.variables:\n if \"x\" not in ds.lat_bounds.dims:\n ds.coords[\"lat_bounds\"] = ds.coords[\"lat_bounds\"] * xr.ones_like(ds.x)\n\n if \"lon_bounds\" in ds.variables:\n if \"y\" not in ds.lon_bounds.dims:\n ds.coords[\"lon_bounds\"] = ds.coords[\"lon_bounds\"] * xr.ones_like(ds.y)\n\n # I am assuming that all bound fields with time were broadcasted in error (except time bounds obviously),\n # and will drop the time dimension.\n error_dims = [\"time\"]\n for ed in error_dims:\n for co in [\"lon_bounds\", \"lat_bounds\", \"lev_bounds\"]:\n if co in ds.variables:\n if ed in ds[co].dims:\n warnings.warn(\n f\"Found {ed} as dimension in `{co}`. Assuming this is an error and just picking the first step along that dimension.\"\n )\n stripped_coord = ds[co].isel({ed: 0}).squeeze()\n # make sure that dimension is actually dropped\n if ed in stripped_coord.coords:\n stripped_coord = stripped_coord.drop(ed)\n\n ds = ds.assign_coords({co: stripped_coord})\n\n # Finally rename the bounds that are given in vertex convention\n for va in [\"lon\", \"lat\"]:\n va_name = va + \"_bounds\"\n if va_name in ds.variables and \"vertex\" in ds[va_name].dims:\n ds = ds.rename({va_name: va + \"_verticies\"})\n\n return ds\n\n\ndef maybe_convert_bounds_to_vertex(ds):\n \"\"\"Converts renamed lon and lat bounds into verticies, by copying\n the values into the corners. Assumes a rectangular cell.\"\"\"\n ds = ds.copy()\n if \"bnds\" in ds.dims:\n if \"lon_bounds\" in ds.variables and \"lat_bounds\" in ds.variables:\n if (\n \"lon_verticies\" not in ds.variables\n and \"lat_verticies\" not in ds.variables\n ):\n lon_b = xr.ones_like(ds.lat) * ds.coords[\"lon_bounds\"]\n lat_b = xr.ones_like(ds.lon) * ds.coords[\"lat_bounds\"]\n\n lon_bb = xr.concat(\n [lon_b.isel(bnds=ii).squeeze(drop=True) for ii in [0, 0, 1, 1]],\n dim=\"vertex\",\n )\n lon_bb = lon_bb.reset_coords(drop=True)\n\n lat_bb = xr.concat(\n [lat_b.isel(bnds=ii).squeeze(drop=True) for ii in [0, 1, 1, 0]],\n dim=\"vertex\",\n )\n lat_bb = lat_bb.reset_coords(drop=True)\n\n ds = ds.assign_coords(lon_verticies=lon_bb, lat_verticies=lat_bb)\n\n return ds\n\n\ndef maybe_convert_vertex_to_bounds(ds):\n \"\"\"Converts lon and lat verticies to bounds by averaging corner points\n on the appropriate cell face center.\"\"\"\n\n ds = ds.copy()\n if \"vertex\" in ds.dims:\n if \"lon_verticies\" in ds.variables and \"lat_verticies\" in ds.variables:\n if \"lon_bounds\" not in ds.variables and \"lat_bounds\" not in ds.variables:\n lon_b = xr.concat(\n [\n ds[\"lon_verticies\"].isel(vertex=[0, 1]).mean(\"vertex\"),\n ds[\"lon_verticies\"].isel(vertex=[2, 3]).mean(\"vertex\"),\n ],\n dim=\"bnds\",\n )\n lat_b = xr.concat(\n [\n ds[\"lat_verticies\"].isel(vertex=[0, 3]).mean(\"vertex\"),\n ds[\"lat_verticies\"].isel(vertex=[1, 2]).mean(\"vertex\"),\n ],\n dim=\"bnds\",\n )\n\n ds = ds.assign_coords(lon_bounds=lon_b, lat_bounds=lat_b)\n ds = promote_empty_dims(ds)\n return ds\n\n\ndef sort_vertex_order(ds):\n \"\"\"sorts the vertex dimension in a coherent order:\n 0: lower left\n 1: upper left\n 2: upper right\n 3: lower right\n \"\"\"\n ds = ds.copy()\n if (\n \"vertex\" in ds.dims\n and \"lon_verticies\" in ds.variables\n and \"lat_verticies\" in ds.variables\n ):\n\n # pick a vertex in the middle of the domain, to avoid the pole areas\n x_idx = len(ds.x) // 2\n y_idx = len(ds.y) // 2\n\n lon_b = ds.lon_verticies.isel(x=x_idx, y=y_idx).load().data\n lat_b = ds.lat_verticies.isel(x=x_idx, y=y_idx).load().data\n vert = ds.vertex.load().data\n\n points = np.vstack((lon_b, lat_b, vert)).T\n\n # split into left and right\n lon_sorted = points[np.argsort(points[:, 0]), :]\n right = lon_sorted[:2, :]\n left = lon_sorted[2:, :]\n # sort again on each side to get top and bottom\n bl, tl = left[np.argsort(left[:, 1]), :]\n br, tr = right[np.argsort(right[:, 1]), :]\n\n points_sorted = np.vstack((bl, tl, tr, br))\n\n idx_sorted = (points_sorted.shape[0] - 1) - np.argsort(points_sorted[:, 2])\n ds = ds.assign_coords(vertex=idx_sorted)\n ds = ds.sortby(\"vertex\")\n\n return ds\n\n\ndef combined_preprocessing(ds):\n if \"AWI\" not in ds.attrs[\"source_id\"]:\n ds = ds.copy()\n # fix naming\n ds = rename_cmip6(ds)\n # promote empty dims to actual coordinates\n ds = promote_empty_dims(ds)\n # demote coordinates from data_variables\n ds = correct_coordinates(ds)\n # broadcast lon/lat\n ds = broadcast_lonlat(ds)\n # shift all lons to consistent 0-360\n ds = correct_lon(ds)\n # fix the units\n ds = correct_units(ds)\n # replace x,y with nominal lon,lat\n ds = replace_x_y_nominal_lat_lon(ds)\n # rename the `bounds` according to their style (bound or vertex)\n ds = parse_lon_lat_bounds(ds)\n # sort verticies in a consistent manner\n ds = sort_vertex_order(ds)\n # convert vertex into bounds and vice versa, so both are available\n ds = maybe_convert_bounds_to_vertex(ds)\n ds = maybe_convert_vertex_to_bounds(ds)\n\n # # sort dims\n # for di in ds.dims:\n # ds = ds.sortby(di)\n\n return ds\n"
] |
[
[
"numpy.array",
"numpy.interp",
"numpy.argsort",
"numpy.unique",
"numpy.vstack"
]
] |
quanvuong/domain_randomization
|
[
"c0b7fdb39f20af1de5e575fde7f0f4e668e02116"
] |
[
"dr/experiment/ppo_pytorch.py"
] |
[
"import os\nimport os.path as osp\nimport pickle\nimport random\nfrom collections import deque\nfrom datetime import datetime\n\nimport gym\nimport numpy as np\nimport scipy.stats as stats\nimport torch\nimport torch.optim as optim\nfrom mpi4py import MPI\n\nimport dr\nfrom dr.ppo.models import Policy, ValueNet\nfrom dr.ppo.train import one_train_iter\nfrom dr.ppo.utils import set_torch_num_threads, RunningMeanStd, traj_seg_gen\n\nCOMM = MPI.COMM_WORLD\nimport tensorboardX\n\n\ndef set_global_seeds(i):\n torch.manual_seed(i)\n np.random.seed(i)\n random.seed(i)\n\n if torch.cuda.is_available():\n torch.cuda.manual_seed_all(i)\n\n\nclass CEMOptimizer(object):\n\n def __init__(self, sol_dim, max_iters, popsize, num_elites, cost_function,\n upper_bound=None, lower_bound=None, epsilon=0.001, alpha=0.25, viz_dir=None):\n \"\"\"Creates an instance of this class.\n Arguments:\n sol_dim (int): The dimensionality of the problem space\n max_iters (int): The maximum number of iterations to perform during optimization\n popsize (int): The number of candidate solutions to be sampled at every iteration\n num_elites (int): The number of top solutions that will be used to obtain the distribution\n at the next iteration.\n upper_bound (np.array): An array of upper bounds\n lower_bound (np.array): An array of lower bounds\n epsilon (float): A minimum variance. If the maximum variance drops below epsilon, optimization is\n stopped.\n alpha (float): Controls how much of the previous mean and variance is used for the next iteration.\n next_mean = alpha * old_mean + (1 - alpha) * elite_mean, and similarly for variance.\n \"\"\"\n super().__init__()\n self.sol_dim, self.max_iters, self.popsize, self.num_elites = sol_dim, max_iters, popsize, num_elites\n\n self.ub, self.lb = upper_bound, lower_bound\n self.epsilon, self.alpha = epsilon, alpha\n\n self.cost_function = cost_function\n\n if viz_dir is not None:\n self.writer = tensorboardX.SummaryWriter(viz_dir)\n else:\n self.writer = tensorboardX.SummaryWriter()\n\n if num_elites > popsize:\n raise ValueError(\"Number of elites must be at most the population size.\")\n\n def reset(self):\n pass\n\n def obtain_solution(self, init_mean, init_var):\n \"\"\"Optimizes the cost function using the provided initial candidate distribution\n Arguments:\n init_mean (np.ndarray): The mean of the initial candidate distribution.\n init_var (np.ndarray): The variance of the initial candidate distribution.\n \"\"\"\n mean, var, t = init_mean, init_var, 0\n X = stats.truncnorm(-2, 2, loc=np.zeros_like(mean), scale=np.ones_like(var))\n\n costs_hist = []\n mean_hist = []\n var_hist = []\n\n while (t < self.max_iters) and np.max(var) > self.epsilon:\n lb_dist, ub_dist = mean - self.lb, self.ub - mean\n constrained_var = np.minimum(np.minimum(np.square(lb_dist / 2), np.square(ub_dist / 2)), var)\n\n samples = X.rvs(size=[self.popsize, self.sol_dim]) * np.sqrt(constrained_var) + mean\n samples = samples.astype(np.float32)\n\n costs = self.cost_function(samples, t)\n\n elites = samples[np.argsort(costs)][:self.num_elites]\n\n new_mean = np.mean(elites, axis=0)\n new_var = np.var(elites, axis=0)\n\n mean = self.alpha * mean + (1 - self.alpha) * new_mean\n var = self.alpha * var + (1 - self.alpha) * new_var\n\n for i, m in enumerate(mean):\n self.writer.add_scalar(f'mean/{i}', m, t)\n\n for i, m in enumerate(var):\n self.writer.add_scalar(f'var/{i}', m, t)\n\n self.writer.add_scalar('costs', np.min(costs), t)\n\n t += 1\n\n costs_hist.append(costs)\n mean_hist.append(mean)\n var_hist.append(var)\n\n self.writer.close()\n\n return dict(\n mean_hist=mean_hist, costs_hist=costs_hist, var_hist=var_hist\n )\n\n\nclass PPO_Pytorch(object):\n\n def __init__(self, experiment_name, env_params, train_params, **kwargs):\n self.experiment_name = experiment_name\n self.env_params = env_params\n self.train_params = train_params\n\n self.log_dir = osp.join('runs',\n f'seed_{str(train_params[\"seed\"])}_{datetime.now().strftime(\"%b%d_%H-%M-%S\")}')\n\n os.makedirs(self.log_dir, exist_ok=True)\n\n with open(osp.join(self.log_dir, 'env_params.pkl'), 'wb+') as f:\n pickle.dump(env_params, f)\n\n with open(osp.join(self.log_dir, 'train_params.pkl'), 'wb+') as f:\n pickle.dump(train_params, f)\n\n super().__init__()\n\n def train(self, env_id, backend,\n train_params, env_params,\n means, stdevs):\n\n # Unpack params\n hid_size = train_params['hid_size']\n pol_init_std = train_params['pol_init_std']\n adam_epsilon = train_params['adam_epsilon']\n optim_stepsize = train_params['optim_stepsize']\n\n # Convert means and stdevs to dict format\n assert len(means) == len(stdevs), (len(means), len(stdevs))\n mean_dict, stdev_dict = PPO_Pytorch._vec_to_dict(env_id, means, stdevs)\n\n # Set parameter of env\n self.env_dist.default_parameters = mean_dict\n self.env_dist.stdev_dict = stdev_dict\n env = self.env_dist.root_env\n\n set_torch_num_threads()\n\n # Construct policy and value network\n pol = Policy(env.observation_space, env.action_space, hid_size, pol_init_std)\n pol_optim = optim.Adam(pol.parameters(), lr=optim_stepsize, eps=adam_epsilon)\n\n val = ValueNet(env.observation_space, hid_size)\n val_optim = optim.Adam(val.parameters(), lr=optim_stepsize, eps=adam_epsilon)\n\n optims = {'pol_optim': pol_optim, 'val_optim': val_optim}\n\n num_train_iter = int(train_params['num_timesteps'] / train_params['ts_per_batch'])\n\n # Buffer for running statistics\n eps_rets_buff = deque(maxlen=100)\n eps_rets_mean_buff = []\n\n state_running_m_std = RunningMeanStd(shape=env.observation_space.shape)\n\n # seg_gen is a generator that yields the training data points\n seg_gen = traj_seg_gen(self.env_dist, pol, val, state_running_m_std, env_params, train_params)\n\n eval_perfs = []\n\n for iter_i in range(num_train_iter):\n one_train_iter(pol, val, optims,\n iter_i, eps_rets_buff, eps_rets_mean_buff, seg_gen,\n state_running_m_std, train_params, self.eval_envs, eval_perfs)\n\n return eval_perfs\n\n def run(self):\n set_global_seeds(self.train_params['seed'])\n\n # Unpack params\n env_name = self.env_params['env_name']\n backend = self.env_params['backend']\n\n stdev = self.train_params['env_dist_stdev']\n mean_scale = self.train_params['mean_scale']\n seed = self.train_params['seed']\n\n num_eval_env = self.train_params['num_eval_env']\n collision_detector = self.env_params['collision_detector']\n\n # Obtain the initial value for the simulation parameters\n env_dist = dr.dist.Normal(env_name, backend, mean_scale=mean_scale)\n init_mean_param = PPO_Pytorch._dict_to_vec(env_name, env_dist.default_parameters)\n init_stdev_param = np.array([stdev] * len(init_mean_param), dtype=np.float32)\n\n cem_init_mean = np.concatenate((init_mean_param, init_stdev_param))\n cem_init_stdev = np.array([1.0] * len(cem_init_mean), dtype=np.float32)\n\n # Make envs that will be reused for training and eval\n self.env_dist = dr.dist.Normal(env_name, backend)\n self.env_dist.backend.set_collision_detector(env_dist.root_env, collision_detector)\n self.env_dist.seed(seed)\n\n if env_name == 'Walker':\n self.eval_envs = [gym.make('Walker2d-v2') for _ in range(num_eval_env)]\n elif env_name == 'Hopper':\n self.eval_envs = [gym.make('Hopper-v2') for _ in range(num_eval_env)]\n else:\n exit('Unrecognized environment')\n\n if COMM.Get_rank() == 0:\n self.optimizer = CEMOptimizer(\n sol_dim=30,\n max_iters=300,\n popsize=self.train_params['pop_size'],\n num_elites=self.train_params['num_elites'],\n cost_function=self._cost_function,\n lower_bound=0.0,\n # TODO: setting the upper bound this way, means that\n # if the initial dimension value is 0, then the upper bound is 0\n upper_bound=cem_init_mean * 5.0,\n alpha=0.75,\n viz_dir=self.log_dir\n )\n\n # This is buggy\n # https://github.com/lanpa/tensorboardX/issues/345\n self.optimizer.writer.add_text('env_params', str(self.env_params), 0)\n self.optimizer.writer.add_text('train_params', str(self.train_params), 0)\n\n res = self.optimizer.obtain_solution(cem_init_mean, cem_init_stdev)\n\n path = osp.join(self.log_dir, 'res.pkl')\n\n with open(path, 'wb') as f:\n pickle.dump(res, f)\n\n COMM.Abort(0)\n else:\n while True:\n args = COMM.recv(source=0)\n\n r = self.train(*args)\n\n COMM.send(r, dest=0)\n\n def _cost_function(self, samples, cem_timestep):\n print(f'cem_timestep: {cem_timestep}')\n\n env_name = self.env_params['env_name']\n backend = self.env_params['backend']\n pop_size = self.train_params['pop_size']\n\n argss = [(env_name, backend,\n self.train_params, self.env_params,\n samples[rank][:len(samples[rank]) // 2],\n samples[rank][len(samples[rank]) // 2:]) for rank in range(len(samples))]\n\n # Send args to other MPI processes\n for rank in range(1, COMM.size):\n COMM.send(argss[rank], dest=rank)\n\n # Obtain results for all args\n r = self.train(*argss[0])\n\n reses = [(0, r)] # 0 is the rank of this process\n\n # Receive results from the other processes:\n for rank in range(1, COMM.size):\n r = COMM.recv(source=rank)\n reses.append((rank, r))\n\n reses = sorted(reses, key=lambda k: k[0])\n print(reses)\n\n # Get the index of the highest performing model in population\n # and write result to tensorboard\n max_idx = 0\n max_perf = max(reses[0][1]) # 0 is the result of process rank 0. 1 brings us the eval perf list\n\n for i, item in enumerate(reses):\n perf = max(item[1])\n if perf > max_perf:\n max_perf = perf\n max_idx = i\n\n # Obtain the \"costs\" that the CEM cost function should return\n costs = [- max(i[1]) for i in reses]\n print(costs)\n print(min(costs))\n print()\n\n return costs\n\n @classmethod\n def _dict_to_vec(cls, env_id, d):\n\n return np.concatenate((\n d['mass'],\n d['damping'],\n [d['gravity']]\n )).flatten().copy()\n\n @classmethod\n def _vec_to_dict(cls, env_id, means, stdevs):\n\n if env_id == 'Walker':\n return dict(\n mass=means[:7],\n damping=means[7:-1],\n gravity=means[-1]\n ), dict(\n mass=stdevs[:7],\n damping=stdevs[7:-1],\n gravity=stdevs[-1]\n )\n elif env_id == 'Hopper':\n return dict(\n mass=means[:4],\n damping=means[4:-1],\n gravity=means[-1]\n ), dict(\n mass=stdevs[:4],\n damping=stdevs[4:-1],\n gravity=stdevs[-1]\n )\n else:\n exit('Unrecognized environment')\n"
] |
[
[
"numpy.concatenate",
"numpy.max",
"numpy.zeros_like",
"numpy.ones_like",
"torch.cuda.manual_seed_all",
"numpy.square",
"numpy.random.seed",
"numpy.min",
"numpy.mean",
"torch.manual_seed",
"torch.cuda.is_available",
"numpy.sqrt",
"numpy.argsort",
"numpy.var"
]
] |
ElliottP-13/opfunu
|
[
"7f4de3c34a91bb37fd8784fd28dbcf550e06d8a7",
"7f4de3c34a91bb37fd8784fd28dbcf550e06d8a7"
] |
[
"opfunu/cec/cec2005/F8.py",
"opfunu/dimension_based/benchmark1d.py"
] |
[
"#!/usr/bin/env python\n# ------------------------------------------------------------------------------------------------------%\n# Created by \"Thieu Nguyen\" at 15:39, 20/04/2020 %\n# %\n# Email: nguyenthieu2102@gmail.com %\n# Homepage: https://www.researchgate.net/profile/Thieu_Nguyen6 %\n# Github: https://github.com/thieu1995 %\n#-------------------------------------------------------------------------------------------------------%\n\nfrom opfunu.cec.cec2005.root import Root\nfrom numpy import sum, dot, cos, exp, pi, e, sqrt\n\n\nclass Model(Root):\n def __init__(self, f_name=\"Shifted Rotated Ackley's Function with Global Optimum on Bounds\", f_shift_data_file=\"data_ackley\",\n f_ext='.txt', f_bias=-140, f_matrix=None):\n Root.__init__(self, f_name, f_shift_data_file, f_ext, f_bias)\n self.f_matrix = f_matrix\n\n def _main__(self, solution=None):\n problem_size = len(solution)\n if problem_size > 100:\n print(\"CEC 2005 not support for problem size > 100\")\n return 1\n if problem_size == 10 or problem_size == 30 or problem_size == 50:\n self.f_matrix = \"ackley_M_D\" + str(problem_size)\n else:\n print(\"CEC 2005 F8 function only support problem size 10, 30, 50\")\n return 1\n shift_data = self.load_shift_data()[:problem_size]\n t1 = int(problem_size/2)\n for j in range(0, t1-1):\n shift_data[2*(j+1)-1] = -32 * shift_data[2*(j+1)]\n matrix = self.load_matrix_data(self.f_matrix)\n\n z = dot((solution - shift_data), matrix)\n result = -20 * exp(-0.2 * sum(z ** 2) / problem_size) - exp(sum(cos(2 * pi * z))) + 20 + e\n return result + self.f_bias\n\n\n\n\n\n",
"#!/usr/bin/env python #\n# ------------------------------------------------------------------------------------------------------#\n# Created by \"Thieu Nguyen\" at 02:52, 07/12/2019 #\n# #\n# Email: nguyenthieu2102@gmail.com #\n# Homepage: https://www.researchgate.net/profile/Thieu_Nguyen6 #\n# Github: https://github.com/thieu1995 #\n#-------------------------------------------------------------------------------------------------------#\n\n\nimport numpy as np\n\nclass Functions:\n \"\"\"\n This class of functions is belongs to 1-dimensional space\n \"\"\"\n\n def _gramacy_lee__(self, solution=None):\n \"\"\"\n Class: uni-modal, non-convex, continuous\n Global: 1 global minimum fx = −0.869011134989500, atx 0.548563444114526\n Link: http://benchmarkfcns.xyz/benchmarkfcns/gramacyleefcn.html\n\n @param solution: A numpy array include 1 items like: [0.5], limited range: [-0.5, 2.5]\n\n \"\"\"\n n = len(solution)\n assert (n == 1, 'Gramacy and Lee function is only defined on a 1D space.')\n return np.sin(10*np.pi*solution) / (2*solution) + (solution-1)**4\n"
] |
[
[
"numpy.sum",
"numpy.dot",
"numpy.cos"
],
[
"numpy.sin"
]
] |
MachineLearningCommunity/ML-From-Scratch
|
[
"09ea418e77b70aa79917bfaaeb58054353d49c5b"
] |
[
"mlfromscratch/utils/data_manipulation.py"
] |
[
"from __future__ import division\nfrom itertools import combinations_with_replacement\nimport numpy as np\nimport math\nimport sys\n\n\ndef shuffle_data(X, y, seed=None):\n if seed:\n np.random.seed(seed)\n n_samples = X.shape[0]\n idx = np.arange(n_samples)\n np.random.shuffle(idx)\n X = X[idx]\n y = y[idx]\n return X, y\n\n\n# Divide dataset based on if sample value on feature index is larger than\n# the given threshold\ndef divide_on_feature(X, feature_i, threshold):\n split_func = None\n if isinstance(threshold, int) or isinstance(threshold, float):\n split_func = lambda sample: sample[feature_i] >= threshold\n else:\n split_func = lambda sample: sample[feature_i] == threshold\n\n X_1 = np.array([sample for sample in X if split_func(sample)])\n X_2 = np.array([sample for sample in X if not split_func(sample)])\n\n return np.array([X_1, X_2])\n\ndef polynomial_features(X, degree):\n\n n_samples, n_features = np.shape(X)\n\n def index_combinations():\n combs = [combinations_with_replacement(range(n_features), i) for i in range(0, degree + 1)]\n flat_combs = [item for sublist in combs for item in sublist]\n return flat_combs\n \n combinations = index_combinations()\n n_output_features = len(combinations)\n X_new = np.empty((n_samples, n_output_features))\n \n for i, index_combs in enumerate(combinations): \n X_new[:, i] = np.prod(X[:, index_combs], axis=1)\n\n return X_new\n\n# Return random subsets (with replacements) of the data\ndef get_random_subsets(X, y, n_subsets, replacements=True):\n n_samples = np.shape(X)[0]\n # Concatenate x and y and do a random shuffle\n X_y = np.concatenate((X, y.reshape((1, len(y))).T), axis=1)\n np.random.shuffle(X_y)\n subsets = []\n\n # Uses 50% of training samples without replacements\n subsample_size = n_samples // 2\n if replacements:\n subsample_size = n_samples # 100% with replacements\n\n for _ in range(n_subsets):\n idx = np.random.choice(\n range(n_samples),\n size=np.shape(range(subsample_size)),\n replace=replacements)\n X = X_y[idx][:, :-1]\n y = X_y[idx][:, -1]\n subsets.append([X, y])\n return subsets\n\n\n# Normalize the dataset X\ndef normalize(X, axis=-1, order=2):\n l2 = np.atleast_1d(np.linalg.norm(X, order, axis))\n l2[l2 == 0] = 1\n return X / np.expand_dims(l2, axis)\n\n\n# Standardize the dataset X\ndef standardize(X):\n X_std = X\n mean = X.mean(axis=0)\n std = X.std(axis=0)\n for col in range(np.shape(X)[1]):\n if std[col]:\n X_std[:, col] = (X_std[:, col] - mean[col]) / std[col]\n # X_std = (X - X.mean(axis=0)) / X.std(axis=0)\n return X_std\n\n\n# Split the data into train and test sets\ndef train_test_split(X, y, test_size=0.5, shuffle=True, seed=None):\n if shuffle:\n X, y = shuffle_data(X, y, seed)\n # Split the training data from test data in the ratio specified in\n # test_size\n split_i = len(y) - int(len(y) // (1 / test_size))\n x_train, x_test = X[:split_i], X[split_i:]\n y_train, y_test = y[:split_i], y[split_i:]\n\n return x_train, x_test, y_train, y_test\n\n\n# Split the data into k sets of training / test data\ndef k_fold_cross_validation_sets(X, y, k, shuffle=True):\n if shuffle:\n X, y = shuffle_data(X, y)\n\n n_samples = len(y)\n left_overs = {}\n n_left_overs = (n_samples % k)\n if n_left_overs != 0:\n left_overs[\"X\"] = X[-n_left_overs:]\n left_overs[\"y\"] = y[-n_left_overs:]\n X = X[:-n_left_overs]\n y = y[:-n_left_overs]\n\n X_split = np.split(X, k)\n y_split = np.split(y, k)\n sets = []\n for i in range(k):\n X_test, y_test = X_split[i], y_split[i]\n X_train = np.concatenate(X_split[:i] + X_split[i + 1:], axis=0)\n y_train = np.concatenate(y_split[:i] + y_split[i + 1:], axis=0)\n sets.append([X_train, X_test, y_train, y_test])\n\n # Add left over samples to last set as training samples\n if n_left_overs != 0:\n np.append(sets[-1][0], left_overs[\"X\"], axis=0)\n np.append(sets[-1][2], left_overs[\"y\"], axis=0)\n\n return np.array(sets)\n\n\n# Making an array of nominal values into a binarized matrix\ndef categorical_to_binary(x):\n n_col = np.amax(x) + 1\n binarized = np.zeros((len(x), n_col))\n for i in range(len(x)):\n binarized[i, x[i]] = 1\n\n return binarized\n\n\n# Converting from binary vectors to nominal values\ndef binary_to_categorical(x):\n categorical = []\n for i in range(len(x)):\n if not 1 in x[i]:\n categorical.append(0)\n else:\n i_where_one = np.where(x[i] == 1)[0][0]\n categorical.append(i_where_one)\n\n return categorical\n\n\n# Converts a vector into an diagonal matrix\ndef make_diagonal(x):\n m = np.zeros((len(x), len(x)))\n for i in range(len(m[0])):\n m[i, i] = x[i]\n\n return m\n"
] |
[
[
"numpy.concatenate",
"numpy.array",
"numpy.linalg.norm",
"numpy.empty",
"numpy.random.seed",
"numpy.shape",
"numpy.random.shuffle",
"numpy.split",
"numpy.where",
"numpy.prod",
"numpy.arange",
"numpy.amax",
"numpy.append",
"numpy.expand_dims"
]
] |
orsdanilo/ml_from_scratch
|
[
"eb045c2525e5b99c2b91b7f8e19ab08b0cee2d96"
] |
[
"src/models/_linear.py"
] |
[
"import pandas as pd\nimport numpy as np\nimport math\nimport matplotlib.pyplot as plt\nfrom .metrics import mse_score, rmse_score, r2_score, mae_score\nfrom ..features.build_features import StandardScaler, MinMaxScaler\n\nclass LinearRegressor():\n \"\"\"Linear regressor\"\"\"\n\n def __init__(self, method='normal_equation', normalize=False, lr=0.01, epochs=1000, add_intercept=False):\n assert method in ['normal_equation', 'gradient_descent'], \"Method not supported. Supported methods are 'normal_equation' and 'gradient_descent'\"\n self.method = method\n self.normalize = normalize\n self.add_intercept = add_intercept\n self._weights = None\n\n if self.method == 'gradient_descent':\n self.lr = lr\n self.epochs = epochs\n\n if self.normalize:\n self._feature_scaler = MinMaxScaler()\n self._target_scaler = MinMaxScaler()\n \n def fit(self, X, y):\n \"\"\"Fit the model to the data\"\"\"\n \n if self.normalize:\n X = self._feature_scaler.fit_transform(X)\n y = self._target_scaler.fit_transform(y)\n\n X = X.to_numpy()\n if self.add_intercept:\n X = np.hstack((np.ones((X.shape[0], 1)), X))\n y = y.to_numpy()\n\n if self.method == 'normal_equation':\n self._weights = np.dot(np.dot(np.linalg.inv(np.dot(X.T, X)), X.T), y)\n\n else:\n # mse_new = np.inf\n self._weights = np.zeros(X.shape[1])\n self.cost_history = [0] * self.epochs\n\n for i in range(self.epochs):\n grad = np.dot(X.T, np.dot(X, self._weights) - y) / y.shape[0]\n self._weights = self._weights - self.lr * grad\n self.cost_history[i] = mse_score(y, np.dot(X, self._weights))\n\n # if (rmse_new > rmse_old):\n # print(\"Stopped at iteration {}\".format(i))\n # break\n plt.scatter(range(self.epochs), self.cost_history)\n plt.xlabel('epoch')\n plt.ylabel('mse')\n\n def predict(self, X):\n \"\"\"Use the fitted model to predict on data\"\"\"\n\n assert self._weights is not None, \"Model needs to be fitted first. Use the fit method\"\n\n if self.normalize:\n X = self._feature_scaler.transform(X)\n\n X = X.to_numpy() \n if self.add_intercept:\n X = np.hstack((np.ones((X.shape[0], 1)), X))\n \n y_pred = np.dot(X, self._weights)\n if self.normalize:\n y_pred = self._target_scaler.inverse_transform(y_pred)\n\n return np.round(y_pred, 2)\n \n def get_weights(self):\n \"\"\"Get weights from the fitted model\"\"\"\n\n assert self._weights is not None, \"Model needs to be fitted first. Use the fit method\"\n return self._weights\n\n def score(self, X, y, metric='r2'):\n \"\"\"Score the model\"\"\"\n\n assert metric in ['r2', 'rmse', 'mae'], \"Metric not supported. Supported metrics are 'r2', 'rmse' and 'mae'\"\n\n y_pred = self.predict(X) \n \n if metric == 'r2':\n score = r2_score(y, y_pred)\n elif metric == 'rmse':\n score = rmse_score(y, y_pred)\n elif metric == 'mae':\n score = mae_score(y, y_pred)\n\n return score"
] |
[
[
"numpy.dot",
"numpy.zeros",
"numpy.round",
"matplotlib.pyplot.xlabel",
"numpy.ones",
"matplotlib.pyplot.ylabel"
]
] |
noah95/edison
|
[
"652af8ed4c99c11000a6c0136d770583a5318d8e",
"652af8ed4c99c11000a6c0136d770583a5318d8e"
] |
[
"audio/edison/audio/bit_depth_analyze.py",
"audio/edison/mfcc/mfcc_utils.py"
] |
[
"import numpy as np\nfrom time import sleep\nimport struct\nimport matplotlib.pyplot as plt\n\n\n# input raw samples from MCU\n# in_data = 'out/data_raw.txt'\nin_data = 'out/8bit.txt'\nfs = 5000\nin_bits = 8\n\n# load file\nraw = np.loadtxt(in_data)\n\n# Stats\nprint(\"Max=%d Min=%d Mean=%d swing=%d %.1fbits\" % \\\n (np.max(raw), np.min(raw), np.mean(raw),\n np.max(raw) - np.min(raw), np.log2(np.max(raw) - np.min(raw))))\n\n# generate different bit audio\ndata_depth = {}\nprint(raw)\ndata_depth['16bit'] = 2**(in_bits-16)*(raw / (2**(in_bits-16))).astype('int')\nprint(data_depth['16bit'])\ndata_depth['10bit'] = 2**(in_bits-10)*(raw / (2**(in_bits-10))).astype('int')\ndata_depth['8bit'] = 2**(in_bits-8)*(raw / (2**(in_bits-8))).astype('int')\ndata_depth['7bit'] = 2**(in_bits-7)*(raw / (2**(in_bits-7))).astype('int')\ndata_depth['6bit'] = 2**(in_bits-6)*(raw / (2**(in_bits-6))).astype('int')\ndata_depth['2bit'] = 2**(in_bits-2)*(raw / (2**(in_bits-2))).astype('int')\n\n# normalize and zero mean all \nfor key in data_depth:\n data_depth[key] = data_depth[key] - np.mean(data_depth[key])\n data_depth[key] = data_depth[key] / np.max(np.abs(data_depth[key]))\n\n# write audio files\nfrom scipy.io.wavfile import write\nfor key in data_depth:\n write('out/test'+key+'.wav', fs, data_depth[key])\n\n# plot some\nt = np.arange(0, len(raw)/fs, 1/fs)\nfig, axs = plt.subplots(1, 1)\n\naxs.step(t, data_depth['16bit'], label='16bit')\naxs.step(t, data_depth['8bit'], label='8bit')\naxs.step(t, data_depth['7bit'], label='7bit')\naxs.step(t, data_depth['6bit'], label='6bit')\naxs.step(t, data_depth['2bit'], label='2bit')\n# axs.set_xlim(0, 6e-3)\n# axs.set_ylim(-1, 1)\naxs.set_xlabel('time [s]')\naxs.set_ylabel('mic data')\naxs.grid(True)\naxs.legend()\n\nfig.tight_layout()\nplt.show()\n\n\n",
"# -*- coding: utf-8 -*-\n# @Author: Noah Huetter\n# @Date: 2020-04-16 16:23:59\n# @Last Modified by: Noah Huetter\n# @Last Modified time: 2020-05-27 16:31:39\n\nimport numpy as np\nfrom scipy.fftpack import dct\nfrom tqdm import tqdm\n\n\n# mel freq. constants -> https://en.wikipedia.org/wiki/Mel_scale\nfrom config import *\n\n\ndef frames(data, frame_length=3, frame_step=1):\n \"\"\"\n Split a data vector into (possibly overlapipng) frames\n\n frame_length: length of each frame\n frame_step: how many sample to advance the frame each step\n \"\"\"\n n_frames = 1 + (data.shape[0] - frame_length) // frame_step\n out = np.zeros((n_frames,frame_length))\n for i in range(n_frames):\n out[i] = data[i*frame_step:i*frame_step+frame_length]\n return out\n\n\ndef hertz_to_mel(frequencies_hertz):\n \"\"\"\n Converts frequencies in `frequencies_hertz` in Hertz to the mel scale.\n \"\"\"\n return MEL_HIGH_FREQUENCY_Q * np.log(1.0 + (frequencies_hertz / MEL_BREAK_FREQUENCY_HERTZ))\n\ndef gen_mel_weight_matrix(num_mel_bins=20, num_spectrogram_bins=129, sample_rate=8000, \\\n lower_edge_hertz=125.0, upper_edge_hertz=3800.0):\n \"\"\"\n Generate mel weight matric from linear frequency spectrum, inspired by \n https://www.tensorflow.org/api_docs/python/tf/signal/linear_to_mel_weight_matrix\n\n \"\"\"\n nyquist_hertz = sample_rate / 2.0\n # excludes DC spectrogram bin\n n_bands_to_zero = 1\n linear_frequencies = np.linspace(0, nyquist_hertz, num_spectrogram_bins)[n_bands_to_zero:]\n # convert linear frequency vector to mel scale\n spectrogram_bins_mel = np.expand_dims( hertz_to_mel(linear_frequencies), 1)\n \n # Compute num_mel_bins triples of (lower_edge, center, upper_edge). The\n # center of each band is the lower and upper edge of the adjacent bands.\n # Accordingly, we divide [lower_edge_hertz, upper_edge_hertz] into\n # num_mel_bins + 2 pieces.\n band_edges_mel = frames(\n np.linspace(hertz_to_mel(lower_edge_hertz), hertz_to_mel(upper_edge_hertz), num_mel_bins + 2),\n frame_length=3, frame_step=1)\n \n # Split the triples up and reshape them into [1, num_mel_bins] vectors, one vector for\n # lower edge, one for center and one for uppers\n lower_edge_mel, center_mel, upper_edge_mel = tuple(np.reshape( t, [1, num_mel_bins] ) for t in np.split(band_edges_mel, 3, axis=1))\n \n # Calculate lower and upper slopes for every spectrogram bin. Line segments are \n # linear in the mel domain, not Hertz.\n lower_slopes = (spectrogram_bins_mel - lower_edge_mel) / (\n center_mel - lower_edge_mel)\n upper_slopes = (upper_edge_mel - spectrogram_bins_mel) / (\n upper_edge_mel - center_mel)\n \n # Intersect the line segments with each other and zero.\n mel_weights_matrix = np.maximum(0, np.minimum(lower_slopes, upper_slopes))\n \n # Re-add the zeroed lower bins we sliced out above\n return np.pad(mel_weights_matrix, [[n_bands_to_zero, 0], [0, 0]])\n\ndef batch_mfcc(data, \\\n fs, nSamples, frame_len, frame_step, frame_count, \\\n fft_len, \\\n mel_nbins, mel_lower_hz, mel_upper_hz):\n \"\"\"\n Runs windowed mfcc on a strem of data\n \n data input data fo shape [..., samples]\n fs input sample rate\n nSamples number of samples in input\n frame_len length of each frame\n frame_step how many samples to advance the frame\n frame_count how many frames to compute\n fft_len length of FFT, ideally frame_len \n mel_nbins number of mel filter banks to create\n mel_lower_hz lowest frequency of mel bank\n mel_upper_hz highest frequency of mel bank\n\n \"\"\"\n\n if frame_count == 0:\n frame_count = 1 + (nSamples - frame_len) // frame_step\n print(\"Running mfcc for %d frames with %d step on %d samples\" % (frame_count, frame_step, data.shape[0]))\n # will return a list with a dict for each frame\n output = np.zeros((data.shape[0], frame_count, mel_nbins))\n\n for sampleCtr in tqdm(range(data.shape[0])):\n for frame_ctr in range(frame_count): \n # get chunk of data\n chunk = data[sampleCtr][frame_ctr*frame_step : frame_ctr*frame_step+frame_len]\n\n # calculate FFT\n stfft = np.fft.fft(chunk)[:frame_len//2]\n \n # calcualte spectorgram\n spectrogram = np.abs(stfft)\n num_spectrogram_bins = len(spectrogram)\n\n # calculate mel weights\n mel_weight_matrix = gen_mel_weight_matrix(num_mel_bins=mel_nbins, \n num_spectrogram_bins=num_spectrogram_bins, sample_rate=fs,\n lower_edge_hertz=mel_lower_hz, upper_edge_hertz=mel_upper_hz)\n\n # dot product of spectrum and mel matrix to get mel spectrogram\n mel_spectrogram = np.dot(spectrogram, mel_weight_matrix)\n \n # take log of mel spectrogram\n log_mel_spectrogram = np.log(mel_spectrogram + 1e-6)\n\n # calculate DCT-II\n mfcc = dct(log_mel_spectrogram, type=2) / np.sqrt(2*mel_nbins)\n frame = np.array(mfcc)\n\n # Add frame to output list\n output[sampleCtr, frame_ctr, ...] = frame\n\n return output\n\n\ndef mfcc(data, \\\n fs, nSamples, frame_len, frame_step, frame_count, \\\n fft_len, \\\n mel_nbins, mel_lower_hz, mel_upper_hz, dummy=None):\n \"\"\"\n Runs windowed mfcc on a strem of data\n \n data input data\n fs input sample rate\n nSamples number of samples in input\n frame_len length of each frame\n frame_step how many samples to advance the frame\n frame_count how many frames to compute\n fft_len length of FFT, ideally frame_len \n mel_nbins number of mel filter banks to create\n mel_lower_hz lowest frequency of mel bank\n mel_upper_hz highest frequency of mel bank\n \n \"\"\"\n\n if frame_count == 0:\n frame_count = 1 + (nSamples - frame_len) // frame_step\n # print(\"Running mfcc for %d frames with %d step\" % (frame_count, frame_step))\n # will return a list with a dict for each frame\n output = []\n\n for frame_ctr in range(frame_count):\n frame = {}\n frame['t_start'] = frame_ctr*frame_step/fs\n frame['t_end'] = (frame_ctr*frame_step+frame_len)/fs\n\n # print(\"frame %d start %f end %f\"%(frame_ctr, frame['t_start'],frame['t_end']))\n\n # get chunk of data\n chunk = data[frame_ctr*frame_step : frame_ctr*frame_step+frame_len]\n\n # calculate FFT\n frame['fft'] = np.fft.fft(chunk)[:frame_len//2]\n \n # calcualte spectorgram\n spectrogram = np.abs(frame['fft'])\n frame['spectrogram'] = spectrogram\n num_spectrogram_bins = len(frame['spectrogram'])\n\n # calculate mel weights\n mel_weight_matrix = gen_mel_weight_matrix(num_mel_bins=mel_nbins, \n num_spectrogram_bins=num_spectrogram_bins, sample_rate=fs,\n lower_edge_hertz=mel_lower_hz, upper_edge_hertz=mel_upper_hz)\n frame['mel_weight_matrix'] = mel_weight_matrix\n\n # dot product of spectrum and mel matrix to get mel spectrogram\n mel_spectrogram = np.dot(spectrogram, mel_weight_matrix)\n frame['mel_spectrogram'] = mel_spectrogram\n \n # take log of mel spectrogram\n log_mel_spectrogram = np.log(mel_spectrogram + 1e-6)\n frame['log_mel_spectrogram'] = log_mel_spectrogram\n\n # calculate DCT-II\n mfcc = dct(log_mel_spectrogram, type=2) / np.sqrt(2*mel_nbins)\n frame['mfcc'] = mfcc\n\n # Add frame to output list\n output.append(frame)\n\n return output\n\ndef mfcc_tf(data, \\\n fs, nSamples, frame_len, frame_step, frame_count, \\\n fft_len, \\\n mel_nbins, mel_lower_hz, mel_upper_hz, unused=None):\n \"\"\"\n Calculate same mfcc using tensor flow functions\n \"\"\"\n import tensorflow as tf\n if tf.__version__.startswith('1'):\n tf.enable_eager_execution()\n # sess = tf.InteractiveSession()\n\n framed = frames(data, frame_length=frame_len, frame_step=frame_step)\n\n # pack data into a tensor of [1, nFrames, frame_len] so we compute only 1 sample\n tensor = tf.convert_to_tensor(framed.reshape((1,framed.shape[0], framed.shape[1])), dtype=tf.float32)\n\n # stfts has shape [..., frames, fft_unique_bins], here [1, nFrames, 1, fft_len/2+1)\n stfts = tf.signal.stft(tensor, frame_length=frame_len, frame_step=frame_step, fft_length=fft_len)\n \n spectrograms = tf.abs(stfts)\n # reshape spectrograms to [1, nFrames, fft_len/2+1)\n spectrograms = tf.reshape(spectrograms, (spectrograms.shape[0],spectrograms.shape[1],-1))\n \n num_spectrogram_bins = stfts.shape[-1]\n linear_to_mel_weight_matrix = tf.signal.linear_to_mel_weight_matrix(\n mel_nbins, num_spectrogram_bins, fs, mel_lower_hz,\n mel_upper_hz)\n # mel_spectrograms has shape [1, nFrames, mel_nbins]\n mel_spectrograms = tf.tensordot(spectrograms, linear_to_mel_weight_matrix, 1)\n # log_mel_spectrograms has shape [1, nFrames, mel_nbins]\n log_mel_spectrograms = tf.math.log(mel_spectrograms + 1e-6)\n # mfccs has shape [1, nFrames, mel_nbins]\n mfccs = tf.signal.mfccs_from_log_mel_spectrograms(log_mel_spectrograms)[..., :mel_nbins]\n\n # fill in same structure as own mfcc implementation\n # for all spectrograms, cut first element corresponding to the DC component\n if frame_count == 0:\n frame_count = 1 + (nSamples - frame_len) // frame_step\n output = []\n for frame_ctr in range(frame_count):\n frame = {}\n frame['t_start'] = frame_ctr*frame_step/fs\n frame['t_end'] = (frame_ctr*frame_step+frame_len)/fs\n frame['fft'] = tf.reshape(stfts, (stfts.shape[0],stfts.shape[1],-1))[0, frame_ctr, 1:]\n frame['spectrogram'] = spectrograms[0, frame_ctr, 1:].numpy()\n # strip DC component from weights matrix\n frame['mel_weight_matrix'] = linear_to_mel_weight_matrix[1:,...].numpy()\n frame['mel_spectrogram'] = mel_spectrograms[0, frame_ctr, ...]\n frame['log_mel_spectrogram'] = log_mel_spectrograms[0, frame_ctr, ...].numpy()\n frame['mfcc'] = mfccs[0, frame_ctr, ...].numpy()\n output.append(frame)\n return output\n\ndef mfcc_mcu(data, \\\n fs, nSamples, frame_len, frame_step, frame_count, \\\n fft_len, \\\n mel_nbins, mel_lower_hz, mel_upper_hz, mel_mtx_scale, use_log=False):\n \"\"\"\n Runs windowed mfcc on a strem of data, with similar calculation to MCU and scaled to match\n output of MCU\n \n data input data\n fs input sample rate\n nSamples number of samples in input\n frame_len length of each frame\n frame_step how many samples to advance the frame\n frame_count how many frames to compute\n fft_len length of FFT, ideally frame_len \n mel_nbins number of mel filter banks to create\n mel_lower_hz lowest frequency of mel bank\n mel_upper_hz highest frequency of mel bank\n \n \"\"\"\n\n # Calculate number of frames\n if frame_count == 0:\n frame_count = 1 + (nSamples - frame_len) // frame_step\n output = []\n \n # calculate mel matrix\n mel_weight_matrix = mel_mtx_scale*gen_mel_weight_matrix(num_mel_bins=mel_nbins, \n num_spectrogram_bins=frame_len//2+1, sample_rate=fs,\n lower_edge_hertz=mel_lower_hz, upper_edge_hertz=mel_upper_hz)\n\n # Iterate over each frame of data\n for frame_ctr in range(frame_count):\n frame = {}\n frame['t_start'] = frame_ctr*frame_step/fs\n frame['t_end'] = (frame_ctr*frame_step+frame_len)/fs\n\n # get chunk of data\n chunk = np.array(data[frame_ctr*frame_step : frame_ctr*frame_step+frame_len])\n sample_size = chunk.shape[0]\n\n # calculate FFT\n frame['fft'] = 1.0/1024*np.fft.fft(chunk)\n \n # calcualte spectorgram\n spectrogram = 1.0/np.sqrt(2)*np.abs(frame['fft'])\n frame['spectrogram'] = spectrogram\n num_spectrogram_bins = len(frame['spectrogram'])\n\n # calculate mel weights\n frame['mel_weight_matrix'] = mel_weight_matrix\n\n # dot product of spectrum and mel matrix to get mel spectrogram\n mel_spectrogram = np.dot(spectrogram[:(sample_size//2)+1], mel_weight_matrix)\n mel_spectrogram /= mel_mtx_scale\n frame['mel_spectrogram'] = mel_spectrogram\n \n # log(x) is intentionally left out to safe computation resources\n if use_log:\n mel_spectrogram = np.log(mel_spectrogram+1e-6)\n frame['log_mel_spectrogram'] = mel_spectrogram\n\n # calculate DCT-II\n mfcc = 1.0/64*dct(mel_spectrogram, type=2)\n frame['mfcc'] = mfcc\n\n # Add frame to output list\n output.append(frame)\n return output\ndef dct2Makhoul(x):\n \"\"\"\n Calculate DCT-II using N-point FFT as in \"A Fast Cosine Transform in O'ne and Two Dimensions\" - Makhoul1980\n Source: https://dsp.stackexchange.com/questions/2807/fast-cosine-transform-via-fft\n \"\"\"\n N = x.shape[0]\n k = np.arange(N)\n\n v = np.empty_like(x)\n v[:(N-1)//2+1] = x[::2]\n if N % 2: # odd length\n v[(N-1)//2+1:] = x[-2::-2]\n else: # even length\n v[(N-1)//2+1:] = x[::-2]\n V = np.fft.fft(v)\n Vr = V * 2 * np.exp(-1j*np.pi*k/(2*N))\n return Vr.real, v, V\n"
] |
[
[
"numpy.max",
"numpy.min",
"scipy.io.wavfile.write",
"numpy.mean",
"matplotlib.pyplot.subplots",
"numpy.loadtxt",
"numpy.abs",
"matplotlib.pyplot.show"
],
[
"numpy.dot",
"numpy.minimum",
"tensorflow.tensordot",
"tensorflow.__version__.startswith",
"tensorflow.reshape",
"numpy.exp",
"tensorflow.signal.stft",
"numpy.fft.fft",
"tensorflow.enable_eager_execution",
"tensorflow.signal.mfccs_from_log_mel_spectrograms",
"numpy.log",
"tensorflow.math.log",
"numpy.arange",
"numpy.sqrt",
"numpy.empty_like",
"tensorflow.abs",
"numpy.pad",
"numpy.array",
"numpy.reshape",
"numpy.zeros",
"tensorflow.signal.linear_to_mel_weight_matrix",
"scipy.fftpack.dct",
"numpy.split",
"numpy.abs",
"numpy.linspace"
]
] |
mlbench/mlbench-benchmarks
|
[
"625226ad1f00f6ba93568c33268a7da57e823115",
"625226ad1f00f6ba93568c33268a7da57e823115"
] |
[
"tensorflow/imagerecognition/openmpi-cifar10-resnet20-all-reduce/main.py",
"pytorch/nlp/language-modeling/wikitext2-lstm-all-reduce/utils/utils.py"
] |
[
"r\"\"\"Distributed TensorFlow with Monitored Training Session.\n\nThis implements the 1a image recognition benchmark task, see https://mlbench.readthedocs.io/en/latest/benchmark-tasks.html#a-image-classification-resnet-cifar-10\nfor more details\n\nAdapted from official tutorial::\n\n https://www.tensorflow.org/deploy/distributed\n\nLaunch::\n\n mpirun -n 3 --allow-run-as-root python ....\n\n\"\"\"\nimport argparse\nimport logging\nimport os\n\nimport tensorflow as tf\nfrom mlbench_core.controlflow.tensorflow.train_validation import train_round, \\\n validation_round\nfrom mlbench_core.dataset.imagerecognition.tensorflow.cifar10 import \\\n DatasetCifar\nfrom mlbench_core.evaluation.goals import task1_time_to_accuracy_light_goal, \\\n task1_time_to_accuracy_goal\nfrom mlbench_core.evaluation.tensorflow.criterion import \\\n softmax_cross_entropy_with_logits_v2_l2_regularized\nfrom mlbench_core.evaluation.tensorflow.metrics import TopKAccuracy\nfrom mlbench_core.lr_scheduler.tensorflow.lr import manual_stepping\nfrom mlbench_core.models.tensorflow.resnet_model import Cifar10Model\nfrom mlbench_core.utils import Tracker\n\n\ndef define_graph(inputs, labels, is_training, batch_size, replicas_to_aggregate):\n \"\"\"\n Define graph for synchronized training.\n \"\"\"\n model = Cifar10Model(\n resnet_size=20,\n data_format='channels_last',\n resnet_version=2,\n dtype=tf.float32)\n\n logits = model(inputs, is_training)\n\n loss = softmax_cross_entropy_with_logits_v2_l2_regularized(\n logits=logits,\n labels=labels,\n l2=2e-4,\n # Exclude BN weights from L2 regularizer\n loss_filter_fn=lambda name: 'batch_normalization' not in name)\n\n # Use Top K accuracy as metrics\n metrics = [\n TopKAccuracy(logits, labels, topk=1),\n TopKAccuracy(logits, labels, topk=5),\n ]\n\n global_step = tf.train.get_or_create_global_step()\n\n # scheduling learning steps.\n lr_scheduler = manual_stepping(\n global_step=global_step,\n boundaries=[32000 // replicas_to_aggregate,\n 48000 // replicas_to_aggregate],\n rates=[0.1, 0.01, 0.001],\n warmup=False)\n\n # Define the optimizer\n optimizer_ = tf.train.MomentumOptimizer(\n learning_rate=lr_scheduler,\n momentum=0.9,\n use_nesterov=True)\n\n # Wrap optimizer with `SyncReplicasOptimizer`\n optimizer = tf.train.SyncReplicasOptimizer(\n optimizer_,\n replicas_to_aggregate=replicas_to_aggregate,\n total_num_replicas=replicas_to_aggregate)\n\n hooks = [\n optimizer.make_session_run_hook((rank == 0), num_tokens=0)\n ]\n\n # The update for batch normalization.\n update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)\n with tf.control_dependencies(update_ops):\n # Not all of the processes contribute one update. Some faster procs can push more updates.\n grads_and_vars = list(optimizer.compute_gradients(\n loss, tf.trainable_variables()))\n\n train_op = optimizer.apply_gradients(\n grads_and_vars, global_step=global_step)\n\n return train_op, loss, metrics, hooks\n\n\ndef main(is_ps, run_id, rank, world_size, cluster_spec, batch_size,\n replicas_to_aggregate, light_target=False):\n logging.info(\"Initial.\")\n\n job_name = \"ps\" if is_ps else \"worker\"\n\n cluster = tf.train.ClusterSpec(cluster_spec)\n\n gpu_options = tf.GPUOptions(allow_growth=True,\n per_process_gpu_memory_fraction=0.2)\n\n session_conf = tf.ConfigProto(\n gpu_options=gpu_options,\n allow_soft_placement=True,\n log_device_placement=False)\n\n server = tf.train.Server(\n cluster, job_name=job_name, task_index=rank, config=session_conf)\n\n if is_ps:\n server.join()\n else:\n # Pin variables to parameter server.\n device_fn = tf.train.replica_device_setter(\n ps_tasks=None,\n ps_device=\"/job:ps\",\n worker_device=\"/job:{}/task:{}/device:GPU:{}\".format(\n job_name, rank, rank),\n merge_devices=True,\n cluster=cluster,\n ps_ops=None,\n ps_strategy=None)\n\n with tf.Graph().as_default():\n with tf.device(device_fn):\n data_loader = DatasetCifar(\n dataset='cifar-10',\n dataset_root='/datasets',\n batch_size=batch_size,\n world_size=world_size,\n rank=rank,\n seed=42,\n tf_dtype=tf.float32)\n\n train_op, loss, metrics, hooks = define_graph(\n data_loader.inputs,\n data_loader.labels,\n data_loader.training,\n batch_size,\n replicas_to_aggregate)\n\n local_init_op = tf.group(\n tf.local_variables_initializer(),\n data_loader.train_init_op,\n data_loader.validation_init_op)\n\n scaffold = tf.train.Scaffold(\n init_op=None,\n init_feed_dict=None,\n init_fn=None,\n ready_op=None,\n ready_for_local_init_op=None,\n local_init_op=local_init_op)\n\n lr_tensor_name = tf.get_default_graph().get_tensor_by_name(\"learning_rate:0\")\n\n with tf.train.MonitoredTrainingSession(config=session_conf,\n master=server.target,\n scaffold=scaffold,\n is_chief=(rank == 0),\n checkpoint_dir=None,\n save_checkpoint_secs=None,\n save_summaries_steps=None,\n stop_grace_period_secs=5,\n hooks=hooks) as sess:\n\n logging.info(\"Begin training.\")\n\n final_epoch = 164\n\n if light_target:\n goal = task1_time_to_accuracy_light_goal()\n else:\n goal = task1_time_to_accuracy_goal()\n\n tracker = Tracker(metrics, run_id, rank, goal=goal)\n tracker.start()\n\n for i_epoch in range(final_epoch):\n logging.debug(\"=> Epoch {}\".format(i_epoch))\n\n train_round(sess, data_loader.train_init_op, train_op,\n loss, metrics, batch_size,\n data_loader.num_batches_per_epoch_for_train,\n tracker, lr_tensor=lr_tensor_name,\n lr_scheduler_level='epoch')\n\n validation_round(sess, data_loader.validation_init_op,\n loss, metrics, batch_size,\n data_loader.num_batches_per_epoch_for_eval,\n tracker)\n tracker.epoch_end()\n\n if tracker.goal_reached:\n print(\"Goal Reached!\")\n return\n\n logging.info(\"Finish.\")\n\n\ndef configure_logger(log_dir, is_ps, rank):\n logger = logging.getLogger('')\n logger.setLevel(logging.DEBUG)\n\n formatter = logging.Formatter(\n '{:6} rank={} : %(message)s'.format(\"ps\" if is_ps else \"worker\", rank),\n \"%Y-%m-%d %H:%M:%S\")\n\n ch = logging.StreamHandler()\n ch.setLevel(logging.DEBUG)\n ch.setFormatter(formatter)\n logger.addHandler(ch)\n\n log_name = '{}-{}.log'.format(\"ps\" if is_ps else \"worker\", rank)\n log_name = os.path.join(log_dir, log_name)\n if os.path.exists(log_name):\n os.remove(log_name)\n\n fh = logging.FileHandler(log_name)\n fh.setLevel(logging.DEBUG)\n fh.setFormatter(formatter)\n logger.addHandler(fh)\n\n\nif __name__ == \"__main__\":\n parser = argparse.ArgumentParser(description='Process run parameters')\n parser.add_argument('--run_id', type=str, help='The id of the run')\n parser.add_argument('--hosts', type=str, help='The hosts participating in this run')\n parser.add_argument('--light', action='store_true', default=False,\n help='Train to light target metric goal')\n args = parser.parse_args()\n\n rank = int(os.environ['OMPI_COMM_WORLD_RANK'])\n size = int(os.environ['OMPI_COMM_WORLD_SIZE'])\n\n hosts = args.hosts.split(\",\")\n\n if len(hosts) < 2:\n raise ValueError(\"At least 2 pods are needed for this benchmark (1 parameter server, 1 worker)\")\n\n workers = [h + \":22222\" for h in hosts[1:]]\n ps = hosts[0] + \":22222\" # First worker is the parameter server\n\n cluster_spec = {\"worker\": workers,\n \"ps\": [ps]}\n\n # Parse role in the cluster by rank.\n is_ps = rank < len(cluster_spec['ps'])\n rank = rank if is_ps else rank - len(cluster_spec['ps'])\n world_size = size - len(cluster_spec['ps'])\n\n # Configure Logging\n if not os.path.exists('/mlbench'):\n os.makedirs('/mlbench')\n configure_logger('/mlbench', is_ps, rank)\n\n batch_size = 128\n replicas_to_aggregate = len(cluster_spec['worker'])\n\n main(is_ps, args.run_id, rank, world_size, cluster_spec,\n batch_size, replicas_to_aggregate, light_target=args.light)\n",
"import logging\n\nimport torch\nimport torch.distributed as dist\n\nfrom mlbench_core.utils import AverageMeter\nfrom mlbench_core.utils.pytorch.distributed import get_backend_tensor, global_average\n\nlogger = logging.getLogger(\"mlbench\")\n\n\ndef repackage_hidden(h):\n \"\"\"Wraps hidden states in new Tensors,\n to detach them from their history.\"\"\"\n if isinstance(h, torch.Tensor):\n return h.detach()\n else:\n return tuple(repackage_hidden(v) for v in h)\n\n\ndef set_sequence_lengths(dataset, random=False):\n \"\"\"Sets the sequences lengths and broadcasts to other workers\n\n Args:\n dataset (:obj:`mlbench_core.dataset.nlp.pytorch.Wikitext2Dataset`)\n random (bool): Use random length. Default False\n \"\"\"\n dataset.generate_sequence_lengths(random=random)\n seq_lens = get_backend_tensor(dataset.sequence_lengths)\n dist.broadcast(seq_lens, src=0)\n dataset.sequence_lengths = seq_lens.cpu()\n\n\ndef validation_round(\n val_set, model, batch_size, metrics, loss_function, tracker, use_cuda=False\n):\n \"\"\"Performs a validation round\n\n Args:\n val_set (:obj:): Validation set\n model (:obj:`torch.nn.Module`): Model to evaluate\n batch_size (int): Validation batch size\n metrics (list): List of metrics to compute\n loss_function (:obj:`torch.nn.Module`): Loss function\n tracker (:obj:`mlbench_core.utils.Tracker`): Tracker object\n use_cuda (bool): Use GPU acceleration\n\n Returns:\n (dict, float): Metric averages and total loss average\n \"\"\"\n # finish one epoch training and to decide if we want to val our model.\n tracker.validation()\n tracker.validation_start()\n\n # each worker finish one epoch training.\n model.eval()\n\n losses = AverageMeter()\n for metric in metrics:\n metric.reset()\n\n # Each worker computer their own losses and metrics\n with torch.no_grad():\n hidden = model.init_hidden(batch_size)\n\n num_batches = val_set.num_batches()\n for batch_idx in range(num_batches):\n data, target = val_set.get_batch(batch_idx, cuda=use_cuda)\n batch_seq_len = data.size(0)\n # Inference\n output, hidden = model(data, hidden)\n\n # Compute loss\n loss = loss_function(output, target)\n\n # Update loss\n losses.update(loss.item(), batch_seq_len)\n\n hidden = repackage_hidden(hidden)\n\n # Update metrics\n for metric in metrics:\n metric_value = metric(output, target)\n metric.update(metric_value, 1)\n\n # Aggregate metrics and loss for all workers\n loss_average = global_average(losses.sum, losses.count)\n metrics_averages = {\n metric: torch.exp(loss_average).item()\n if metric.name == \"Perplexity\"\n else metric.average().item()\n for metric in metrics\n }\n\n logger.info(\n \"Got loss {}, avg metric={}\".format(\n loss_average,\n [m.average().item() for m in metrics if m.name == \"Perplexity\"][0],\n )\n )\n tracker.validation_end()\n\n return metrics_averages, loss_average.item()\n"
] |
[
[
"tensorflow.train.SyncReplicasOptimizer",
"tensorflow.GPUOptions",
"tensorflow.train.Server",
"tensorflow.control_dependencies",
"tensorflow.trainable_variables",
"tensorflow.train.ClusterSpec",
"tensorflow.get_default_graph",
"tensorflow.train.MomentumOptimizer",
"tensorflow.Graph",
"tensorflow.train.Scaffold",
"tensorflow.ConfigProto",
"tensorflow.device",
"tensorflow.train.get_or_create_global_step",
"tensorflow.train.MonitoredTrainingSession",
"tensorflow.local_variables_initializer",
"tensorflow.get_collection"
],
[
"torch.no_grad",
"torch.exp",
"torch.distributed.broadcast"
]
] |
Minaramzey/Sauti-Africa-Market-Monitoring-DS
|
[
"3b132e75565a5a4c1f6a131990d1b4371fecf7f6"
] |
[
"routes.py"
] |
[
"import datetime\nimport numpy as np\nimport os\nimport pandas as pd\nimport psycopg2\n\nfrom dotenv import load_dotenv, find_dotenv\nfrom flask import current_app as app\nfrom flask import json, jsonify, request\n\nload_dotenv()\n\n############################################################################################################\n\n'''Verify the credentials before running deployment. '''\n\n############################################################################################################\n\n@app.route(\"/\") \ndef home_view(): \n return \"<h1>Welcome to Sauti DS</h1>\"\n\n\n@app.route('/verifyconn', methods=['GET'])\ndef verify_db_conn():\n '''\n Verifies the connection to the db.\n '''\n try:\n\n labs_conn = psycopg2.connect(user=os.environ.get('aws_db_user'),\n password=os.environ.get('aws_db_password'),\n host=os.environ.get('aws_db_host'),\n port=os.environ.get('aws_db_port'),\n database=os.environ.get('aws_db_name'))\n\n return 'Connection verified.'\n\n except:\n\n return 'Connection failed.'\n\n finally:\n\n if (labs_conn):\n labs_conn.close()\n\n@app.errorhandler(404)\ndef page_not_found(e):\n \n return '<h1>Error 404</h1><p> Sorry, I cannot show anything arround here.</p><img src=\"/static/404.png\">', 404\n\n\n###############################################################\n\n############# Pulling all the data from tables. #############\n\n###############################################################\n\n@app.route(\"/wholesale/data-quality/\")\ndef get_table_dqws():\n labs_conn = psycopg2.connect(user=os.environ.get('aws_db_user'),\n password=os.environ.get('aws_db_password'),\n host=os.environ.get('aws_db_host'),\n port=os.environ.get('aws_db_port'),\n database=os.environ.get('aws_db_name'))\n labs_curs = labs_conn.cursor()\n\n Q_select_all = \"\"\"SELECT * FROM qc_wholesale_observed_price;\"\"\"\n labs_curs.execute(Q_select_all)\n # print(\"\\nSELECT * Query Excecuted.\")\n\n rows = labs_curs.fetchall()\n\n df = pd.DataFrame(rows, columns=[\n \"id\", \"market\", \"product\", \"source\",\n \"start\", \"end\", \"timeliness\", \"data_length\",\n \"completeness\", \"duplicates\", \"mode_D\", \"data_points\",\n \"DQI\", \"DQI_cat\"\n ])\n\n Q_select_all = \"\"\"SELECT * FROM markets;\"\"\"\n labs_curs.execute(Q_select_all)\n # print(\"\\nSELECT * Query Excecuted.\")\n\n rowsM = labs_curs.fetchall()\n dfM = pd.DataFrame(rowsM, columns=[\"id\", \"market_id\", \"market_name\", \"country_code\"])\n \n Q_select_all = \"\"\"SELECT id, source_name FROM sources;\"\"\"\n labs_curs.execute(Q_select_all)\n # print(\"\\nSELECT * Query Excecuted.\")\n\n rowsM = labs_curs.fetchall()\n dfS = pd.DataFrame(rowsM, columns=[\"id\", \"source_name\"])\n\n labs_curs.close()\n labs_conn.close()\n # print(\"Cursor and Connection Closed.\")\n\n\n merged = df.merge(dfM, left_on='market', right_on='market_id')\n merged[\"id\"] = merged[\"id_x\"]\n merged = merged.drop([\"id_x\", \"id_y\", \"market_id\"], axis=1)\n merged = merged.merge(dfS, left_on='source', right_on='id')\n merged[\"id\"] = merged[\"id_x\"]\n merged = merged.drop([\"id_x\", \"id_y\", \"source\"], axis=1)\n cols = ['id', 'market_name','country_code', 'product', 'source_name', 'start', 'end', 'timeliness',\n 'data_length', 'completeness', 'duplicates', 'mode_D', 'data_points',\n 'DQI', 'DQI_cat']\n merged = merged[cols]\n merged['start'] = merged['start'] .apply(lambda x: datetime.date.strftime(x,\"%Y-%m-%d\"))\n merged['end'] = merged['end'].apply(lambda x: datetime.date.strftime(x,\"%Y-%m-%d\"))\n merged['price_category'] = \"wholesale\"\n merged['DQI'] = merged['DQI'].apply(lambda x: round(x,4) if type(x) == float else None)\n merged['completeness'] = (merged['completeness'].apply(lambda x: round(x*100,2) if type(x) == float else None)).astype(str) + ' %'\n\n result = []\n for _, row in merged.iterrows():\n result.append(dict(row))\n return jsonify(result)\n\n@app.route(\"/retail/data-quality/\")\ndef get_table_dqrt():\n labs_conn = psycopg2.connect(user=os.environ.get('aws_db_user'),\n password=os.environ.get('aws_db_password'),\n host=os.environ.get('aws_db_host'),\n port=os.environ.get('aws_db_port'),\n database=os.environ.get('aws_db_name'))\n labs_curs = labs_conn.cursor()\n\n Q_select_all = \"\"\"SELECT * FROM qc_retail_observed_price;\"\"\"\n labs_curs.execute(Q_select_all)\n # print(\"\\nSELECT * Query Excecuted.\")\n\n rows = labs_curs.fetchall()\n\n df = pd.DataFrame(rows, columns=[\n \"id\", \"market\", \"product\", \"source\",\n \"start\", \"end\", \"timeliness\", \"data_length\",\n \"completeness\", \"duplicates\", \"mode_D\", \"data_points\",\n \"DQI\", \"DQI_cat\"\n ])\n\n Q_select_all = \"\"\"SELECT * FROM markets;\"\"\"\n labs_curs.execute(Q_select_all)\n # print(\"\\nSELECT * Query Excecuted.\")\n\n rowsM = labs_curs.fetchall()\n dfM = pd.DataFrame(rowsM, columns=[\"id\", \"market_id\", \"market_name\", \"country_code\"])\n\n Q_select_all = \"\"\"SELECT id, source_name FROM sources;\"\"\"\n labs_curs.execute(Q_select_all)\n # print(\"\\nSELECT * Query Excecuted.\")\n\n rowsM = labs_curs.fetchall()\n dfS = pd.DataFrame(rowsM, columns=[\"id\", \"source_name\"])\n\n labs_curs.close()\n labs_conn.close()\n # print(\"Cursor and Connection Closed.\")\n\n\n merged = df.merge(dfM, left_on='market', right_on='market_id')\n merged[\"id\"] = merged[\"id_x\"]\n merged = merged.drop([\"id_x\", \"id_y\", \"market_id\"], axis=1)\n merged = merged.merge(dfS, left_on='source', right_on='id')\n merged[\"id\"] = merged[\"id_x\"]\n merged = merged.drop([\"id_x\", \"id_y\", \"source\"], axis=1)\n cols = ['id', 'market_name','country_code', 'product', 'source_name', 'start', 'end', 'timeliness',\n 'data_length', 'completeness', 'duplicates', 'mode_D', 'data_points',\n 'DQI', 'DQI_cat']\n merged = merged[cols]\n merged['start'] = merged['start'] .apply(lambda x: datetime.date.strftime(x,\"%Y-%m-%d\"))\n merged['end'] = merged['end'].apply(lambda x: datetime.date.strftime(x,\"%Y-%m-%d\"))\n merged['price_category'] = \"retail\"\n merged['DQI'] = merged['DQI'].apply(lambda x: round(x,4) if type(x) == float else None)\n merged['completeness'] = (merged['completeness'].apply(lambda x: round(x*100,2) if type(x) == float else None)).astype(str) + ' %'\n\n result = []\n for _, row in merged.iterrows():\n result.append(dict(row))\n return jsonify(result)\n\n@app.route(\"/wholesale/price-status/\")\ndef get_table_psws():\n\n labs_conn = psycopg2.connect(user=os.environ.get('aws_db_user'),\n password=os.environ.get('aws_db_password'),\n host=os.environ.get('aws_db_host'),\n port=os.environ.get('aws_db_port'),\n database=os.environ.get('aws_db_name'))\n labs_curs = labs_conn.cursor()\n \n Q_select_all = \"\"\"SELECT product_name, market_name, country_code,\n source_name, currency_code, date_price,\n observed_price, observed_alps_class, alps_type_method,\n alps_stressness, observed_arima_alps_class, arima_alps_stressness\n FROM wholesale_prices;\"\"\"\n labs_curs.execute(Q_select_all)\n # print(\"\\nSELECT * Query Excecuted.\")\n\n rows = labs_curs.fetchall()\n\n df = pd.DataFrame(rows, columns= [\n \"product_name\", \"market_name\", \"country_code\", \"source_name\",\n \"currency_code\", \"date_price\", \"observed_price\", \n \"observed_alps_class\", \"alps_type_method\", \"alps_stressness\",\n \"observed_arima_alps_class\", \"arima_alps_stressness\"\n ])\n labs_curs.close()\n labs_conn.close()\n # print(\"Cursor and Connection Closed.\")\n\n df['date_price'] = df['date_price'].apply(lambda x: datetime.date.strftime(x,\"%Y-%m-%d\"))\n df['alps_stressness'] = df['alps_stressness'].apply(lambda x: round(x*100,2) if type(x) == float else None)\n df['alps_stressness'] = df['alps_stressness'].astype(str)\n df['observed_alps_class'] = df['observed_alps_class'].astype(str)\n df['observed_alps_class'] = df['observed_alps_class'] + ' ('+ df['alps_stressness'] + ' %)' \n df['alps_type_method'] = df['alps_type_method'].astype(str)\n df['arima_alps_stressness'] = df['arima_alps_stressness'].apply(lambda x: round(x*100,2) if type(x) == float else None)\n df['arima_alps_stressness'] = df['arima_alps_stressness'].astype(str)\n df['observed_arima_alps_class'] = df['observed_arima_alps_class'].astype(str) + ' ('+ df['arima_alps_stressness'] + ' %)' \n df['observed_alps_class'] = df['observed_alps_class'].replace('None (nan %)', 'Not available')\n df['alps_stressness'] = df['alps_stressness'].replace('nan', 'Not available')\n df['alps_type_method'] = df['alps_type_method'].replace('None', 'Not available')\n df['observed_arima_alps_class'] = df['observed_arima_alps_class'].replace('None (nan %)', 'Not available')\n df['arima_alps_stressness'] = df['arima_alps_stressness'].replace('nan', 'Not available')\n \n df['price_category'] = \"wholesale\"\n\n result = []\n for _, row in df.iterrows():\n result.append(dict(row))\n \n return json.dumps(result, indent=4)\n\n@app.route(\"/retail/price-status/\")\ndef get_table_psrt():\n\n labs_conn = psycopg2.connect(user=os.environ.get('aws_db_user'),\n password=os.environ.get('aws_db_password'),\n host=os.environ.get('aws_db_host'),\n port=os.environ.get('aws_db_port'),\n database=os.environ.get('aws_db_name'))\n labs_curs = labs_conn.cursor()\n \n Q_select_all = \"\"\"SELECT product_name, market_name, country_code,\n source_name, currency_code, date_price,\n observed_price, observed_alps_class, alps_type_method,\n alps_stressness, observed_arima_alps_class, arima_alps_stressness\n FROM retail_prices;\"\"\"\n labs_curs.execute(Q_select_all)\n # print(\"\\nSELECT * Query Excecuted.\")\n\n rows = labs_curs.fetchall()\n\n df = pd.DataFrame(rows, columns= [\n \"product_name\", \"market_name\", \"country_code\", \"source_name\",\n \"currency_code\", \"date_price\", \"observed_price\", \n \"observed_alps_class\", \"alps_type_method\", \"alps_stressness\",\n \"observed_arima_alps_class\", \"arima_alps_stressness\"\n ])\n labs_curs.close()\n labs_conn.close()\n # print(\"Cursor and Connection Closed.\")\n\n df['date_price'] = df['date_price'].apply(lambda x: datetime.date.strftime(x,\"%Y-%m-%d\"))\n df['alps_stressness'] = df['alps_stressness'].apply(lambda x: round(x*100,2) if type(x) == float else None)\n df['alps_stressness'] = df['alps_stressness'].astype(str)\n df['observed_alps_class'] = df['observed_alps_class'].astype(str)\n df['observed_alps_class'] = df['observed_alps_class'] + ' ('+ df['alps_stressness'] + ' %)' \n df['alps_type_method'] = df['alps_type_method'].astype(str)\n df['arima_alps_stressness'] = df['arima_alps_stressness'].apply(lambda x: round(x*100,2) if type(x) == float else None)\n df['arima_alps_stressness'] = df['arima_alps_stressness'].astype(str)\n df['observed_arima_alps_class'] = df['observed_arima_alps_class'].astype(str) + ' ('+ df['arima_alps_stressness'] + ' %)' \n df['observed_alps_class'] = df['observed_alps_class'].replace('None (nan %)', 'Not available')\n df['alps_stressness'] = df['alps_stressness'].replace('nan', 'Not available')\n df['alps_type_method'] = df['alps_type_method'].replace('None', 'Not available')\n df['observed_arima_alps_class'] = df['observed_arima_alps_class'].replace('None (nan %)', 'Not available')\n df['arima_alps_stressness'] = df['arima_alps_stressness'].replace('nan', 'Not available')\n\n df['price_category'] = \"retail\"\n\n result = []\n for _, row in df.iterrows():\n result.append(dict(row))\n return json.dumps(result, indent=4)\n\n\n\n@app.route(\"/wholesale/labeled/\")\ndef get_table_psws_labeled():\n\n labs_conn = psycopg2.connect(user=os.environ.get('aws_db_user'),\n password=os.environ.get('aws_db_password'),\n host=os.environ.get('aws_db_host'),\n port=os.environ.get('aws_db_port'),\n database=os.environ.get('aws_db_name'))\n labs_curs = labs_conn.cursor()\n \n Q_select_all = \"\"\"SELECT product_name, market_name, country_code,\n source_name, currency_code, date_price,\n observed_price, observed_alps_class, alps_type_method,\n alps_stressness, observed_arima_alps_class, arima_alps_stressness\n FROM wholesale_prices\n WHERE observed_alps_class IS NOT NULL\n OR observed_arima_alps_class IS NOT NULL;\n \"\"\"\n labs_curs.execute(Q_select_all)\n # print(\"\\nSELECT * Query Excecuted.\")\n\n rows = labs_curs.fetchall()\n\n df = pd.DataFrame(rows, columns= [\n \"product_name\", \"market_name\", \"country_code\", \"source_name\",\n \"currency_code\", \"date_price\", \"observed_price\", \n \"observed_alps_class\", \"alps_type_method\", \"alps_stressness\",\n \"observed_arima_alps_class\", \"arima_alps_stressness\"\n ])\n labs_curs.close()\n labs_conn.close()\n # print(\"Cursor and Connection Closed.\")\n\n df['date_price'] = df['date_price'].apply(lambda x: datetime.date.strftime(x,\"%Y-%m-%d\"))\n df['alps_stressness'] = df['alps_stressness'].apply(lambda x: round(x*100,2) if type(x) == float else None)\n df['alps_stressness'] = df['alps_stressness'].astype(str)\n df['observed_alps_class'] = df['observed_alps_class'].astype(str)\n df['observed_alps_class'] = df['observed_alps_class'] + ' ('+ df['alps_stressness'] + ' %)' \n df['alps_type_method'] = df['alps_type_method'].astype(str)\n df['arima_alps_stressness'] = df['arima_alps_stressness'].apply(lambda x: round(x*100,2) if type(x) == float else None)\n df['arima_alps_stressness'] = df['arima_alps_stressness'].astype(str)\n df['observed_arima_alps_class'] = df['observed_arima_alps_class'].astype(str) + ' ('+ df['arima_alps_stressness'] + ' %)' \n df['observed_alps_class'] = df['observed_alps_class'].replace('None (nan %)', 'Not available')\n df['alps_stressness'] = df['alps_stressness'].replace('nan', 'Not available')\n df['alps_type_method'] = df['alps_type_method'].replace('None', 'Not available')\n df['observed_arima_alps_class'] = df['observed_arima_alps_class'].replace('None (nan %)', 'Not available')\n df['arima_alps_stressness'] = df['arima_alps_stressness'].replace('nan', 'Not available')\n\n df['price_category'] = \"wholesale\"\n\n result = []\n for _, row in df.iterrows():\n result.append(dict(row))\n return jsonify(result)\n\n@app.route(\"/retail/labeled/\")\ndef get_table_psrt_labeled():\n\n labs_conn = psycopg2.connect(user=os.environ.get('aws_db_user'),\n password=os.environ.get('aws_db_password'),\n host=os.environ.get('aws_db_host'),\n port=os.environ.get('aws_db_port'),\n database=os.environ.get('aws_db_name'))\n labs_curs = labs_conn.cursor()\n \n Q_select_all = \"\"\"SELECT product_name, market_name, country_code,\n source_name, currency_code, date_price,\n observed_price, observed_alps_class, alps_type_method,\n alps_stressness, observed_arima_alps_class, arima_alps_stressness\n FROM wholesale_prices\n WHERE observed_alps_class IS NOT NULL\n OR observed_arima_alps_class IS NOT NULL;\n \"\"\"\n labs_curs.execute(Q_select_all)\n # print(\"\\nSELECT * Query Excecuted.\")\n\n rows = labs_curs.fetchall()\n\n df = pd.DataFrame(rows, columns= [\n \"product_name\", \"market_name\", \"country_code\", \"source_name\",\n \"currency_code\", \"date_price\", \"observed_price\", \n \"observed_alps_class\", \"alps_type_method\", \"alps_stressness\",\n \"observed_arima_alps_class\", \"arima_alps_stressness\"\n ])\n labs_curs.close()\n labs_conn.close()\n # print(\"Cursor and Connection Closed.\")\n\n df['date_price'] = df['date_price'].apply(lambda x: datetime.date.strftime(x,\"%Y-%m-%d\"))\n df['alps_stressness'] = df['alps_stressness'].apply(lambda x: round(x*100,2) if type(x) == float else None)\n df['alps_stressness'] = df['alps_stressness'].astype(str)\n df['observed_alps_class'] = df['observed_alps_class'].astype(str)\n df['observed_alps_class'] = df['observed_alps_class'] + ' ('+ df['alps_stressness'] + ' %)' \n df['alps_type_method'] = df['alps_type_method'].astype(str)\n df['arima_alps_stressness'] = df['arima_alps_stressness'].apply(lambda x: round(x*100,2) if type(x) == float else None)\n df['arima_alps_stressness'] = df['arima_alps_stressness'].astype(str)\n df['observed_arima_alps_class'] = df['observed_arima_alps_class'].astype(str) + ' ('+ df['arima_alps_stressness'] + ' %)' \n df['observed_alps_class'] = df['observed_alps_class'].replace('None (nan %)', 'Not available')\n df['alps_stressness'] = df['alps_stressness'].replace('nan', 'Not available')\n df['alps_type_method'] = df['alps_type_method'].replace('None', 'Not available')\n df['observed_arima_alps_class'] = df['observed_arima_alps_class'].replace('None (nan %)', 'Not available')\n df['arima_alps_stressness'] = df['arima_alps_stressness'].replace('nan', 'Not available')\n\n df['price_category'] = \"retail\"\n\n result = []\n for _, row in df.iterrows():\n result.append(dict(row))\n return jsonify(result)\n\n\n@app.route(\"/wholesale/labeled/latest/\")\ndef get_table_psws_labeled_latest():\n\n labs_conn = psycopg2.connect(user=os.environ.get('aws_db_user'),\n password=os.environ.get('aws_db_password'),\n host=os.environ.get('aws_db_host'),\n port=os.environ.get('aws_db_port'),\n database=os.environ.get('aws_db_name'))\n labs_curs = labs_conn.cursor()\n \n Q_select_all = \"\"\"SELECT product_name, market_name, country_code,\n source_name, currency_code, date_price,\n observed_price, observed_alps_class, alps_type_method,\n alps_stressness, observed_arima_alps_class, arima_alps_stressness\n FROM wholesale_prices\n WHERE observed_alps_class IS NOT NULL\n OR observed_arima_alps_class IS NOT NULL;\n \"\"\"\n labs_curs.execute(Q_select_all)\n # print(\"\\nSELECT * Query Excecuted.\")\n\n rows = labs_curs.fetchall()\n\n df = pd.DataFrame(rows, columns= [\n \"product_name\", \"market_name\", \"country_code\", \"source_name\",\n \"currency_code\", \"date_price\", \"observed_price\", \n \"observed_alps_class\", \"alps_type_method\", \"alps_stressness\",\n \"observed_arima_alps_class\", \"arima_alps_stressness\"\n ])\n labs_curs.close()\n labs_conn.close()\n # print(\"Cursor and Connection Closed.\")\n\n list_to_drop = df[df.sort_values(by=['date_price'], ascending=False).duplicated(['product_name', 'market_name', 'source_name','currency_code'], keep='first')].index\n\n df = df.drop(labels = list_to_drop, axis=0)\n\n df['date_price'] = df['date_price'].apply(lambda x: datetime.date.strftime(x,\"%Y-%m-%d\"))\n df['alps_stressness'] = df['alps_stressness'].apply(lambda x: round(x*100,2) if type(x) == float else None)\n df['alps_stressness'] = df['alps_stressness'].astype(str)\n df['observed_alps_class'] = df['observed_alps_class'].astype(str)\n df['observed_alps_class'] = df['observed_alps_class'] + ' ('+ df['alps_stressness'] + ' %)' \n df['alps_type_method'] = df['alps_type_method'].astype(str)\n df['arima_alps_stressness'] = df['arima_alps_stressness'].apply(lambda x: round(x*100,2) if type(x) == float else None)\n df['arima_alps_stressness'] = df['arima_alps_stressness'].astype(str)\n df['observed_arima_alps_class'] = df['observed_arima_alps_class'].astype(str) + ' ('+ df['arima_alps_stressness'] + ' %)' \n df['observed_alps_class'] = df['observed_alps_class'].replace('None (nan %)', 'Not available')\n df['alps_stressness'] = df['alps_stressness'].replace('nan', 'Not available')\n df['alps_type_method'] = df['alps_type_method'].replace('None', 'Not available')\n df['observed_arima_alps_class'] = df['observed_arima_alps_class'].replace('None (nan %)', 'Not available')\n df['arima_alps_stressness'] = df['arima_alps_stressness'].replace('nan', 'Not available')\n\n df['price_category'] = \"wholesale\"\n\n result = []\n for _, row in df.iterrows():\n result.append(dict(row))\n return jsonify(result)\n\n@app.route(\"/retail/labeled/latest/\")\ndef get_table_psrt_labeled_latest():\n\n labs_conn = psycopg2.connect(user=os.environ.get('aws_db_user'),\n password=os.environ.get('aws_db_password'),\n host=os.environ.get('aws_db_host'),\n port=os.environ.get('aws_db_port'),\n database=os.environ.get('aws_db_name'))\n labs_curs = labs_conn.cursor()\n \n Q_select_all = \"\"\"SELECT product_name, market_name, country_code,\n source_name, currency_code, date_price,\n observed_price, observed_alps_class, alps_type_method,\n alps_stressness, observed_arima_alps_class, arima_alps_stressness\n FROM wholesale_prices\n WHERE observed_alps_class IS NOT NULL\n OR observed_arima_alps_class IS NOT NULL;\n \"\"\"\n labs_curs.execute(Q_select_all)\n # print(\"\\nSELECT * Query Excecuted.\")\n\n rows = labs_curs.fetchall()\n\n df = pd.DataFrame(rows, columns= [\n \"product_name\", \"market_name\", \"country_code\", \"source_name\",\n \"currency_code\", \"date_price\", \"observed_price\", \n \"observed_alps_class\", \"alps_type_method\", \"alps_stressness\",\n \"observed_arima_alps_class\", \"arima_alps_stressness\"\n ])\n labs_curs.close()\n labs_conn.close()\n # print(\"Cursor and Connection Closed.\")\n\n list_to_drop = df[df.sort_values(by=['date_price'], ascending=False).duplicated(['product_name', 'market_name', 'source_name','currency_code'], keep='first')].index\n\n df = df.drop(labels = list_to_drop, axis=0)\n\n df['date_price'] = df['date_price'].apply(lambda x: datetime.date.strftime(x,\"%Y-%m-%d\"))\n df['alps_stressness'] = df['alps_stressness'].apply(lambda x: round(x*100,2) if type(x) == float else None)\n df['alps_stressness'] = df['alps_stressness'].astype(str)\n df['observed_alps_class'] = df['observed_alps_class'].astype(str)\n df['observed_alps_class'] = df['observed_alps_class'] + ' ('+ df['alps_stressness'] + ' %)' \n df['alps_type_method'] = df['alps_type_method'].astype(str)\n df['arima_alps_stressness'] = df['arima_alps_stressness'].apply(lambda x: round(x*100,2) if type(x) == float else None)\n df['arima_alps_stressness'] = df['arima_alps_stressness'].astype(str)\n df['observed_arima_alps_class'] = df['observed_arima_alps_class'].astype(str) + ' ('+ df['arima_alps_stressness'] + ' %)' \n df['observed_alps_class'] = df['observed_alps_class'].replace('None (nan %)', 'Not available')\n df['alps_stressness'] = df['alps_stressness'].replace('nan', 'Not available')\n df['alps_type_method'] = df['alps_type_method'].replace('None', 'Not available')\n df['observed_arima_alps_class'] = df['observed_arima_alps_class'].replace('None (nan %)', 'Not available')\n df['arima_alps_stressness'] = df['arima_alps_stressness'].replace('nan', 'Not available')\n \n df['price_category'] = \"retail\"\n\n result = []\n for _, row in df.iterrows():\n result.append(dict(row))\n return jsonify(result)\n\n\n\n########################################################################\n\n############# Pulling specific product market pair data. #############\n\n########################################################################\n\n\n@app.route('/raw/')\ndef query_raw_data():\n\n query_parameters = request.args\n product_name = query_parameters.get('product_name')\n market_name = query_parameters.get('market_name')\n country_code = query_parameters.get('country_code')\n source_name = query_parameters.get('source_name')\n\n labs_conn = psycopg2.connect(user=os.environ.get('aws_db_user'),\n password=os.environ.get('aws_db_password'),\n host=os.environ.get('aws_db_host'),\n port=os.environ.get('aws_db_port'),\n database=os.environ.get('aws_db_name'))\n\n labs_curs = labs_conn.cursor()\n\n if source_name:\n\n labs_curs.execute('''\n SELECT id\n FROM sources\n WHERE source_name = %s\n ''', (source_name,))\n\n source_id = labs_curs.fetchall()\n\n if not source_id:\n\n return 'That source name is not in the db.'\n\n else:\n\n source_id = source_id[0][0]\n\n query = ''' \n SELECT *\n FROM raw_table\n WHERE\n '''\n to_filter = []\n\n\n if product_name:\n query += ' product_name=%s AND'\n to_filter.append(product_name)\n if market_name and country_code:\n market_id = market_name + ' : ' + country_code\n query += ' market_id=%s AND'\n to_filter.append(market_id)\n if source_name:\n labs_curs.execute('''\n SELECT id\n FROM sources\n WHERE source_name = %s\n ''', (source_name,))\n\n source_id = labs_curs.fetchall()\n\n if source_id:\n\n source_id = source_id[0][0]\n query += ' source_id = %s AND'\n to_filter.append(source_id)\n if not (product_name and market_name and country_code):\n return page_not_found(404)\n\n query = query[:-4] + ';'\n\n labs_curs.execute(query, to_filter)\n\n result = labs_curs.fetchall()\n\n if result:\n\n return jsonify(result)\n \n else:\n \n return page_not_found(404)\n\n if labs_conn:\n \n labs_conn.close()\n\n\n@app.route('/retail/')\ndef query_retail_data():\n\n query_parameters = request.args\n product_name = query_parameters.get('product_name')\n market_name = query_parameters.get('market_name')\n country_code = query_parameters.get('country_code')\n source_name = query_parameters.get('source_name')\n currency_code = query_parameters.get('currency_code')\n\n labs_conn = psycopg2.connect(user=os.environ.get('aws_db_user'),\n password=os.environ.get('aws_db_password'),\n host=os.environ.get('aws_db_host'),\n port=os.environ.get('aws_db_port'),\n database=os.environ.get('aws_db_name'))\n\n labs_curs = labs_conn.cursor()\n\n if source_name:\n\n labs_curs.execute('''\n SELECT id\n FROM sources\n WHERE source_name = %s\n ''', (source_name,))\n\n source_id = labs_curs.fetchall()\n\n if not source_id:\n\n return 'That source name is not in the db.'\n\n else:\n\n source_id = source_id[0][0]\n\n query_0 = ''' \n SELECT *\n FROM retail_prices\n WHERE\n '''\n\n query_1 = '''\n SELECT *\n FROM retail_stats\n WHERE\n '''\n\n to_filter = []\n\n\n if product_name:\n query_0 += ' product_name=%s AND'\n query_1 += ' product_name=%s AND'\n to_filter.append(product_name)\n if market_name and country_code:\n market_id = market_name + ' : ' + country_code\n query_0 += ' market_id=%s AND'\n query_1 += ' market_id=%s AND'\n to_filter.append(market_id)\n if source_name:\n labs_curs.execute('''\n SELECT id\n FROM sources\n WHERE source_name = %s\n ''', (source_name,))\n\n source_id = labs_curs.fetchall()\n\n if source_id:\n\n source_id = source_id[0][0]\n query_0 += ' source_id = %s AND'\n query_1 += ' source_id = %s AND'\n to_filter.append(source_id)\n\n else:\n\n labs_curs.execute('''\n SELECT source_id\n FROM retail_prices\n WHERE product_name = %s\n AND market_id = %s\n GROUP BY source_id\n ORDER BY count(source_id) DESC;\n ''', (product_name,market_id))\n \n source_id = labs_curs.fetchall()\n\n if source_id:\n\n source_id = source_id[0][0]\n query_0 += ' source_id = %s AND'\n query_1 += ' source_id = %s AND'\n to_filter.append(source_id)\n\n\n if currency_code:\n query_0 += ' currency_code = %s AND'\n query_1 += ' currency_code = %s AND'\n to_filter.append(currency_code) \n\n else:\n\n labs_curs.execute('''\n SELECT currency_code\n from retail_prices\n WHERE product_name = %s\n AND market_id = %s\n GROUP BY currency_code\n ORDER BY count(currency_code) DESC;\n ''', (product_name,market_id))\n\n currency_code = labs_curs.fetchall()\n\n if currency_code:\n\n currency_code = currency_code[0][0]\n query_0 += ' currency_code = %s AND'\n query_1 += ' currency_code = %s AND'\n to_filter.append(currency_code) \n\n if not (product_name and market_name and country_code):\n return page_not_found(404)\n\n query_0 = query_0[:-4] + ';'\n query_1 = query_1[:-4] + ';'\n\n labs_curs.execute(query_0, to_filter)\n\n result = labs_curs.fetchall()\n\n labs_curs.execute('''\n SELECT category_id\n FROM products\n WHERE product_name = %s\n ''', (product_name,))\n\n category_id = labs_curs.fetchall()[0][0]\n\n labs_curs.execute('''\n SELECT category_name\n FROM categories\n WHERE id = %s\n ''', (category_id,))\n\n product_category = labs_curs.fetchall()\n\n if product_category:\n\n product_category = product_category[0][0]\n\n else:\n product_category = 'Unknown'\n\n if result:\n\n df = pd.DataFrame(result, columns=['id', 'product_name','market_id','market_name', 'country_code','source_id',\n 'source_name', 'currency_code', 'unit_scale', 'date_price', 'observed_price',\n 'observed_alps_class', 'alps_type_method', 'forecasted_price', 'forecasted_class', \n 'forecasting_model', 'trending', 'normal_band_limit', 'stress_band_limit', 'alert_band_limit',\n 'alps_stressness', 'date_run_model', 'observed_arima_alps_class', 'arima_alps_stressness'])\n df['date_price'] = df['date_price'].apply(lambda x: datetime.date.strftime(x,\"%Y-%m-%d\"))\n df['alps_stressness'] = df['alps_stressness'].apply(lambda x: round(x*100,2) if type(x) == float else None)\n df['alps_stressness'] = df['alps_stressness'].astype(str)\n df['observed_alps_class'] = df['observed_alps_class'].astype(str)\n df['observed_alps_class'] = df['observed_alps_class'] + ' ('+ df['alps_stressness'] + ' %)' \n df['alps_type_method'] = df['alps_type_method'].astype(str)\n df['arima_alps_stressness'] = df['arima_alps_stressness'].apply(lambda x: round(x*100,2) if type(x) == float else None)\n df['arima_alps_stressness'] = df['arima_alps_stressness'].astype(str)\n df['observed_arima_alps_class'] = df['observed_arima_alps_class'].astype(str) + ' ('+ df['arima_alps_stressness'] + ' %)' \n df['observed_alps_class'] = df['observed_alps_class'].replace('None (nan %)', 'Not available')\n df['alps_stressness'] = df['alps_stressness'].replace('nan', 'Not available')\n df['alps_type_method'] = df['alps_type_method'].replace('None', 'Not available')\n df['observed_arima_alps_class'] = df['observed_arima_alps_class'].replace('None (None %)', 'Not available')\n df['arima_alps_stressness'] = df['arima_alps_stressness'].replace('nan', 'Not available')\n\n df = df.drop(labels=['id'],axis=1)\n\n prices_stats = df[['date_price','observed_price']].sort_values(by=['observed_price'])\n\n min_price_date = prices_stats.iloc[0,0]\n min_price_value = round(prices_stats.iloc[0,1],2)\n\n max_price_date = prices_stats.iloc[-1,0]\n max_price_value = round(prices_stats.iloc[-1,1],2)\n\n mean_price_value= round(df['observed_price'].mean(),2)\n\n labs_curs.execute(query_1,to_filter)\n\n stats = labs_curs.fetchall()\n\n if stats:\n\n stats_dict = {'product_category':product_category,'price_category' : 'Retail','start_date' : datetime.date.strftime(stats[0][5],\"%Y-%m-%d\"), 'end_date': datetime.date.strftime(stats[0][6],\"%Y-%m-%d\"), 'Mode_D': stats[0][12], 'number_of_observations': stats[0][13], 'mean': mean_price_value, 'min_price_date': min_price_date, 'min_price': min_price_value, 'max_price_date': max_price_date, 'max_price': max_price_value, 'days_between_start_end': stats[0][21], 'completeness': str(round(stats[0][22]*100 / .7123,2)) + ' %', 'DQI': 'not available', 'DQI_cat': 'not available'}\n\n labs_curs.execute('''\n SELECT *\n FROM qc_retail_observed_price\n WHERE product_name = %s\n AND market_id = %s\n ''', (product_name,market_id))\n\n DQI_info = labs_curs.fetchall()\n\n if DQI_info:\n\n stats_dict['DQI'] = round(DQI_info[0][-2],2)\n stats_dict['DQI_cat'] = DQI_info[0][-1].capitalize()\n\n else:\n\n stats_dict = {'product_data':'missing'}\n\n return jsonify(quality = stats_dict, history = df.to_dict('records'))\n\n \n else:\n \n return page_not_found(404)\n\n if labs_conn:\n \n labs_conn.close()\n\n@app.route('/wholesale/')\ndef query_wholesale_data():\n\n query_parameters = request.args\n product_name = query_parameters.get('product_name')\n market_name = query_parameters.get('market_name')\n country_code = query_parameters.get('country_code')\n source_name = query_parameters.get('source_name')\n currency_code = query_parameters.get('currency_code')\n\n labs_conn = psycopg2.connect(user=os.environ.get('aws_db_user'),\n password=os.environ.get('aws_db_password'),\n host=os.environ.get('aws_db_host'),\n port=os.environ.get('aws_db_port'),\n database=os.environ.get('aws_db_name'))\n\n labs_curs = labs_conn.cursor()\n\n if source_name:\n\n labs_curs.execute('''\n SELECT id\n FROM sources\n WHERE source_name = %s\n ''', (source_name,))\n\n source_id = labs_curs.fetchall()\n\n if not source_id:\n\n return 'That source name is not in the db.'\n\n else:\n\n source_id = source_id[0][0]\n\n query_0 = ''' \n SELECT *\n FROM wholesale_prices\n WHERE\n '''\n\n query_1 = '''\n SELECT *\n FROM wholesale_stats\n WHERE\n '''\n\n to_filter = []\n\n\n if product_name:\n query_0 += ' product_name=%s AND'\n query_1 += ' product_name=%s AND'\n to_filter.append(product_name)\n if market_name and country_code:\n market_id = market_name + ' : ' + country_code\n query_0 += ' market_id=%s AND'\n query_1 += ' market_id=%s AND'\n to_filter.append(market_id)\n if source_name:\n labs_curs.execute('''\n SELECT id\n FROM sources\n WHERE source_name = %s\n ''', (source_name,))\n\n source_id = labs_curs.fetchall()\n\n if source_id:\n\n source_id = source_id[0][0]\n query_0 += ' source_id = %s AND'\n query_1 += ' source_id = %s AND'\n to_filter.append(source_id)\n\n else:\n\n labs_curs.execute('''\n SELECT source_id\n FROM wholesale_prices\n WHERE product_name = %s\n AND market_id = %s\n GROUP BY source_id\n ORDER BY count(source_id) DESC;\n ''', (product_name,market_id))\n \n source_id = labs_curs.fetchall()\n\n if source_id:\n\n source_id = source_id[0][0]\n query_0 += ' source_id = %s AND'\n query_1 += ' source_id = %s AND'\n to_filter.append(source_id)\n\n\n if currency_code:\n\n query_0 += ' currency_code = %s AND'\n query_1 += ' currency_code = %s AND'\n to_filter.append(currency_code) \n\n else:\n\n labs_curs.execute('''\n SELECT currency_code\n from wholesale_prices\n WHERE product_name = %s\n AND market_id = %s\n GROUP BY currency_code\n ORDER BY count(currency_code) DESC;\n ''', (product_name,market_id))\n\n currency_code = labs_curs.fetchall()\n\n if currency_code:\n\n currency_code = currency_code[0][0]\n query_0 += ' currency_code = %s AND'\n query_1 += ' currency_code = %s AND'\n to_filter.append(currency_code) \n\n if not (product_name and market_name and country_code):\n return page_not_found(404)\n\n query_0 = query_0[:-4] + ';'\n query_1 = query_1[:-4] + ';'\n\n labs_curs.execute(query_0, to_filter)\n\n result = labs_curs.fetchall()\n\n labs_curs.execute('''\n SELECT category_id\n FROM products\n WHERE product_name = %s\n ''', (product_name,))\n\n category_id = labs_curs.fetchall()[0][0]\n\n labs_curs.execute('''\n SELECT category_name\n FROM categories\n WHERE id = %s\n ''', (category_id,))\n\n product_category = labs_curs.fetchall()\n\n if product_category:\n\n product_category = product_category[0][0]\n\n else:\n product_category = 'Unknown'\n\n\n if result:\n\n df = pd.DataFrame(result, columns=['id', 'product_name','market_id','market_name', 'country_code','source_id',\n 'source_name', 'currency_code', 'unit_scale', 'date_price', 'observed_price',\n 'observed_alps_class', 'alps_type_method', 'forecasted_price', 'forecasted_class', \n 'forecasting_model', 'trending', 'normal_band_limit', 'stress_band_limit', 'alert_band_limit',\n 'alps_stressness', 'date_run_model', 'observed_arima_alps_class', 'arima_alps_stressness'])\n df['date_price'] = df['date_price'].apply(lambda x: datetime.date.strftime(x,\"%Y-%m-%d\"))\n df['alps_stressness'] = df['alps_stressness'].apply(lambda x: round(x*100,2) if type(x) == float else None)\n df['alps_stressness'] = df['alps_stressness'].astype(str)\n df['observed_alps_class'] = df['observed_alps_class'].astype(str)\n df['observed_alps_class'] = df['observed_alps_class'] + ' ('+ df['alps_stressness'] + ' %)' \n df['alps_type_method'] = df['alps_type_method'].astype(str)\n df['arima_alps_stressness'] = df['arima_alps_stressness'].apply(lambda x: round(x*100,2) if type(x) == float else None)\n df['arima_alps_stressness'] = df['arima_alps_stressness'].astype(str)\n df['observed_arima_alps_class'] = df['observed_arima_alps_class'].astype(str) + ' ('+ df['arima_alps_stressness'] + ' %)' \n df['observed_alps_class'] = df['observed_alps_class'].replace('None (nan %)', 'Not available')\n df['alps_stressness'] = df['alps_stressness'].replace('nan', 'Not available')\n df['alps_type_method'] = df['alps_type_method'].replace('None', 'Not available')\n df['observed_arima_alps_class'] = df['observed_arima_alps_class'].replace('None (None %)', 'Not available')\n df['arima_alps_stressness'] = df['arima_alps_stressness'].replace('nan', 'Not available')\n df = df.drop(labels=['id'],axis=1)\n\n prices_stats = df[['date_price','observed_price']].sort_values(by=['observed_price'])\n\n min_price_date = prices_stats.iloc[0,0]\n min_price_value = round(prices_stats.iloc[0,1],2)\n\n max_price_date = prices_stats.iloc[-1,0]\n max_price_value = round(prices_stats.iloc[-1,1],2)\n\n mean_price_value= round(df['observed_price'].mean(),2)\n\n\n labs_curs.execute(query_1,to_filter)\n\n stats = labs_curs.fetchall()\n\n if stats:\n\n stats_dict = {'product_category':product_category,'price_category' : 'Wholesale','start_date' : datetime.date.strftime(stats[0][5],\"%Y-%m-%d\"), 'end_date': datetime.date.strftime(stats[0][6],\"%Y-%m-%d\"), 'Mode_D': stats[0][12], 'number_of_observations': stats[0][13], 'mean': mean_price_value, 'min_price_date': min_price_date, 'min_price': min_price_value, 'max_price_date': max_price_date, 'max_price': max_price_value, 'days_between_start_end': stats[0][21], 'completeness': str(round(stats[0][22]*100 / .7123,2)) + ' %', 'DQI': 'not available', 'DQI_cat': 'not available'}\n\n labs_curs.execute('''\n SELECT *\n FROM qc_wholesale_observed_price\n WHERE product_name = %s\n AND market_id = %s\n ''', (product_name,market_id))\n\n DQI_info = labs_curs.fetchall()\n\n if DQI_info:\n\n stats_dict['DQI'] = round(DQI_info[0][-2],2)\n stats_dict['DQI_cat'] = DQI_info[0][-1].capitalize()\n\n else:\n\n stats_dict = {'product_data':'missing'}\n\n return jsonify(quality = stats_dict, history = df.to_dict('records'))\n\n else:\n \n return page_not_found(404)\n\n if labs_conn:\n \n labs_conn.close()\n \n\n@app.route(\"/availablepairsobjects/\")\ndef get_available_pairs_objects():\n\n labs_conn = psycopg2.connect(user=os.environ.get('aws_db_user'),\n password=os.environ.get('aws_db_password'),\n host=os.environ.get('aws_db_host'),\n port=os.environ.get('aws_db_port'),\n database=os.environ.get('aws_db_name'))\n \n labs_curs = labs_conn.cursor()\n\n all_pairs = {'retail':None, 'wholesale':None}\n\n labs_curs.execute('''\n SELECT country_code\n FROM countries\n ''')\n\n countries = labs_curs.fetchall()\n\n if countries:\n\n countries = [x[0] for x in countries]\n\n country_market_product_pairs = {country: None for country in countries}\n\n for country in countries:\n\n \n labs_curs.execute('''\n SELECT market_name \n FROM markets\n WHERE country_code = %s\n ''', (country,))\n\n markets = labs_curs.fetchall()\n\n if markets:\n\n markets = [x[0] for x in markets]\n\n country_market_product_pairs[country]= {market : None for market in markets}\n\n retail_pairs = country_market_product_pairs.copy()\n wholesale_pairs = country_market_product_pairs.copy()\n\n for market in markets:\n\n # retail query\n\n labs_curs.execute('''\n SELECT DISTINCT(product_name) \n FROM retail_prices\n WHERE country_code = %s\n AND market_name = %s\n ''', (country,market))\n\n products = labs_curs.fetchall()\n\n if products:\n\n products = [x[0] for x in products]\n\n retail_pairs[country][market] = products\n all_pairs['retail'] = retail_pairs\n \n\n # wholesale query\n\n labs_curs.execute('''\n SELECT DISTINCT(product_name) \n FROM wholesale_prices\n WHERE country_code = %s\n AND market_name = %s\n ''', (country,market))\n\n products = labs_curs.fetchall()\n\n if products:\n\n products = [x[0] for x in products]\n\n wholesale_pairs[country][market] = products\n all_pairs['wholesale'] = retail_pairs\n\n else:\n\n del wholesale_pairs[country][market]\n\n keys_to_drop = []\n\n for sale_type in ['retail', 'wholesale']:\n\n for key in all_pairs[sale_type].keys():\n\n if not all_pairs[sale_type][key]:\n\n keys_to_drop.append(key)\n \n for key in keys_to_drop:\n\n del all_pairs[sale_type][key]\n \n keys_to_drop = []\n\n\n labs_curs.close()\n labs_conn.close()\n\n\n return jsonify(all_pairs)\n\n\n@app.route(\"/availablepairs/\")\ndef get_available_pairs():\n\n labs_conn = psycopg2.connect(user=os.environ.get('aws_db_user'),\n password=os.environ.get('aws_db_password'),\n host=os.environ.get('aws_db_host'),\n port=os.environ.get('aws_db_port'),\n database=os.environ.get('aws_db_name'))\n \n labs_curs = labs_conn.cursor()\n\n all_pairs = [{'retail':None, 'wholesale':None}]\n\n labs_curs.execute('''\n SELECT country_code\n FROM countries\n ''')\n\n countries = labs_curs.fetchall()\n\n if countries:\n\n countries = [x[0] for x in countries]\n\n country_market_product_pairs = {country: None for country in countries}\n\n for country in countries:\n\n\n labs_curs.execute('''\n SELECT market_name \n FROM markets\n WHERE country_code = %s\n ''', (country,))\n\n markets = labs_curs.fetchall()\n\n if markets:\n\n markets = [x[0] for x in markets]\n\n country_market_product_pairs[country]= [{market : None for market in markets}]\n\n retail_pairs = country_market_product_pairs.copy()\n wholesale_pairs = country_market_product_pairs.copy()\n\n for market in markets:\n\n # retail query\n\n labs_curs.execute('''\n SELECT DISTINCT(product_name) \n FROM retail_prices\n WHERE country_code = %s\n AND market_name = %s\n ''', (country,market))\n\n products = labs_curs.fetchall()\n\n if products:\n\n products = [x[0] for x in products]\n\n retail_pairs[country][0][market] = products\n all_pairs[0]['retail'] = [retail_pairs]\n\n\n\n # wholesale query\n\n labs_curs.execute('''\n SELECT DISTINCT(product_name) \n FROM wholesale_prices\n WHERE country_code = %s\n AND market_name = %s\n ''', (country,market))\n\n products = labs_curs.fetchall()\n\n if products:\n\n products = [x[0] for x in products]\n\n wholesale_pairs[country][0][market] = products\n all_pairs[0]['wholesale'] = [wholesale_pairs]\n\n else:\n\n del wholesale_pairs[country][0][market]\n \n labs_curs.close()\n labs_conn.close()\n\n keys_to_drop = []\n\n for sale_type in ['retail', 'wholesale']:\n\n for key in all_pairs[0][sale_type][0].keys():\n\n if not all_pairs[0][sale_type][0][key]:\n\n keys_to_drop.append(key)\n \n for key in keys_to_drop:\n\n del all_pairs[0][sale_type][0][key]\n \n keys_to_drop = []\n\n\n\n\n\n\n\n\n return jsonify(all_pairs)\n\n\n\n\n"
] |
[
[
"pandas.DataFrame"
]
] |
andrevitorelli/BlendHunter
|
[
"64e4c97e7e0995e2d3561300dff708ca86adb380"
] |
[
"blendhunter/network.py"
] |
[
"# -*- coding: utf-8 -*-\n\n\"\"\" NETWORK\n\nThis module defines the BlendHunter class which can be used to retrain the\nnetwork or use predefined weights to make predictions on unseen data.\n\n:Author: Samuel Farrens <samuel.farrens@cea.fr>\n\n\"\"\"\n\nimport os\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nfrom time import time\nfrom cv2 import imread\nfrom keras.preprocessing.image import ImageDataGenerator\nfrom keras.models import Sequential, Model\nfrom keras.layers import Dropout, Flatten, Dense, Input\nfrom keras.applications import VGG16\nfrom keras.optimizers import Adam, SGD\nfrom keras.callbacks import ModelCheckpoint\nfrom keras.callbacks import EarlyStopping\nfrom keras.callbacks import ReduceLROnPlateau\n\n\nclass BlendHunter(object):\n \"\"\" BlendHunter\n\n Class for identifying blended galaxy images in postage stamps.\n\n Parameters\n ----------\n image_shape : tuple, optional\n Expected shape of input images\n classes : tuple, optional\n List of classes, default is ('blended', 'not_blended')\n weights_path : str, optional\n Path to weights, default is './weights'\n top_model_file : str, optional\n File name for top model weights, default is 'top_model_weights'\n final_model_file : str, optional\n File name of the final model weights, default is\n 'final_model_weights'\n\n \"\"\"\n\n def __init__(self, image_shape=None, classes=('blended', 'not_blended'),\n weights_path='./weights', top_model_file='top_model_weights',\n final_model_file='final_model_weights', verbose=0):\n\n self._image_shape = image_shape\n self._classes = classes\n self._weights_path = weights_path\n self._top_model_file = self._format(weights_path, top_model_file)\n self._final_model_file = self._format(weights_path, final_model_file)\n self._verbose = verbose\n self.history = None\n\n @staticmethod\n def _format(path, name):\n \"\"\" Format\n\n Add path to name.\n\n Parameters\n ----------\n path : str\n Base path\n name : str\n Path extension\n\n Returns\n -------\n str\n Formated path\n\n \"\"\"\n\n return '{}/{}'.format(path, name)\n\n def getkwarg(self, key, default=None):\n \"\"\" Get keyword agrument\n\n Get value from keyword agruments if it exists otherwise return default.\n\n Parameters\n ----------\n key : str\n Dictionary key\n default : optional\n Default value\n\n \"\"\"\n\n return self._kwargs[key] if key in self._kwargs else default\n\n @staticmethod\n def _get_image_shape(file):\n \"\"\" Get Image Shape\n\n Get the input image shape from an example image.\n\n Parameters\n ----------\n file : str\n File name\n\n Returns\n -------\n tuple\n Image shape\n\n \"\"\"\n\n return imread(file).shape\n\n def _get_target_shape(self, image_path=None):\n \"\"\" Get Target Shape\n\n Get the network target shape from the image shape.\n\n Parameters\n ----------\n image_path : str, optional\n Path to image file\n\n \"\"\"\n\n if isinstance(self._image_shape, type(None)) and image_path:\n file = self._format(image_path, os.listdir(image_path)[0])\n self._image_shape = self._get_image_shape(file)\n\n self._target_size = self._image_shape[:2]\n\n def _load_generator(self, input_dir, batch_size=None,\n class_mode=None, augmentation=False):\n \"\"\" Load Generator\n\n Load files from an input directory into a Keras generator.\n\n Parameters\n ----------\n input_dir : str\n Input directory\n batch_size : int, optional\n Batch size\n class_mode : str, optional\n Generator class mode\n shuffle : bool, optional\n Option to shuffle input files\n\n Returns\n -------\n keras_preprocessing.image.DirectoryIterator\n Keras generator\n\n \"\"\"\n\n if augmentation:\n datagen = ImageDataGenerator(rescale=1. / 255,\n shear_range=0.2,\n zoom_range=0.2,\n horizontal_flip=True)\n else:\n datagen = ImageDataGenerator(rescale=1. / 255)\n\n generator = (datagen.flow_from_directory(input_dir,\n target_size=self._target_size,\n batch_size=batch_size, class_mode=class_mode,\n shuffle=False))\n generator.steps = generator.n // generator.batch_size\n\n return generator\n\n def _get_feature(self, input_dir):\n \"\"\" Get Feature\n\n Get network feature and labels from VGG16 model.\n\n Parameters\n ----------\n input_dir : str\n Input directory\n\n Returns\n -------\n tuple\n VGG16 bottleneck feature, class labels\n\n \"\"\"\n\n generator = self._load_generator(input_dir,\n batch_size=self._batch_size_top)\n labels = generator.classes[:generator.steps * self._batch_size_top]\n\n return (self._vgg16_model.predict_generator(generator,\n generator.steps), labels)\n\n @staticmethod\n def _save_data(data, data_type, file_path):\n \"\"\" Save Data\n\n Save data to file.\n\n Parameters\n ----------\n data : np.ndarray\n Output data\n data_type : str\n Type of feature to be saved\n file_path : str\n File path\n\n \"\"\"\n\n file_name = '{}_{}.npy'.format(file_path, data_type)\n np.save(file_name, data)\n\n @staticmethod\n def _load_data(data_type, file_path):\n \"\"\" Load Data\n\n Load data from file.\n\n Parameters\n ----------\n data_type : str\n Type of feature to be loaded\n file_path : str\n File path\n\n \"\"\"\n\n file_name = '{}_{}.npy'.format(file_path, data_type)\n if os.path.isfile(file_name):\n return np.load(file_name)\n else:\n raise IOError('{} not found'.format(file_name))\n\n @staticmethod\n def _build_vgg16_model(input_shape=None):\n \"\"\" Build VGG16 Model\n\n Build VGG16 CNN model using imagenet weights.\n\n Parameters\n ----------\n input_shape : str, optional\n Input data shape\n\n Returns\n -------\n\n VGG16 model\n\n \"\"\"\n\n return VGG16(include_top=False, weights='imagenet',\n input_shape=input_shape)\n\n def _get_features(self):\n \"\"\" Get Features\n\n Get the network (bottleneck) features from the VGG16 model.\n\n \"\"\"\n\n self._vgg16_model = self._build_vgg16_model()\n\n for key, value in self._features.items():\n\n bot_feat, labels = self._get_feature(value['dir'])\n\n if self._save_bottleneck:\n self._save_data(bot_feat, key, self._bottleneck_file)\n\n if self._save_labels:\n self._save_data(labels, key, self._labels_file)\n\n value['bottleneck'] = bot_feat\n value['labels'] = labels\n\n def _load_features(self):\n \"\"\" Load Bottleneck Features\n\n Load VGG16 bottleneck features.\n\n \"\"\"\n\n for feature_name in ('bottleneck', 'labels'):\n\n if feature_name == 'bottleneck':\n out_path = self._bottleneck_file\n else:\n out_path = self._labels_file\n\n for key, value in self._features.items():\n if feature_name not in value:\n value[feature_name] = self._load_data(key, out_path)\n\n @staticmethod\n def _build_top_model(input_shape, dense_output=(256, 1024), dropout=0.1):\n \"\"\" Build Top Model\n\n Build the fully connected layers of the network.\n\n Parameters\n ----------\n input_shape : tuple\n Input data shape\n dense_output : tuple, optional\n Size of dense output layers, default is (256, 1024)\n dropout : float, optional\n Dropout rate, default is 0.1\n\n Returns\n -------\n keras.model\n Fully connected top model\n\n \"\"\"\n\n model = Sequential()\n model.add(Flatten(input_shape=input_shape))\n model.add(Dense(dense_output[0]))\n model.add(Dropout(dropout))\n model.add(Dense(dense_output[1], activation='relu'))\n model.add(Dense(1, activation='sigmoid'))\n\n return model\n\n def _train_top_model(self):\n \"\"\" Train Top Model\n\n Train fully connected top model of the network.\n\n \"\"\"\n\n self._load_features()\n\n model = (self._build_top_model(\n input_shape=self._features['train']['bottleneck'].shape[1:]))\n\n model.compile(optimizer=self.getkwarg('top_opt', 'adam'),\n loss=self.getkwarg('top_loss', 'binary_crossentropy'),\n metrics=self.getkwarg('top_metrics', ['accuracy']))\n\n top_model_file = '{}.h5'.format(self._top_model_file)\n\n callbacks = []\n callbacks.append(ModelCheckpoint(top_model_file,\n monitor='val_loss', verbose=self._verbose,\n save_best_only=True, save_weights_only=True,\n mode='auto', period=1))\n\n if self.getkwarg('top_early_stop', True):\n\n min_delta = self.getkwarg('top_min_delta', 0.001)\n patience = self.getkwarg('top_patience', 10)\n\n callbacks.append(EarlyStopping(monitor='val_loss',\n min_delta=min_delta,\n patience=patience,\n verbose=self._verbose))\n\n callbacks.append(ReduceLROnPlateau(monitor='val_loss', factor=0.5,\n patience=5, min_delta=0.001,\n cooldown=2, verbose=self._verbose))\n\n self.history = (model.fit(self._features['train']['bottleneck'],\n self._features['train']['labels'],\n epochs=self._epochs_top,\n batch_size=self._batch_size_top,\n callbacks=callbacks,\n validation_data=(self._features['valid']['bottleneck'],\n self._features['valid']['labels']),\n verbose=self._verbose))\n\n model.save_weights(top_model_file)\n\n def plot_history(self):\n \"\"\" Plot History\n\n Plot the training history metrics.\n\n \"\"\"\n\n sns.set(style=\"darkgrid\")\n\n if not isinstance(self.history, type(None)):\n\n plt.figure(figsize=(16, 8))\n\n plt.subplot(121)\n plt.plot(self.history.history['acc'])\n plt.plot(self.history.history['val_acc'])\n plt.title('Model Accuracy')\n plt.ylabel('Accuracy')\n plt.xlabel('Epoch')\n plt.legend(['train', 'valid'], loc='upper left')\n\n plt.subplot(122)\n plt.plot(self.history.history['loss'])\n plt.plot(self.history.history['val_loss'])\n plt.title('Model Loss')\n plt.ylabel('Loss')\n plt.xlabel('Epoch')\n plt.legend(['train', 'valid'], loc='upper left')\n\n plt.show()\n\n else:\n\n print('No history to display. Run training first.')\n\n def _freeze_layers(self, model, depth):\n \"\"\" Freeze Network Layers\n\n Parameters\n ----------\n model :\n Keras model\n depth : int\n Depth of layers to be frozen\n\n \"\"\"\n\n for layer in model.layers[:depth]:\n layer.trainable = False\n\n def _build_final_model(self, load_top_weights=False,\n load_final_weights=False):\n \"\"\" Build Final Model\n\n Build the final BlendHunter model.\n\n Parameters\n ----------\n load_top_weights : bool\n Option to load the top model weights\n load_final_weights : bool\n Option to load the final model weights\n\n Returns\n -------\n\n Final model\n\n \"\"\"\n\n vgg16_model = self._build_vgg16_model(self._image_shape)\n top_model = self._build_top_model(vgg16_model.output_shape[1:],\n dropout=0.4)\n\n if load_top_weights:\n top_model.load_weights('{}.h5'.format(self._top_model_file))\n\n model = Model(inputs=vgg16_model.input,\n outputs=top_model(vgg16_model.output))\n\n if load_final_weights:\n model.load_weights('{}.h5'.format(self._final_model_file))\n\n return model\n\n def _fine_tune(self):\n \"\"\" Fine Tune\n\n Fine tune the final model training.\n\n \"\"\"\n\n model = self._build_final_model(load_top_weights=True)\n\n self._freeze_layers(model, 18)\n\n model.compile(loss='binary_crossentropy',\n optimizer=Adam(lr=0.0001),\n metrics=['binary_accuracy'])\n\n train_gen = self._load_generator(self._features['train']['dir'],\n batch_size=self._batch_size_fine,\n class_mode='binary',\n augmentation=True)\n\n valid_gen = self._load_generator(self._features['valid']['dir'],\n batch_size=self._batch_size_fine,\n class_mode='binary')\n\n callbacks = []\n callbacks.append(ModelCheckpoint('{}.h5'.format(self._fine_tune_file),\n monitor='val_loss', verbose=self._verbose,\n save_best_only=True, save_weights_only=True,\n mode='auto', period=1))\n callbacks.append(EarlyStopping(monitor='val_loss', min_delta=0.001,\n patience=10, verbose=self._verbose))\n callbacks.append(ReduceLROnPlateau(monitor='val_loss', factor=0.5,\n patience=5, min_delta=0.001,\n cooldown=2, verbose=self._verbose))\n\n model.fit_generator(train_gen, steps_per_epoch=train_gen.steps,\n epochs=self._epochs_fine,\n callbacks=callbacks,\n validation_data=valid_gen,\n validation_steps=valid_gen.steps,\n verbose=self._verbose)\n\n self._freeze_layers(model, 19)\n model.layers[17].trainable = True\n\n model.compile(loss='binary_crossentropy',\n optimizer=SGD(lr=10e-5),\n metrics=['binary_accuracy'])\n\n model.fit_generator(train_gen, steps_per_epoch=train_gen.steps,\n epochs=self._epochs_fine,\n callbacks=callbacks,\n validation_data=valid_gen,\n validation_steps=valid_gen.steps,\n verbose=self._verbose)\n\n model.save_weights('{}.h5'.format(self._final_model_file))\n\n def train(self, input_path, get_features=True, train_top=True,\n fine_tune=True, train_dir_name='train',\n valid_dir_name='validation', epochs_top=500, epochs_fine=50,\n batch_size_top=250, batch_size_fine=16, save_bottleneck=True,\n bottleneck_file='bottleneck_features',\n save_labels=True, labels_file='labels',\n fine_tune_file='fine_tune_checkpoint',\n top_model_file='top_model_weights', **kwargs):\n \"\"\" Train\n\n Train the BlendHunter network.\n\n Parameters\n ----------\n input_path : str\n Path to input data\n get_features : bool, optional\n Option to get bottleneck features, default is True\n train_top : bool, optional\n Option to train top model, default is True\n fine_tune : bool, optional\n Option to run fine tuning component of training, default is True\n train_dir_name : str, optional\n Training data directory name, default is 'train'\n valid_dir_name : str, optional\n Validation data directory name, default is 'validation'\n epochs_top : int, optional\n Number of training epochs for top model, default is 500\n epochs_fine : int, optional\n Number of training epochs for fine tuning, default is 50\n batch_size_top : int, optional\n Batch size for top model, default is 256\n batch_size_fine : int, optional\n Batch size for fine tuning, default is 16\n save_bottleneck : bool, optional\n Option to save bottleneck features, default is True\n bottleneck_file : str, optional\n File name for bottleneck features, default is\n 'bottleneck_features'\n fine_tune_file : str, optional\n Training checkpoint for the fine tuning step, default is\n 'fine_tune_checkpoint'\n\n \"\"\"\n\n start = time()\n\n self._epochs_top = epochs_top\n self._epochs_fine = epochs_fine\n self._batch_size_top = batch_size_top\n self._batch_size_fine = batch_size_fine\n self._save_bottleneck = save_bottleneck\n self._save_labels = save_labels\n self._bottleneck_file = self._format(self._weights_path,\n bottleneck_file)\n self._labels_file = self._format(self._weights_path, labels_file)\n self._fine_tune_file = self._format(self._weights_path, fine_tune_file)\n self._features = {'train': {}, 'valid': {}}\n self._features['train']['dir'] = self._format(input_path,\n train_dir_name)\n self._features['valid']['dir'] = self._format(input_path,\n valid_dir_name)\n self._kwargs = kwargs\n\n self._get_target_shape(self._format(self._features['train']['dir'],\n self._classes[0]))\n if get_features:\n self._get_features()\n if train_top:\n self._train_top_model()\n if fine_tune:\n self._fine_tune()\n\n end = time()\n\n print('Duration {:0.2f}s'.format(end - start))\n\n def predict(self, input_path=None, input_path_keras=None, input_data=None,\n weights_type='fine'):\n \"\"\" Predict\n\n Predict classes for test data\n\n Parameters\n ----------\n input_path : str\n Path to input data\n input_path_keras : str\n Path to input data in Keras format, i.e. path to directory one\n level above where the data is stored\n input_data : np.ndarray\n Array of input images\n weights_type : str, optional {'fine', 'top'}\n Type of weights to use for predition, default is 'fine'\n\n Returns\n -------\n dict\n Dictionary of file names and corresponding classes\n\n \"\"\"\n\n if input_path:\n test_path = '/'.join(input_path.split('/')[:-1])\n elif input_path_keras:\n test_path = input_path_keras\n else:\n test_path = None\n if weights_type not in ('fine', 'top'):\n raise ValueError('Invalid value for weights_type. Options are '\n '\"fine\" or \"top\"')\n\n if test_path:\n\n self._get_target_shape(self._format(test_path,\n os.listdir(test_path)[0]))\n if weights_type == 'fine':\n model = self._build_final_model(load_final_weights=True)\n elif weights_type == 'top':\n model = self._build_final_model(load_top_weights=True)\n test_gen = self._load_generator(test_path,\n class_mode='categorical',\n batch_size=1)\n self.filenames = test_gen.filenames\n test_gen.reset()\n res = model.predict_generator(test_gen,\n verbose=self._verbose,\n steps=test_gen.steps).flatten()\n\n elif not isinstance(input_data, type(None)):\n\n self._image_shape = input_data.shape[1:]\n self._get_target_shape()\n model = self._build_final_model(load_final_weights=True)\n res = model.predict(input_data, verbose=self._verbose).flatten()\n\n else:\n\n raise RuntimeError('No input data provided.')\n\n labels = {0: self._classes[0], 1: self._classes[1]}\n preds = [labels[k] for k in np.around(res)]\n\n return preds\n"
] |
[
[
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.plot",
"numpy.load",
"matplotlib.pyplot.title",
"numpy.save",
"matplotlib.pyplot.figure",
"matplotlib.pyplot.legend",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.show",
"numpy.around",
"matplotlib.pyplot.subplot"
]
] |
hematthi/SysSim_Plotting
|
[
"bc8c4708e9242102f5790af004c8d19ef1191334",
"bc8c4708e9242102f5790af004c8d19ef1191334"
] |
[
"examples/plot_kepler_catalog/plot_observed_kepler.py",
"src/functions_compute_RVs.py"
] |
[
"# To import required modules:\nimport numpy as np\nimport time\nimport os\nimport sys\nimport matplotlib\nimport matplotlib.cm as cm #for color maps\nimport matplotlib.pyplot as plt\nfrom matplotlib.gridspec import GridSpec #for specifying plot attributes\nfrom matplotlib import ticker #for setting contour plots to log scale\nimport scipy.integrate #for numerical integration\nimport scipy.misc #for factorial function\nfrom scipy.special import erf #error function, used in computing CDF of normal distribution\nimport scipy.interpolate #for interpolation functions\nimport corner #corner.py package for corner plots\n#matplotlib.rc('text', usetex=True)\n\nsys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.realpath(__file__)))))\n\nfrom src.functions_general import *\nfrom src.functions_compare_kepler import *\nfrom src.functions_load_sims import *\nfrom src.functions_plot_catalogs import *\nfrom src.functions_plot_params import *\n\n\n\n\n\nsavefigures = False\nsavefigures_directory = ''\n\n\n\n\n\n##### To load the files with the systems with observed planets:\n\n# To first read the number of simulated targets and bounds for the periods and radii:\nP_min, P_max, radii_min, radii_max = 3., 300., 0.5, 10.\n\n# To load and process the observed Kepler catalog and compare with our simulated catalog:\nstars_cleaned = load_Kepler_stars_cleaned()\nssk_per_sys, ssk = compute_summary_stats_from_Kepler_catalog(P_min, P_max, radii_min, radii_max, compute_ratios=compute_ratios_adjacent)\n\n\n\n\n\n#'''\n##### To plot the Kepler catalog as marginal distributions:\n\nsubdirectory = 'Stellar_samples/Kepler_data/E_BP_MIN_RP/Interpolate_e_bp_min_rp/e_bp_min_rp_dist/' #'Paper_Figures/'; 'Talk_Figures/'\n\nfig_size = (8,3) #size of each panel (figure)\nfig_lbrt = [0.15, 0.3, 0.95, 0.925]\n\nn_bins = 100\nlw = 1 #linewidth\n#alpha = 0.2 #transparency of histograms\n\nafs = 20 #axes labels font size\ntfs = 20 #text labels font size\nlfs = 16 #legend labels font size\n\n\n\n# Multiplicities:\nplot_fig_counts_hist_simple(fig_size, [], [ssk_per_sys['Mtot_obs']], x_min=0, y_max=1e4, x_llim=0.5, log_y=True, lines_Kep=True, lw=lw, xlabel_text='Observed planets per system', afs=afs, tfs=tfs, lfs=lfs, legend=True, show_counts_Kep=True, fig_lbrt=fig_lbrt, save_name=savefigures_directory + subdirectory + 'Kepler_multiplicities.pdf', save_fig=savefigures)\n\n# Periods:\nplot_fig_pdf_simple(fig_size, [], [ssk['P_obs']], x_min=P_min, x_max=P_max, n_bins=n_bins, normalize=False, log_x=True, log_y=True, lw=lw, xticks_custom=[3,10,30,100,300], xlabel_text=r'$P$ (days)', ylabel_text='Number', afs=afs, tfs=tfs, lfs=lfs, legend=True, fig_lbrt=fig_lbrt, save_name=savefigures_directory + subdirectory + 'Kepler_periods.pdf', save_fig=savefigures)\n\n# Period ratios (all, with some upper cut-off):\nR_max_cut = 30. #upper cut-off for plotting period ratios; np.max(sss['Rm_obs'])\nplot_fig_pdf_simple(fig_size, [], [ssk['Rm_obs'][ssk['Rm_obs'] < R_max_cut]], x_min=1., x_max=R_max_cut, n_bins=n_bins, normalize=False, log_x=True, lw=lw, xticks_custom=[1,2,3,4,5,10,20], xlabel_text=r'$P_{i+1}/P_i$', ylabel_text='Number', afs=afs, tfs=tfs, lfs=lfs, fig_lbrt=fig_lbrt, save_name=savefigures_directory + subdirectory + 'Kepler_periodratios.pdf', save_fig=savefigures)\n\n# Period ratios (< 5):\nplot_fig_pdf_simple(fig_size, [], [ssk['Rm_obs'][ssk['Rm_obs'] < 5.]], x_min=1., x_max=5., n_bins=n_bins, normalize=False, lw=lw, xlabel_text=r'$P_{i+1}/P_i$', ylabel_text='Number', afs=afs, tfs=tfs, lfs=lfs, fig_lbrt=fig_lbrt, save_name=savefigures_directory + subdirectory + 'Kepler_periodratios_less5.pdf', save_fig=savefigures)\n\n# Transit durations:\nplot_fig_pdf_simple(fig_size, [], [ssk['tdur_obs']], x_max=15., n_bins=n_bins, normalize=False, lw=lw, xlabel_text=r'$t_{\\rm dur}$ (hrs)', ylabel_text='Number', afs=afs, tfs=tfs, lfs=lfs, fig_lbrt=fig_lbrt, save_name=savefigures_directory + subdirectory + 'Kepler_durations.pdf', save_fig=savefigures)\n\n# Transit durations (for singles and multis):\nplot_fig_pdf_simple(fig_size, [], [ssk['tdur_tcirc_1_obs'], ssk['tdur_tcirc_2p_obs']], x_max=1.5, n_bins=n_bins, normalize=False, c_Kep=['b','r'], ls_Kep=['-','-'], lw=lw, labels_Kep=['Singles', 'Multis'], xlabel_text=r'$t_{\\rm dur}/t_{\\rm circ}$', ylabel_text='Number', afs=afs, tfs=tfs, lfs=lfs, legend=True, fig_lbrt=fig_lbrt, save_name=savefigures_directory + subdirectory + 'Kepler_durations_norm_circ_singles_multis.pdf', save_fig=savefigures)\n\n# Transit depths:\nplot_fig_pdf_simple(fig_size, [], [ssk['D_obs']], x_min=1e-5, x_max=10.**-1.5, n_bins=n_bins, normalize=False, log_x=True, lw=lw, xlabel_text=r'$\\delta$', ylabel_text='Number', afs=afs, tfs=tfs, lfs=lfs, fig_lbrt=fig_lbrt, save_name=savefigures_directory + subdirectory + 'Kepler_depths.pdf', save_fig=savefigures)\n\n# Transit depths (above and below the photoevaporation boundary):\nplot_fig_pdf_simple(fig_size, [], [ssk['D_above_obs'], ssk['D_below_obs']], x_min=1e-5, x_max=10.**-1.5, n_bins=n_bins, normalize=False, log_x=True, c_Kep=['b','r'], ls_Kep=['-','-'], lw=lw, labels_Kep=['Above', 'Below'], xlabel_text=r'$\\delta$', ylabel_text='Number', afs=afs, tfs=tfs, lfs=lfs, legend=True, fig_lbrt=fig_lbrt, save_name=savefigures_directory + subdirectory + 'Kepler_depths_photoevap.pdf', save_fig=savefigures)\n\n# Planet radii:\nplot_fig_pdf_simple(fig_size, [], [ssk['radii_obs']], x_min=radii_min, x_max=radii_max, n_bins=n_bins, normalize=False, lw=lw, xlabel_text=r'$R_p (R_\\oplus)$', ylabel_text='Number', afs=afs, tfs=tfs, lfs=lfs, fig_lbrt=fig_lbrt, save_name=savefigures_directory + subdirectory + 'Kepler_radii.pdf', save_fig=savefigures)\n\n# Stellar radii:\nplot_fig_pdf_simple(fig_size, [], [ssk['Rstar_obs']], n_bins=n_bins, normalize=False, lw=lw, xlabel_text=r'$R_\\star (R_\\odot)$', ylabel_text='Number', afs=afs, tfs=tfs, lfs=lfs, fig_lbrt=fig_lbrt, save_name=savefigures_directory + subdirectory + 'Kepler_stellar_radii.pdf', save_fig=savefigures)\n\n# Transit depth ratios:\nplot_fig_pdf_simple(fig_size, [], [ssk['D_ratio_obs']], x_min=10.**-1.5, x_max=10.**1.5, n_bins=n_bins, normalize=False, log_x=True, lw=lw, xlabel_text=r'$\\delta_{i+1}/\\delta_i$', ylabel_text='Number', afs=afs, tfs=tfs, lfs=lfs, fig_lbrt=fig_lbrt, save_name=savefigures_directory + subdirectory + 'Kepler_depthratios.pdf', save_fig=savefigures)\n\n# Transit depth ratios (above, below, and across the photoevaporation boundary):\nplot_fig_pdf_simple(fig_size, [], [ssk['D_ratio_above_obs'], ssk['D_ratio_below_obs'], ssk['D_ratio_across_obs']], x_min=10.**-1.5, x_max=10.**1.5, n_bins=n_bins, normalize=False, log_x=True, c_Kep=['b','r','k'], ls_Kep=['-','-','-'], lw=lw, labels_Kep=['Above', 'Below', 'Across'], xlabel_text=r'$\\delta_{i+1}/\\delta_i$', ylabel_text='Number', afs=afs, tfs=tfs, lfs=lfs, legend=True, fig_lbrt=fig_lbrt, save_name=savefigures_directory + subdirectory + 'Kepler_depthratios_photoevap.pdf', save_fig=savefigures)\n\n# Log(xi):\nplot_fig_pdf_simple(fig_size, [], [np.log10(ssk['xi_obs'])], x_min=-0.5, x_max=0.5, n_bins=n_bins, normalize=False, lw=lw, xlabel_text=r'$\\log{\\xi}$', ylabel_text='Number', afs=afs, tfs=tfs, lfs=lfs, fig_lbrt=fig_lbrt, save_name=savefigures_directory + subdirectory + 'Kepler_logxi_all.pdf', save_fig=savefigures)\n\n# Log(xi) by res/non-res:\nplot_fig_pdf_simple(fig_size, [], [np.log10(ssk['xi_res_obs']), np.log10(ssk['xi_nonres_obs'])], x_min=-0.5, x_max=0.5, n_bins=n_bins, normalize=False, c_Kep=['m','g'], ls_Kep=['-','-'], lw=lw, labels_Kep=['Near MMR', 'Not near MMR'], xlabel_text=r'$\\log{\\xi}$', ylabel_text='Number', afs=afs, tfs=tfs, lfs=lfs, legend=True, fig_lbrt=fig_lbrt, save_name=savefigures_directory + subdirectory + 'Kepler_logxi.pdf', save_fig=savefigures)\n\n# Log(xi) within res:\nplot_fig_pdf_simple(fig_size, [], [np.log10(ssk['xi_res32_obs']), np.log10(ssk['xi_res21_obs'])], x_min=-0.5, x_max=0.5, n_bins=n_bins, normalize=False, c_Kep=['r','b'], ls_Kep=['-','-'], lw=lw, labels_Kep=['Near 3:2 MMR', 'Near 2:1 MMR'], xlabel_text=r'$\\log{\\xi}$', ylabel_text='Number', afs=afs, tfs=tfs, lfs=lfs, legend=True, fig_lbrt=fig_lbrt, save_name=savefigures_directory + subdirectory + 'Kepler_logxi_res.pdf', save_fig=savefigures)\n\nplt.show()\n#plt.close()\n#'''\n\n\n\n\n\n##### To plot a histogram of the zeta statistic:\n\nzeta1_all = zeta1(ssk['Rm_obs'])\npratios_small = ssk['Rm_obs'][ssk['Rm_obs'] < 2.5]\nzeta1_small = zeta1(pratios_small)\nplot_fig_pdf_simple(fig_size, [], [zeta1_all, zeta1_small], x_min=-1., x_max=1., n_bins=30, normalize=True, c_Kep=['b','r'], ls_Kep=['-','-'], lw=lw, labels_Kep=['All period ratios', 'Period ratios < 2.5'], xlabel_text=r'$\\zeta_1$', ylabel_text='Number', afs=afs, tfs=tfs, lfs=lfs, legend=True, fig_lbrt=fig_lbrt, save_name=savefigures_directory + subdirectory + 'Kepler_zeta1.pdf', save_fig=savefigures)\n#plot_fig_pdf_simple(fig_size, [], [zeta1_all], x_min=-1., x_max=1., n_bins=30, normalize=True, c_Kep=['b'], lw=lw, labels_Kep=['All period ratios'], xlabel_text=r'$\\zeta_1$', ylabel_text='Number', afs=afs, tfs=tfs, lfs=lfs, legend=True, fig_lbrt=fig_lbrt, save_name=savefigures_directory + subdirectory + 'Kepler_zeta1_all.pdf', save_fig=savefigures)\n#plot_fig_pdf_simple(fig_size, [], [zeta1_small], x_min=-1., x_max=1., n_bins=30, normalize=True, c_Kep=['r'], lw=lw, labels_Kep=['Period ratios < 2.5'], xlabel_text=r'$\\zeta_1$', ylabel_text='Number', afs=afs, tfs=tfs, lfs=lfs, legend=True, fig_lbrt=fig_lbrt, save_name=savefigures_directory + subdirectory + 'Kepler_zeta1_small.pdf', save_fig=savefigures)\nplt.show()\n\n\n\n\n\n##### To make various plots involving CDPP (4.5hr):\n'''\n# Histograms of CDPP (all stars and planet hosting stars):\nplot_fig_pdf_simple((10,4), [stars_cleaned['rrmscdpp04p5']], [ssk_per_sys['cdpp4p5_obs']], log_x=True, n_bins=100, normalize=True, lw=lw, labels_sim=['All stars'], labels_Kep=['Planet hosting stars'], xlabel_text=r'$\\sigma_{\\rm CDPP, 4.5hr}$ (ppm)', afs=afs, tfs=tfs, lfs=lfs, legend=True, fig_lbrt=fig_lbrt, save_name=savefigures_directory + subdirectory + 'Kepler_cdpp4p5.pdf', save_fig=savefigures)\n\n# CDPP vs. bp-rp color:\nfig = plt.figure(figsize=(8,8))\nplot = GridSpec(1,1,left=0.15,bottom=0.1,right=0.95,top=0.95,wspace=0.3,hspace=0.6)\nax = plt.subplot(plot[0,0])\nplt.scatter(stars_cleaned['rrmscdpp04p5'], stars_cleaned['bp_rp'], s=1, marker='.', label='All stars')\nplt.scatter(ssk_per_sys['cdpp4p5_obs'], ssk_per_sys['bp_rp_obs'], s=1, marker='.', label='Planet hosting stars')\nplt.gca().set_xscale(\"log\")\nax.tick_params(axis='both', labelsize=16)\nplt.xlabel(r'$\\sigma_{\\rm CDPP, 4.5hr}$ (ppm)', fontsize=20)\nplt.ylabel(r'$b_p - r_p$ (mag)', fontsize=20)\nplt.legend(loc='lower right', bbox_to_anchor=(0.99,0.01), ncol=1, frameon=True, fontsize=16)\nif savefigures:\n plt.savefig(savefigures_directory + subdirectory + 'Kepler_cdpp4p5_bprp.pdf')\nelse:\n plt.show()\n\n# Rstar*sqrt(CDPP) vs. bp-rp color:\nfig = plt.figure(figsize=(8,8))\nplot = GridSpec(1,1,left=0.15,bottom=0.1,right=0.95,top=0.95,wspace=0.3,hspace=0.6)\nax = plt.subplot(plot[0,0])\nplt.scatter(stars_cleaned['radius']*np.sqrt(stars_cleaned['rrmscdpp04p5']/1e6), stars_cleaned['bp_rp'], s=1, marker='.', label='All stars')\nplt.scatter(ssk_per_sys['Rstar_obs']*np.sqrt(ssk_per_sys['cdpp4p5_obs']/1e6), ssk_per_sys['bp_rp_obs'], s=1, marker='.', label='Planet hosting stars')\nplt.gca().set_xscale(\"log\")\nax.tick_params(axis='both', labelsize=16)\nplt.xlabel(r'$R_\\star \\sqrt{\\sigma_{\\rm CDPP, 4.5hr}}$ ($R_\\odot$)', fontsize=20)\nplt.ylabel(r'$b_p - r_p$ (mag)', fontsize=20)\nplt.legend(loc='upper right', bbox_to_anchor=(0.99,0.99), ncol=1, frameon=True, fontsize=16)\nif savefigures:\n plt.savefig(savefigures_directory + subdirectory + 'Kepler_Rstar_root_cdpp4p5_bprp.pdf')\nelse:\n plt.show()\n\n# CDPP vs. transit depths:\nfig = plt.figure(figsize=(8,8))\nplot = GridSpec(1,1,left=0.15,bottom=0.1,right=0.95,top=0.95,wspace=0.3,hspace=0.6)\nax = plt.subplot(plot[0,0])\nplt.scatter(ssk['cdpp4p5_obs'], 1e6*ssk['D_obs'], s=5, marker='.', label='Planet hosting stars')\nplt.gca().set_xscale(\"log\")\nplt.gca().set_yscale(\"log\")\nax.tick_params(axis='both', labelsize=16)\nplt.xlabel(r'$\\sigma_{\\rm CDPP, 4.5hr}$ (ppm)', fontsize=20)\nplt.ylabel(r'$\\delta$ (ppm)', fontsize=20)\nif savefigures:\n plt.savefig(savefigures_directory + subdirectory + 'Kepler_cdpp4p5_depths.pdf')\nelse:\n plt.show()\n\n# Histogram of CDPP with 10 bins, dividing each bin into red and blue halves based on bp-rp color:\nfig = plt.figure(figsize=(8,8))\nplot = GridSpec(1,1,left=0.15,bottom=0.1,right=0.95,top=0.95,wspace=0.3,hspace=0.6)\nax = plt.subplot(plot[0,0])\nnbins = 10\nbins, i_blue_per_bin, i_red_per_bin = split_colors_per_cdpp_bin(stars_cleaned, nbins=nbins)\nplt.hist(stars_cleaned['rrmscdpp04p5'], bins=bins, alpha=0.2, label='All stars')\nplt.hist([stars_cleaned['rrmscdpp04p5'][i_blue_per_bin], stars_cleaned['rrmscdpp04p5'][i_red_per_bin]], bins=bins, histtype='step', color=['b','r'], stacked=True, label=['Bluer half', 'Redder half'])\nplt.gca().set_xscale(\"log\")\nax.tick_params(axis='both', labelsize=16)\nplt.xlabel(r'$\\sigma_{\\rm CDPP, 4.5hr}$ (ppm)', fontsize=20)\nplt.legend(loc='upper right', bbox_to_anchor=(0.99,0.99), ncol=1, frameon=True, fontsize=16)\nif savefigures:\n plt.savefig(savefigures_directory + subdirectory + 'Kepler_cdpp4p5_split_bprp.pdf')\nelse:\n plt.show()\n'''\n\n\n\n\n\n##### To plot R_star*CDPP vs. bprp, with histograms of R_star*CDPP on top for the bluer and redder halves:\n'''\nfig = plt.figure(figsize=(8,8))\n\nplot = GridSpec(1,1,left=0.15,bottom=0.85,right=0.95,top=0.98,wspace=0,hspace=0)\nax = plt.subplot(plot[0,0])\nx_all = stars_cleaned['radius']*stars_cleaned['rrmscdpp04p5']/1e6\nx_min, x_max = 1e-5, 1e-3 #np.min(x_all), np.max(x_all)\nbins = 100\nplt.hist([x_all[stars_cleaned['bp_rp'] < 0.95], x_all[stars_cleaned['bp_rp'] > 0.95]], bins=np.logspace(np.log10(x_min), np.log10(x_max), bins+1), histtype='step', color=['b','r'], label=['Bluer', 'Redder'])\nplt.gca().set_xscale(\"log\")\nax.tick_params(axis='both', labelsize=16, labelbottom=False)\nplt.xlim([x_min, x_max])\nplt.legend(loc='upper left', bbox_to_anchor=(0.01,0.99), ncol=1, frameon=False, fontsize=16)\n\nplot = GridSpec(1,1,left=0.15,bottom=0.1,right=0.95,top=0.85,wspace=0,hspace=0)\nax = plt.subplot(plot[0,0])\nplt.scatter(stars_cleaned['radius']*stars_cleaned['rrmscdpp04p5']/1e6, stars_cleaned['bp_rp'], s=1, marker='.', label='All stars')\nplt.scatter(ssk_per_sys['Rstar_obs']*ssk_per_sys['cdpp4p5_obs']/1e6, ssk_per_sys['bp_rp_obs'], s=1, marker='.', label='Planet hosting stars')\nplt.gca().set_xscale(\"log\")\nax.tick_params(axis='both', labelsize=16)\nplt.xlim([x_min, x_max])\nplt.ylim([np.min(stars_cleaned['bp_rp']), np.max(stars_cleaned['bp_rp'])])\nplt.xlabel(r'$R_\\star \\sigma_{\\rm CDPP, 4.5hr}$ ($R_\\odot$)', fontsize=20)\nplt.ylabel(r'$b_p - r_p$ (mag)', fontsize=20)\nplt.legend(loc='upper left', bbox_to_anchor=(0.01,0.99), ncol=1, frameon=True, fontsize=16)\n\nif savefigures:\n plt.savefig(savefigures_directory + subdirectory + 'Kepler_Rstar_cdpp4p5_bprp.pdf')\n plt.close()\nplt.show()\n\n##### To plot the above (R_star*CDPP vs. bprp, with histograms of R_star*CDPP on top) along with CDPP vs. bprp (also with histograms on top) for the bluer and redder halves:\n\nfig = plt.figure(figsize=(16,8))\n\n# CDPP vs. bprp\nplot = GridSpec(1,1,left=0.08,bottom=0.85,right=0.5,top=0.95,wspace=0,hspace=0)\nax = plt.subplot(plot[0,0])\nx_all = stars_cleaned['rrmscdpp04p5']/1e6\nx_min, x_max = 1e-5, 1e-3 #np.min(x_all), np.max(x_all)\nbins = 100\nplt.hist([x_all[stars_cleaned['bp_rp'] < 0.95], x_all[stars_cleaned['bp_rp'] > 0.95]], bins=np.logspace(np.log10(x_min), np.log10(x_max), bins+1), histtype='step', color=['b','r'], label=['Bluer', 'Redder'])\nplt.gca().set_xscale(\"log\")\nax.tick_params(axis='both', labelsize=16, labelbottom=False)\nplt.xlim([x_min, x_max])\nplt.legend(loc='upper left', bbox_to_anchor=(0.01,0.99), ncol=1, frameon=False, fontsize=16)\n\nplot = GridSpec(1,1,left=0.08,bottom=0.1,right=0.5,top=0.85,wspace=0,hspace=0)\nax = plt.subplot(plot[0,0])\nplt.scatter(stars_cleaned['rrmscdpp04p5']/1e6, stars_cleaned['bp_rp'], s=1, marker='.', label='All stars')\nplt.scatter(ssk_per_sys['cdpp4p5_obs']/1e6, ssk_per_sys['bp_rp_obs'], s=1, marker='.', label='Planet hosting stars')\nplt.gca().set_xscale(\"log\")\nax.tick_params(axis='both', labelsize=16)\nplt.xlim([x_min, x_max])\nplt.ylim([np.min(stars_cleaned['bp_rp']), np.max(stars_cleaned['bp_rp'])])\nplt.xlabel(r'$\\sigma_{\\rm CDPP, 4.5hr}$', fontsize=20)\nplt.ylabel(r'$b_p - r_p$ (mag)', fontsize=20)\nplt.legend(loc='upper left', bbox_to_anchor=(0.01,0.99), ncol=1, frameon=True, fontsize=16)\n\n# R_star*CDPP vs. bprp\nplot = GridSpec(1,1,left=0.55,bottom=0.85,right=0.97,top=0.95,wspace=0,hspace=0)\nax = plt.subplot(plot[0,0])\nx_all = stars_cleaned['radius']*stars_cleaned['rrmscdpp04p5']/1e6\nx_min, x_max = 1e-5, 1e-3 #np.min(x_all), np.max(x_all)\nbins = 100\nplt.hist([x_all[stars_cleaned['bp_rp'] < 0.95], x_all[stars_cleaned['bp_rp'] > 0.95]], bins=np.logspace(np.log10(x_min), np.log10(x_max), bins+1), histtype='step', color=['b','r'], label=['Bluer', 'Redder'])\nplt.gca().set_xscale(\"log\")\nax.tick_params(axis='both', labelsize=16, labelbottom=False)\nplt.xlim([x_min, x_max])\n\nplot = GridSpec(1,1,left=0.55,bottom=0.1,right=0.97,top=0.85,wspace=0,hspace=0)\nax = plt.subplot(plot[0,0])\nplt.scatter(stars_cleaned['radius']*stars_cleaned['rrmscdpp04p5']/1e6, stars_cleaned['bp_rp'], s=1, marker='.', label='All stars')\nplt.scatter(ssk_per_sys['Rstar_obs']*ssk_per_sys['cdpp4p5_obs']/1e6, ssk_per_sys['bp_rp_obs'], s=1, marker='.', label='Planet hosting stars')\nplt.gca().set_xscale(\"log\")\nax.tick_params(axis='both', labelsize=16)\nplt.xlim([x_min, x_max])\nplt.ylim([np.min(stars_cleaned['bp_rp']), np.max(stars_cleaned['bp_rp'])])\nplt.xlabel(r'$R_\\star \\sigma_{\\rm CDPP, 4.5hr}$ ($R_\\odot$)', fontsize=20)\nplt.ylabel('')\n\nif savefigures:\n plt.savefig(savefigures_directory + subdirectory + 'Kepler_Rstar_cdpp4p5_bprp_two.pdf')\n plt.close()\nplt.show()\n'''\n\n##### To plot the above but with contours (2d histograms using corner.hist2d) instead of all the points:\n\nfig = plt.figure(figsize=(16,8))\n\n# CDPP vs. bprp\nplot = GridSpec(1,1,left=0.08,bottom=0.85,right=0.5,top=0.95,wspace=0,hspace=0)\nax = plt.subplot(plot[0,0])\nx_all = stars_cleaned['rrmscdpp04p5']/1e6\nx_min, x_max = 1e-5, 1e-3 #np.min(x_all), np.max(x_all)\nbins = 100\nplt.hist([x_all[stars_cleaned['bp_rp'] < 0.95], x_all[stars_cleaned['bp_rp'] > 0.95]], bins=np.logspace(np.log10(x_min), np.log10(x_max), bins+1), histtype='step', color=['b','r'], label=['Bluer', 'Redder'])\nplt.gca().set_xscale(\"log\")\nax.tick_params(axis='both', labelsize=16, labelbottom=False)\nplt.xlim([x_min, x_max])\nplt.legend(loc='upper left', bbox_to_anchor=(0.01,0.99), ncol=1, frameon=False, fontsize=16)\n\nplot = GridSpec(1,1,left=0.08,bottom=0.1,right=0.5,top=0.85,wspace=0,hspace=0)\nax = plt.subplot(plot[0,0])\ncorner.hist2d(np.log10(stars_cleaned['rrmscdpp04p5']/1e6), stars_cleaned['bp_rp'], bins=50, plot_density=False, contour_kwargs={'colors': ['0.6','0.4','0.2','0']})\nplt.scatter(np.log10(ssk_per_sys['cdpp4p5_obs']/1e6), ssk_per_sys['bp_rp_obs'], s=1, marker='o', c='tab:orange', label='Planet hosting stars')\nax.tick_params(axis='both', labelsize=16)\nax.set_xticks([-5,-4.5,-4,-3.5,-3])\nplt.xlim([np.log10(x_min), np.log10(x_max)])\nplt.ylim([np.min(stars_cleaned['bp_rp']), np.max(stars_cleaned['bp_rp'])])\nplt.xlabel(r'$\\log_{10}{(\\sigma_{\\rm CDPP, 4.5hr})}$', fontsize=20)\nplt.ylabel(r'$b_p - r_p$ (mag)', fontsize=20)\n#plt.legend(loc='upper left', bbox_to_anchor=(0.01,0.99), ncol=1, frameon=False, fontsize=16)\n\n# R_star*CDPP vs. bprp\nplot = GridSpec(1,1,left=0.55,bottom=0.85,right=0.97,top=0.95,wspace=0,hspace=0)\nax = plt.subplot(plot[0,0])\nx_all = stars_cleaned['radius']*stars_cleaned['rrmscdpp04p5']/1e6\nx_min, x_max = 1e-5, 1e-3 #np.min(x_all), np.max(x_all)\nbins = 100\nplt.hist([x_all[stars_cleaned['bp_rp'] < 0.95], x_all[stars_cleaned['bp_rp'] > 0.95]], bins=np.logspace(np.log10(x_min), np.log10(x_max), bins+1), histtype='step', color=['b','r'], label=['Bluer', 'Redder'])\nplt.gca().set_xscale(\"log\")\nax.tick_params(axis='both', labelsize=16, labelbottom=False)\nplt.xlim([x_min, x_max])\n\nplot = GridSpec(1,1,left=0.55,bottom=0.1,right=0.97,top=0.85,wspace=0,hspace=0)\nax = plt.subplot(plot[0,0])\ncorner.hist2d(np.log10(stars_cleaned['radius']*stars_cleaned['rrmscdpp04p5']/1e6), stars_cleaned['bp_rp'], bins=50, plot_density=False, contour_kwargs={'colors': ['0.6','0.4','0.2','0']})\nplt.scatter(np.log10(ssk_per_sys['Rstar_obs']*ssk_per_sys['cdpp4p5_obs']/1e6), ssk_per_sys['bp_rp_obs'], s=1, marker='o', c='tab:orange', label='Planet hosting stars')\nax.tick_params(axis='both', labelsize=16)\nax.set_xticks([-5,-4.5,-4,-3.5,-3])\nplt.xlim([np.log10(x_min), np.log10(x_max)])\nplt.ylim([np.min(stars_cleaned['bp_rp']), np.max(stars_cleaned['bp_rp'])])\nplt.xlabel(r'$\\log_{10}{((R_\\star/R_\\odot)\\sigma_{\\rm CDPP, 4.5hr})}$', fontsize=20)\nplt.ylabel('')\n\nif savefigures:\n plt.savefig(savefigures_directory + subdirectory + 'Kepler_Rstar_cdpp4p5_bprp_two_contours.pdf')\n plt.close()\nplt.show()\n\n\n\n\n\n##### RE-DO THE ABOVE BUT WITH CORRECTED COLORS:\n\nbprp_corr = stars_cleaned['bp_rp'] - stars_cleaned['e_bp_rp_interp']\nbprp_corr_med = np.nanmedian(bprp_corr)\n\nfig = plt.figure(figsize=(16,7))\nplot = GridSpec(5,3,left=0.08,bottom=0.15,right=0.97,top=0.95,wspace=0,hspace=0)\n\nx_min, x_max = 10**-4.8, 10**-2.7\ny_min, y_max = 0, 2500\n\n# CDPP vs. bprp\nax = plt.subplot(plot[0,0]) # histograms\nx_all = stars_cleaned['rrmscdpp04p5']/1e6\n#x_min, x_max = np.min(x_all), np.max(x_all)\nbins = 100\nplt.hist([x_all[bprp_corr < bprp_corr_med], x_all[bprp_corr > bprp_corr_med]], bins=np.logspace(np.log10(x_min), np.log10(x_max), bins+1), histtype='step', color=['b','r'], label=['Bluer', 'Redder'])\nplt.gca().set_xscale(\"log\")\nax.tick_params(axis='both', labelsize=16, labelbottom=False)\nplt.xlim([x_min, x_max])\nplt.ylim([y_min, y_max])\nplt.legend(loc='upper left', bbox_to_anchor=(0.01,0.99), ncol=1, frameon=False, fontsize=16)\n\nax = plt.subplot(plot[1:,0]) # scatter contours\ncorner.hist2d(np.log10(stars_cleaned['rrmscdpp04p5']/1e6), bprp_corr, bins=50, plot_density=False, contour_kwargs={'colors': ['0.6','0.4','0.2','0']})\nplt.scatter(np.log10(ssk_per_sys['cdpp4p5_obs']/1e6), ssk_per_sys['bp_rp_obs'] - ssk_per_sys['e_bp_rp_obs'], s=1, marker='o', c='tab:orange', label='Planet hosting stars')\nax.tick_params(axis='both', labelsize=16)\nax.set_xticks([-5,-4.5,-4,-3.5,-3])\nplt.xlim([np.log10(x_min), np.log10(x_max)])\nplt.ylim([np.min(bprp_corr), np.max(bprp_corr)])\nplt.xlabel(r'$\\log_{10}{(\\sigma_{\\rm CDPP, 4.5hr})}$', fontsize=20)\nplt.ylabel(r'$b_p - r_p - E^*$ (mag)', fontsize=20)\n#plt.legend(loc='upper left', bbox_to_anchor=(0.01,0.99), ncol=1, frameon=False, fontsize=16)\n\n# R_star^2*CDPP vs. bprp\nax = plt.subplot(plot[0,1]) # histograms\nx_all = (stars_cleaned['radius']**2.)*stars_cleaned['rrmscdpp04p5']/1e6\n#x_min, x_max = np.min(x_all), np.max(x_all)\nbins = 100\nplt.hist([x_all[bprp_corr < bprp_corr_med], x_all[bprp_corr > bprp_corr_med]], bins=np.logspace(np.log10(x_min), np.log10(x_max), bins+1), histtype='step', color=['b','r'], label=['Bluer', 'Redder'])\nplt.gca().set_xscale(\"log\")\nax.tick_params(axis='both', labelsize=16, labelbottom=False)\nplt.yticks([])\nplt.xlim([x_min, x_max])\nplt.ylim([y_min, y_max])\n\nax = plt.subplot(plot[1:,1])\ncorner.hist2d(np.log10((stars_cleaned['radius']**2.)*stars_cleaned['rrmscdpp04p5']/1e6), bprp_corr, bins=50, plot_density=False, contour_kwargs={'colors': ['0.6','0.4','0.2','0']})\nplt.scatter(np.log10((ssk_per_sys['Rstar_obs']**2.)*ssk_per_sys['cdpp4p5_obs']/1e6), ssk_per_sys['bp_rp_obs'] - ssk_per_sys['e_bp_rp_obs'], s=1, marker='o', c='tab:orange', label='Planet hosting stars')\nax.tick_params(axis='both', labelsize=16)\nax.set_xticks([-5,-4.5,-4,-3.5,-3])\nplt.yticks([])\nplt.xlim([np.log10(x_min), np.log10(x_max)])\nplt.ylim([np.min(bprp_corr), np.max(bprp_corr)])\nplt.xlabel(r'$\\log_{10}{[(R_\\star/R_\\odot)^2 \\sigma_{\\rm CDPP, 4.5hr}]}$', fontsize=20)\nplt.ylabel('')\n\n# R_star^(2 + alpha_R1)*CDPP vs. bprp\n'''\nalpha_R1 = -1.4\nax = plt.subplot(plot[0,2]) # histograms\nx_all = (stars_cleaned['radius']**(2.+alpha_R1))*stars_cleaned['rrmscdpp04p5']/1e6\n#x_min, x_max = np.min(x_all), np.max(x_all)\nbins = 100\nplt.hist([x_all[bprp_corr < bprp_corr_med], x_all[bprp_corr > bprp_corr_med]], bins=np.logspace(np.log10(x_min), np.log10(x_max), bins+1), histtype='step', color=['b','r'], label=['Bluer', 'Redder'])\nplt.gca().set_xscale(\"log\")\nax.tick_params(axis='both', labelsize=16, labelbottom=False)\nplt.yticks([])\nplt.xlim([x_min, x_max])\nplt.ylim([y_min, y_max])\n\nax = plt.subplot(plot[1:,2])\ncorner.hist2d(np.log10((stars_cleaned['radius']**(2.+alpha_R1))*stars_cleaned['rrmscdpp04p5']/1e6), bprp_corr, bins=50, plot_density=False, contour_kwargs={'colors': ['0.6','0.4','0.2','0']})\nplt.scatter(np.log10((ssk_per_sys['Rstar_obs']**(2.+alpha_R1))*ssk_per_sys['cdpp4p5_obs']/1e6), ssk_per_sys['bp_rp_obs'] - ssk_per_sys['e_bp_rp_obs'], s=1, marker='o', c='tab:orange', label='Planet hosting stars')\nax.tick_params(axis='both', labelsize=16)\nax.set_xticks([-5,-4.5,-4,-3.5,-3])\nplt.yticks([])\nplt.xlim([np.log10(x_min), np.log10(x_max)])\nplt.ylim([np.min(bprp_corr), np.max(bprp_corr)])\nplt.xlabel(r'$\\log_{10}{[(R_\\star/R_\\odot)^{%.1f} \\sigma_{\\rm CDPP, 4.5hr}]}$' % (2.+alpha_R1), fontsize=20)\nplt.ylabel('')\n'''\n\n# R_star*CDPP vs. bprp\n#'''\nax = plt.subplot(plot[0,2]) # histograms\nx_all = (stars_cleaned['radius']**0.5)*stars_cleaned['rrmscdpp04p5']/1e6\n#x_min, x_max = np.min(x_all), np.max(x_all)\nbins = 100\nplt.hist([x_all[bprp_corr < bprp_corr_med], x_all[bprp_corr > bprp_corr_med]], bins=np.logspace(np.log10(x_min), np.log10(x_max), bins+1), histtype='step', color=['b','r'], label=['Bluer', 'Redder'])\nplt.gca().set_xscale(\"log\")\nax.tick_params(axis='both', labelsize=16, labelbottom=False)\nplt.yticks([])\nplt.xlim([x_min, x_max])\nplt.ylim([y_min, y_max])\n\nax = plt.subplot(plot[1:,2])\ncorner.hist2d(np.log10((stars_cleaned['radius']**0.5)*stars_cleaned['rrmscdpp04p5']/1e6), bprp_corr, bins=50, plot_density=False, contour_kwargs={'colors': ['0.6','0.4','0.2','0']})\nplt.scatter(np.log10((ssk_per_sys['Rstar_obs']**0.5)*ssk_per_sys['cdpp4p5_obs']/1e6), ssk_per_sys['bp_rp_obs'] - ssk_per_sys['e_bp_rp_obs'], s=1, marker='o', c='tab:orange', label='Planet hosting stars')\nax.tick_params(axis='both', labelsize=16)\nax.set_xticks([-5,-4.5,-4,-3.5,-3])\nplt.yticks([])\nplt.xlim([np.log10(x_min), np.log10(x_max)])\nplt.ylim([np.min(bprp_corr), np.max(bprp_corr)])\nplt.xlabel(r'$\\log_{10}{[(R_\\star/R_\\odot)^{0.5} \\sigma_{\\rm CDPP, 4.5hr}]}$', fontsize=20)\nplt.ylabel('')\n#'''\n\nif savefigures:\n plt.savefig(savefigures_directory + subdirectory + 'Kepler_Rstar_cdpp4p5_bprp_corrected_three_contours.pdf')\n plt.close()\nplt.show()\n\n\n\n\n\n##### Histograms only:\n\n# CDPP:\nx_all = stars_cleaned['rrmscdpp04p5']/1e6\nplot_fig_pdf_simple(fig_size, [x_all[bprp_corr < bprp_corr_med], x_all[bprp_corr > bprp_corr_med]], [], x_min=1e-5, x_max=1e-3, n_bins=n_bins, normalize=False, log_x=True, c_sim=['b','r'], ls_sim=['-','-'], lw=lw, labels_sim=['Bluer', 'Redder'], xlabel_text=r'$\\sigma_{\\rm CDPP, 4.5hr}$', ylabel_text='Counts', afs=afs, tfs=tfs, lfs=lfs, fig_lbrt=fig_lbrt, legend=True, save_name=savefigures_directory + subdirectory + 'Kepler_cdpp4p5_split_hists.pdf', save_fig=savefigures)\n\n# R_star:\nx_all = stars_cleaned['radius']\nplot_fig_pdf_simple(fig_size, [x_all[bprp_corr < bprp_corr_med], x_all[bprp_corr > bprp_corr_med]], [], x_min=0.4, x_max=2.5, n_bins=n_bins, normalize=False, log_x=False, c_sim=['b','r'], ls_sim=['-','-'], lw=lw, labels_sim=['Bluer', 'Redder'], xlabel_text=r'$R_\\star$ $(R_\\odot)$', ylabel_text='Counts', afs=afs, tfs=tfs, lfs=lfs, fig_lbrt=fig_lbrt, save_name=savefigures_directory + subdirectory + 'Kepler_Rstar_split_hists.pdf', save_fig=savefigures)\n\n# (R_star^2)*CDPP\nx_all = (stars_cleaned['radius']**2.)*stars_cleaned['rrmscdpp04p5']/1e6\nplot_fig_pdf_simple(fig_size, [x_all[bprp_corr < bprp_corr_med], x_all[bprp_corr > bprp_corr_med]], [], x_min=1e-5, x_max=3e-3, n_bins=n_bins, normalize=False, log_x=True, c_sim=['b','r'], ls_sim=['-','-'], lw=lw, labels_sim=['Bluer', 'Redder'], xlabel_text=r'$(R_\\star/R_\\odot)^2 \\sigma_{\\rm CDPP, 4.5hr}$', ylabel_text='Counts', afs=afs, tfs=tfs, lfs=lfs, fig_lbrt=fig_lbrt, save_name=savefigures_directory + subdirectory + 'Kepler_Rstar_sq_cdpp4p5_split_hists.pdf', save_fig=savefigures)\n\n# R_star*CDPP\nx_all = stars_cleaned['radius']*stars_cleaned['rrmscdpp04p5']/1e6\nplot_fig_pdf_simple(fig_size, [x_all[bprp_corr < bprp_corr_med], x_all[bprp_corr > bprp_corr_med]], [], x_min=1e-5, x_max=1e-3, n_bins=n_bins, normalize=False, log_x=True, c_sim=['b','r'], ls_sim=['-','-'], lw=lw, labels_sim=['Bluer', 'Redder'], xlabel_text=r'$(R_\\star/R_\\odot) \\sigma_{\\rm CDPP, 4.5hr}$', ylabel_text='Counts', afs=afs, tfs=tfs, lfs=lfs, fig_lbrt=fig_lbrt, save_name=savefigures_directory + subdirectory + 'Kepler_Rstar_cdpp4p5_split_hists.pdf', save_fig=savefigures)\n\n# (R_star^0.5)*CDPP\nx_all = np.sqrt(stars_cleaned['radius'])*stars_cleaned['rrmscdpp04p5']/1e6\nplot_fig_pdf_simple(fig_size, [x_all[bprp_corr < bprp_corr_med], x_all[bprp_corr > bprp_corr_med]], [], x_min=1e-5, x_max=1e-3, n_bins=n_bins, normalize=False, log_x=True, c_sim=['b','r'], ls_sim=['-','-'], lw=lw, labels_sim=['Bluer', 'Redder'], xlabel_text=r'$(R_\\star/R_\\odot)^{0.5} \\sigma_{\\rm CDPP, 4.5hr}$', ylabel_text='Counts', afs=afs, tfs=tfs, lfs=lfs, fig_lbrt=fig_lbrt, save_name=savefigures_directory + subdirectory + 'Kepler_Rstar_root_cdpp4p5_split_hists.pdf', save_fig=savefigures)\n\n\n\n\n\n##### To plot a period-radius diagram showing the radius valley:\n\nP_all = ssk['P_obs']\nR_all = ssk['radii_obs']\n\nP_l, P_u = 3., 300.\nR_l, R_u = 1., 5.\nP_plot = P_all[(P_all > P_l) & (P_all < P_u) & (R_all > R_l) & (R_all < R_u)]\nR_plot = R_all[(P_all > P_l) & (P_all < P_u) & (R_all > R_l) & (R_all < R_u)]\n\nfig = plt.figure(figsize=(8,8))\nplot = GridSpec(5,5,left=0.15,bottom=0.15,right=0.95,top=0.95,wspace=0,hspace=0)\n\nax = plt.subplot(plot[1:,:4])\ncorner.hist2d(np.log10(P_plot), np.log10(R_plot), bins=20, smooth=1., plot_density=False, contour_kwargs={'colors': ['0.6','0.4','0.2','0']})\nplt.scatter(np.log10(P_plot), np.log10(R_plot), s=1, marker='o', c='k')\nP_axis = np.linspace(np.log10(P_l), np.log10(P_u), 101)\nplt.plot(P_axis, -0.09*P_axis + np.log10(2.4), '--', lw=2., c='r')\nax.tick_params(axis='both', labelsize=16)\nxtick_vals = np.array([3,10,30,100])\nytick_vals = np.array([1,1.5,2,3,4])\nplt.xticks(np.log10(xtick_vals), xtick_vals)\nplt.yticks(np.log10(ytick_vals), ytick_vals)\nplt.xlabel(r'Orbital Period $P$ (days)', fontsize=20)\nplt.ylabel(r'Planet radius $R_p$ ($R_\\oplus$)', fontsize=20)\n#plt.legend(loc='upper left', bbox_to_anchor=(0.01,0.99), ncol=1, frameon=False, fontsize=16)\n\nax = plt.subplot(plot[0,:4]) # top histogram\nplt.hist(P_plot, bins=np.logspace(np.log10(P_l), np.log10(P_u), 51), weights=np.ones(len(P_plot))/len(P_plot), histtype='step', color='k', ls='-')\nplt.gca().set_xscale(\"log\")\nplt.xlim([P_l, P_u])\nplt.xticks([])\nplt.yticks([])\nplt.minorticks_off()\n\nax = plt.subplot(plot[1:,4]) # side histogram\nplt.hist(R_plot, bins=np.logspace(np.log10(R_l), np.log10(R_u), 51), weights=np.ones(len(R_plot))/len(R_plot), histtype='step', orientation='horizontal', color='k', ls='-')\nplt.gca().set_yscale(\"log\")\nplt.ylim([R_l, R_u])\nplt.xticks([])\nplt.yticks([])\nplt.minorticks_off()\n\nplt.show()\n",
"# To import required modules:\nimport numpy as np\nimport matplotlib\n#import matplotlib.cm as cm #for color maps\nimport matplotlib.pyplot as plt\nfrom matplotlib.gridspec import GridSpec #for specifying plot attributes\nfrom matplotlib import ticker #for setting contour plots to log scale\nfrom matplotlib.colors import LogNorm #for log color scales\nfrom mpl_toolkits.axes_grid1.inset_locator import inset_axes #for inset axes\nfrom scipy.optimize import brentq # for solving roots of equations\nimport scipy.linalg # for linear algebra\nimport time\n\nimport src.functions_general as gen\n\n\n\n\n\n# Functions to compute the RV signals of planets:\n\ndef M_anom(t, T0, P):\n # Compute the mean anomaly M (radians) at a time t (yrs) given a reference epoch T0 (yrs) and period P (yrs)\n M = (2.*np.pi*(t - T0))/P\n return M\n\ndef fzero_E_anom(E, t, T0, P, e):\n # Kepler's equation moved to one side (solve for zeros to get solutions)\n M = M_anom(t, T0, P)\n return E - e*np.sin(E) - M\n\ndef E_anom(t, T0, P, e):\n # Compute the eccentric anomaly E (radians) numerically at a time t (yrs) given a reference epoch T0 (yrs), period P (yrs), and eccentricity e\n \n #E = brentq(fzero_E_anom, 0., 2.*np.pi, args=(t, T0, P, e)) # doesn't always work!\n \n # Try to solve iteratively:\n M = M_anom(t, T0, P)\n E0 = 0\n dE = 1\n while dE > 1e-10:\n E = M + e*np.sin(E0)\n dE = E - E0\n E0 = E\n \n return E\n\ndef nu_anom(E, e):\n # Compute the true anomaly nu (radians) given an eccentric anomaly E (radians) and eccentricity e\n nu = 2.*np.arctan(np.sqrt((1.+e)/(1.-e))*np.tan(E/2.))\n return nu\n\ndef RV_true(t, K, P, T0=0., e=0., w=0., gamma=0.):\n # Compute the true radial velocity (m/s) at a time t (yrs) given the semi-amplitude K (m/s), period P (yrs), reference epoch T0 (yrs), eccentricity e, argument of pericenter w (radians), and reference zero-point gamma (m/s)\n E = E_anom(t, T0, P, e)\n nu = nu_anom(E, e)\n V_r = K*(np.cos(nu + w) + e*np.cos(w)) + gamma\n return V_r\n\ndef RV_true_sys(t, K_sys, P_sys, T0_sys, e_sys, w_sys, gamma=0.):\n # Compute the true radial velocity (m/s) at a time t (yrs) given all the planets in the system\n n_pl = len(K_sys)\n assert n_pl == len(P_sys) == len(T0_sys) == len(e_sys) == len(w_sys)\n V_r_per_pl = np.zeros(n_pl)\n for i in range(n_pl):\n V_r_per_pl[i] = RV_true(t, K_sys[i], P_sys[i], T0=T0_sys[i], e=e_sys[i], w=w_sys[i])\n V_r = np.sum(V_r_per_pl)\n return V_r\n\ndef rv_K(m, P, e=None, i=None, Mstar=1.0):\n # Compute the radial velocity semi-amplitude K of a system given arrays of the planet masses m (M_earth) and periods (days), and optionally eccentricities, sky-inclinations (rad), and stellar mass (Msun)\n n_pl = len(m)\n e = np.zeros(n_pl) if e is None else e\n i = (np.pi/2.)*np.ones(n_pl) if i is None else i\n \n assert all(m >= 0) & all(P > 0) & (Mstar > 0)\n assert all(0 <= e) & all(e < 1)\n \n K = (28.4329/np.sqrt(1. - e**2.)) * (m*np.sin(i)*gen.Mearth/gen.Mjup) * (np.sum(m)*(gen.Mearth/gen.Msun) + Mstar)**(-2./3.) * (P/365.25)**(-1./3.)\n return K # units of m/s\n\n\n\n\n\n# Functions to fit RV time series using generalized least squares (GLS):\n\ndef fit_rv_K_single_planet_model_GLS(t_obs, RV_obs, covarsc, P, T0=0., e=0., w=0.):\n # Fit a radial velocity series RV_obs (m/s) using generalized least squares assuming a single planet model with known period P (days), epoch T0 (days), eccentricity e, and argument of pericenter w (radians), for the semi-amplitude K (m/s)\n # The array of observation times t_obs (days) must correspond to the array of RV observations RV_obs, and to the covariance matrix of observation uncertainties covarsc\n E_obs = np.array([E_anom(t, T0, P, e) for t in t_obs])\n nu_obs = nu_anom(E_obs, e)\n\n sincosphase = np.cos(nu_obs + w) + e*np.cos(w) # V_r = K*sincosphase\n\n Xt_inv_covar_X = sincosphase.transpose() @ scipy.linalg.solve(covarsc, sincosphase)\n X_inv_covar_y = sincosphase.transpose() @ scipy.linalg.solve(covarsc, RV_obs)\n K_hat = scipy.linalg.solve(Xt_inv_covar_X, X_inv_covar_y) # estimated K (m/s)\n inv_covar_of_fit_params = sincosphase.transpose() @ scipy.linalg.solve(covarsc, sincosphase)\n sigma_K = 1./np.sqrt(inv_covar_of_fit_params) # estimated uncertainty in K (m/s)\n\n return K_hat, sigma_K\n \ndef fit_rv_Ks_multi_planet_model_GLS(t_obs, RV_obs, covarsc, P_all, T0_all, e_all, w_all):\n # Fit a radial velocity series RV_obs (m/s) using generalized least squares assuming a multi-planet model with known periods P_all (days), epochs T0_all (days), eccentricities e_all, and argument of pericenter w_all (radians), for the semi-amplitudes K (m/s) of each planet\n # The array of observation times t_obs (days) must correspond to the array of RV observations RV_obs, and to the covariance matrix of observation uncertainties covarsc\n n_pl = len(P_all)\n assert n_pl == len(T0_all) == len(e_all) == len(w_all)\n sincosphase = []\n for i in range(n_pl):\n E_obs = np.array([E_anom(t, T0_all[i], P_all[i], e_all[i]) for t in t_obs])\n nu_obs = nu_anom(E_obs, e_all[i])\n sincosphase.append(np.cos(nu_obs + w_all[i]) + e_all[i]*np.cos(w_all[i]))\n sincosphase = np.array(sincosphase).transpose()\n\n Xt_inv_covar_X = sincosphase.transpose() @ scipy.linalg.solve(covarsc, sincosphase)\n X_inv_covar_y = sincosphase.transpose() @ scipy.linalg.solve(covarsc, RV_obs)\n K_hat_all = scipy.linalg.solve(Xt_inv_covar_X, X_inv_covar_y) # estimated K's (m/s)\n inv_covar_of_fit_params = sincosphase.transpose() @ scipy.linalg.solve(covarsc, sincosphase)\n symmetrized_inv_covar_of_fit_params = 0.5 * (inv_covar_of_fit_params + inv_covar_of_fit_params.transpose())\n sigma_K_all = 1./np.diag(scipy.linalg.cholesky(symmetrized_inv_covar_of_fit_params))\n \n return K_hat_all, sigma_K_all\n\n\n\n\n\n# Functions to condition catalogs on a set of planet properties and simulate RV observations (fitting RVs to measure the amplitude of the transiting planet):\n\ndef conditionals_dict(P_cond_bounds=None, Rp_cond_bounds=None, Mp_cond_bounds=None, det=True):\n \n # P_cond_bounds = [P_lower, P_upper] for period of planet conditioned on\n # Rp_cond_bounds = [Rp_lower, Rp_upper] for radius of planet conditioned on\n # Mp_cond_bounds = [Mp_lower, Mp_upper] for mass of planet conditioned on\n P_lower, P_upper = [0., np.inf] if P_cond_bounds==None else P_cond_bounds\n Rp_lower, Rp_upper = [0., np.inf] if Rp_cond_bounds==None else Rp_cond_bounds\n Mp_lower, Mp_upper = [0., np.inf] if Mp_cond_bounds==None else Mp_cond_bounds\n assert P_lower < P_upper\n assert Rp_lower < Rp_upper\n assert Mp_lower < Mp_upper\n \n conds = {}\n conds['P_lower'] = P_lower\n conds['P_upper'] = P_upper\n conds['Rp_lower'] = Rp_lower\n conds['Rp_upper'] = Rp_upper\n conds['Mp_lower'] = Mp_lower\n conds['Mp_upper'] = Mp_upper\n conds['det'] = det\n return conds\n\ndef condition_planets_bools_per_sys(sssp_per_sys, conds):\n # Compute a 2d array of booleans where the conditioned planets are indicated by True values\n # Note: includes systems without any conditioned planets (i.e. rows with all False values)\n bools_cond_per_sys = (sssp_per_sys['P_all'] > conds['P_lower']) & (sssp_per_sys['P_all'] < conds['P_upper']) & (sssp_per_sys['radii_all'] > conds['Rp_lower']) & (sssp_per_sys['radii_all'] < conds['Rp_upper']) & (sssp_per_sys['mass_all'] > conds['Mp_lower']) & (sssp_per_sys['mass_all'] < conds['Mp_upper']) # 2d array with True for each conditioned planet (should be at least one True per row/system)\n if conds['det']:\n bools_cond_per_sys = bools_cond_per_sys & (sssp_per_sys['det_all'] == 1)\n return bools_cond_per_sys\n\ndef condition_systems_indices(sssp_per_sys, conds):\n bools_cond_per_sys = condition_planets_bools_per_sys(sssp_per_sys, conds)\n bools_in_bounds = np.any(bools_cond_per_sys, axis=1)\n n_per_sys = sssp_per_sys['Mtot_all']\n i_cond = np.arange(len(n_per_sys))[bools_in_bounds]\n print('Number of systems that have a planet with period in [%s,%s] d, radius in [%s,%s] R_earth, and mass in [%s,%s] M_earth: %s/%s' % (conds['P_lower'], conds['P_upper'], conds['Rp_lower'], conds['Rp_upper'], conds['Mp_lower'], conds['Mp_upper'], len(i_cond), len(n_per_sys)))\n return i_cond\n\ndef plot_systems_gallery_with_RVseries_conditional(sssp_per_sys, sssp, conds, outputs_RVs=None, mark_undet=True, fit_RVs=False, N_obs_all=None, repeat=1000, σ_1obs=1., t_obs_σ=0.2, fig_size=(9,10), seed=None, N_sample=20, N_per_plot=20, afs=12, tfs=12, save_name_base='no_name_fig', save_fig=False):\n \n # outputs_RVs = None: if provided (a table of RV simulations of conditioned systems), will draw systems from these (must have system ids and match the catalog that is provided)\n \n if outputs_RVs is not None:\n i_cond = outputs_RVs['id_sys']\n else:\n i_cond = condition_systems_indices(sssp_per_sys, conds)\n \n np.random.seed(seed)\n #i_sample = np.random.choice(i_cond, N_sample, replace=False)\n i_sample = i_cond[:N_sample]\n \n # To sort by stellar mass:\n #i_sort = np.argsort(sssp['Mstar_all'][i_sample])\n \n # To sort by K_cond:\n K_cond_sample = np.zeros(N_sample)\n for i in range(N_sample):\n Mstar_sys = sssp['Mstar_all'][i_sample][i]\n P_sys = sssp_per_sys['P_all'][i_sample][i]\n det_sys = sssp_per_sys['det_all'][i_sample][i]\n Mp_sys = sssp_per_sys['mass_all'][i_sample][i]\n Rp_sys = sssp_per_sys['radii_all'][i_sample][i]\n e_sys = sssp_per_sys['e_all'][i_sample][i]\n incl_sys = sssp_per_sys['incl_all'][i_sample][i]\n clusterids_sys = sssp_per_sys['clusterids_all'][i_sample][i]\n \n det_sys = det_sys[P_sys > 0]\n Mp_sys = Mp_sys[P_sys > 0]\n Rp_sys = Rp_sys[P_sys > 0]\n e_sys = e_sys[P_sys > 0]\n incl_sys = incl_sys[P_sys > 0]\n clusterids_sys = clusterids_sys[P_sys > 0]\n P_sys = P_sys[P_sys > 0]\n \n K_sys = rv_K(Mp_sys, P_sys, e=e_sys, i=incl_sys, Mstar=Mstar_sys)\n id_pl_cond = np.arange(len(P_sys))[(P_sys > conds['P_lower']) & (P_sys < conds['P_upper']) & (Rp_sys > conds['Rp_lower']) & (Rp_sys < conds['Rp_upper'])][0] # index of conditioned planet\n K_cond = K_sys[id_pl_cond]\n \n K_cond_sample[i] = K_cond\n i_sort = np.argsort(K_cond_sample)\n \n # To not sort (just plot systems from top to bottom):\n #i_sort = np.arange(N_sample)[::-1]\n\n Mstar_sample = sssp['Mstar_all'][i_sample][i_sort]\n P_sample = sssp_per_sys['P_all'][i_sample][i_sort]\n det_sample = sssp_per_sys['det_all'][i_sample][i_sort]\n Mp_sample = sssp_per_sys['mass_all'][i_sample][i_sort]\n Rp_sample = sssp_per_sys['radii_all'][i_sample][i_sort]\n e_sample = sssp_per_sys['e_all'][i_sample][i_sort]\n incl_sample = sssp_per_sys['incl_all'][i_sample][i_sort]\n clusterids_sample = sssp_per_sys['clusterids_all'][i_sample][i_sort]\n\n n_figs = int(np.ceil(float(N_sample)/N_per_plot))\n print('Generating %s figures...' % n_figs)\n for h in range(n_figs):\n fig = plt.figure(figsize=fig_size)\n plt.figtext(0.5, 0.96, r'Systems conditioned on a Venus-like planet', va='center', ha='center', fontsize=tfs)\n #plt.figtext(0.5, 0.96, r'Systems conditioned on a planet in $P = [%s,%s]$d, $R_p = [%s,%s] R_\\oplus$' % (conds['P_lower'], conds['P_upper'], conds['Rp_lower'], conds['Rp_upper']), va='center', ha='center', fontsize=tfs)\n ###plt.figtext(0.5, 0.96, 'Systems conditioned on a planet in\\n' r'$P = %s$d, $R_p = %s R_\\oplus$' % (conds['P_lower'], conds['P_upper'], conds['Rp_lower'], conds['Rp_upper']), va='center', ha='center', fontsize=tfs)\n \n # For the gallery:\n plot = GridSpec(1,1,left=0.08,bottom=0.1,right=0.44,top=0.8,wspace=0,hspace=0)\n #plot = GridSpec(1,1,left=0.1,bottom=0.075,right=0.46,top=0.85,wspace=0,hspace=0)\n ax = plt.subplot(plot[:,:])\n for j in range(N_per_plot):\n id_sys = h*n_figs + j\n \n Mstar_sys = Mstar_sample[id_sys]\n P_sys = P_sample[id_sys]\n det_sys = det_sample[id_sys]\n Mp_sys = Mp_sample[id_sys]\n Rp_sys = Rp_sample[id_sys]\n e_sys = e_sample[id_sys]\n incl_sys = incl_sample[id_sys]\n clusterids_sys = clusterids_sample[id_sys]\n \n det_sys = det_sys[P_sys > 0]\n Mp_sys = Mp_sys[P_sys > 0]\n Rp_sys = Rp_sys[P_sys > 0]\n e_sys = e_sys[P_sys > 0]\n incl_sys = incl_sys[P_sys > 0]\n clusterids_sys = clusterids_sys[P_sys > 0]\n P_sys = P_sys[P_sys > 0]\n \n K_sys = rv_K(Mp_sys, P_sys, e=e_sys, i=incl_sys, Mstar=Mstar_sys)\n id_pl_cond = np.arange(len(P_sys))[(P_sys > conds['P_lower']) & (P_sys < conds['P_upper']) & (Rp_sys > conds['Rp_lower']) & (Rp_sys < conds['Rp_upper'])][0] # index of conditioned planet\n K_cond = K_sys[id_pl_cond]\n \n #print(K_sys)\n # Defaults: s=10*Rp^2, vmin=0, vmax=5\n ecolor = 'r' if mark_undet else None\n sc = plt.scatter(P_sys[det_sys == 1], np.ones(np.sum(det_sys == 1))+j, c=K_sys[det_sys == 1], s=20.*Rp_sys[det_sys == 1]**2., vmin=0., vmax=2.)\n plt.scatter(P_sys[det_sys == 0], np.ones(np.sum(det_sys == 0))+j, c=K_sys[det_sys == 0], edgecolors=ecolor, s=20.*Rp_sys[det_sys == 0]**2., vmin=0., vmax=2.) #facecolors='none'\n ###sc = plt.scatter(P_sys, np.ones(len(P_sys))+j, c=K_sys, s=10.*Rp_sys**2., vmin=0., vmax=10.)\n ###plt.scatter(P_sys[det_sys == 0], np.ones(np.sum(det_sys == 0))+j, color='r', marker='x', s=8.*Rp_sys[det_sys == 0]**2.)\n \n plt.axhline(y=j+0.5, lw=0.5, ls='-', color='k')\n plt.text(x=1.8, y=j+1, s='{:.2f}'.format(np.round(K_cond,2)), va='center', ha='right', fontsize=10)\n plt.text(x=1., y=j+1.6, s=r'$K_{\\rm cond}$ (m/s)', va='bottom', ha='left', fontsize=10)\n #plt.text(x=1.5, y=j+1.6, s=r'$M_\\star$ ($M_\\odot$)', va='bottom', ha='center', fontsize=10)\n #plt.fill_betweenx(y=[0,j+2], x1=conds['P_lower'], x2=conds['P_upper'], color='g', alpha=0.2)\n plt.gca().set_xscale(\"log\")\n ax.tick_params(axis='both', labelsize=afs)\n ax.set_xticks([3,10,30,100,300])\n ax.get_xaxis().set_major_formatter(matplotlib.ticker.ScalarFormatter())\n ax.set_yticks([])\n plt.xlim([2., 400.])\n plt.ylim([0.5, N_per_plot+0.5])\n plt.xlabel(r'Orbital period $P$ (days)', fontsize=tfs)\n \n # For colorbar:\n plot = GridSpec(1,1,left=0.08,bottom=0.89,right=0.44,top=0.92,wspace=0,hspace=0)\n #plot = GridSpec(1,1,left=0.1,bottom=0.91,right=0.46,top=0.93,wspace=0,hspace=0)\n cax = plt.subplot(plot[0,0])\n cbar = plt.colorbar(sc, cax=cax, orientation='horizontal')\n cbar.set_label(r'RV semi-amplitude $K$ (m/s)', fontsize=10)\n \n # For the RV time series:\n plot = GridSpec(N_per_plot,1,left=0.52,bottom=0.1,right=0.88,top=0.8,wspace=0,hspace=0)\n #plot = GridSpec(N_per_plot,1,left=0.54,bottom=0.075,right=0.9,top=0.85,wspace=0,hspace=0)\n for j in range(N_per_plot):\n # NOTE: still starting from j=0 but will index the panels starting from the bottom to match the systems in the gallery\n ax = plt.subplot(plot[N_per_plot-j-1,:])\n id_sys = h*n_figs + j\n \n Mstar_sys = Mstar_sample[id_sys]\n P_sys = P_sample[id_sys]\n det_sys = det_sample[id_sys]\n Mp_sys = Mp_sample[id_sys]\n Rp_sys = Rp_sample[id_sys]\n e_sys = e_sample[id_sys]\n incl_sys = incl_sample[id_sys]\n clusterids_sys = clusterids_sample[id_sys]\n \n det_sys = det_sys[P_sys > 0]\n Mp_sys = Mp_sys[P_sys > 0]\n Rp_sys = Rp_sys[P_sys > 0]\n e_sys = e_sys[P_sys > 0]\n incl_sys = incl_sys[P_sys > 0]\n clusterids_sys = clusterids_sys[P_sys > 0]\n P_sys = P_sys[P_sys > 0]\n \n T0_sys = P_sys*np.random.random(len(P_sys)) # reference epochs for each planet\n omega_sys = 2.*np.pi*np.random.random(len(P_sys)) # WARNING: need to get from simulated physical catalogs, NOT re-drawn\n \n K_sys = rv_K(Mp_sys, P_sys, e=e_sys, i=incl_sys, Mstar=Mstar_sys)\n id_pl_cond = np.arange(len(P_sys))[(P_sys > conds['P_lower']) & (P_sys < conds['P_upper']) & (Rp_sys > conds['Rp_lower']) & (Rp_sys < conds['Rp_upper'])][0] # index of conditioned planet\n P_cond = P_sys[id_pl_cond] # period of conditioned planet (days)\n Rp_cond = Rp_sys[id_pl_cond] # radius of conditioned planet (Earth radii)\n K_cond = K_sys[id_pl_cond] # K of the conditioned planet (m/s)\n \n t_end = 150. # days\n t_array = np.linspace(0., t_end, 1001)\n RV_sys_per_pl = np.zeros((len(t_array),len(P_sys)))\n for i in range(len(P_sys)):\n T0 = P_sys[i]*np.random.uniform()\n omega = 2.*np.pi*np.random.uniform()\n RV_sys_per_pl[:,i] = [RV_true(t, K_sys[i], P_sys[i], T0=T0, e=e_sys[i], w=omega) for t in t_array]\n RV_sys = np.sum(RV_sys_per_pl, axis=1)\n RV_absmax = np.max([-np.min(RV_sys), np.max(RV_sys)])\n \n # To plot the true RV time series:\n plt.plot(t_array, RV_sys, '-', color='k', label='RV of total system')\n plt.plot(t_array, RV_sys_per_pl[:,id_pl_cond], ':', color='r', label='RV of conditioned planet')\n plt.xlim([t_array[0], t_array[-1]])\n plt.ylim([-RV_absmax, RV_absmax])\n plt.yticks([-0.6*RV_absmax, 0., 0.6*RV_absmax])\n ax.yaxis.set_major_formatter(ticker.FormatStrFormatter('%.2f'))\n if j == 0:\n ax.tick_params(axis='x', labelsize=afs)\n plt.xlabel('Time (days)', fontsize=tfs)\n else:\n plt.xticks([])\n \n # If want to also report the N_obs required for measuring K:\n if outputs_RVs is None and fit_RVs:\n start = time.time()\n \n K_cond_hat_daily = np.zeros((len(N_obs_all), repeat))\n K_cond_hat_daily_ideal = np.zeros((len(N_obs_all), repeat))\n sigma_K_cond_daily = np.zeros((len(N_obs_all), repeat))\n sigma_K_cond_daily_ideal = np.zeros((len(N_obs_all), repeat))\n for n in range(repeat):\n t_obs_daily = []\n for i,N_obs in enumerate(N_obs_all):\n covarsc = σ_1obs**2. * np.identity(N_obs)\n N_obs_add = N_obs - len(t_obs_daily) # number of observations to add\n t_obs_daily = t_obs_daily + list(len(t_obs_daily) + np.arange(N_obs_add) + t_obs_σ*np.random.random(N_obs_add))\n \n RV_obs_daily = np.array([RV_true_sys(t, K_sys, P_sys, T0_sys, e_sys, omega_sys) for t in t_obs_daily]) + σ_1obs*np.random.randn(N_obs) # RV obs of the system\n RV_obs_daily_ideal = np.array([RV_true(t, K_cond, P_cond, T0=T0_sys[id_pl_cond], e=e_sys[id_pl_cond], w=omega_sys[id_pl_cond]) for t in t_obs_daily]) + σ_1obs*np.random.randn(N_obs) # RV obs of the conditioned planet only (throwing out all other planets)\n \n K_cond_hat_daily[i,n], sigma_K_cond_daily[i,n] = fit_rv_K_single_planet_model_GLS(t_obs_daily, RV_obs_daily, covarsc, P_sys[id_pl_cond], T0=T0_sys[id_pl_cond], e=e_sys[id_pl_cond], w=omega_sys[id_pl_cond])\n K_cond_hat_daily_ideal[i,n], sigma_K_cond_daily_ideal[i,n] = fit_rv_K_single_planet_model_GLS(t_obs_daily, RV_obs_daily_ideal, covarsc, P_sys[id_pl_cond], T0=T0_sys[id_pl_cond], e=e_sys[id_pl_cond], w=omega_sys[id_pl_cond])\n rmsd_K_daily_all = np.sqrt(np.mean((K_cond_hat_daily - K_cond)**2., axis=1))\n rmsd_K_daily_ideal_all = np.sqrt(np.mean((K_cond_hat_daily_ideal - K_cond)**2., axis=1))\n rms_sigma_K_daily_all = np.sqrt(np.mean(sigma_K_cond_daily**2., axis=1))\n rms_sigma_K_daily_ideal_all = np.sqrt(np.mean(sigma_K_cond_daily_ideal**2., axis=1))\n \n i_N_obs_20p = rmsd_K_daily_all/K_cond < 0.2\n i_N_obs_20p_ideal = rmsd_K_daily_ideal_all/K_cond < 0.2\n N_obs_min_20p = N_obs_all[i_N_obs_20p][0] if np.sum(i_N_obs_20p) > 0 else np.nan\n N_obs_min_20p_ideal = N_obs_all[i_N_obs_20p_ideal][0] if np.sum(i_N_obs_20p_ideal) > 0 else np.nan\n rms_sigma_K_20p = rms_sigma_K_daily_all[i_N_obs_20p][0] if np.sum(i_N_obs_20p) > 0 else np.nan\n rms_sigma_K_20p_ideal = rms_sigma_K_daily_ideal_all[i_N_obs_20p_ideal][0] if np.sum(i_N_obs_20p_ideal) > 0 else np.nan\n \n stop = time.time()\n print('{:d} ({:0.1f}s): K = {:0.3f} m/s --- N_obs for RMSD(K_cond)/K_cond <20%: {:.0f} ({:.0f} ideal)'.format(j, stop-start, K_cond, N_obs_min_20p, N_obs_min_20p_ideal))\n \n s1 = '{:d}'.format(N_obs_min_20p) if ~np.isnan(N_obs_min_20p) else '>{:d}'.format(N_obs_all[-1])\n s2 = '{:d}'.format(N_obs_min_20p_ideal) if ~np.isnan(N_obs_min_20p_ideal) else '>{:d}'.format(N_obs_all[-1])\n plt.text(x=1.02*t_end, y=0, s='%s (%s)' % (s1, s2), va='center', ha='left', fontsize=10)\n if j == N_per_plot-1:\n plt.text(x=1.02, y=1.1, s=r'$N_{\\rm obs}$ (ideal)', va='bottom', ha='left', fontsize=10, transform=ax.transAxes)\n plt.legend(loc='lower left', bbox_to_anchor=(0,1.2), ncol=1, frameon=False, fontsize=10)\n elif outputs_RVs is not None:\n ##### WARNING: double check if indexing is right\n i_of_i_sort = i_sort[id_sys] #i_sort[-(id_sys+1)]\n N_obs_max = int(np.nanmax(outputs_RVs['N_obs_min_20p']))\n N_obs_min_20p = outputs_RVs['N_obs_min_20p'][i_of_i_sort]\n N_obs_min_20p_ideal = outputs_RVs['N_obs_min_20p_ideal'][i_of_i_sort]\n \n s1 = '{:d}'.format(int(N_obs_min_20p)) if ~np.isnan(N_obs_min_20p) else '>{:d}'.format(N_obs_max)\n s2 = '{:d}'.format(int(N_obs_min_20p_ideal)) if ~np.isnan(N_obs_min_20p_ideal) else '>{:d}'.format(N_obs_max)\n plt.text(x=1.02*t_end, y=0, s='%s (%s)' % (s1, s2), va='center', ha='left', fontsize=10)\n if j == N_per_plot-1:\n plt.text(x=1.02, y=1.1, s=r'$N_{\\rm obs}$ (ideal)', va='bottom', ha='left', fontsize=10, transform=ax.transAxes)\n plt.legend(loc='lower left', bbox_to_anchor=(0,1.2), ncol=1, frameon=False, fontsize=10)\n else: # if outputs_RVs=None and fit_RVs=False\n plt.text(x=1.02*t_end, y=0, s='{:.2f}'.format(np.round(np.max(K_sys),2)), va='center', ha='left', fontsize=10)\n if j == N_per_plot-1:\n plt.text(x=1.02, y=1.1, s=r'$K_{\\rm max}$ (m/s)', va='bottom', ha='left', fontsize=10, transform=ax.transAxes)\n plt.legend(loc='lower left', bbox_to_anchor=(0,1.2), ncol=1, frameon=False, fontsize=10)\n \n save_name = save_name_base + '_%s.pdf' % h\n if save_fig:\n plt.savefig(save_name)\n plt.close()\n\ndef fit_RVobs_systems_conditional(sssp_per_sys, sssp, conds, N_obs_all, cond_only=False, fit_sys_cond=True, fit_all_planets=False, N_sample=20, repeat=1000, σ_1obs=1., obs_mode='daily'):\n \n # cond_only = False: set True to simulate ideal case (RV signal without any other planets)\n # fit_sys_cond = True: set True to simulate real case (fitting conditioned planet only)\n # fit_all_planets = False: set True to simulate optimistic case (fitting all planets)\n \n # σ_1obs = 1. # single-measurement uncertainity in RVs (m/s)\n # obs_mode = 'daily' or 'random' # how the observation times are drawn\n t_obs_σ = 0.2 # variation in exact 'daily' observing time (days) to avoid aliasing\n \n i_cond = condition_systems_indices(sssp_per_sys, conds)\n i_sample = np.random.choice(i_cond, N_sample, replace=False)\n\n Mstar_sample = sssp['Mstar_all'][i_sample]\n P_sample = sssp_per_sys['P_all'][i_sample]\n det_sample = sssp_per_sys['det_all'][i_sample]\n Mp_sample = sssp_per_sys['mass_all'][i_sample]\n Rp_sample = sssp_per_sys['radii_all'][i_sample]\n e_sample = sssp_per_sys['e_all'][i_sample]\n incl_sample = sssp_per_sys['incl_all'][i_sample]\n clusterids_sample = sssp_per_sys['clusterids_all'][i_sample]\n\n outputs = []\n for id_sys in range(len(i_sample)):\n start = time.time()\n \n Mstar_sys = Mstar_sample[id_sys]\n P_sys = P_sample[id_sys]\n det_sys = det_sample[id_sys]\n Mp_sys = Mp_sample[id_sys]\n Rp_sys = Rp_sample[id_sys]\n e_sys = e_sample[id_sys]\n incl_sys = incl_sample[id_sys]\n clusterids_sys = clusterids_sample[id_sys]\n \n det_sys = det_sys[P_sys > 0]\n Mp_sys = Mp_sys[P_sys > 0]\n Rp_sys = Rp_sys[P_sys > 0]\n e_sys = e_sys[P_sys > 0]\n incl_sys = incl_sys[P_sys > 0]\n clusterids_sys = clusterids_sys[P_sys > 0]\n P_sys = P_sys[P_sys > 0]\n \n T0_sys = P_sys*np.random.random(len(P_sys)) # reference epochs for each planet\n omega_sys = 2.*np.pi*np.random.random(len(P_sys)) # WARNING: need to get from simulated physical catalogs, NOT re-drawn\n \n K_sys = rv_K(Mp_sys, P_sys, e=e_sys, i=incl_sys, Mstar=Mstar_sys)\n id_pl_cond = np.arange(len(P_sys))[(P_sys > conds['P_lower']) & (P_sys < conds['P_upper']) & (Rp_sys > conds['Rp_lower']) & (Rp_sys < conds['Rp_upper'])][0] # index of conditioned planet\n P_cond = P_sys[id_pl_cond] # period of conditioned planet (days)\n Rp_cond = Rp_sys[id_pl_cond] # radius of conditioned planet (Earth radii)\n Mp_cond = Mp_sys[id_pl_cond] # mass of conditioned planet (Earth masses)\n K_cond = K_sys[id_pl_cond] # K of the conditioned planet (m/s)\n K_max = np.max(K_sys)\n \n # To compute the true RV time series:\n t_end = 150. # days\n t_array = np.linspace(0., t_end, 1001)\n RV_sys_per_pl = np.zeros((len(t_array),len(P_sys)))\n for i in range(len(P_sys)):\n RV_sys_per_pl[:,i] = [RV_true(t, K_sys[i], P_sys[i], T0=T0_sys[i], e=e_sys[i], w=omega_sys[i]) for t in t_array]\n RV_sys = np.sum(RV_sys_per_pl, axis=1)\n RV_absmax = np.max([-np.min(RV_sys), np.max(RV_sys)])\n \n # To simulate and fit RV observations for measuring K of the conditioned planet:\n K_cond_hat_ideal = np.zeros((len(N_obs_all), repeat)) # cond_only\n K_cond_hat = np.zeros((len(N_obs_all), repeat)) # fit_sys_cond\n K_cond_hat_fitall = np.zeros((len(N_obs_all), repeat)) # fit_all_planets\n sigma_K_cond_ideal = np.zeros((len(N_obs_all), repeat))\n sigma_K_cond = np.zeros((len(N_obs_all), repeat))\n sigma_K_cond_fitall = np.zeros((len(N_obs_all), repeat))\n sigma_K_cond_theory = σ_1obs * np.sqrt(2./N_obs_all)\n #print('##### P_sys: ', P_sys)\n for n in range(repeat):\n t_obs = []\n for i,N_obs in enumerate(N_obs_all):\n covarsc = σ_1obs**2. * np.identity(N_obs)\n if obs_mode == 'daily':\n N_obs_add = N_obs - len(t_obs) # number of observations to add\n t_obs = t_obs + list(len(t_obs) + np.arange(N_obs_add) + t_obs_σ*np.random.random(N_obs_add))\n elif obs_mode == 'random':\n t_obs = np.sort(t_end*np.random.random(N_obs))\n \n if cond_only:\n # RV time series of conditioned planet only:\n RV_obs = np.array([RV_true(t, K_cond, P_cond, T0=T0_sys[id_pl_cond], e=e_sys[id_pl_cond], w=omega_sys[id_pl_cond]) for t in t_obs]) + σ_1obs*np.random.randn(N_obs)\n K_cond_hat_ideal[i,n], sigma_K_cond_ideal[i,n] = fit_rv_K_single_planet_model_GLS(t_obs, RV_obs, covarsc, P_sys[id_pl_cond], T0=T0_sys[id_pl_cond], e=e_sys[id_pl_cond], w=omega_sys[id_pl_cond])\n \n # RV time series of the system:\n RV_obs = np.array([RV_true_sys(t, K_sys, P_sys, T0_sys, e_sys, omega_sys) for t in t_obs]) + σ_1obs*np.random.randn(N_obs)\n \n if fit_sys_cond:\n K_cond_hat[i,n], sigma_K_cond[i,n] = fit_rv_K_single_planet_model_GLS(t_obs, RV_obs, covarsc, P_sys[id_pl_cond], T0=T0_sys[id_pl_cond], e=e_sys[id_pl_cond], w=omega_sys[id_pl_cond])\n \n if fit_all_planets:\n bools_fit = K_sys > 0. #σ_1obs/2.\n id_pl_cond_of_fits = np.where(np.arange(len(K_sys))[bools_fit] == id_pl_cond)[0][0] # index of conditioned planet counting only fitted planets\n # Do not attempt fitting if fewer observations than free parameters (planets)\n if N_obs < 2*np.sum(bools_fit):\n #print('Skipping N_obs = ', N_obs)\n K_cond_hat_fitall[i,n] = np.inf\n continue\n else:\n try:\n K_hat_all, sigma_K_all = fit_rv_Ks_multi_planet_model_GLS(t_obs, RV_obs, covarsc, P_sys[bools_fit], T0_sys[bools_fit], e_sys[bools_fit], omega_sys[bools_fit])\n K_cond_hat_fitall[i,n], sigma_K_cond_fitall[i,n] = K_hat_all[id_pl_cond_of_fits], sigma_K_all[id_pl_cond_of_fits]\n except:\n print('##### Possible singular/non-positive-definite matrices; skipping N_obs = ', N_obs)\n K_cond_hat_fitall[i,n] = np.inf\n \n rmsd_K_all_ideal = np.sqrt(np.mean((K_cond_hat_ideal - K_cond)**2., axis=1))\n rmsd_K_all = np.sqrt(np.mean((K_cond_hat - K_cond)**2., axis=1))\n rmsd_K_all_fitall = np.sqrt(np.mean((K_cond_hat_fitall - K_cond)**2., axis=1))\n rms_sigma_K_all_ideal = np.sqrt(np.mean(sigma_K_cond_ideal**2., axis=1))\n rms_sigma_K_all = np.sqrt(np.mean(sigma_K_cond**2., axis=1))\n rms_sigma_K_all_fitall = np.sqrt(np.mean(sigma_K_cond_fitall**2., axis=1))\n \n stop = time.time()\n \n data_values = (i_sample[id_sys], len(K_sys), P_cond, Rp_cond, Mp_cond, K_cond, K_max, np.sum(K_sys))\n print('{:d} ({:0.1f}s): sys_id = {:d} --- n_pl = {:d} --- P_cond = {:0.3f} d --- Rp_cond = {:0.3f} R_earth --- Mp_cond = {:0.3f} M_earth --- K_cond = {:0.3f} m/s --- K_max = {:0.3f} m/s --- K_cond/sum(K) = {:0.3f}'.format(id_sys, stop-start, i_sample[id_sys], len(K_sys), P_cond, Rp_cond, Mp_cond, K_cond, K_max, K_cond/np.sum(K_sys)))\n \n rmsd_K_cond_ferr = [0.3, 0.2, 0.1, 0.05] # fraction error rmsd(K_cond)/K_cond thresholds\n if cond_only:\n N_obs_min_ferr = []\n rms_sigma_K_ferr = []\n for ferr in rmsd_K_cond_ferr:\n i_ferr = rmsd_K_all_ideal/K_cond < ferr\n N_obs_min_ferr.append(N_obs_all[i_ferr][0] if np.sum(i_ferr) > 0 else np.nan)\n rms_sigma_K_ferr.append(rms_sigma_K_all_ideal[i_ferr][0] if np.sum(i_ferr) > 0 else np.nan)\n data_values += tuple(N_obs_min_ferr + rms_sigma_K_ferr + [np.min(rmsd_K_all_ideal/K_cond)])\n print('Ideal case --- N_obs for RMSD(K_cond)/K_cond < %s: %s --- best error = %s' % (rmsd_K_cond_ferr, N_obs_min_ferr, np.round(np.min(rmsd_K_all_ideal/K_cond),3)))\n \n if fit_sys_cond:\n N_obs_min_ferr = []\n rms_sigma_K_ferr = []\n for ferr in rmsd_K_cond_ferr:\n i_ferr = rmsd_K_all/K_cond < ferr\n N_obs_min_ferr.append(N_obs_all[i_ferr][0] if np.sum(i_ferr) > 0 else np.nan)\n rms_sigma_K_ferr.append(rms_sigma_K_all[i_ferr][0] if np.sum(i_ferr) > 0 else np.nan)\n data_values += tuple(N_obs_min_ferr + rms_sigma_K_ferr + [np.min(rmsd_K_all/K_cond)])\n print('Fit cond case --- N_obs for RMSD(K_cond)/K_cond < %s: %s --- best error = %s' % (rmsd_K_cond_ferr, N_obs_min_ferr, np.round(np.min(rmsd_K_all/K_cond),3)))\n \n if fit_all_planets:\n N_obs_min_ferr = []\n rms_sigma_K_ferr = []\n for ferr in rmsd_K_cond_ferr:\n i_ferr = rmsd_K_all_fitall/K_cond < ferr\n N_obs_min_ferr.append(N_obs_all[i_ferr][0] if np.sum(i_ferr) > 0 else np.nan)\n rms_sigma_K_ferr.append(rms_sigma_K_all_fitall[i_ferr][0] if np.sum(i_ferr) > 0 else np.nan)\n data_values += tuple(N_obs_min_ferr + rms_sigma_K_ferr + [np.min(rmsd_K_all_fitall/K_cond)])\n print('Fit all case --- N_obs for RMSD(K_cond)/K_cond < %s: %s --- best error = %s' % (rmsd_K_cond_ferr, N_obs_min_ferr, np.round(np.min(rmsd_K_all_fitall/K_cond),3)))\n \n outputs.append(data_values)\n\n # Make sure the dtypes match the appended outputs!\n data_dtypes = [('id_sys','i4'), ('n_pl','i4'), ('P_cond','f8'), ('Rp_cond','f8'), ('Mp_cond','f8'), ('K_cond','f8'), ('K_max','f8'), ('K_sum','f8')]\n if cond_only:\n data_dtypes += [('N_obs_min_30p_ideal','f8'), ('N_obs_min_20p_ideal','f8'), ('N_obs_min_10p_ideal','f8'), ('N_obs_min_5p_ideal','f8'), ('rms_sigma_K_30p_ideal','f8'), ('rms_sigma_K_20p_ideal','f8'), ('rms_sigma_K_10p_ideal','f8'), ('rms_sigma_K_5p_ideal','f8'), ('rmsd_best_ideal','f8')]\n if fit_sys_cond:\n data_dtypes += [('N_obs_min_30p','f8'), ('N_obs_min_20p','f8'), ('N_obs_min_10p','f8'), ('N_obs_min_5p','f8'), ('rms_sigma_K_30p','f8'), ('rms_sigma_K_20p','f8'), ('rms_sigma_K_10p','f8'), ('rms_sigma_K_5p','f8'), ('rmsd_best','f8')]\n if fit_all_planets:\n data_dtypes += [('N_obs_min_30p_fitall','f8'), ('N_obs_min_20p_fitall','f8'), ('N_obs_min_10p_fitall','f8'), ('N_obs_min_5p_fitall','f8'), ('rms_sigma_K_30p_fitall','f8'), ('rms_sigma_K_20p_fitall','f8'), ('rms_sigma_K_10p_fitall','f8'), ('rms_sigma_K_5p_fitall','f8'), ('rmsd_best_fitall','f8')]\n \n outputs = np.array(outputs, dtype=data_dtypes)\n \n # To make some additional plots:\n '''\n fig = plt.figure(figsize=(16,8))\n plot = GridSpec(2,2,left=0.1,bottom=0.1,right=0.975,top=0.95,wspace=0.2,hspace=0.4)\n\n ax = plt.subplot(plot[0,0])\n plt.plot(outputs['N_obs_min_20p'], outputs['K_cond']/outputs['K_sum'], 'o')\n ax.tick_params(axis='both', labelsize=afs)\n plt.xlabel(r'Number of obs. needed for RMSD(K_cond)/K_cond < 0.2', fontsize=tfs)\n plt.ylabel(r'$K_{\\rm cond}/\\sum{K}$', fontsize=tfs)\n\n ax = plt.subplot(plot[1,0])\n sc = plt.scatter(outputs['K_cond'], outputs['K_cond']/outputs['K_sum'], c=outputs['N_obs_min_20p'])\n ax.tick_params(axis='both', labelsize=afs)\n plt.xlabel(r'$K_{\\rm cond}$', fontsize=tfs)\n plt.ylabel(r'$K_{\\rm cond}/\\sum{K}$', fontsize=tfs)\n cbar = plt.colorbar(sc, orientation='horizontal')\n cbar.set_label(r'Number of obs. needed for RMSD(K_cond)/K_cond < 0.2', fontsize=10)\n \n ax = plt.subplot(plot[0,1])\n plt.plot(outputs['N_obs_min_20p'], outputs['K_cond'], 'o', color='r', label=r'$K_{\\rm cond}$')\n plt.plot(outputs['N_obs_min_20p'], outputs['K_max'], 'o', color='b', label=r'$K_{\\rm max}$')\n plt.plot(outputs['N_obs_min_20p'], outputs['K_sum'], 'o', color='k', label=r'$\\sum{K}$')\n ax.tick_params(axis='both', labelsize=afs)\n plt.xlabel(r'Number of obs. needed for RMSD(K_cond)/K_cond < 0.2', fontsize=tfs)\n plt.ylabel(r'$K$ (m/s)', fontsize=tfs)\n plt.legend(loc='upper right', bbox_to_anchor=(1,1), ncol=1, fontsize=lfs)\n \n ax = plt.subplot(plot[1,1])\n sc = plt.scatter(outputs['K_cond'], outputs['K_cond']/outputs['K_sum'], c=outputs['rmsd_best'])\n ax.tick_params(axis='both', labelsize=afs)\n plt.xlabel(r'$K_{\\rm cond}$', fontsize=tfs)\n plt.ylabel(r'$K_{\\rm cond}/\\sum{K}$', fontsize=tfs)\n cbar = plt.colorbar(sc, orientation='horizontal')\n cbar.set_label(r'RMSD(K_cond)', fontsize=10)\n \n if show_fig:\n plt.show()\n else:\n plt.close()\n '''\n return outputs\n\ndef fit_RVobs_single_planets_vs_K(K_array, N_obs_all, P_bounds, alpha_P=0., sigma_ecc=0.25, repeat=1000, σ_1obs=1., t_obs_σ=0.2):\n\n # σ_1obs = 1. # single-measurement uncertainity in RVs (m/s)\n # t_obs_σ = 0.2 # variation in exact 'daily' observing time (days) to avoid aliasing\n P_lower, P_upper = P_bounds\n assert P_lower < P_upper\n \n outputs = []\n for j,K in enumerate(K_array):\n start = time.time()\n \n # To simulate and fit RV observations for measuring K:\n K_hat_random = np.zeros((len(N_obs_all), repeat))\n K_hat_daily = np.zeros((len(N_obs_all), repeat))\n sigma_K_random = np.zeros((len(N_obs_all), repeat))\n sigma_K_daily = np.zeros((len(N_obs_all), repeat))\n sigma_K_ideal_all = σ_1obs * np.sqrt(2./N_obs_all)\n \n for n in range(repeat):\n P = np.random.power(alpha_P + 1.)*(P_upper - P_lower) + P_lower\n ecc = np.random.rayleigh(sigma_ecc)\n while ecc >= 1:\n ecc = np.random.rayleigh(sigma_ecc)\n \n T0 = P*np.random.random() # reference epoch\n omega = 2.*np.pi*np.random.random()\n \n # To compute the true RV time series:\n t_end = 150. # days\n t_array = np.linspace(0., t_end, 1001)\n RV_sys = np.array([RV_true(t, K, P, T0=T0, e=ecc, w=omega) for t in t_array])\n \n t_obs_daily = []\n for i,N_obs in enumerate(N_obs_all):\n covarsc = σ_1obs**2. * np.identity(N_obs)\n t_obs_random = np.sort(t_end*np.random.random(N_obs))\n N_obs_add = N_obs - len(t_obs_daily) # number of observations to add\n t_obs_daily = t_obs_daily + list(len(t_obs_daily) + np.arange(N_obs_add) + t_obs_σ*np.random.random(N_obs_add))\n \n RV_obs_random = np.array([RV_true(t, K, P, T0, ecc, omega) for t in t_obs_random]) + σ_1obs*np.random.randn(N_obs)\n RV_obs_daily = np.array([RV_true(t, K, P, T0, ecc, omega) for t in t_obs_daily]) + σ_1obs*np.random.randn(N_obs)\n \n K_hat_random[i,n], sigma_K_random[i,n] = fit_rv_K_single_planet_model_GLS(t_obs_random, RV_obs_random, covarsc, P, T0=T0, e=ecc, w=omega)\n K_hat_daily[i,n], sigma_K_daily[i,n] = fit_rv_K_single_planet_model_GLS(t_obs_daily, RV_obs_daily, covarsc, P, T0=T0, e=ecc, w=omega)\n\n stop = time.time()\n \n rmsd_K_random_all = np.sqrt(np.mean((K_hat_random - K)**2., axis=1))\n rmsd_K_daily_all = np.sqrt(np.mean((K_hat_daily - K)**2., axis=1))\n\n N_obs_20p = N_obs_all[rmsd_K_daily_all/K < 0.2]\n N_obs_min_20p = N_obs_20p[0] if len(N_obs_20p) > 0 else np.nan\n if len(N_obs_20p) > 0:\n print('{:d} ({:0.1f}s): K = {:0.3f} m/s --- N_obs needed for <20% error: {:d}'.format(j, stop-start, K, N_obs_20p[0]))\n else:\n print('{:d} ({:0.1f}s): K = {:0.3f} m/s --- No N_obs with <20% error; best error = {:0.3f}'.format(j, stop-start, K, np.min(rmsd_K_daily_all/K)))\n \n outputs.append((K, N_obs_min_20p, np.min(rmsd_K_daily_all)))\n\n outputs = np.array(outputs, dtype=[('K','f8'), ('N_obs_min_20p','f8'), ('rmsd_best','f8')])\n return outputs\n\ndef plot_scatter_K_vs_P_conditional(sssp_per_sys, sssp, conds, log_y=False, fig_size=(8,5), afs=20, tfs=20, lfs=16, save_name='no_name_fig.pdf', save_fig=False):\n \n i_cond = condition_systems_indices(sssp_per_sys, conds)\n\n Mstar_sample = sssp['Mstar_all'][i_cond]\n P_sample = sssp_per_sys['P_all'][i_cond]\n det_sample = sssp_per_sys['det_all'][i_cond]\n Mp_sample = sssp_per_sys['mass_all'][i_cond]\n Rp_sample = sssp_per_sys['radii_all'][i_cond]\n e_sample = sssp_per_sys['e_all'][i_cond]\n incl_sample = sssp_per_sys['incl_all'][i_cond]\n clusterids_sample = sssp_per_sys['clusterids_all'][i_cond]\n\n K_sample = []\n max_pl = np.shape(P_sample)[1]\n for i in range(len(P_sample)):\n Mstar_sys = Mstar_sample[i]\n P_sys = P_sample[i]\n Mp_sys = Mp_sample[i]\n Rp_sys = Rp_sample[i]\n e_sys = e_sample[i]\n incl_sys = incl_sample[i]\n \n Mp_sys = Mp_sys[P_sys > 0]\n Rp_sys = Rp_sys[P_sys > 0]\n e_sys = e_sys[P_sys > 0]\n incl_sys = incl_sys[P_sys > 0]\n P_sys = P_sys[P_sys > 0]\n \n K_sys = rv_K(Mp_sys, P_sys, e=e_sys, i=incl_sys, Mstar=Mstar_sys)\n K_sample.append(list(K_sys) + [0]*(max_pl - len(K_sys)))\n K_sample = np.array(K_sample)\n\n # To make a scatter plot of K/K_max vs P:\n fig = plt.figure(figsize=fig_size)\n plot = GridSpec(1,1,left=0.15,bottom=0.15,right=0.95,top=0.85,wspace=0,hspace=0)\n ax = plt.subplot(plot[:,:])\n plt.title('Systems conditioned on a planet with\\n' r'$P = [%s,%s]$d, $R_p = [%s,%s] R_\\oplus$' % (conds['P_lower'], conds['P_upper'], conds['Rp_lower'], conds['Rp_upper']), va='center', ha='center', fontsize=tfs)\n real_det_bools = (P_sample > 0) & (det_sample == 1)\n real_undet_bools = (P_sample > 0) & (det_sample == 0)\n plt.scatter(P_sample[real_det_bools], (K_sample/np.max(K_sample, axis=1)[:,None])[real_det_bools], s=10.*(Rp_sample[real_det_bools])**2., c=K_sample[real_det_bools], vmin=0., vmax=5., label='Detected')\n plt.scatter(P_sample[real_undet_bools], (K_sample/np.max(K_sample, axis=1)[:,None])[real_undet_bools], s=10.*(Rp_sample[real_undet_bools])**2., c=K_sample[real_undet_bools], vmin=0., vmax=5., edgecolors='r', label='Undetected')\n plt.fill_betweenx(y=[0,1], x1=conds['P_lower'], x2=conds['P_upper'], color='g', alpha=0.2)\n plt.gca().set_xscale(\"log\")\n if log_y:\n plt.gca().set_yscale(\"log\")\n ax.tick_params(axis='both', labelsize=afs)\n ax.set_xticks([3,10,30,100,300])\n ax.get_xaxis().set_major_formatter(matplotlib.ticker.ScalarFormatter())\n plt.xlim([3., 300.])\n if log_y:\n plt.ylim([np.min(K_sample[K_sample > 0]), np.max(K_sample/np.max(K_sample, axis=1)[:,None])])\n else:\n plt.ylim([0., np.max(K_sample/np.max(K_sample, axis=1)[:,None])])\n plt.xlabel(r'Orbital period $P$ (days)', fontsize=tfs)\n plt.ylabel(r'$K/K_{\\rm max}$', fontsize=tfs)\n plt.legend(loc='upper right', bbox_to_anchor=(1,1), ncol=1, frameon=True, fontsize=lfs)\n cbar = plt.colorbar()\n cbar.set_label(r'$K$', fontsize=lfs)\n \n if save_fig:\n plt.savefig(save_name + 'v1.pdf')\n plt.close()\n\n # To make a scatter plot of K vs P:\n fig = plt.figure(figsize=fig_size)\n plot = GridSpec(1,1,left=0.15,bottom=0.15,right=1,top=0.85,wspace=0,hspace=0)\n ax = plt.subplot(plot[:,:])\n plt.title('Systems conditioned on a planet with\\n' r'$P = [%s,%s]$d, $R_p = [%s,%s] R_\\oplus$' % (conds['P_lower'], conds['P_upper'], conds['Rp_lower'], conds['Rp_upper']), va='center', ha='center', fontsize=tfs)\n real_det_bools = (P_sample > 0) & (det_sample == 1)\n real_undet_bools = (P_sample > 0) & (det_sample == 0)\n plt.scatter(P_sample[real_det_bools], K_sample[real_det_bools], s=10.*(Rp_sample[real_det_bools])**2., c=(K_sample/np.max(K_sample, axis=1)[:,None])[real_det_bools], label='Detected')\n plt.scatter(P_sample[real_undet_bools], K_sample[real_undet_bools], s=10.*(Rp_sample[real_undet_bools])**2., c=(K_sample/np.max(K_sample, axis=1)[:,None])[real_undet_bools], edgecolors='r', label='Undetected')\n plt.fill_betweenx(y=[0,np.max(K_sample)], x1=conds['P_lower'], x2=conds['P_upper'], color='g', alpha=0.2)\n plt.gca().set_xscale(\"log\")\n if log_y:\n plt.gca().set_yscale(\"log\")\n ax.tick_params(axis='both', labelsize=afs)\n ax.set_xticks([3,10,30,100,300])\n ax.get_xaxis().set_major_formatter(matplotlib.ticker.ScalarFormatter())\n plt.xlim([3., 300.])\n if log_y:\n plt.ylim([np.min(K_sample[K_sample > 0]), np.max(K_sample)])\n else:\n plt.ylim([0., np.max(K_sample)])\n plt.xlabel(r'Orbital period $P$ (days)', fontsize=tfs)\n plt.ylabel(r'RV semi-amplitude $K$ (m/s)', fontsize=tfs)\n plt.legend(loc='upper right', bbox_to_anchor=(1,1), ncol=1, frameon=True, fontsize=lfs)\n cbar = plt.colorbar()\n cbar.set_label(r'$K/K_{\\rm max}$', fontsize=lfs)\n \n if save_fig:\n plt.savefig(save_name + 'v2.pdf')\n plt.close()\n\n\n\ndef generate_latex_table_RVobs_systems_conditional(outputs_RVs, nan_str=r'$>1000$', N_sample=40):\n table_array = []\n for i in range(N_sample):\n osys = outputs_RVs[i]\n N_obs_str = '{:d}'.format(int(osys['N_obs_min_20p'])) if not np.isnan(osys['N_obs_min_20p']) else nan_str\n N_obs_fitall_str = '{:d}'.format(int(osys['N_obs_min_20p_fitall'])) if not np.isnan(osys['N_obs_min_20p_fitall']) else nan_str\n N_obs_ideal_str = '{:d}'.format(int(osys['N_obs_min_20p_ideal'])) if not np.isnan(osys['N_obs_min_20p_ideal']) else nan_str\n row_str = '{:d} & {:0.3f} & {:0.3f} & {:0.3f} & {:0.3f} & {:0.3f} & {:0.3f} & '.format(int(osys['n_pl']), osys['P_cond'], osys['Rp_cond'], osys['Mp_cond'], osys['K_cond'], osys['K_max'], osys['K_sum'])\n row_str += ' & '.join([N_obs_str, N_obs_fitall_str, N_obs_ideal_str]) + r' \\\\'\n table_array.append(row_str)\n table_array = np.array(table_array)\n return table_array\n \n\n\n\n# Functions to fit and use a line for a set of simulations for log(N_obs) vs. log(K_cond) (ideal single-planet case):\n\ndef fit_line_loglog_Nobs_K_single_planets(outputs_ideal, σ_1obs, p0):\n # outputs_ideal: dictionary with simulated RV observations ('K' and 'N_obs_min_20p' fields)\n # σ_1obs: single measurement precision, to serve as normalization point K_norm\n # p0: initial guesses for line parameters N_obs(K_norm) and slope\n \n K_norm = σ_1obs # single measurement precision serves as normalization point\n f_linear = lambda p, x: p[0] + p[1]*x - p[1]*np.log10(K_norm)\n f_err = lambda p, x, y: y - f_linear(p,x)\n \n log_K = np.log10(outputs_ideal['K'][outputs_ideal['N_obs_min_20p'] > 5]) # this should remove NaNs and 5s\n log_N_obs = np.log10(outputs_ideal['N_obs_min_20p'][outputs_ideal['N_obs_min_20p'] > 5])\n fit = scipy.optimize.leastsq(f_err, p0, args=(log_K, log_N_obs), full_output=1)\n logN_slope = fit[0]\n logN = logN_slope[0] # normalization parameter; log10(N_obs) at K_norm\n slope = logN_slope[1] # slope parameter\n return logN, slope\n\ndef linear_logNobs_logK(K, K_norm, Nobs_norm, slope, Nobs_min=5, round_to_ints=True):\n logK = np.log10(np.array(K))\n logNobs_K = slope*(logK - np.log10(K_norm)) + np.log10(Nobs_norm) # log(N_obs) at K\n Nobs_K = 10.**logNobs_K # N_obs at K\n Nobs_K[Nobs_K < 5] = 5\n if round_to_ints:\n Nobs_K = np.round(Nobs_K).astype(int)\n return Nobs_K\n \n"
] |
[
[
"matplotlib.pyplot.xlim",
"numpy.min",
"matplotlib.pyplot.xticks",
"matplotlib.pyplot.minorticks_off",
"numpy.max",
"matplotlib.pyplot.savefig",
"numpy.sqrt",
"matplotlib.pyplot.gca",
"numpy.log10",
"numpy.nanmedian",
"matplotlib.pyplot.subplot",
"numpy.array",
"matplotlib.pyplot.close",
"matplotlib.pyplot.yticks",
"matplotlib.pyplot.figure",
"matplotlib.pyplot.show",
"matplotlib.gridspec.GridSpec",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.ylim",
"matplotlib.pyplot.legend",
"matplotlib.pyplot.ylabel"
],
[
"matplotlib.pyplot.text",
"numpy.random.choice",
"matplotlib.pyplot.xlim",
"numpy.tan",
"numpy.min",
"numpy.mean",
"numpy.cos",
"numpy.random.rayleigh",
"numpy.random.random",
"matplotlib.pyplot.xticks",
"numpy.max",
"matplotlib.pyplot.colorbar",
"numpy.sin",
"matplotlib.pyplot.savefig",
"matplotlib.pyplot.fill_betweenx",
"numpy.arange",
"numpy.sqrt",
"numpy.log10",
"matplotlib.pyplot.gca",
"numpy.nanmax",
"matplotlib.pyplot.subplot",
"numpy.array",
"numpy.zeros",
"matplotlib.pyplot.axhline",
"numpy.round",
"matplotlib.pyplot.title",
"numpy.random.power",
"matplotlib.pyplot.close",
"numpy.shape",
"matplotlib.pyplot.figure",
"matplotlib.pyplot.yticks",
"matplotlib.ticker.FormatStrFormatter",
"numpy.identity",
"numpy.random.randn",
"numpy.argsort",
"matplotlib.ticker.ScalarFormatter",
"matplotlib.gridspec.GridSpec",
"numpy.isnan",
"numpy.random.seed",
"numpy.sum",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.ylim",
"matplotlib.pyplot.legend",
"numpy.ones",
"matplotlib.pyplot.plot",
"numpy.any",
"matplotlib.pyplot.figtext",
"numpy.random.uniform",
"matplotlib.pyplot.ylabel",
"numpy.linspace"
]
] |
hassan-alhujhoj/ENEL420-GA-DSP
|
[
"e550300bc671950f27909b499d440446a325326d",
"e550300bc671950f27909b499d440446a325326d",
"e550300bc671950f27909b499d440446a325326d",
"e550300bc671950f27909b499d440446a325326d"
] |
[
"src/.history/DSP_main_20201014012000.py",
"src/.history/DSP_main_20201015183927.py",
"src/.history/DSP_main_20201013235435.py",
"src/.history/DSP_main_20201015175156.py"
] |
[
"\"\"\"\r\nGenetic Algorithms for Digital Signal Processing\r\nCreated on Mon Oct 05 20:01:05 2020\r\nLast Edited on Mon Oct 12 2020 by Luke Trenberth\r\nTODO tidy up this code and to finalise it. Add up the third FIR filter method in here too.\r\n\"\"\"\r\nfrom os import major\r\nimport numpy as np\r\nimport matplotlib\r\nfrom scipy import signal\r\nfrom scipy.fftpack import fft\r\nimport matplotlib.pyplot as plt\r\nimport DSP_GA as ga\r\n\r\nclass DSP_Signal():\r\n def __init__(self, filename, fs=1024, N_Coeff=400):\r\n file = open(filename, \"r\")\r\n self.y_0 = []\r\n for line in file:\r\n words = line.split(\" \")\r\n for word in words:\r\n if word != \"\":\r\n self.y_0.append(float(word))\r\n self.fs = fs\r\n self.N = len(self.y_0)\r\n self.N_2 = int(self.N/2)\r\n self.t = [x/self.fs for x in list(range(0, self.N))]\r\n self.f = [x*self.fs/self.N for x in list(range(0, self.N_2))]\r\n self.P_0 = np.var(self.y_0)\r\n self.FFT_0 = fft(self.y_0)\r\n \r\n self.N_Coeff = N_Coeff # Number of coefficients\r\n \r\n #Window Filtering method for the data class\r\n def WF(self, GA_data):\r\n #GA Data: [noise_f_1, noise_f_2, width]\r\n \r\n # Window Filtering\r\n self.width_WF = 8 # Width of stop band, Hz\r\n self.band_1 = [GA_data[0] -GA_data[2]/2, GA_data[0]+GA_data[2]/2] # Define band 1 bounds\r\n self.band_2 = [GA_data[1] -GA_data[2]/2, GA_data[1]+GA_data[2]/2] # Define band 2 bounds\r\n \r\n self.filter1_WF = signal.firwin(self.N_Coeff+1, self.band_1, window='hann', pass_zero='bandstop', fs=self.fs) # Filter for noise frequency 1\r\n self.filter2_WF = signal.firwin(self.N_Coeff+1, self.band_2, window='hann', pass_zero='bandstop', fs=self.fs) # Filter for noise frequency 2\r\n self.filter_WF = signal.convolve(self.filter1_WF, self.filter2_WF) # Combined filter for noise frequencies\r\n self.y_WF = signal.lfilter(self.filter_WF, 1, self.y_0) # Apply noise filters to original data\r\n self.f_WF, self.h_WF = signal.freqz(self.filter_WF, 1, fs=self.fs) #\r\n self.FFT_WF = fft(self.y_WF)\r\n return self.SNR(self.y_WF)\r\n \r\n #Parks McLellan Filtering Method\r\n def PM(self, GA_data, TW =3, BW=5):\r\n # Filter Bands for filtering frequency 1 & 2\r\n f_1 = GA_data[0]\r\n f_2 = GA_data[1]\r\n if len(GA_data) > 2:\r\n TW = GA_data[2]\r\n if len(GA_data) > 3:\r\n BW = GA_data[3]\r\n \r\n band1_PM = [0, f_1 -BW/2-TW, f_1 -BW/2, f_1+BW/2, f_1+BW/2+TW, self.fs/2]\r\n band2_PM = [0, f_2 -BW/2-TW, f_2 -BW/2, f_2+BW/2, f_2+BW/2+TW, self.fs/2]\r\n gain_PM = [1, 0, 1]\r\n \r\n # Create filters for filtering frequency 1 & 2\r\n filter1_PM = signal.remez(self.N_Coeff+1, band1_PM, gain_PM, fs=self.fs) # Filter frequency 1\r\n filter2_PM = signal.remez(self.N_Coeff+1, band2_PM, gain_PM, fs=self.fs) # Filter frequency 2\r\n filter_PM = signal.convolve(filter1_PM, filter2_PM) # Combined Filter\r\n \r\n self.y_PM = signal.lfilter(filter_PM, 1, self.y_0) # Filter original data in time domain\r\n self.f_PM, self.h_PM = signal.freqz(filter_PM, 1, fs=self.fs) # Return filter frequency response\r\n self.FFT_PM = fft(self.y_PM) # Filtered data frequency domain response\r\n return self.SNR(self.y_PM)\r\n \r\n\r\n #Returns a Signal to Noise Ratio for a given input Power\r\n def SNR (self, y):\r\n return self.P_0 - np.var(y)\r\n \r\n \r\n # Plots a Fast Fourier Transform for simple graphing\r\n def FFTplot(self, f, FFT, title=\"ECG Signal Frequency Spectrum\"):\r\n plt.figure()\r\n plt.plot(f, abs(FFT)[:self.N_2])\r\n plt.xlabel(\"Frequency (Hz)\")\r\n plt.ylabel(\"Voltage (uV)\")\r\n plt.title(title)\r\n plt.show()\r\n \r\n \r\n\r\n\r\n\r\n\r\n#The GA_filter function filters an input waveform \r\ndef GA_filter(waveform, input_num, solutions_per_population, mating_parent_number, num_generations):\r\n \r\n\r\n # Defining the population size.\r\n pop_size = (solutions_per_population,input_num) # The population will have sol_per_pop chromosome where each chromosome has num_weights genes.\r\n #Creating the initial population.\r\n new_population = ga.create_population(pop_size)\r\n \r\n \r\n best_outputs = []\r\n for generation in range(num_generations):\r\n # Measuring the fitness of each chromosome in the population.\r\n fitness = ga.cal_pop_fitness(waveform, new_population)\r\n # The best result in the current iteration.\r\n best_outputs.append(np.max(fitness))\r\n # Selecting the best parents in the population for mating.\r\n parents = ga.select_mating_pool(new_population, fitness, \r\n mating_parent_number)\r\n # Generating next generation using crossover.\r\n offspring_crossover = ga.crossover(parents, offspring_size=(pop_size[0]-parents.shape[0], input_num))\r\n # Adding some variations to the offspring using mutation.\r\n offspring_mutation = ga.mutation(offspring_crossover, num_mutations=2)\r\n # Creating the new population based on the parents and offspring.\r\n new_population[0:parents.shape[0], :] = parents\r\n new_population[parents.shape[0]:, :] = offspring_mutation\r\n \r\n# if (generation < 20):\r\n# print(\"{}\\n {}\\n\\n\".format(new_population, pop_fitness))\r\n if (generation%10 == 0 and generation != 0):\r\n print(\"{} Generations Completed\".format(generation))\r\n \r\n \r\n # Getting the best solution after iterating finishing all generations.\r\n #At first, the fitness is calculated for each solution in the final generation.\r\n fitness = ga.cal_pop_fitness(waveform, new_population)\r\n # Then return the index of that solution corresponding to the best fitness.\r\n best_match_idx = np.where(fitness == np.max(fitness))[0]\r\n return new_population[best_match_idx, :], fitness[best_match_idx][0][0], best_outputs\r\n \r\n\r\n# Implementation of a Parks-McLellan Filter using Genetic Algorithms\r\ndef main():\r\n waveform = DSP_Signal(\"Signal_files/enel420_grp_15.txt\")\r\n \r\n # Fixed Parameters, found by trial and error s\r\n f_count = 2\r\n mating_parent_number = 3\r\n pop_size = 10\r\n num_generations = 10\r\n \r\n # Conduct a Genetic Algorithm approximation\r\n best_soln, best_soln_fitness, best_outputs = GA_filter(waveform, \r\n f_count, pop_size, \r\n mating_parent_number, num_generations) \r\n print(\"Best solution : \\n\", best_soln)\r\n print(\"Best solution fitness : \\n\", best_soln_fitness)\r\n plt.figure()\r\n plt.plot(best_outputs, \"-g\", label=\"Fittest Output\")\r\n plt.title(\"Fitness of ECG Signal using GA Algorithm\")\r\n plt.xlabel(\"Number of Iterations\")\r\n plt.ylabel(\"Fitness (Signal to Noise Ratio)\")\r\n plt.legend(loc=\"upper right\")\r\n plt.grid()\r\n plt.show()\r\n\r\n waveform.FFTplot(waveform.f, waveform.FFT_0, title=\"Before filtering\")\r\n waveform.PM(best_soln[0])\r\n waveform.FFTplot(waveform.f, waveform.FFT_PM, title=\"After Filtering\")\r\n \r\nmain()\r\n\r\n",
"\"\"\"\r\nGenetic Algorithms for Digital Signal Processing\r\nCreated on Mon Oct 05 20:01:05 2020\r\nLast Edited on Mon Oct 12 2020 by Luke Trenberth\r\nTODO tidy up this code and to finalise it. Add up the third FIR filter method in here too.\r\n\"\"\"\r\nfrom os import major\r\nimport numpy as np\r\nimport matplotlib\r\nfrom scipy import signal\r\nfrom scipy.fftpack import fft\r\nimport matplotlib.pyplot as plt\r\nimport DSP_GA as ga\r\n\r\nclass DSP_Signal():\r\n def __init__(self, filename, fs=1024, N_Coeff=400):\r\n file = open(filename, \"r\")\r\n self.y_0 = []\r\n for line in file:\r\n words = line.split(\" \")\r\n for word in words:\r\n if word != \"\":\r\n self.y_0.append(float(word))\r\n self.fs = fs\r\n self.N = len(self.y_0)\r\n self.N_2 = int(self.N/2)\r\n self.t = [x/self.fs for x in list(range(0, self.N))]\r\n self.f = [x*self.fs/self.N for x in list(range(0, self.N_2))]\r\n self.P_0 = np.var(self.y_0)\r\n self.FFT_0 = fft(self.y_0)\r\n \r\n self.N_Coeff = N_Coeff # Number of coefficients\r\n \r\n #Window Filtering method for the data class\r\n def WF(self, GA_data):\r\n #GA Data: [noise_f_1, noise_f_2, width]\r\n \r\n # Window Filtering\r\n self.width_WF = 8 # Width of stop band, Hz\r\n self.band_1 = [GA_data[0] -GA_data[2]/2, GA_data[0]+GA_data[2]/2] # Define band 1 bounds\r\n self.band_2 = [GA_data[1] -GA_data[2]/2, GA_data[1]+GA_data[2]/2] # Define band 2 bounds\r\n \r\n self.filter1_WF = signal.firwin(self.N_Coeff+1, self.band_1, window='hann', pass_zero='bandstop', fs=self.fs) # Filter for noise frequency 1\r\n self.filter2_WF = signal.firwin(self.N_Coeff+1, self.band_2, window='hann', pass_zero='bandstop', fs=self.fs) # Filter for noise frequency 2\r\n self.filter_WF = signal.convolve(self.filter1_WF, self.filter2_WF) # Combined filter for noise frequencies\r\n self.y_WF = signal.lfilter(self.filter_WF, 1, self.y_0) # Apply noise filters to original data\r\n self.f_WF, self.h_WF = signal.freqz(self.filter_WF, 1, fs=self.fs) #\r\n self.FFT_WF = fft(self.y_WF)\r\n return self.SNR(self.y_WF)\r\n \r\n #Parks McLellan Filtering Method\r\n def PM(self, GA_data, TW =3, BW=5):\r\n # Filter Bands for filtering frequency 1 & 2\r\n f_1 = GA_data[0]\r\n f_2 = GA_data[1]\r\n if len(GA_data) > 2:\r\n TW = GA_data[2]\r\n if len(GA_data) > 3:\r\n BW = GA_data[3]\r\n \r\n band1_PM = [0, f_1 -BW/2-TW, f_1 -BW/2, f_1+BW/2, f_1+BW/2+TW, self.fs/2]\r\n band2_PM = [0, f_2 -BW/2-TW, f_2 -BW/2, f_2+BW/2, f_2+BW/2+TW, self.fs/2]\r\n gain_PM = [1, 0, 1]\r\n \r\n # Create filters for filtering frequency 1 & 2\r\n filter1_PM = signal.remez(self.N_Coeff+1, band1_PM, gain_PM, fs=self.fs) # Filter frequency 1\r\n filter2_PM = signal.remez(self.N_Coeff+1, band2_PM, gain_PM, fs=self.fs) # Filter frequency 2\r\n filter_PM = signal.convolve(filter1_PM, filter2_PM) # Combined Filter\r\n \r\n self.y_PM = signal.lfilter(filter_PM, 1, self.y_0) # Filter original data in time domain\r\n self.f_PM, self.h_PM = signal.freqz(filter_PM, 1, fs=self.fs) # Return filter frequency response\r\n self.FFT_PM = fft(self.y_PM) # Filtered data frequency domain response\r\n return self.SNR(self.y_PM)\r\n \r\n # TODO Frequency Sampling Filtering Method. THIS IS COPIED FROM ASSIGNMENT I.\r\n def FS(self, fs):\r\n trans_FS = 4 # Width of transition from pass band to stop band, Hz\r\n width_FS = 8 # Width of the stop band, Hz\r\n band1_FS = [0, noise_f[0] -width_FS/2-trans_FS, noise_f[0] -width_FS/2, noise_f[0]+width_FS/2, noise_f[0]+width_FS/2+trans_FS, fs/2]\r\n band2_FS = [0, noise_f[1] -width_FS/2-trans_FS, noise_f[1] -width_FS/2, noise_f[1]+width_FS/2, noise_f[1]+width_FS/2+trans_FS, fs/2]\r\n gain_FS = [1, 1, 0, 0, 1, 1] # Gain coefficients of bands\r\n\r\n filter1_FS = signal.firwin2(N_Coeff+1, band1_FS, gain_FS, fs=fs) # Filter for noise frequency 1\r\n filter2_FS = signal.firwin2(N_Coeff+1, band2_FS, gain_FS, fs=fs) # Filter for noise frequency 2\r\n filter_FS = signal.convolve(filter1_FS, filter2_FS) # Filter for both noise frequencies\r\n\r\n y_FS = signal.lfilter(filter_FS, 1, y_0) # Apply filter to time domain data\r\n f_FS, h_FS = signal.freqz(filter_FS, 1, fs=fs) # Filter Response\r\n FFT_FS = fft(y_FS) # Filtered Frequency Domain Response\r\n return 0\r\n \r\n # TODO maybe add IIR filtering method in here but that might be to much. Don't know tho.\r\n def IIR(self, fs):\r\n # The undesired frequencies and desired bandwidth of\r\n freq1 = 31.456\r\n freq2 = 74.36\r\n BW = 5\r\n\r\n deg1 = 2 * np.pi * (freq1 / fs)\r\n deg2 = 2 * np.pi * (freq2 / fs)\r\n r = 1 - (BW / fs) * np.pi\r\n\r\n # Assign the coefficients for first and second filters\r\n a = 1 * 1\r\n b = (1 * -np.exp(-deg1 * 1j)) + (1 * -np.exp(deg1 * 1j))\r\n c = (1 * -np.exp(-deg1 * 1j)) * (1 * -np.exp(deg1 * 1j))\r\n\r\n d = 1 * 1 * 1j\r\n e = (-r * np.exp(-deg1 * 1j)) + (-r * np.exp(deg1 * 1j))\r\n f = (-r * np.exp(-deg1 * 1j)) * (-r * np.exp(deg1 * 1j))\r\n\r\n g = 1 * 1\r\n h = (-1 * np.exp(-deg2 * 1j)) + (-1 * np.exp(deg2 * 1j))\r\n ii = (-1 * np.exp(-deg2 * 1j)) * (-1 * np.exp(deg2 * 1j))\r\n\r\n j = 1 * 1\r\n k = (-r * np.exp(-deg2 * 1j)) + (-r * np.exp(deg2 * 1j))\r\n l = (-r * np.exp(-deg2 * 1j)) * (-r * np.exp(deg2 * 1j))\r\n\r\n # Calculte the gain of the overall transfer function\r\n Wf = 2 * np.pi * 10\r\n ND_array = [np.exp(0), np.exp(np.i * Wf), np.exp(-2 * Wf)]\r\n H_Z1_dot = np.dot(ND_array,[a, b, c])\r\n H_Z2_dot = np.dot(ND_array, [d, e, f])\r\n Gain = abs(H_Z2_dot / H_Z1_dot)\r\n\r\n # convlute the the de/numerator of the first transfer function with de/numerator of the second funcion\r\n NUM_Z = np.array( np.convolve( [a, b, c], [g, h, ii] ) )\r\n DEN_Z = np.array( np.convolve( [d, e, f], [j, k, l] ) )\r\n\r\n w, H = signal.freqz(Gain * NUM_Z, DEN_Z, self.N)\r\n f = fs * w / (2 * np.pi)\r\n return 0\r\n\r\n #Returns a Signal to Noise Ratio for a given input Power\r\n def SNR (self, y):\r\n return self.P_0 - np.var(y)\r\n \r\n # Plots a Fast Fourier Transform for simple graphing\r\n def FFTplot(self, f, FFT, title=\"ECG Signal Frequency Spectrum\"):\r\n plt.figure()\r\n plt.plot(f, abs(FFT)[:self.N_2])\r\n plt.xlabel(\"Frequency (Hz)\")\r\n plt.ylabel(\"Voltage (uV)\")\r\n plt.title(title)\r\n plt.show()\r\n \r\n\r\n#The GA_filter function filters an input waveform \r\ndef GA_filter(waveform, input_num, solutions_per_population, mating_parent_number, num_generations):\r\n \r\n\r\n # Defining the population size.\r\n pop_size = (solutions_per_population,input_num) # The population will have sol_per_pop chromosome where each chromosome has num_weights genes.\r\n #Creating the initial population.\r\n new_population = ga.create_population(pop_size)\r\n \r\n \r\n best_outputs = []\r\n for generation in range(num_generations):\r\n # Measuring the fitness of each chromosome in the population.\r\n fitness = ga.cal_pop_fitness(waveform, new_population)\r\n # The best result in the current iteration.\r\n best_outputs.append(np.max(fitness))\r\n # Selecting the best parents in the population for mating.\r\n parents = ga.select_mating_pool(new_population, fitness, \r\n mating_parent_number)\r\n # Generating next generation using crossover.\r\n offspring_crossover = ga.crossover(parents, offspring_size=(pop_size[0]-parents.shape[0], input_num))\r\n # Adding some variations to the offspring using mutation.\r\n offspring_mutation = ga.mutation(offspring_crossover, num_mutations=2)\r\n # Creating the new population based on the parents and offspring.\r\n new_population[0:parents.shape[0], :] = parents\r\n new_population[parents.shape[0]:, :] = offspring_mutation\r\n \r\n# if (generation < 20):\r\n# print(\"{}\\n {}\\n\\n\".format(new_population, pop_fitness))\r\n if (generation%10 == 0 and generation != 0):\r\n print(\"{} Generations Completed\".format(generation))\r\n \r\n \r\n # Getting the best solution after iterating finishing all generations.\r\n #At first, the fitness is calculated for each solution in the final generation.\r\n fitness = ga.cal_pop_fitness(waveform, new_population)\r\n # Then return the index of that solution corresponding to the best fitness.\r\n best_match_idx = np.where(fitness == np.max(fitness))[0]\r\n return new_population[best_match_idx, :], fitness[best_match_idx][0][0], best_outputs\r\n \r\n\r\n# Implementation of a Parks-McLellan Filter using Genetic Algorithms\r\ndef main():\r\n waveform = DSP_Signal(\"Signal_files/ECG15.txt\")\r\n \r\n # Fixed Parameters, found by trial and error s\r\n f_count = 2\r\n mating_parent_number = 3\r\n pop_size = 20\r\n num_generations = 10\r\n my_dpi = 200 #dots per inch (resolution of an image)\r\n \r\n # Conduct a Genetic Algorithm approximation\r\n best_soln, best_soln_fitness, best_outputs = GA_filter(waveform, \r\n f_count, pop_size, \r\n mating_parent_number, num_generations) \r\n print(\"Best solution : \\n\", best_soln)\r\n print(\"Best solution fitness : \\n\", best_soln_fitness)\r\n plt.figure(1)\r\n plt.plot(best_outputs, \"-k\", label=\"Fittest Output\")\r\n plt.title(\"Fitness of ECG Signal using GA Algorithm\")\r\n plt.xlabel(\"Number of Iterations\")\r\n plt.ylabel(\"Fitness (Signal to Noise Ratio)\")\r\n plt.legend(loc=\"upper right\")\r\n plt.grid()\r\n plt.show()\r\n # plt.savefig('wiki/{}Gen{}Pop.png'.format(num_generations, pop_size))\r\n\r\n plt.figure(2, figsize=(10, 10), dpi=my_dpi)\r\n plt.plot(best_outputs, \"-g\", label=\"IIR Filter\")\r\n plt.title(\"IIR Filter\")\r\n plt.xlabel(\"Frequency (Hz)\")\r\n plt.ylabel(\"Magnitude (uV)\")\r\n plt.legend(loc=\"upper right\")\r\n plt.grid()\r\n plt.savefig('wiki/IIR_magnitude.png', dpi = my_dpi)\r\n plt.show()\r\n \r\n waveform.FFTplot(waveform.f, waveform.FFT_0, title=\"Before filtering\")\r\n waveform.PM(best_soln[0])\r\n waveform.FFTplot(waveform.f, waveform.FFT_PM, title=\"After Filtering\")\r\n \r\nmain()\r\n\r\n",
"\"\"\"\r\nGenetic Algorithms for Digital Signal Processing\r\nCreated on Mon Oct 05 20:01:05 2020\r\nLast Edited on Mon Oct 12 2020 by Luke Trenberth\r\n\"\"\"\r\nimport numpy as np\r\nfrom scipy import signal\r\nfrom scipy.fftpack import fft\r\nimport matplotlib.pyplot as plt\r\nimport DSP_GA as ga\r\n\r\nclass DSP_Signal():\r\n def __init__(self, filename, fs=1024, N_Coeff=400):\r\n file = open(filename, \"r\")\r\n self.y_0 = []\r\n for line in file:\r\n words = line.split(\" \")\r\n for word in words:\r\n if word != \"\":\r\n self.y_0.append(float(word))\r\n self.fs = fs\r\n self.N = len(self.y_0)\r\n self.N_2 = int(self.N/2)\r\n self.t = [x/self.fs for x in list(range(0, self.N))]\r\n self.f = [x*self.fs/self.N for x in list(range(0, self.N_2))]\r\n self.P_0 = np.var(self.y_0)\r\n self.FFT_0 = fft(self.y_0)\r\n \r\n self.N_Coeff = N_Coeff # Number of coefficients\r\n \r\n #Window Filtering method for the data class\r\n def WF(self, GA_data):\r\n #GA Data: [noise_f_1, noise_f_2, width]\r\n \r\n # Window Filtering\r\n self.width_WF = 8 # Width of stop band, Hz\r\n self.band_1 = [GA_data[0] -GA_data[2]/2, GA_data[0]+GA_data[2]/2] # Define band 1 bounds\r\n self.band_2 = [GA_data[1] -GA_data[2]/2, GA_data[1]+GA_data[2]/2] # Define band 2 bounds\r\n \r\n self.filter1_WF = signal.firwin(self.N_Coeff+1, self.band_1, window='hann', pass_zero='bandstop', fs=self.fs) # Filter for noise frequency 1\r\n self.filter2_WF = signal.firwin(self.N_Coeff+1, self.band_2, window='hann', pass_zero='bandstop', fs=self.fs) # Filter for noise frequency 2\r\n self.filter_WF = signal.convolve(self.filter1_WF, self.filter2_WF) # Combined filter for noise frequencies\r\n self.y_WF = signal.lfilter(self.filter_WF, 1, self.y_0) # Apply noise filters to original data\r\n self.f_WF, self.h_WF = signal.freqz(self.filter_WF, 1, fs=self.fs) #\r\n self.FFT_WF = fft(self.y_WF)\r\n return self.SNR(self.y_WF)\r\n \r\n #Parks McLellan Filtering Method\r\n def PM(self, GA_data, TW =3, BW=5):\r\n # Filter Bands for filtering frequency 1 & 2\r\n f_1 = GA_data[0]\r\n f_2 = GA_data[1]\r\n if len(GA_data) > 2:\r\n TW = GA_data[2]\r\n if len(GA_data) > 3:\r\n BW = GA_data[3]\r\n \r\n band1_PM = [0, f_1 -BW/2-TW, f_1 -BW/2, f_1+BW/2, f_1+BW/2+TW, self.fs/2]\r\n band2_PM = [0, f_2 -BW/2-TW, f_2 -BW/2, f_2+BW/2, f_2+BW/2+TW, self.fs/2]\r\n gain_PM = [1, 0, 1]\r\n \r\n # Create filters for filtering frequency 1 & 2\r\n filter1_PM = signal.remez(self.N_Coeff+1, band1_PM, gain_PM, fs=self.fs) # Filter frequency 1\r\n filter2_PM = signal.remez(self.N_Coeff+1, band2_PM, gain_PM, fs=self.fs) # Filter frequency 2\r\n filter_PM = signal.convolve(filter1_PM, filter2_PM) # Combined Filter\r\n \r\n self.y_PM = signal.lfilter(filter_PM, 1, self.y_0) # Filter original data in time domain\r\n self.f_PM, self.h_PM = signal.freqz(filter_PM, 1, fs=self.fs) # Return filter frequency response\r\n self.FFT_PM = fft(self.y_PM) # Filtered data frequency domain response\r\n return self.SNR(self.y_PM)\r\n \r\n\r\n #Returns a Signal to Noise Ratio for a given input Power\r\n def SNR (self, y):\r\n return self.P_0 - np.var(y)\r\n \r\n \r\n # Plots a Fast Fourier Transform for simple graphing\r\n def FFTplot(self, f, FFT, title=\"ECG Signal Frequency Spectrum\"):\r\n plt.figure()\r\n plt.plot(f, abs(FFT)[:self.N_2])\r\n plt.xlabel(\"Frequency (Hz)\")\r\n plt.ylabel(\"Voltage (uV)\")\r\n plt.title(title)\r\n plt.show()\r\n \r\n \r\n\r\n\r\n\r\n\r\n#The GA_filter function filters an input waveform \r\ndef GA_filter(waveform, input_num, solutions_per_population, mating_parent_number, num_generations):\r\n \r\n\r\n # Defining the population size.\r\n pop_size = (solutions_per_population,input_num) # The population will have sol_per_pop chromosome where each chromosome has num_weights genes.\r\n #Creating the initial population.\r\n new_population = ga.create_population(pop_size)\r\n \r\n \r\n best_outputs = []\r\n for generation in range(num_generations):\r\n # Measuring the fitness of each chromosome in the population.\r\n fitness = ga.cal_pop_fitness(waveform, new_population)\r\n # The best result in the current iteration.\r\n best_outputs.append(np.max(fitness))\r\n # Selecting the best parents in the population for mating.\r\n parents = ga.select_mating_pool(new_population, fitness, \r\n mating_parent_number)\r\n # Generating next generation using crossover.\r\n offspring_crossover = ga.crossover(parents, offspring_size=(pop_size[0]-parents.shape[0], input_num))\r\n # Adding some variations to the offspring using mutation.\r\n offspring_mutation = ga.mutation(offspring_crossover, num_mutations=2)\r\n # Creating the new population based on the parents and offspring.\r\n new_population[0:parents.shape[0], :] = parents\r\n new_population[parents.shape[0]:, :] = offspring_mutation\r\n \r\n# if (generation < 20):\r\n# print(\"{}\\n {}\\n\\n\".format(new_population, pop_fitness))\r\n if (generation%10 == 0 and generation != 0):\r\n print(\"{} Generations Completed\".format(generation))\r\n \r\n \r\n # Getting the best solution after iterating finishing all generations.\r\n #At first, the fitness is calculated for each solution in the final generation.\r\n fitness = ga.cal_pop_fitness(waveform, new_population)\r\n # Then return the index of that solution corresponding to the best fitness.\r\n best_match_idx = np.where(fitness == np.max(fitness))[0]\r\n return new_population[best_match_idx, :], fitness[best_match_idx][0][0], best_outputs\r\n \r\n\r\n# Implementation of a Parks-McLellan Filter using Genetic Algorithms\r\ndef main():\r\n waveform = DSP_Signal(\"Signal_files/enel420_grp_15.txt\")\r\n \r\n # Fixed Parameters, found by trial and error s\r\n f_count = 2\r\n mating_parent_number = 3\r\n pop_size = 10\r\n num_generations = 1000\r\n \r\n # Conduct a Genetic Algorithm approximation\r\n best_soln, best_soln_fitness, best_outputs = GA_filter(waveform, \r\n f_count, pop_size, \r\n mating_parent_number, num_generations) \r\n print(\"Best solution : \\n\", best_soln)\r\n print(\"Best solution fitness : \\n\", best_soln_fitness)\r\n plt.figure()\r\n plt.plot(best_outputs)\r\n plt.ti\r\n plt.xlabel(\"Number of Iterations\")\r\n plt.ylabel(\"Fitness (Signal to Noise Ratio)\")\r\n plt.grid()\r\n plt.show()\r\n\r\n waveform.FFTplot(waveform.f, waveform.FFT_0, title=\"Before filtering\")\r\n waveform.PM(best_soln[0])\r\n waveform.FFTplot(waveform.f, waveform.FFT_PM, title=\"After Filtering\")\r\n \r\nmain()\r\n\r\n",
"\"\"\"\r\nGenetic Algorithms for Digital Signal Processing\r\nCreated on Mon Oct 05 20:01:05 2020\r\nLast Edited on Mon Oct 12 2020 by Luke Trenberth\r\nTODO tidy up this code and to finalise it. Add up the third FIR filter method in here too.\r\n\"\"\"\r\nfrom os import major\r\nimport numpy as np\r\nimport matplotlib\r\nfrom scipy import signal\r\nfrom scipy.fftpack import fft\r\nimport matplotlib.pyplot as plt\r\nimport DSP_GA as ga\r\n\r\nclass DSP_Signal():\r\n def __init__(self, filename, fs=1024, N_Coeff=400):\r\n file = open(filename, \"r\")\r\n self.y_0 = []\r\n for line in file:\r\n words = line.split(\" \")\r\n for word in words:\r\n if word != \"\":\r\n self.y_0.append(float(word))\r\n self.fs = fs\r\n self.N = len(self.y_0)\r\n self.N_2 = int(self.N/2)\r\n self.t = [x/self.fs for x in list(range(0, self.N))]\r\n self.f = [x*self.fs/self.N for x in list(range(0, self.N_2))]\r\n self.P_0 = np.var(self.y_0)\r\n self.FFT_0 = fft(self.y_0)\r\n \r\n self.N_Coeff = N_Coeff # Number of coefficients\r\n \r\n #Window Filtering method for the data class\r\n def WF(self, GA_data):\r\n #GA Data: [noise_f_1, noise_f_2, width]\r\n \r\n # Window Filtering\r\n self.width_WF = 8 # Width of stop band, Hz\r\n self.band_1 = [GA_data[0] -GA_data[2]/2, GA_data[0]+GA_data[2]/2] # Define band 1 bounds\r\n self.band_2 = [GA_data[1] -GA_data[2]/2, GA_data[1]+GA_data[2]/2] # Define band 2 bounds\r\n \r\n self.filter1_WF = signal.firwin(self.N_Coeff+1, self.band_1, window='hann', pass_zero='bandstop', fs=self.fs) # Filter for noise frequency 1\r\n self.filter2_WF = signal.firwin(self.N_Coeff+1, self.band_2, window='hann', pass_zero='bandstop', fs=self.fs) # Filter for noise frequency 2\r\n self.filter_WF = signal.convolve(self.filter1_WF, self.filter2_WF) # Combined filter for noise frequencies\r\n self.y_WF = signal.lfilter(self.filter_WF, 1, self.y_0) # Apply noise filters to original data\r\n self.f_WF, self.h_WF = signal.freqz(self.filter_WF, 1, fs=self.fs) #\r\n self.FFT_WF = fft(self.y_WF)\r\n return self.SNR(self.y_WF)\r\n \r\n #Parks McLellan Filtering Method\r\n def PM(self, GA_data, TW =3, BW=5):\r\n # Filter Bands for filtering frequency 1 & 2\r\n f_1 = GA_data[0]\r\n f_2 = GA_data[1]\r\n if len(GA_data) > 2:\r\n TW = GA_data[2]\r\n if len(GA_data) > 3:\r\n BW = GA_data[3]\r\n \r\n band1_PM = [0, f_1 -BW/2-TW, f_1 -BW/2, f_1+BW/2, f_1+BW/2+TW, self.fs/2]\r\n band2_PM = [0, f_2 -BW/2-TW, f_2 -BW/2, f_2+BW/2, f_2+BW/2+TW, self.fs/2]\r\n gain_PM = [1, 0, 1]\r\n \r\n # Create filters for filtering frequency 1 & 2\r\n filter1_PM = signal.remez(self.N_Coeff+1, band1_PM, gain_PM, fs=self.fs) # Filter frequency 1\r\n filter2_PM = signal.remez(self.N_Coeff+1, band2_PM, gain_PM, fs=self.fs) # Filter frequency 2\r\n filter_PM = signal.convolve(filter1_PM, filter2_PM) # Combined Filter\r\n \r\n self.y_PM = signal.lfilter(filter_PM, 1, self.y_0) # Filter original data in time domain\r\n self.f_PM, self.h_PM = signal.freqz(filter_PM, 1, fs=self.fs) # Return filter frequency response\r\n self.FFT_PM = fft(self.y_PM) # Filtered data frequency domain response\r\n return self.SNR(self.y_PM)\r\n \r\n # TODO Frequency Sampling Filtering Method. THIS IS COPIED FROM ASSIGNMENT I.\r\n def FS(self, fs):\r\n trans_FS = 4 # Width of transition from pass band to stop band, Hz\r\n width_FS = 8 # Width of the stop band, Hz\r\n band1_FS = [0, noise_f[0] -width_FS/2-trans_FS, noise_f[0] -width_FS/2, noise_f[0]+width_FS/2, noise_f[0]+width_FS/2+trans_FS, fs/2]\r\n band2_FS = [0, noise_f[1] -width_FS/2-trans_FS, noise_f[1] -width_FS/2, noise_f[1]+width_FS/2, noise_f[1]+width_FS/2+trans_FS, fs/2]\r\n gain_FS = [1, 1, 0, 0, 1, 1] # Gain coefficients of bands\r\n\r\n filter1_FS = signal.firwin2(N_Coeff+1, band1_FS, gain_FS, fs=fs) # Filter for noise frequency 1\r\n filter2_FS = signal.firwin2(N_Coeff+1, band2_FS, gain_FS, fs=fs) # Filter for noise frequency 2\r\n filter_FS = signal.convolve(filter1_FS, filter2_FS) # Filter for both noise frequencies\r\n\r\n y_FS = signal.lfilter(filter_FS, 1, y_0) # Apply filter to time domain data\r\n f_FS, h_FS = signal.freqz(filter_FS, 1, fs=fs) # Filter Response\r\n FFT_FS = fft(y_FS) # Filtered Frequency Domain Response\r\n return 0\r\n \r\n # TODO maybe add IIR filtering method in here but that might be to much. Don't know tho.\r\n def IIR(self, fs):\r\n # The undesired frequencies and desired bandwidth of\r\n freq1 = 31.456\r\n freq2 = 74.36\r\n BW = 5\r\n\r\n deg1 = 2 * np.pi * (freq1 / fs)\r\n deg2 = 2 * np.pi * (freq2 / fs)\r\n r = 1 - (BW / fs) * np.pi\r\n\r\n # Assign the coefficients for first and second filters\r\n a = 1 * 1\r\n b = (1 * -np.exp(-deg1 * 1j)) + (1 * -np.exp(deg1 * 1j))\r\n c = (1 * -np.exp(-deg1 * 1j)) * (1 * -np.exp(deg1 * 1j))\r\n\r\n d = 1 * 1 * 1j\r\n e = (-r * np.exp(-deg1 * 1j)) + (-r * np.exp(deg1 * 1j))\r\n f = (-r * np.exp(-deg1 * 1j)) * (-r * np.exp(deg1 * 1j))\r\n\r\n g = 1 * 1\r\n h = (-1 * np.exp(-deg2 * 1j)) + (-1 * np.exp(deg2 * 1j))\r\n ii = (-1 * np.exp(-deg2 * 1j)) * (-1 * np.exp(deg2 * 1j))\r\n\r\n j = 1 * 1\r\n k = (-r * np.exp(-deg2 * 1j)) + (-r * np.exp(deg2 * 1j))\r\n l = (-r * np.exp(-deg2 * 1j)) * (-r * np.exp(deg2 * 1j))\r\n\r\n # Calculte the gain of the overall transfer function\r\n Wf = 2 * np.pi * 10\r\n ND_array = [np.exp(0), np.exp(np.i * Wf), np.exp(-2 * Wf)]\r\n H_Z1_dot = np.dot(ND_array,[a, b, c])\r\n H_Z2_dot = np.dot(ND_array, [d, e, f])\r\n Gain = abs(H_Z2_dot / H_Z1_dot)\r\n\r\n # convlute the the de/numerator of the first transfer function with de/numerator of the second funcion\r\n NUM_Z = np.array( np.convolve( [a, b, c], [g, h, ii] ) )\r\n DEN_Z = np.array( np.convolve( [d, e, f], [j, k, l] ) )\r\n\r\n w, H = signal.freqz(Gain * NUM_Z, DEN_Z, self.N)\r\n f = fs * w / (2 * np.pi)\r\n return 0\r\n\r\n #Returns a Signal to Noise Ratio for a given input Power\r\n def SNR (self, y):\r\n return self.P_0 - np.var(y)\r\n \r\n # Plots a Fast Fourier Transform for simple graphing\r\n def FFTplot(self, f, FFT, title=\"ECG Signal Frequency Spectrum\"):\r\n plt.figure()\r\n plt.plot(f, abs(FFT)[:self.N_2])\r\n plt.xlabel(\"Frequency (Hz)\")\r\n plt.ylabel(\"Voltage (uV)\")\r\n plt.title(title)\r\n plt.show()\r\n \r\n\r\n#The GA_filter function filters an input waveform \r\ndef GA_filter(waveform, input_num, solutions_per_population, mating_parent_number, num_generations):\r\n \r\n\r\n # Defining the population size.\r\n pop_size = (solutions_per_population,input_num) # The population will have sol_per_pop chromosome where each chromosome has num_weights genes.\r\n #Creating the initial population.\r\n new_population = ga.create_population(pop_size)\r\n \r\n \r\n best_outputs = []\r\n for generation in range(num_generations):\r\n # Measuring the fitness of each chromosome in the population.\r\n fitness = ga.cal_pop_fitness(waveform, new_population)\r\n # The best result in the current iteration.\r\n best_outputs.append(np.max(fitness))\r\n # Selecting the best parents in the population for mating.\r\n parents = ga.select_mating_pool(new_population, fitness, \r\n mating_parent_number)\r\n # Generating next generation using crossover.\r\n offspring_crossover = ga.crossover(parents, offspring_size=(pop_size[0]-parents.shape[0], input_num))\r\n # Adding some variations to the offspring using mutation.\r\n offspring_mutation = ga.mutation(offspring_crossover, num_mutations=2)\r\n # Creating the new population based on the parents and offspring.\r\n new_population[0:parents.shape[0], :] = parents\r\n new_population[parents.shape[0]:, :] = offspring_mutation\r\n \r\n# if (generation < 20):\r\n# print(\"{}\\n {}\\n\\n\".format(new_population, pop_fitness))\r\n if (generation%10 == 0 and generation != 0):\r\n print(\"{} Generations Completed\".format(generation))\r\n \r\n \r\n # Getting the best solution after iterating finishing all generations.\r\n #At first, the fitness is calculated for each solution in the final generation.\r\n fitness = ga.cal_pop_fitness(waveform, new_population)\r\n # Then return the index of that solution corresponding to the best fitness.\r\n best_match_idx = np.where(fitness == np.max(fitness))[0]\r\n return new_population[best_match_idx, :], fitness[best_match_idx][0][0], best_outputs\r\n \r\n\r\n# Implementation of a Parks-McLellan Filter using Genetic Algorithms\r\ndef main():\r\n waveform = DSP_Signal(\"Signal_files/ECG15.txt\")\r\n \r\n # Fixed Parameters, found by trial and error s\r\n f_count = 2\r\n mating_parent_number = 3\r\n pop_size = 20\r\n num_generations = 10\r\n \r\n # Conduct a Genetic Algorithm approximation\r\n best_soln, best_soln_fitness, best_outputs = GA_filter(waveform, \r\n f_count, pop_size, \r\n mating_parent_number, num_generations) \r\n print(\"Best solution : \\n\", best_soln)\r\n print(\"Best solution fitness : \\n\", best_soln_fitness)\r\n plt.figure(1)\r\n plt.plot(best_outputs, \"-k\", label=\"Fittest Output\")\r\n plt.title(\"Fitness of ECG Signal using GA Algorithm\")\r\n plt.xlabel(\"Number of Iterations\")\r\n plt.ylabel(\"Fitness (Signal to Noise Ratio)\")\r\n plt.legend(loc=\"upper right\")\r\n plt.grid()\r\n plt.show()\r\n\r\n plt.figure(2)\r\n plt.plot(best_outputs, \"-g\", label=\"IIR Filter\")\r\n plt.title(\"IIR Filter\")\r\n plt.xlabel(\"Number of Iterations\")\r\n plt.ylabel(\"Fitness (Signal to Noise Ratio)\")\r\n plt.legend(loc=\"upper right\")\r\n plt.grid()\r\n plt.show()\r\n\r\n waveform.FFTplot(waveform.f, waveform.FFT_0, title=\"Before filtering\")\r\n waveform.PM(best_soln[0])\r\n waveform.FFTplot(waveform.f, waveform.FFT_PM, title=\"After Filtering\")\r\n \r\nmain()\r\n\r\n"
] |
[
[
"numpy.max",
"scipy.signal.firwin",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.grid",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.title",
"matplotlib.pyplot.legend",
"scipy.signal.remez",
"matplotlib.pyplot.figure",
"scipy.fftpack.fft",
"scipy.signal.lfilter",
"matplotlib.pyplot.ylabel",
"scipy.signal.freqz",
"matplotlib.pyplot.show",
"numpy.var",
"scipy.signal.convolve"
],
[
"scipy.signal.firwin",
"numpy.dot",
"numpy.exp",
"scipy.signal.lfilter",
"scipy.signal.convolve",
"numpy.max",
"matplotlib.pyplot.savefig",
"scipy.fftpack.fft",
"numpy.convolve",
"scipy.signal.remez",
"matplotlib.pyplot.title",
"scipy.signal.firwin2",
"matplotlib.pyplot.figure",
"scipy.signal.freqz",
"matplotlib.pyplot.show",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.grid",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.legend",
"matplotlib.pyplot.ylabel",
"numpy.var"
],
[
"numpy.max",
"scipy.signal.firwin",
"matplotlib.pyplot.grid",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.plot",
"scipy.signal.remez",
"matplotlib.pyplot.title",
"matplotlib.pyplot.figure",
"scipy.fftpack.fft",
"scipy.signal.lfilter",
"matplotlib.pyplot.ylabel",
"scipy.signal.freqz",
"matplotlib.pyplot.show",
"numpy.var",
"scipy.signal.convolve"
],
[
"scipy.signal.firwin",
"numpy.dot",
"numpy.exp",
"scipy.signal.lfilter",
"scipy.signal.convolve",
"numpy.max",
"scipy.fftpack.fft",
"numpy.convolve",
"scipy.signal.remez",
"matplotlib.pyplot.title",
"scipy.signal.firwin2",
"matplotlib.pyplot.figure",
"scipy.signal.freqz",
"matplotlib.pyplot.show",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.grid",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.legend",
"matplotlib.pyplot.ylabel",
"numpy.var"
]
] |
kernelmachine/quality-filter
|
[
"a462657a0ae1cc04b38cea73cba58de1e79a9a42"
] |
[
"lr/hyperparameters.py"
] |
[
"from typing import Any, Dict, List, Union\nimport numpy as np\nimport logging\nimport os\n\n# Create a custom logger\nlogger = logging.getLogger(__name__)\nlogger.setLevel(logging.DEBUG)\n\n\n\nclass RandomSearch:\n\n @staticmethod\n def random_choice(args: List[Any], n: int = 1):\n \"\"\"\n pick a random element from a set.\n \n Example:\n >> sampler = RandomSearch.random_choice(1,2,3)\n >> sampler()\n 2\n \"\"\"\n choices = []\n for arg in args:\n choices.append(arg)\n if n == 1:\n return lambda: np.random.choice(choices, replace=False)\n else:\n return lambda: np.random.choice(choices, n, replace=False)\n\n @staticmethod\n def random_integer(low: Union[int, float], high: Union[int, float]):\n \"\"\"\n pick a random integer between two bounds\n \n Example:\n >> sampler = RandomSearch.random_integer(1, 10)\n >> sampler()\n 9\n \"\"\"\n return lambda: int(np.random.randint(low, high))\n\n @staticmethod\n def random_loguniform(low: Union[float, int], high: Union[float, int]):\n \"\"\"\n pick a random float between two bounds, using loguniform distribution\n \n Example:\n >> sampler = RandomSearch.random_loguniform(1e-5, 1e-2)\n >> sampler()\n 0.0004\n \"\"\"\n return lambda: np.exp(np.random.uniform(np.log(low), np.log(high)))\n\n @staticmethod\n def random_uniform(low: Union[float, int], high: Union[float, int]):\n \"\"\"\n pick a random float between two bounds, using uniform distribution\n \n Example:\n >> sampler = RandomSearch.random_uniform(0, 1)\n >> sampler()\n 0.01\n \"\"\"\n return lambda: np.random.uniform(low, high)\n\n\nclass HyperparameterSearch:\n\n def __init__(self, **kwargs):\n self.search_space = {}\n self.lambda_ = lambda: 0\n for key, val in kwargs.items():\n self.search_space[key] = val\n\n def parse(self, val: Any):\n \n if isinstance(val, (int, np.int)):\n return int(val)\n elif isinstance(val, (float, np.float)):\n return val\n elif isinstance(val, (np.ndarray, list)):\n return \" \".join(val)\n elif val is None:\n return None\n if isinstance(val, str):\n return val\n else:\n val = val()\n if isinstance(val, (int, np.int)):\n return int(val)\n elif isinstance(val, (np.ndarray, list)):\n return \" \".join(val)\n else:\n return val\n\n\n def sample(self) -> Dict:\n res = {}\n for key, val in self.search_space.items():\n try:\n res[key] = self.parse(val)\n except (TypeError, ValueError) as error:\n logger.error(f\"Could not parse key {key} with value {val}. {error}\")\n\n return res\n\n def update_environment(self, sample) -> None:\n for key, val in sample.items():\n os.environ[key] = str(val)\n\n\nSEARCH_SPACE = {\n \"penalty\": RandomSearch.random_choice([\"l1\", \"l2\"]),\n \"C\": RandomSearch.random_uniform(0, 1),\n \"solver\": \"liblinear\",\n \"multi_class\": \"auto\",\n \"tol\": RandomSearch.random_loguniform(10e-5, 10e-3),\n \"stopwords\": RandomSearch.random_choice([0, 1]),\n \"weight\": RandomSearch.random_choice([\"hash\"]),\n \"ngram_range\": RandomSearch.random_choice([\"1 2\", \"2 3\", \"1 3\"]),\n \"random_state\": RandomSearch.random_integer(0, 100000)\n}\nBEST_HPS = {\n \"penalty\": \"l1\",\n \"C\": 0.977778,\n \"multi_class\": \"auto\",\n \"solver\": \"liblinear\",\n \"tol\": 0.000816,\n \"ngram_range\": \"1 2\",\n \"random_state\": 44555,\n \"weight\": \"hash\",\n \"stopwords\": None\n}"
] |
[
[
"numpy.random.randint",
"numpy.random.uniform",
"numpy.random.choice",
"numpy.log"
]
] |
SpikeyCNS/spikey
|
[
"03a49073491974eff01bc017fd8eadb822e13f0d"
] |
[
"unit_tests/test_input.py"
] |
[
"\"\"\"\nTests for snn.Input.\n\"\"\"\nimport unittest\nfrom unittest import mock\nfrom unit_tests import ModuleTest\nimport numpy as np\nfrom spikey.snn import input\n\n\nN_STATES = 10\nPROCESSING_TIME = 100\n\nstate_rate_map = np.arange(N_STATES) / N_STATES\nstate_spike_map = np.random.uniform(\n (N_STATES, PROCESSING_TIME)\n) <= state_rate_map.reshape((-1, 1))\n\n\ndef get_values(state):\n return np.zeros(shape=len(state))\n\n\nclass TestInput(unittest.TestCase, ModuleTest):\n \"\"\"\n Tests for snn.Input.\n \"\"\"\n\n TYPES = [input.RateMap, input.StaticMap]\n BASE_CONFIG = {\n \"n_inputs\": 2,\n \"magnitude\": 1,\n \"input_firing_steps\": -1,\n \"input_pct_inhibitory\": 0,\n \"state_rate_map\": state_rate_map,\n \"state_spike_map\": state_spike_map,\n }\n\n @ModuleTest.run_all_types\n def test_len(self):\n for n_inputs in [1, 100]:\n inputs = self.get_obj(n_inputs=n_inputs)\n self.assertEqual(len(inputs), n_inputs)\n\n @ModuleTest.run_all_types\n def test_polarity(self):\n inputs = self.get_obj()\n inputs.reset()\n self.assertTrue(hasattr(inputs, \"polarities\"))\n self.assertIsInstance(inputs.polarities, np.ndarray)\n\n inputs.polarities = type(\n \"polarity\", (object,), {\"__rmul__\": mock.Mock(return_value=0)}\n )()\n inputs.update(5)\n spikes = inputs()\n inputs.polarities.__rmul__.assert_called()\n\n @ModuleTest.run_all_types\n def test_update(self):\n inputs = self.get_obj()\n inputs.reset()\n\n inputs.update(2)\n inputs.update((0,))\n inputs.update(np.array([1]))\n\n @ModuleTest.run_all_types\n def test_loop(self):\n inputs = self.get_obj()\n inputs.reset()\n\n for state in range(3):\n inputs.update(state)\n self.assertEqual(inputs.network_time, 0)\n\n for time in range(PROCESSING_TIME):\n spikes = inputs()\n self.assertEqual(inputs.network_time, time + 1)\n self.assertIsInstance(spikes, np.ndarray)\n\n\nif __name__ == \"__main__\":\n unittest.main()\n"
] |
[
[
"numpy.array",
"numpy.random.uniform",
"numpy.arange"
]
] |
duennbart/masterthesis_VAE
|
[
"1a161bc5c234acc0a021d84cde8cd69e784174e1"
] |
[
"general/utilTF1/dataset.py"
] |
[
"from __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport multiprocessing\nfrom functools import partial\nimport tensorflow as tf\nimport tensorflow.contrib.eager as tfe\n\nfrom general.utilTF1.utils import session\nfrom general.kneeOsteoarthritisDataset.KneeOsteoarthritsDataset import KneeOsteoarthritsDataset\n\n_N_CPU = multiprocessing.cpu_count()\n\n\ndef batch_dataset(dataset, batch_size, prefetch_batch=_N_CPU + 1, drop_remainder=True, filter=None,\n map_func=None, num_threads=_N_CPU, shuffle=True, buffer_size=4096, repeat=-1):\n if filter:\n dataset = dataset.filter(filter)\n\n if map_func:\n dataset = dataset.map(map_func, num_parallel_calls=num_threads)\n\n if shuffle:\n dataset = dataset.shuffle(buffer_size)\n\n if drop_remainder:\n dataset = dataset.apply(tf.contrib.data.batch_and_drop_remainder(batch_size))\n else:\n dataset = dataset.batch(batch_size)\n\n dataset = dataset.repeat(repeat).prefetch(prefetch_batch)\n\n return dataset\n\n\nclass Dataset(object):\n\n def __init__(self):\n self._dataset = None\n self._iterator = None\n self._batch_op = None\n self._sess = None\n\n self._is_eager = tf.executing_eagerly()\n self._eager_iterator = None\n\n def __del__(self):\n if self._sess:\n self._sess.close()\n\n def __iter__(self):\n return self\n\n def __next__(self):\n try:\n b = self.get_next()\n except:\n raise StopIteration\n else:\n return b\n\n next = __next__\n\n def get_next(self):\n if self._is_eager:\n return self._eager_iterator.get_next()\n else:\n return self._sess.run(self._batch_op)\n\n def reset(self, feed_dict={}):\n if self._is_eager:\n self._eager_iterator = tfe.Iterator(self._dataset)\n else:\n self._sess.run(self._iterator.initializer, feed_dict=feed_dict)\n\n def _bulid(self, dataset, sess=None):\n self._dataset = dataset\n\n if self._is_eager:\n self._eager_iterator = tfe.Iterator(dataset)\n else:\n self._iterator = dataset.make_initializable_iterator()\n self._batch_op = self._iterator.get_next()\n if sess:\n self._sess = sess\n else:\n self._sess = session()\n\n try:\n self.reset()\n except:\n pass\n\n @property\n def dataset(self):\n return self._dataset\n\n @property\n def iterator(self):\n return self._iterator\n\n @property\n def batch_op(self):\n return self._batch_op\n\ndef get_dataset(data_set_path,shuffle=True):\n # shape\n img_shape = [256,256, 1]\n # dataset\n def _map_func(img,label):\n img = tf.image.resize_images(img, [img_shape[0], img_shape[1]], method=tf.image.ResizeMethod.BICUBIC)\n img = tf.clip_by_value(tf.cast(img, tf.float32), 0, 255) / 255 # / 127.5 - 1\n\n return img,label\n\n # get image pathes\n #\n kneeosteo_train = KneeOsteoarthritsDataset(data_path=data_set_path)\n\n labels = list(kneeosteo_train.dict_url_class.values())\n paths = list(kneeosteo_train.dict_url_class.keys())\n assert (len(paths) == len(labels))\n print('The dataset %s has %f elements. ' % (data_set_path, len(labels)))\n\n Dataset = partial(DiskImageData, img_paths=paths,labels=labels, repeat=1, map_func=_map_func,shuffle=shuffle)\n\n\n\n # index func\n def get_imgs(batch):\n return batch\n\n return Dataset, img_shape, get_imgs\n\ndef disk_image_batch_dataset(img_paths, batch_size, labels=None, prefetch_batch=_N_CPU + 1, drop_remainder=True, filter=None,\n map_func=None, num_threads=_N_CPU, shuffle=True, buffer_size=4096, repeat=-1):\n \"\"\"Disk image batch dataset.\n\n This function is suitable for jpg and png files\n\n Arguments:\n img_paths : String list or 1-D tensor, each of which is an iamge path\n labels : Label list/tuple_of_list or tensor/tuple_of_tensor, each of which is a corresponding label\n \"\"\"\n if labels is None:\n dataset = tf.data.Dataset.from_tensor_slices(img_paths)\n elif isinstance(labels, tuple):\n dataset = tf.data.Dataset.from_tensor_slices((img_paths,) + tuple(labels))\n else:\n dataset = tf.data.Dataset.from_tensor_slices((img_paths, labels))\n\n def parse_func(path, *label):\n img = tf.read_file(path)\n img = tf.image.decode_png(img, 1)\n return (img,) + label\n\n if map_func:\n def map_func_(*args):\n return map_func(*parse_func(*args))\n else:\n map_func_ = parse_func\n\n # dataset = dataset.map(parse_func, num_parallel_calls=num_threads) is slower\n\n dataset = batch_dataset(dataset, batch_size, prefetch_batch, drop_remainder, filter,\n map_func_, num_threads, shuffle, buffer_size, repeat)\n\n return dataset\n\n\nclass DiskImageData(Dataset):\n \"\"\"DiskImageData.\n\n This class is suitable for jpg and png files\n\n Arguments:\n img_paths : String list or 1-D tensor, each of which is an iamge path\n labels : Label list or tensor, each of which is a corresponding label\n \"\"\"\n\n def __init__(self, img_paths, batch_size, labels=None, prefetch_batch=_N_CPU + 1, drop_remainder=True, filter=None,\n map_func=None, num_threads=_N_CPU, shuffle=True, buffer_size=4096, repeat=-1, sess=None):\n super(DiskImageData, self).__init__()\n dataset = disk_image_batch_dataset(img_paths, batch_size, labels, prefetch_batch, drop_remainder, filter,\n map_func, num_threads, shuffle, buffer_size, repeat)\n self._bulid(dataset, sess)\n self._n_data = len(img_paths)\n\n def __len__(self):\n return self._n_data\n"
] |
[
[
"tensorflow.data.Dataset.from_tensor_slices",
"tensorflow.read_file",
"tensorflow.executing_eagerly",
"tensorflow.image.decode_png",
"tensorflow.contrib.eager.Iterator",
"tensorflow.contrib.data.batch_and_drop_remainder",
"tensorflow.image.resize_images",
"tensorflow.cast"
]
] |
caiovini/Image_reader_api
|
[
"afc60aac989f1fed827e9cf8f7df0c0c05c67885"
] |
[
"venv/Lib/site-packages/tensorflow/python/ops/gen_user_ops.py"
] |
[
"\"\"\"Python wrappers around TensorFlow ops.\n\nThis file is MACHINE GENERATED! Do not edit.\n\"\"\"\n\nimport collections as _collections\nimport six as _six\n\nfrom tensorflow.python import pywrap_tensorflow as _pywrap_tensorflow\nfrom tensorflow.python.eager import context as _context\nfrom tensorflow.python.eager import core as _core\nfrom tensorflow.python.eager import execute as _execute\nfrom tensorflow.python.framework import dtypes as _dtypes\nfrom tensorflow.python.framework import errors as _errors\nfrom tensorflow.python.framework import tensor_shape as _tensor_shape\n\nfrom tensorflow.core.framework import op_def_pb2 as _op_def_pb2\n# Needed to trigger the call to _set_call_cpp_shape_fn.\nfrom tensorflow.python.framework import common_shapes as _common_shapes\nfrom tensorflow.python.framework import op_def_registry as _op_def_registry\nfrom tensorflow.python.framework import ops as _ops\nfrom tensorflow.python.framework import op_def_library as _op_def_library\nfrom tensorflow.python.util.tf_export import tf_export\n\n\ndef fact(name=None):\n r\"\"\"Output a fact about factorials.\n\n Args:\n name: A name for the operation (optional).\n\n Returns:\n A `Tensor` of type `string`.\n \"\"\"\n _ctx = _context._context\n if _ctx is None or not _ctx._eager_context.is_eager:\n _, _, _op = _op_def_lib._apply_op_helper(\n \"Fact\", name=name)\n _result = _op.outputs[:]\n _inputs_flat = _op.inputs\n _attrs = None\n _execute.record_gradient(\n \"Fact\", _inputs_flat, _attrs, _result, name)\n _result, = _result\n return _result\n\n else:\n try:\n _result = _pywrap_tensorflow.TFE_Py_FastPathExecute(\n _ctx._context_handle, _ctx._eager_context.device_name, \"Fact\", name,\n _ctx._post_execution_callbacks)\n return _result\n except _core._FallbackException:\n return fact_eager_fallback(\n name=name, ctx=_ctx)\n except _core._NotOkStatusException as e:\n if name is not None:\n message = e.message + \" name: \" + name\n else:\n message = e.message\n _six.raise_from(_core._status_to_exception(e.code, message), None)\n\n\ndef fact_eager_fallback(name=None, ctx=None):\n r\"\"\"This is the slowpath function for Eager mode.\n This is for function fact\n \"\"\"\n _ctx = ctx if ctx else _context.context()\n _inputs_flat = []\n _attrs = None\n _result = _execute.execute(b\"Fact\", 1, inputs=_inputs_flat, attrs=_attrs,\n ctx=_ctx, name=name)\n _execute.record_gradient(\n \"Fact\", _inputs_flat, _attrs, _result, name)\n _result, = _result\n return _result\n\ndef _InitOpDefLibrary(op_list_proto_bytes):\n op_list = _op_def_pb2.OpList()\n op_list.ParseFromString(op_list_proto_bytes)\n _op_def_registry.register_op_list(op_list)\n op_def_lib = _op_def_library.OpDefLibrary()\n op_def_lib.add_op_list(op_list)\n return op_def_lib\n# op {\n# name: \"Fact\"\n# output_arg {\n# name: \"fact\"\n# type: DT_STRING\n# }\n# }\n_op_def_lib = _InitOpDefLibrary(b\"\\n\\020\\n\\004Fact\\032\\010\\n\\004fact\\030\\007\")\n"
] |
[
[
"tensorflow.python.eager.context.context",
"tensorflow.python.eager.execute.record_gradient",
"tensorflow.python.eager.execute.execute",
"tensorflow.core.framework.op_def_pb2.OpList",
"tensorflow.python.pywrap_tensorflow.TFE_Py_FastPathExecute",
"tensorflow.python.framework.op_def_library.OpDefLibrary",
"tensorflow.python.eager.core._status_to_exception",
"tensorflow.python.framework.op_def_registry.register_op_list"
]
] |
gagdiez/WPI_WMQL_t
|
[
"2dfcf37edaa579757d3cdca5357d5ee31c9fb1fc"
] |
[
"setup.py"
] |
[
"#!/usr/bin/env python\nfrom distutils.core import setup\n\nDISTNAME = 'tract_querier'\nDESCRIPTION = \\\n 'WMQL: Query language for automatic tract extraction from '\\\n 'full-brain tractographies with '\\\n 'a registered template on top of them'\nLONG_DESCRIPTION = open('README.md').read()\nMAINTAINER = 'Demian Wassermann'\nMAINTAINER_EMAIL = 'demian@bwh.harvard.edu'\nURL = 'http://demianw.github.io/tract_querier'\nLICENSE = open('license.rst').read()\nDOWNLOAD_URL = 'https://github.com/demianw/tract_querier'\nVERSION = '0.1'\n\n\ndef configuration(parent_package='', top_path=None):\n from numpy.distutils.misc_util import Configuration\n config = Configuration(None, parent_package, top_path)\n config.set_options(quiet=True)\n config.add_subpackage('tract_querier')\n return config\n\n\nif __name__ == \"__main__\":\n setup(\n name=DISTNAME,\n maintainer=MAINTAINER,\n maintainer_email=MAINTAINER_EMAIL,\n description=DESCRIPTION,\n license=LICENSE,\n url=URL,\n version=VERSION,\n download_url=DOWNLOAD_URL,\n long_description=LONG_DESCRIPTION,\n requires=[\n 'numpy(>=1.6)',\n 'nibabel(>=1.3)'\n ],\n classifiers=[\n 'Intended Audience :: Science/Research',\n 'Programming Language :: Python',\n 'Topic :: Scientific/Engineering',\n 'Operating System :: Microsoft :: Windows',\n 'Operating System :: POSIX',\n 'Operating System :: Unix',\n 'Operating System :: MacOS'\n ],\n scripts=[\n 'scripts/tract_querier',\n 'scripts/tract_math',\n 'scripts/volume_querier'\n ],\n test_suite='nose.collector',\n **(configuration().todict())\n )\n"
] |
[
[
"numpy.distutils.misc_util.Configuration"
]
] |
nbei/mmgeneration
|
[
"12811a03ff2a77672b423e95b7a5180b6a4f5344"
] |
[
"apps/stylegan_projector.py"
] |
[
"r\"\"\"\n This app is used to invert the styleGAN series synthesis network. We find\n the matching latent vector w for given images so that we can manipulate\n images in the latent feature space.\n Ref: https://github.com/rosinality/stylegan2-pytorch/blob/master/projector.py # noqa\n\"\"\"\nimport argparse\nimport os\nimport sys\n\nimport mmcv\nimport numpy as np\nimport torch\nimport torch.nn.functional as F\nfrom mmcv import Config\nfrom mmcv.runner import load_checkpoint\nfrom PIL import Image\nfrom torch import optim\nfrom torchvision import transforms\nfrom torchvision.utils import save_image\nfrom tqdm import tqdm\n\n# yapf: disable\nsys.path.append(os.path.abspath(os.path.join(__file__, '../..'))) # isort:skip # noqa\n\nfrom mmgen.apis import set_random_seed # isort:skip # noqa\nfrom mmgen.models import build_model # isort:skip # noqa\nfrom mmgen.models.architectures.lpips import PerceptualLoss # isort:skip # noqa\n\n# yapf: enable\n\n\ndef parse_args():\n parser = argparse.ArgumentParser(\n description='Image projector to the StyleGAN-based generator latent \\\n spaces')\n parser.add_argument('config', help='evaluation config file path')\n parser.add_argument('checkpoint', help='checkpoint file')\n parser.add_argument(\n 'files',\n metavar='FILES',\n nargs='+',\n help='path to image files to be projected')\n parser.add_argument(\n '--results-path', type=str, help='path to store projection results.')\n parser.add_argument(\n '--use-cpu',\n action='store_true',\n help='whether to use cpu device for sampling')\n parser.add_argument('--seed', type=int, default=2021, help='random seed')\n parser.add_argument(\n '--deterministic',\n action='store_true',\n help='whether to set deterministic options for CUDNN backend.')\n parser.add_argument(\n '--sample-model',\n type=str,\n default='ema',\n help='use which mode (ema/orig) in sampling.')\n parser.add_argument(\n '--lr-rampup',\n type=float,\n default=0.05,\n help='proportion of the learning rate warmup iters in the total iters')\n parser.add_argument(\n '--lr-rampdown',\n type=float,\n default=0.25,\n help='proportion of the learning rate decay iters in the total iters')\n parser.add_argument(\n '--lr', type=float, default=0.1, help='maximum learning rate')\n parser.add_argument(\n '--noise',\n type=float,\n default=0.05,\n help='strength of the noise level')\n parser.add_argument(\n '--noise-ramp',\n type=float,\n default=0.75,\n help='proportion of the noise level decay iters in the total iters',\n )\n parser.add_argument(\n '--total-iters', type=int, default=1000, help='optimize iterations')\n parser.add_argument(\n '--noise-regularize',\n type=float,\n default=1e5,\n help='weight of the noise regularization',\n )\n parser.add_argument(\n '--mse', type=float, default=0, help='weight of the mse loss')\n parser.add_argument(\n '--n-mean-latent',\n type=int,\n default=10000,\n help='sampling times to obtain the mean latent')\n parser.add_argument(\n '--w-plus',\n action='store_true',\n help='allow to use distinct latent codes to each layers',\n )\n args = parser.parse_args()\n return args\n\n\ndef noise_regularize(noises):\n loss = 0\n for noise in noises:\n size = noise.shape[2]\n while True:\n loss = (\n loss +\n (noise * torch.roll(noise, shifts=1, dims=3)).mean().pow(2) +\n (noise * torch.roll(noise, shifts=1, dims=2)).mean().pow(2))\n if size <= 8:\n break\n noise = noise.reshape([-1, 1, size // 2, 2, size // 2, 2])\n noise = noise.mean([3, 5])\n size //= 2\n return loss\n\n\ndef noise_normalize_(noises):\n for noise in noises:\n mean = noise.mean()\n std = noise.std()\n noise.data.add_(-mean).div_(std)\n\n\ndef get_lr(t, initial_lr, rampdown=0.25, rampup=0.05):\n lr_ramp = min(1, (1 - t) / rampdown)\n lr_ramp = 0.5 - 0.5 * np.cos(lr_ramp * np.pi)\n lr_ramp = lr_ramp * min(1, t / rampup)\n return initial_lr * lr_ramp\n\n\ndef latent_noise(latent, strength):\n noise = torch.randn_like(latent) * strength\n return latent + noise\n\n\ndef main():\n args = parse_args()\n cfg = Config.fromfile(args.config)\n # set cudnn_benchmark\n if cfg.get('cudnn_benchmark', False):\n torch.backends.cudnn.benchmark = True\n\n # set random seeds\n if args.seed is not None:\n print('set random seed to', args.seed)\n set_random_seed(args.seed, deterministic=args.deterministic)\n\n # build the model and load checkpoint\n model = build_model(\n cfg.model, train_cfg=cfg.train_cfg, test_cfg=cfg.test_cfg)\n _ = load_checkpoint(model, args.checkpoint, map_location='cpu')\n # sanity check for models without ema\n if not model.use_ema:\n args.sample_model = 'orig'\n if args.sample_model == 'ema':\n generator = model.generator_ema\n else:\n generator = model.generator\n\n mmcv.print_log(f'Sampling model: {args.sample_model}', 'mmgen')\n\n generator.eval()\n device = 'cpu'\n if not args.use_cpu:\n generator = generator.cuda()\n device = 'cuda'\n\n img_size = min(generator.out_size, 256)\n transform = transforms.Compose([\n transforms.Resize(img_size),\n transforms.ToTensor(),\n transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5]),\n ])\n\n # read images\n imgs = []\n for imgfile in args.files:\n img = Image.open(imgfile).convert('RGB')\n img = transform(img)\n img = img[[2, 1, 0], ...]\n imgs.append(img)\n\n imgs = torch.stack(imgs, 0).to(device)\n\n # get mean and standard deviation of style latents\n with torch.no_grad():\n noise_sample = torch.randn(\n args.n_mean_latent, generator.style_channels, device=device)\n latent_out = generator.style_mapping(noise_sample)\n latent_mean = latent_out.mean(0)\n latent_std = ((latent_out - latent_mean).pow(2).sum() /\n args.n_mean_latent)**0.5\n latent_in = latent_mean.detach().clone().unsqueeze(0).repeat(\n imgs.shape[0], 1)\n if args.w_plus:\n latent_in = latent_in.unsqueeze(1).repeat(1, generator.num_latents, 1)\n latent_in.requires_grad = True\n\n # define lpips loss\n percept = PerceptualLoss(use_gpu=device.startswith('cuda'))\n\n # initialize layer noises\n noises_single = generator.make_injected_noise()\n noises = []\n for noise in noises_single:\n noises.append(noise.repeat(imgs.shape[0], 1, 1, 1).normal_())\n for noise in noises:\n noise.requires_grad = True\n\n optimizer = optim.Adam([latent_in] + noises, lr=args.lr)\n pbar = tqdm(range(args.total_iters))\n # run optimization\n for i in pbar:\n t = i / args.total_iters\n lr = get_lr(t, args.lr, args.lr_rampdown, args.lr_rampup)\n optimizer.param_groups[0]['lr'] = lr\n noise_strength = latent_std * args.noise * max(\n 0, 1 - t / args.noise_ramp)**2\n latent_n = latent_noise(latent_in, noise_strength.item())\n\n img_gen = generator([latent_n],\n input_is_latent=True,\n injected_noise=noises)\n\n batch, channel, height, width = img_gen.shape\n\n if height > 256:\n factor = height // 256\n\n img_gen = img_gen.reshape(batch, channel, height // factor, factor,\n width // factor, factor)\n img_gen = img_gen.mean([3, 5])\n\n p_loss = percept(img_gen, imgs).sum()\n n_loss = noise_regularize(noises)\n mse_loss = F.mse_loss(img_gen, imgs)\n\n loss = p_loss + args.noise_regularize * n_loss + args.mse * mse_loss\n\n optimizer.zero_grad()\n loss.backward()\n optimizer.step()\n\n noise_normalize_(noises)\n\n pbar.set_description(\n f' perceptual: {p_loss.item():.4f}, noise regularize:'\n f'{n_loss.item():.4f}, mse: {mse_loss.item():.4f}, lr: {lr:.4f}')\n\n results = generator([latent_in.detach().clone()],\n input_is_latent=True,\n injected_noise=noises)\n # rescale value range to [0, 1]\n results = ((results + 1) / 2)\n results = results[:, [2, 1, 0], ...]\n results = results.clamp_(0, 1)\n\n mmcv.mkdir_or_exist(args.results_path)\n # save projection results\n result_file = {}\n for i, input_name in enumerate(args.files):\n noise_single = []\n for noise in noises:\n noise_single.append(noise[i:i + 1])\n result_file[input_name] = {\n 'img': img_gen[i],\n 'latent': latent_in[i],\n 'injected_noise': noise_single,\n }\n img_name = os.path.splitext(\n os.path.basename(input_name))[0] + '-project.png'\n save_image(results[i], os.path.join(args.results_path, img_name))\n\n torch.save(result_file, os.path.join(args.results_path,\n 'project_result.pt'))\n\n\nif __name__ == '__main__':\n main()\n"
] |
[
[
"torch.roll",
"torch.stack",
"torch.no_grad",
"torch.optim.Adam",
"torch.nn.functional.mse_loss",
"torch.randn_like",
"numpy.cos",
"torch.randn"
]
] |
tak-ka3/radio-news-make
|
[
"c80e64d2c56b08136fa510b72be199de27b6cbbe"
] |
[
"gpt2-transform.py"
] |
[
"import json\nimport os\nimport numpy as np\nimport tensorflow.compat.v1 as tf\nimport argparse\nfrom tqdm import tqdm\nimport model\nfrom encode_bpe import BPEEncoder_ja\n\nif int(tf.__version__[0]) > 1:\n from model import HParams as HParams\nelse:\n from tensorflow.contrib.training import HParams\n\nparser = argparse.ArgumentParser()\nparser.add_argument('--model', type=str, default='gpt2ja-medium')\nparser.add_argument('--context', type=str, required=True)\nparser.add_argument('--gpu', type=str, default='0')\nargs = parser.parse_args()\n\nwith open('ja-bpe.txt', encoding='utf-8') as f:\n bpe = f.read().split('\\n')\n\nwith open('emoji.json', encoding='utf-8') as f:\n emoji = json.loads(f.read())\n\nenc = BPEEncoder_ja(bpe, emoji)\nn_vocab = len(enc)\n\nif os.path.isfile(args.model+'/hparams.json'):\n with open(args.model+'/hparams.json', encoding='utf-8') as f:\n params = json.loads(f.read())\n hparams = HParams(**params)\nelif 'small' in args.model:\n hparams = HParams(**{\n \"n_vocab\": n_vocab,\n \"n_ctx\": 1024,\n \"n_embd\": 768,\n \"n_head\": 12,\n \"n_layer\": 12\n })\nelif 'medium' in args.model:\n hparams = HParams(**{\n \"n_vocab\": n_vocab,\n \"n_ctx\": 1024,\n \"n_embd\": 1024,\n \"n_head\": 16,\n \"n_layer\": 24\n })\nelif 'large' in args.model:\n hparams = HParams(**{\n \"n_vocab\": n_vocab,\n \"n_ctx\": 1024,\n \"n_embd\": 1280,\n \"n_head\": 20,\n \"n_layer\": 36\n })\nelse:\n raise ValueError('invalid model name.')\n\nconfig = tf.ConfigProto()\nif int(args.gpu) >= 0:\n config.gpu_options.allow_growth = True\n config.gpu_options.visible_device_list = args.gpu\nwith tf.Session(config=config,graph=tf.Graph()) as sess:\n context = tf.placeholder(tf.int32, [1, None])\n output = model.model(hparams=hparams, X=context, past=None, reuse=tf.AUTO_REUSE)\n\n saver = tf.train.Saver()\n ckpt = tf.train.latest_checkpoint(args.model)\n saver.restore(sess, ckpt)\n\n context_tokens = enc.encode(args.context)\n out = sess.run(output, feed_dict={\n context: [context_tokens]\n })\n output = out['h_flat'][-1]\n print(output.tolist())\n"
] |
[
[
"tensorflow.compat.v1.placeholder",
"tensorflow.compat.v1.Graph",
"tensorflow.compat.v1.train.Saver",
"tensorflow.compat.v1.ConfigProto",
"tensorflow.contrib.training.HParams",
"tensorflow.compat.v1.train.latest_checkpoint"
]
] |
mpolson64/Ax-1
|
[
"cf9e12cc1253efe0fc893f2620e99337e0927a26",
"cf9e12cc1253efe0fc893f2620e99337e0927a26"
] |
[
"ax/modelbridge/transforms/power_transform_y.py",
"ax/core/tests/test_observation.py"
] |
[
"#!/usr/bin/env python3\n# Copyright (c) Meta Platforms, Inc. and affiliates.\n#\n# This source code is licensed under the MIT license found in the\n# LICENSE file in the root directory of this source tree.\n\nfrom __future__ import annotations\n\nfrom collections import defaultdict\nfrom typing import TYPE_CHECKING, Dict, List, Optional, Tuple\n\nimport numpy as np\nfrom ax.core.observation import ObservationData, ObservationFeatures\nfrom ax.core.optimization_config import OptimizationConfig\nfrom ax.core.outcome_constraint import ScalarizedOutcomeConstraint\nfrom ax.core.search_space import SearchSpace\nfrom ax.modelbridge.transforms.base import Transform\nfrom ax.modelbridge.transforms.utils import get_data, match_ci_width_truncated\nfrom ax.models.types import TConfig\nfrom ax.utils.common.logger import get_logger\nfrom ax.utils.common.typeutils import checked_cast_list\nfrom sklearn.preprocessing import PowerTransformer\n\nif TYPE_CHECKING:\n # import as module to make sphinx-autodoc-typehints happy\n from ax import modelbridge as modelbridge_module # noqa F401 # pragma: no cover\n\n\nlogger = get_logger(__name__)\n\n\nclass PowerTransformY(Transform):\n \"\"\"Transform the values to look as normally distributed as possible.\n\n This fits a power transform to the data with the goal of making the transformed\n values look as normally distributed as possible. We use Yeo-Johnson\n (https://www.stat.umn.edu/arc/yjpower.pdf), which can handle both positive and\n negative values.\n\n While the transform seems to be quite robust, it probably makes sense to apply a\n bit of winsorization and also standardize the inputs before applying the power\n transform. The power transform will automatically standardize the data so the\n data will remain standardized.\n\n The transform can't be inverted for all values, so we apply clipping to move\n values to the image of the transform. This behavior can be controlled via the\n `clip_mean` setting.\n \"\"\"\n\n def __init__(\n self,\n search_space: SearchSpace,\n observation_features: List[ObservationFeatures],\n observation_data: List[ObservationData],\n modelbridge: Optional[modelbridge_module.base.ModelBridge] = None,\n config: Optional[TConfig] = None,\n ) -> None:\n if config is None:\n raise ValueError(\"PowerTransform requires a config.\")\n # pyre-fixme[6]: Same issue as for LogY\n metric_names = list(config.get(\"metrics\", []))\n if len(metric_names) == 0:\n raise ValueError(\"Must specify at least one metric in the config.\")\n self.clip_mean = config.get(\"clip_mean\", True)\n self.metric_names = metric_names\n Ys = get_data(observation_data=observation_data, metric_names=metric_names)\n self.power_transforms = _compute_power_transforms(Ys=Ys)\n self.inv_bounds = _compute_inverse_bounds(self.power_transforms, tol=1e-10)\n\n def transform_observation_data(\n self,\n observation_data: List[ObservationData],\n observation_features: List[ObservationFeatures],\n ) -> List[ObservationData]:\n \"\"\"Winsorize observation data in place.\"\"\"\n for obsd in observation_data:\n for i, m in enumerate(obsd.metric_names):\n if m in self.metric_names:\n transform = self.power_transforms[m].transform\n obsd.means[i], obsd.covariance[i, i] = match_ci_width_truncated(\n mean=obsd.means[i],\n variance=obsd.covariance[i, i],\n transform=lambda y: transform(np.array(y, ndmin=2)),\n lower_bound=-np.inf,\n upper_bound=np.inf,\n )\n return observation_data\n\n def untransform_observation_data(\n self,\n observation_data: List[ObservationData],\n observation_features: List[ObservationFeatures],\n ) -> List[ObservationData]:\n \"\"\"Winsorize observation data in place.\"\"\"\n for obsd in observation_data:\n for i, m in enumerate(obsd.metric_names):\n if m in self.metric_names:\n l, u = self.inv_bounds[m]\n transform = self.power_transforms[m].inverse_transform\n if not self.clip_mean and (obsd.means[i] < l or obsd.means[i] > u):\n raise ValueError(\n \"Can't untransform mean outside the bounds without clipping\"\n )\n obsd.means[i], obsd.covariance[i, i] = match_ci_width_truncated(\n mean=obsd.means[i],\n variance=obsd.covariance[i, i],\n transform=lambda y: transform(np.array(y, ndmin=2)),\n lower_bound=l,\n upper_bound=u,\n clip_mean=True,\n )\n return observation_data\n\n def transform_optimization_config(\n self,\n optimization_config: OptimizationConfig,\n modelbridge: Optional[modelbridge_module.base.ModelBridge],\n fixed_features: ObservationFeatures,\n ) -> OptimizationConfig:\n for c in optimization_config.all_constraints:\n if isinstance(c, ScalarizedOutcomeConstraint):\n c_metric_names = [metric.name for metric in c.metrics]\n intersection = set(c_metric_names) & set(self.metric_names)\n if intersection:\n raise NotImplementedError(\n f\"PowerTransformY cannot be used for metric(s) {intersection} \"\n \"that are part of a ScalarizedOutcomeConstraint.\"\n )\n elif c.metric.name in self.metric_names:\n if c.relative:\n raise ValueError(\n f\"PowerTransformY cannot be applied to metric {c.metric.name} \"\n \"since it is subject to a relative constraint.\"\n )\n else:\n transform = self.power_transforms[c.metric.name].transform\n c.bound = transform(np.array(c.bound, ndmin=2)).item()\n return optimization_config\n\n\ndef _compute_power_transforms(\n Ys: Dict[str, List[float]]\n) -> Dict[str, PowerTransformer]:\n \"\"\"Compute power transforms.\"\"\"\n power_transforms = {}\n for k, ys in Ys.items():\n y = np.array(ys)[:, None] # Need to unsqueeze the last dimension\n pt = PowerTransformer(method=\"yeo-johnson\").fit(y)\n power_transforms[k] = pt\n return power_transforms\n\n\ndef _compute_inverse_bounds(\n power_transforms: Dict[str, PowerTransformer], tol: float = 1e-10\n) -> Dict[str, Tuple[float, float]]:\n \"\"\"Computes the image of the transform so we can clip when we untransform.\n\n The inverse of the Yeo-Johnson transform is given by:\n if X >= 0 and lambda == 0:\n X = exp(X_trans) - 1\n elif X >= 0 and lambda != 0:\n X = (X_trans * lambda + 1) ** (1 / lambda) - 1\n elif X < 0 and lambda != 2:\n X = 1 - (-(2 - lambda) * X_trans + 1) ** (1 / (2 - lambda))\n elif X < 0 and lambda == 2:\n X = 1 - exp(-X_trans)\n\n We can break this down into three cases:\n lambda < 0: X < -1 / lambda\n 0 <= lambda <= 2: X is unbounded\n lambda > 2: X > 1 / (2 - lambda)\n\n Sklearn standardizes the transformed values to have mean zero and standard\n deviation 1, so we also need to account for this when we compute the bounds.\n \"\"\"\n inv_bounds = defaultdict()\n for k, pt in power_transforms.items():\n bounds = [-np.inf, np.inf]\n mu, sigma = pt._scaler.mean_.item(), pt._scaler.scale_.item() # pyre-ignore\n lambda_ = pt.lambdas_.item() # pyre-ignore\n if lambda_ < -1 * tol:\n bounds[1] = (-1.0 / lambda_ - mu) / sigma\n elif lambda_ > 2.0 + tol:\n bounds[0] = (1.0 / (2.0 - lambda_) - mu) / sigma\n inv_bounds[k] = tuple(checked_cast_list(float, bounds))\n return inv_bounds\n",
"#!/usr/bin/env python3\n# Copyright (c) Meta Platforms, Inc. and affiliates.\n#\n# This source code is licensed under the MIT license found in the\n# LICENSE file in the root directory of this source tree.\n\nimport json\nfrom unittest.mock import Mock, PropertyMock\n\nimport numpy as np\nimport pandas as pd\nfrom ax.core.arm import Arm\nfrom ax.core.base_trial import TrialStatus\nfrom ax.core.batch_trial import BatchTrial\nfrom ax.core.data import Data\nfrom ax.core.generator_run import GeneratorRun\nfrom ax.core.map_data import MapData, MapKeyInfo\nfrom ax.core.observation import (\n Observation,\n ObservationData,\n ObservationFeatures,\n observations_from_data,\n observations_from_map_data,\n separate_observations,\n)\nfrom ax.core.trial import Trial\nfrom ax.utils.common.testutils import TestCase\n\n\nclass ObservationsTest(TestCase):\n def testObservationFeatures(self):\n t = np.datetime64(\"now\")\n attrs = {\n \"parameters\": {\"x\": 0, \"y\": \"a\"},\n \"trial_index\": 2,\n \"start_time\": t,\n \"end_time\": t,\n \"random_split\": 1,\n }\n obsf = ObservationFeatures(**attrs)\n for k, v in attrs.items():\n self.assertEqual(getattr(obsf, k), v)\n printstr = \"ObservationFeatures(parameters={'x': 0, 'y': 'a'}, \"\n printstr += \"trial_index=2, \"\n printstr += \"start_time={t}, end_time={t}, \".format(t=t)\n printstr += \"random_split=1)\"\n self.assertEqual(repr(obsf), printstr)\n obsf2 = ObservationFeatures(**attrs)\n self.assertEqual(hash(obsf), hash(obsf2))\n a = {obsf, obsf2}\n self.assertEqual(len(a), 1)\n self.assertEqual(obsf, obsf2)\n attrs.pop(\"trial_index\")\n obsf3 = ObservationFeatures(**attrs)\n self.assertNotEqual(obsf, obsf3)\n self.assertFalse(obsf == 1)\n\n def testClone(self):\n # Test simple cloning.\n arm = Arm({\"x\": 0, \"y\": \"a\"})\n obsf = ObservationFeatures.from_arm(arm, trial_index=3)\n self.assertIsNot(obsf, obsf.clone())\n self.assertEqual(obsf, obsf.clone())\n\n # Test cloning with swapping parameters.\n clone_with_new_params = obsf.clone(replace_parameters={\"x\": 1, \"y\": \"b\"})\n self.assertNotEqual(obsf, clone_with_new_params)\n obsf.parameters = {\"x\": 1, \"y\": \"b\"}\n self.assertEqual(obsf, clone_with_new_params)\n\n def testObservationFeaturesFromArm(self):\n arm = Arm({\"x\": 0, \"y\": \"a\"})\n obsf = ObservationFeatures.from_arm(arm, trial_index=3)\n self.assertEqual(obsf.parameters, arm.parameters)\n self.assertEqual(obsf.trial_index, 3)\n\n def testUpdateFeatures(self):\n parameters = {\"x\": 0, \"y\": \"a\"}\n new_parameters = {\"z\": \"foo\"}\n\n obsf = ObservationFeatures(parameters=parameters, trial_index=3)\n\n # Ensure None trial_index doesn't override existing value\n obsf.update_features(ObservationFeatures(parameters={}))\n self.assertEqual(obsf.trial_index, 3)\n\n # Test override\n new_obsf = ObservationFeatures(\n parameters=new_parameters,\n trial_index=4,\n start_time=pd.Timestamp(\"2005-02-25\"),\n end_time=pd.Timestamp(\"2005-02-26\"),\n random_split=7,\n )\n obsf.update_features(new_obsf)\n self.assertEqual(obsf.parameters, {**parameters, **new_parameters})\n self.assertEqual(obsf.trial_index, 4)\n self.assertEqual(obsf.random_split, 7)\n self.assertEqual(obsf.start_time, pd.Timestamp(\"2005-02-25\"))\n self.assertEqual(obsf.end_time, pd.Timestamp(\"2005-02-26\"))\n\n def testObservationData(self):\n attrs = {\n \"metric_names\": [\"a\", \"b\"],\n \"means\": np.array([4.0, 5.0]),\n \"covariance\": np.array([[1.0, 4.0], [3.0, 6.0]]),\n }\n obsd = ObservationData(**attrs)\n self.assertEqual(obsd.metric_names, attrs[\"metric_names\"])\n self.assertTrue(np.array_equal(obsd.means, attrs[\"means\"]))\n self.assertTrue(np.array_equal(obsd.covariance, attrs[\"covariance\"]))\n # use legacy printing for numpy (<= 1.13 add spaces in front of floats;\n # to get around tests failing on older versions, peg version to 1.13)\n if np.__version__ >= \"1.14\":\n np.set_printoptions(legacy=\"1.13\")\n printstr = \"ObservationData(metric_names=['a', 'b'], means=[ 4. 5.], \"\n printstr += \"covariance=[[ 1. 4.]\\n [ 3. 6.]])\"\n self.assertEqual(repr(obsd), printstr)\n self.assertEqual(obsd.means_dict, {\"a\": 4.0, \"b\": 5.0})\n self.assertEqual(\n obsd.covariance_matrix,\n {\"a\": {\"a\": 1.0, \"b\": 4.0}, \"b\": {\"a\": 3.0, \"b\": 6.0}},\n )\n\n def testObservationDataValidation(self):\n with self.assertRaises(ValueError):\n ObservationData(\n metric_names=[\"a\", \"b\"],\n means=np.array([4.0]),\n covariance=np.array([[1.0, 4.0], [3.0, 6.0]]),\n )\n with self.assertRaises(ValueError):\n ObservationData(\n metric_names=[\"a\", \"b\"],\n means=np.array([4.0, 5.0]),\n covariance=np.array([1.0, 4.0]),\n )\n\n def testObservationDataEq(self):\n od1 = ObservationData(\n metric_names=[\"a\", \"b\"],\n means=np.array([4.0, 5.0]),\n covariance=np.array([[1.0, 4.0], [3.0, 6.0]]),\n )\n od2 = ObservationData(\n metric_names=[\"a\", \"b\"],\n means=np.array([4.0, 5.0]),\n covariance=np.array([[1.0, 4.0], [3.0, 6.0]]),\n )\n od3 = ObservationData(\n metric_names=[\"a\", \"b\"],\n means=np.array([4.0, 5.0]),\n covariance=np.array([[2.0, 4.0], [3.0, 6.0]]),\n )\n self.assertEqual(od1, od2)\n self.assertNotEqual(od1, od3)\n self.assertFalse(od1 == 1)\n\n def testObservation(self):\n obs = Observation(\n features=ObservationFeatures(parameters={\"x\": 20}),\n data=ObservationData(\n means=np.array([1]), covariance=np.array([[2]]), metric_names=[\"a\"]\n ),\n arm_name=\"0_0\",\n )\n self.assertEqual(obs.features, ObservationFeatures(parameters={\"x\": 20}))\n self.assertEqual(\n obs.data,\n ObservationData(\n means=np.array([1]), covariance=np.array([[2]]), metric_names=[\"a\"]\n ),\n )\n self.assertEqual(obs.arm_name, \"0_0\")\n obs2 = Observation(\n features=ObservationFeatures(parameters={\"x\": 20}),\n data=ObservationData(\n means=np.array([1]), covariance=np.array([[2]]), metric_names=[\"a\"]\n ),\n arm_name=\"0_0\",\n )\n self.assertEqual(obs, obs2)\n obs3 = Observation(\n features=ObservationFeatures(parameters={\"x\": 10}),\n data=ObservationData(\n means=np.array([1]), covariance=np.array([[2]]), metric_names=[\"a\"]\n ),\n arm_name=\"0_0\",\n )\n self.assertNotEqual(obs, obs3)\n self.assertNotEqual(obs, 1)\n\n def testObservationsFromData(self):\n truth = [\n {\n \"arm_name\": \"0_0\",\n \"parameters\": {\"x\": 0, \"y\": \"a\"},\n \"mean\": 2.0,\n \"sem\": 2.0,\n \"trial_index\": 1,\n \"metric_name\": \"a\",\n },\n {\n \"arm_name\": \"0_1\",\n \"parameters\": {\"x\": 1, \"y\": \"b\"},\n \"mean\": 3.0,\n \"sem\": 3.0,\n \"trial_index\": 2,\n \"metric_name\": \"a\",\n },\n {\n \"arm_name\": \"0_0\",\n \"parameters\": {\"x\": 0, \"y\": \"a\"},\n \"mean\": 4.0,\n \"sem\": 4.0,\n \"trial_index\": 1,\n \"metric_name\": \"b\",\n },\n ]\n arms = {\n obs[\"arm_name\"]: Arm(name=obs[\"arm_name\"], parameters=obs[\"parameters\"])\n for obs in truth\n }\n experiment = Mock()\n experiment._trial_indices_by_status = {status: set() for status in TrialStatus}\n trials = {\n obs[\"trial_index\"]: Trial(\n experiment, GeneratorRun(arms=[arms[obs[\"arm_name\"]]])\n )\n for obs in truth\n }\n type(experiment).arms_by_name = PropertyMock(return_value=arms)\n type(experiment).trials = PropertyMock(return_value=trials)\n\n df = pd.DataFrame(truth)[\n [\"arm_name\", \"trial_index\", \"mean\", \"sem\", \"metric_name\"]\n ]\n data = Data(df=df)\n observations = observations_from_data(experiment, data)\n\n self.assertEqual(len(observations), 2)\n # Get them in the order we want for tests below\n if observations[0].features.parameters[\"x\"] == 1:\n observations.reverse()\n\n obsd_truth = {\n \"metric_names\": [[\"a\", \"b\"], [\"a\"]],\n \"means\": [np.array([2.0, 4.0]), np.array([3])],\n \"covariance\": [np.diag([4.0, 16.0]), np.array([[9.0]])],\n }\n cname_truth = [\"0_0\", \"0_1\"]\n\n for i, obs in enumerate(observations):\n self.assertEqual(obs.features.parameters, truth[i][\"parameters\"])\n self.assertEqual(obs.features.trial_index, truth[i][\"trial_index\"])\n self.assertEqual(obs.data.metric_names, obsd_truth[\"metric_names\"][i])\n self.assertTrue(np.array_equal(obs.data.means, obsd_truth[\"means\"][i]))\n self.assertTrue(\n np.array_equal(obs.data.covariance, obsd_truth[\"covariance\"][i])\n )\n self.assertEqual(obs.arm_name, cname_truth[i])\n\n def testObservationsFromDataWithFidelities(self):\n truth = {\n 0.5: {\n \"arm_name\": \"0_0\",\n \"parameters\": {\"x\": 0, \"y\": \"a\", \"z\": 1},\n \"mean\": 2.0,\n \"sem\": 2.0,\n \"trial_index\": 1,\n \"metric_name\": \"a\",\n \"fidelities\": json.dumps({\"z\": 0.5}),\n \"updated_parameters\": {\"x\": 0, \"y\": \"a\", \"z\": 0.5},\n \"mean_t\": np.array([2.0]),\n \"covariance_t\": np.array([[4.0]]),\n },\n 0.25: {\n \"arm_name\": \"0_1\",\n \"parameters\": {\"x\": 1, \"y\": \"b\", \"z\": 0.5},\n \"mean\": 3.0,\n \"sem\": 3.0,\n \"trial_index\": 2,\n \"metric_name\": \"a\",\n \"fidelities\": json.dumps({\"z\": 0.25}),\n \"updated_parameters\": {\"x\": 1, \"y\": \"b\", \"z\": 0.25},\n \"mean_t\": np.array([3.0]),\n \"covariance_t\": np.array([[9.0]]),\n },\n 1: {\n \"arm_name\": \"0_0\",\n \"parameters\": {\"x\": 0, \"y\": \"a\", \"z\": 1},\n \"mean\": 4.0,\n \"sem\": 4.0,\n \"trial_index\": 1,\n \"metric_name\": \"b\",\n \"fidelities\": json.dumps({\"z\": 1}),\n \"updated_parameters\": {\"x\": 0, \"y\": \"a\", \"z\": 1},\n \"mean_t\": np.array([4.0]),\n \"covariance_t\": np.array([[16.0]]),\n },\n }\n arms = {\n obs[\"arm_name\"]: Arm(name=obs[\"arm_name\"], parameters=obs[\"parameters\"])\n for _, obs in truth.items()\n }\n experiment = Mock()\n experiment._trial_indices_by_status = {status: set() for status in TrialStatus}\n trials = {\n obs[\"trial_index\"]: Trial(\n experiment, GeneratorRun(arms=[arms[obs[\"arm_name\"]]])\n )\n for _, obs in truth.items()\n }\n type(experiment).arms_by_name = PropertyMock(return_value=arms)\n type(experiment).trials = PropertyMock(return_value=trials)\n\n df = pd.DataFrame(list(truth.values()))[\n [\"arm_name\", \"trial_index\", \"mean\", \"sem\", \"metric_name\", \"fidelities\"]\n ]\n data = Data(df=df)\n observations = observations_from_data(experiment, data)\n\n self.assertEqual(len(observations), 3)\n for obs in observations:\n t = truth[obs.features.parameters[\"z\"]]\n self.assertEqual(obs.features.parameters, t[\"updated_parameters\"])\n self.assertEqual(obs.features.trial_index, t[\"trial_index\"])\n self.assertEqual(obs.data.metric_names, [t[\"metric_name\"]])\n self.assertTrue(np.array_equal(obs.data.means, t[\"mean_t\"]))\n self.assertTrue(np.array_equal(obs.data.covariance, t[\"covariance_t\"]))\n self.assertEqual(obs.arm_name, t[\"arm_name\"])\n\n def testObservationsFromMapData(self):\n truth = {\n 0.5: {\n \"arm_name\": \"0_0\",\n \"parameters\": {\"x\": 0, \"y\": \"a\", \"z\": 1},\n \"mean\": 2.0,\n \"sem\": 2.0,\n \"trial_index\": 1,\n \"metric_name\": \"a\",\n \"updated_parameters\": {\"x\": 0, \"y\": \"a\", \"z\": 0.5},\n \"mean_t\": np.array([2.0]),\n \"covariance_t\": np.array([[4.0]]),\n \"z\": 0.5,\n \"timestamp\": 50,\n },\n 0.25: {\n \"arm_name\": \"0_1\",\n \"parameters\": {\"x\": 1, \"y\": \"b\", \"z\": 0.5},\n \"mean\": 3.0,\n \"sem\": 3.0,\n \"trial_index\": 2,\n \"metric_name\": \"a\",\n \"updated_parameters\": {\"x\": 1, \"y\": \"b\", \"z\": 0.25},\n \"mean_t\": np.array([3.0]),\n \"covariance_t\": np.array([[9.0]]),\n \"z\": 0.25,\n \"timestamp\": 25,\n },\n 1: {\n \"arm_name\": \"0_0\",\n \"parameters\": {\"x\": 0, \"y\": \"a\", \"z\": 1},\n \"mean\": 4.0,\n \"sem\": 4.0,\n \"trial_index\": 1,\n \"metric_name\": \"b\",\n \"updated_parameters\": {\"x\": 0, \"y\": \"a\", \"z\": 1},\n \"mean_t\": np.array([4.0]),\n \"covariance_t\": np.array([[16.0]]),\n \"z\": 1,\n \"timestamp\": 100,\n },\n }\n arms = {\n obs[\"arm_name\"]: Arm(name=obs[\"arm_name\"], parameters=obs[\"parameters\"])\n for _, obs in truth.items()\n }\n experiment = Mock()\n experiment._trial_indices_by_status = {status: set() for status in TrialStatus}\n trials = {\n obs[\"trial_index\"]: Trial(\n experiment, GeneratorRun(arms=[arms[obs[\"arm_name\"]]])\n )\n for _, obs in truth.items()\n }\n type(experiment).arms_by_name = PropertyMock(return_value=arms)\n type(experiment).trials = PropertyMock(return_value=trials)\n\n df = pd.DataFrame(list(truth.values()))[\n [\"arm_name\", \"trial_index\", \"mean\", \"sem\", \"metric_name\", \"z\", \"timestamp\"]\n ]\n data = MapData(\n df=df,\n map_key_infos=[\n MapKeyInfo(key=\"z\", default_value=0.0),\n MapKeyInfo(key=\"timestamp\", default_value=0.0),\n ],\n )\n observations = observations_from_map_data(experiment, data)\n\n self.assertEqual(len(observations), 3)\n\n for obs in observations:\n t = truth[obs.features.parameters[\"z\"]]\n self.assertEqual(obs.features.parameters, t[\"updated_parameters\"])\n self.assertEqual(obs.features.trial_index, t[\"trial_index\"])\n self.assertEqual(obs.data.metric_names, [t[\"metric_name\"]])\n self.assertTrue(np.array_equal(obs.data.means, t[\"mean_t\"]))\n self.assertTrue(np.array_equal(obs.data.covariance, t[\"covariance_t\"]))\n self.assertEqual(obs.arm_name, t[\"arm_name\"])\n self.assertEqual(obs.features.metadata, {\"timestamp\": t[\"timestamp\"]})\n\n def testObservationsFromDataAbandoned(self):\n truth = {\n 0.5: {\n \"arm_name\": \"0_0\",\n \"parameters\": {\"x\": 0, \"y\": \"a\", \"z\": 1},\n \"mean\": 2.0,\n \"sem\": 2.0,\n \"trial_index\": 0,\n \"metric_name\": \"a\",\n \"updated_parameters\": {\"x\": 0, \"y\": \"a\", \"z\": 0.5},\n \"mean_t\": np.array([2.0]),\n \"covariance_t\": np.array([[4.0]]),\n \"z\": 0.5,\n \"timestamp\": 50,\n },\n 1: {\n \"arm_name\": \"1_0\",\n \"parameters\": {\"x\": 0, \"y\": \"a\", \"z\": 1},\n \"mean\": 4.0,\n \"sem\": 4.0,\n \"trial_index\": 1,\n \"metric_name\": \"b\",\n \"updated_parameters\": {\"x\": 0, \"y\": \"a\", \"z\": 1},\n \"mean_t\": np.array([4.0]),\n \"covariance_t\": np.array([[16.0]]),\n \"z\": 1,\n \"timestamp\": 100,\n },\n 0.25: {\n \"arm_name\": \"2_0\",\n \"parameters\": {\"x\": 1, \"y\": \"a\", \"z\": 0.5},\n \"mean\": 3.0,\n \"sem\": 3.0,\n \"trial_index\": 2,\n \"metric_name\": \"a\",\n \"updated_parameters\": {\"x\": 1, \"y\": \"b\", \"z\": 0.25},\n \"mean_t\": np.array([3.0]),\n \"covariance_t\": np.array([[9.0]]),\n \"z\": 0.25,\n \"timestamp\": 25,\n },\n 0.75: {\n \"arm_name\": \"2_1\",\n \"parameters\": {\"x\": 1, \"y\": \"b\", \"z\": 0.75},\n \"mean\": 3.0,\n \"sem\": 3.0,\n \"trial_index\": 2,\n \"metric_name\": \"a\",\n \"updated_parameters\": {\"x\": 1, \"y\": \"b\", \"z\": 0.75},\n \"mean_t\": np.array([3.0]),\n \"covariance_t\": np.array([[9.0]]),\n \"z\": 0.75,\n \"timestamp\": 25,\n },\n }\n arms = {\n obs[\"arm_name\"]: Arm(name=obs[\"arm_name\"], parameters=obs[\"parameters\"])\n for _, obs in truth.items()\n }\n experiment = Mock()\n experiment._trial_indices_by_status = {status: set() for status in TrialStatus}\n trials = {\n obs[\"trial_index\"]: (\n Trial(experiment, GeneratorRun(arms=[arms[obs[\"arm_name\"]]]))\n )\n for _, obs in list(truth.items())[:-1]\n if not obs[\"arm_name\"].startswith(\"2\")\n }\n batch = BatchTrial(experiment, GeneratorRun(arms=[arms[\"2_0\"], arms[\"2_1\"]]))\n trials.update({2: batch})\n trials.get(1).mark_abandoned()\n trials.get(2).mark_arm_abandoned(arm_name=\"2_1\")\n type(experiment).arms_by_name = PropertyMock(return_value=arms)\n type(experiment).trials = PropertyMock(return_value=trials)\n\n df = pd.DataFrame(list(truth.values()))[\n [\"arm_name\", \"trial_index\", \"mean\", \"sem\", \"metric_name\"]\n ]\n data = Data(df=df)\n\n # 1 arm is abandoned and 1 trial is abandoned, so only 2 observations should be\n # included.\n obs_no_abandoned = observations_from_data(experiment, data)\n self.assertEqual(len(obs_no_abandoned), 2)\n\n # 1 arm is abandoned and 1 trial is abandoned, so only 2 observations should be\n # included.\n obs_with_abandoned = observations_from_data(\n experiment, data, include_abandoned=True\n )\n self.assertEqual(len(obs_with_abandoned), 4)\n\n def testObservationsFromDataWithSomeMissingTimes(self):\n truth = [\n {\n \"arm_name\": \"0_0\",\n \"parameters\": {\"x\": 0, \"y\": \"a\"},\n \"mean\": 2.0,\n \"sem\": 2.0,\n \"trial_index\": 1,\n \"metric_name\": \"a\",\n \"start_time\": 0,\n },\n {\n \"arm_name\": \"0_1\",\n \"parameters\": {\"x\": 1, \"y\": \"b\"},\n \"mean\": 3.0,\n \"sem\": 3.0,\n \"trial_index\": 2,\n \"metric_name\": \"a\",\n \"start_time\": 0,\n },\n {\n \"arm_name\": \"0_0\",\n \"parameters\": {\"x\": 0, \"y\": \"a\"},\n \"mean\": 4.0,\n \"sem\": 4.0,\n \"trial_index\": 1,\n \"metric_name\": \"b\",\n \"start_time\": None,\n },\n {\n \"arm_name\": \"0_1\",\n \"parameters\": {\"x\": 1, \"y\": \"b\"},\n \"mean\": 5.0,\n \"sem\": 5.0,\n \"trial_index\": 2,\n \"metric_name\": \"b\",\n \"start_time\": None,\n },\n ]\n arms = {\n obs[\"arm_name\"]: Arm(name=obs[\"arm_name\"], parameters=obs[\"parameters\"])\n for obs in truth\n }\n experiment = Mock()\n experiment._trial_indices_by_status = {status: set() for status in TrialStatus}\n trials = {\n obs[\"trial_index\"]: Trial(\n experiment, GeneratorRun(arms=[arms[obs[\"arm_name\"]]])\n )\n for obs in truth\n }\n type(experiment).arms_by_name = PropertyMock(return_value=arms)\n type(experiment).trials = PropertyMock(return_value=trials)\n\n df = pd.DataFrame(truth)[\n [\"arm_name\", \"trial_index\", \"mean\", \"sem\", \"metric_name\", \"start_time\"]\n ]\n data = Data(df=df)\n observations = observations_from_data(experiment, data)\n\n self.assertEqual(len(observations), 2)\n # Get them in the order we want for tests below\n if observations[0].features.parameters[\"x\"] == 1:\n observations.reverse()\n\n obsd_truth = {\n \"metric_names\": [[\"a\", \"b\"], [\"a\", \"b\"]],\n \"means\": [np.array([2.0, 4.0]), np.array([3.0, 5.0])],\n \"covariance\": [np.diag([4.0, 16.0]), np.diag([9.0, 25.0])],\n }\n cname_truth = [\"0_0\", \"0_1\"]\n\n for i, obs in enumerate(observations):\n self.assertEqual(obs.features.parameters, truth[i][\"parameters\"])\n self.assertEqual(obs.features.trial_index, truth[i][\"trial_index\"])\n self.assertEqual(obs.data.metric_names, obsd_truth[\"metric_names\"][i])\n self.assertTrue(np.array_equal(obs.data.means, obsd_truth[\"means\"][i]))\n self.assertTrue(\n np.array_equal(obs.data.covariance, obsd_truth[\"covariance\"][i])\n )\n self.assertEqual(obs.arm_name, cname_truth[i])\n\n def testSeparateObservations(self):\n obs = Observation(\n features=ObservationFeatures(parameters={\"x\": 20}),\n data=ObservationData(\n means=np.array([1]), covariance=np.array([[2]]), metric_names=[\"a\"]\n ),\n arm_name=\"0_0\",\n )\n obs_feats, obs_data = separate_observations(observations=[obs])\n self.assertEqual(obs.features, ObservationFeatures(parameters={\"x\": 20}))\n self.assertEqual(\n obs.data,\n ObservationData(\n means=np.array([1]), covariance=np.array([[2]]), metric_names=[\"a\"]\n ),\n )\n obs_feats, obs_data = separate_observations(observations=[obs], copy=True)\n self.assertEqual(obs.features, ObservationFeatures(parameters={\"x\": 20}))\n self.assertEqual(\n obs.data,\n ObservationData(\n means=np.array([1]), covariance=np.array([[2]]), metric_names=[\"a\"]\n ),\n )\n\n def testObservationsWithCandidateMetadata(self):\n SOME_METADATA_KEY = \"metadatum\"\n truth = [\n {\n \"arm_name\": \"0_0\",\n \"parameters\": {\"x\": 0, \"y\": \"a\"},\n \"mean\": 2.0,\n \"sem\": 2.0,\n \"trial_index\": 0,\n \"metric_name\": \"a\",\n },\n {\n \"arm_name\": \"1_0\",\n \"parameters\": {\"x\": 1, \"y\": \"b\"},\n \"mean\": 3.0,\n \"sem\": 3.0,\n \"trial_index\": 1,\n \"metric_name\": \"a\",\n },\n ]\n arms = {\n obs[\"arm_name\"]: Arm(name=obs[\"arm_name\"], parameters=obs[\"parameters\"])\n for obs in truth\n }\n experiment = Mock()\n experiment._trial_indices_by_status = {status: set() for status in TrialStatus}\n trials = {\n obs[\"trial_index\"]: Trial(\n experiment,\n GeneratorRun(\n arms=[arms[obs[\"arm_name\"]]],\n candidate_metadata_by_arm_signature={\n arms[obs[\"arm_name\"]].signature: {\n SOME_METADATA_KEY: f\"value_{obs['trial_index']}\"\n }\n },\n ),\n )\n for obs in truth\n }\n type(experiment).arms_by_name = PropertyMock(return_value=arms)\n type(experiment).trials = PropertyMock(return_value=trials)\n\n df = pd.DataFrame(truth)[\n [\"arm_name\", \"trial_index\", \"mean\", \"sem\", \"metric_name\"]\n ]\n data = Data(df=df)\n observations = observations_from_data(experiment, data)\n for observation in observations:\n self.assertEqual(\n observation.features.metadata.get(SOME_METADATA_KEY),\n f\"value_{observation.features.trial_index}\",\n )\n"
] |
[
[
"numpy.array",
"sklearn.preprocessing.PowerTransformer"
],
[
"numpy.array",
"numpy.array_equal",
"numpy.set_printoptions",
"pandas.DataFrame",
"pandas.Timestamp",
"numpy.diag",
"numpy.datetime64"
]
] |
simonjayhawkins/fletcher
|
[
"b8e541f2bfb8973c4290698f0c576d62980a0ce4",
"b8e541f2bfb8973c4290698f0c576d62980a0ce4"
] |
[
"tests/test_pandas_extension.py",
"tests/test_numba_integration.py"
] |
[
"import datetime\nimport string\nfrom collections import namedtuple\nfrom distutils.version import LooseVersion\nfrom random import choices\nfrom typing import Optional, Type\n\nimport numpy as np\nimport pandas as pd\nimport pyarrow as pa\nimport pytest\nfrom pandas.tests.extension.base import (\n BaseArithmeticOpsTests,\n BaseBooleanReduceTests,\n BaseCastingTests,\n BaseComparisonOpsTests,\n BaseConstructorsTests,\n BaseDtypeTests,\n BaseGetitemTests,\n BaseGroupbyTests,\n BaseInterfaceTests,\n BaseMethodsTests,\n BaseMissingTests,\n BaseNoReduceTests,\n BaseNumericReduceTests,\n BaseParsingTests,\n BasePrintingTests,\n BaseReshapingTests,\n BaseSetitemTests,\n)\n\nfrom fletcher import FletcherBaseDtype\n\nif LooseVersion(pd.__version__) >= \"0.25.0\":\n # imports of pytest fixtures needed for derived unittest classes\n from pandas.tests.extension.conftest import ( # noqa: F401\n as_array, # noqa: F401\n use_numpy, # noqa: F401\n groupby_apply_op, # noqa: F401\n as_frame, # noqa: F401\n as_series, # noqa: F401\n )\n\n\nPANDAS_GE_1_1_0 = LooseVersion(pd.__version__) >= \"1.1.0\"\n\n\nFletcherTestType = namedtuple(\n \"FletcherTestType\",\n [\n \"dtype\",\n \"data\",\n \"data_missing\",\n \"data_for_grouping\",\n \"data_for_sorting\",\n \"data_missing_for_sorting\",\n \"data_repeated\",\n ],\n)\n\n\ndef is_arithmetic_type(arrow_dtype: pa.DataType) -> bool:\n \"\"\"Check whether this is a type that support arithmetics.\"\"\"\n return (\n pa.types.is_integer(arrow_dtype)\n or pa.types.is_floating(arrow_dtype)\n or pa.types.is_decimal(arrow_dtype)\n )\n\n\nskip_non_artithmetic_type = pytest.mark.skip_by_type_filter(\n [lambda x: not is_arithmetic_type(x)]\n)\nxfail_list_scalar_constuctor_not_implemented = pytest.mark.xfail_by_type_filter(\n [pa.types.is_list], \"constructor from scalars is not implemented for lists\"\n)\nxfail_list_equals_not_implemented = pytest.mark.xfail_by_type_filter(\n [pa.types.is_list], \"== is not implemented for lists\"\n)\nxfail_list_setitem_not_implemented = pytest.mark.xfail_by_type_filter(\n [pa.types.is_list], \"__setitem__ is not implemented for lists\"\n)\nxfail_missing_list_dict_encode = pytest.mark.xfail_by_type_filter(\n [pa.types.is_list],\n \"ArrowNotImplementedError: dictionary-encode not implemented for list<item: string>\",\n)\nxfail_bool_too_few_uniques = pytest.mark.xfail_by_type_filter(\n [pa.types.is_boolean], \"Test requires at least 3 unique values\"\n)\n\n\ntest_types = [\n FletcherTestType(\n pa.string(),\n [\"🙈\", \"Ö\", \"Č\", \"a\", \"B\"] * 20,\n [None, \"A\"],\n [\"B\", \"B\", None, None, \"A\", \"A\", \"B\", \"C\"],\n [\"B\", \"C\", \"A\"],\n [\"B\", None, \"A\"],\n lambda: choices(list(string.ascii_letters), k=10),\n ),\n FletcherTestType(\n pa.bool_(),\n [True, False, True, True, False] * 20,\n [None, False],\n [True, True, None, None, False, False, True, False],\n [True, False, False],\n [True, None, False],\n lambda: choices([True, False], k=10),\n ),\n FletcherTestType(\n pa.int8(),\n # Use small values here so that np.prod stays in int32\n [2, 1, 1, 2, 1] * 20,\n [None, 1],\n [2, 2, None, None, -100, -100, 2, 100],\n [2, 100, -10],\n [2, None, -10],\n lambda: choices(list(range(100)), k=10),\n ),\n FletcherTestType(\n pa.int16(),\n # Use small values here so that np.prod stays in int32\n [2, 1, 3, 2, 1] * 20,\n [None, 1],\n [2, 2, None, None, -100, -100, 2, 100],\n [2, 100, -10],\n [2, None, -10],\n lambda: choices(list(range(100)), k=10),\n ),\n FletcherTestType(\n pa.int32(),\n # Use small values here so that np.prod stays in int32\n [2, 1, 3, 2, 1] * 20,\n [None, 1],\n [2, 2, None, None, -100, -100, 2, 100],\n [2, 100, -10],\n [2, None, -10],\n lambda: choices(list(range(100)), k=10),\n ),\n FletcherTestType(\n pa.int64(),\n # Use small values here so that np.prod stays in int64\n [2, 1, 3, 2, 1] * 20,\n [None, 1],\n [2, 2, None, None, -100, -100, 2, 100],\n [2, 100, -10],\n [2, None, -10],\n lambda: choices(list(range(100)), k=10),\n ),\n FletcherTestType(\n pa.float64(),\n [2, 1.0, 1.0, 5.5, 6.6] * 20,\n [None, 1.1],\n [2.5, 2.5, None, None, -100.1, -100.1, 2.5, 100.1],\n [2.5, 100.99, -10.1],\n [2.5, None, -10.1],\n lambda: choices([2.5, 1.0, -1.0, 0, 66.6], k=10),\n ),\n # Most of the tests fail as assert_extension_array_equal casts to numpy object\n # arrays and on them equality is not defined.\n pytest.param(\n FletcherTestType(\n pa.list_(pa.string()),\n [[\"B\", \"C\"], [\"A\"], [None], [\"A\", \"A\"], []] * 20,\n [None, [\"A\"]],\n [[\"B\"], [\"B\"], None, None, [\"A\"], [\"A\"], [\"B\"], [\"C\"]],\n [[\"B\"], [\"C\"], [\"A\"]],\n [[\"B\"], None, [\"A\"]],\n lambda: choices([[\"B\", \"C\"], [\"A\"], [None], [\"A\", \"A\"]], k=10),\n )\n ),\n FletcherTestType(\n pa.date64(),\n [\n datetime.date(2015, 1, 1),\n datetime.date(2010, 12, 31),\n datetime.date(1970, 1, 1),\n datetime.date(1900, 3, 31),\n datetime.date(1999, 12, 31),\n ]\n * 20,\n [None, datetime.date(2015, 1, 1)],\n [\n datetime.date(2015, 2, 2),\n datetime.date(2015, 2, 2),\n None,\n None,\n datetime.date(2015, 1, 1),\n datetime.date(2015, 1, 1),\n datetime.date(2015, 2, 2),\n datetime.date(2015, 3, 3),\n ],\n [\n datetime.date(2015, 2, 2),\n datetime.date(2015, 3, 3),\n datetime.date(2015, 1, 1),\n ],\n [datetime.date(2015, 2, 2), None, datetime.date(2015, 1, 1)],\n lambda: choices(list(pd.date_range(\"2010-1-1\", \"2011-1-1\").date), k=10),\n ),\n]\n\n\n@pytest.fixture(params=[True, False])\ndef box_in_series(request):\n \"\"\"Whether to box the data in a Series.\"\"\"\n return request.param\n\n\n@pytest.fixture(params=test_types)\ndef fletcher_type(request):\n return request.param\n\n\n@pytest.fixture(autouse=True)\ndef skip_by_type_filter(request, fletcher_type):\n if request.node.get_closest_marker(\"skip_by_type_filter\"):\n for marker in request.node.iter_markers(\"skip_by_type_filter\"):\n for func in marker.args[0]:\n if func(fletcher_type.dtype):\n pytest.skip(f\"skipped for type: {fletcher_type}\")\n\n\n@pytest.fixture(autouse=True)\ndef xfail_by_type_filter(request, fletcher_type):\n if request.node.get_closest_marker(\"xfail_by_type_filter\"):\n for marker in request.node.iter_markers(\"xfail_by_type_filter\"):\n for func in marker.args[0]:\n if func(fletcher_type.dtype):\n pytest.xfail(f\"XFAIL for type: {fletcher_type}\")\n\n\n@pytest.fixture\ndef dtype(fletcher_type, fletcher_dtype):\n return fletcher_dtype(fletcher_type.dtype)\n\n\n@pytest.fixture\ndef data(fletcher_type, fletcher_array):\n return fletcher_array(fletcher_type.data, dtype=fletcher_type.dtype)\n\n\n@pytest.fixture\ndef data_for_twos(dtype, fletcher_type, fletcher_array):\n if dtype._is_numeric:\n return fletcher_array([2] * 100, dtype=fletcher_type.dtype)\n else:\n return None\n\n\n@pytest.fixture\ndef data_missing(fletcher_type, fletcher_array):\n return fletcher_array(fletcher_type.data_missing, dtype=fletcher_type.dtype)\n\n\n@pytest.fixture\ndef data_repeated(fletcher_type, fletcher_array):\n \"\"\"Return different versions of data for count times.\"\"\"\n pass # noqa\n\n def gen(count):\n for _ in range(count):\n yield fletcher_array(\n fletcher_type.data_repeated(), dtype=fletcher_type.dtype\n )\n\n yield gen\n\n\n@pytest.fixture\ndef data_for_grouping(fletcher_type, fletcher_array):\n \"\"\"Fixture with data for factorization, grouping, and unique tests.\n\n Expected to be like [B, B, NA, NA, A, A, B, C]\n\n Where A < B < C and NA is missing\n \"\"\"\n return fletcher_array(fletcher_type.data_for_grouping, dtype=fletcher_type.dtype)\n\n\n@pytest.fixture\ndef data_for_sorting(fletcher_type, fletcher_array):\n \"\"\"Length-3 array with a known sort order.\n\n This should be three items [B, C, A] with\n A < B < C\n \"\"\"\n return fletcher_array(fletcher_type.data_for_sorting, dtype=fletcher_type.dtype)\n\n\n@pytest.fixture\ndef data_missing_for_sorting(fletcher_type, fletcher_array):\n \"\"\"Length-3 array with a known sort order.\n\n This should be three items [B, NA, A] with\n A < B and NA missing.\n \"\"\"\n return fletcher_array(\n fletcher_type.data_missing_for_sorting, dtype=fletcher_type.dtype\n )\n\n\n@pytest.fixture(params=[None, lambda x: x])\ndef sort_by_key(request):\n \"\"\"\n Return a simple fixture for festing keys in sorting methods.\n\n Tests None (no key) and the identity key.\n \"\"\"\n return request.param\n\n\nclass TestBaseCasting(BaseCastingTests):\n pass\n\n\nclass TestBaseConstructors(BaseConstructorsTests):\n def test_from_dtype(self, data):\n if pa.types.is_string(data.dtype.arrow_dtype):\n pytest.xfail(\n \"String construction is failing as Pandas wants to pass the FletcherChunkedDtype to NumPy\"\n )\n BaseConstructorsTests.test_from_dtype(self, data)\n\n @xfail_list_scalar_constuctor_not_implemented\n def test_series_constructor_scalar_with_index(self, data, dtype):\n if PANDAS_GE_1_1_0:\n BaseConstructorsTests.test_series_constructor_scalar_with_index(\n self, data, dtype\n )\n\n\nclass TestBaseDtype(BaseDtypeTests):\n pass\n\n\nclass TestBaseGetitemTests(BaseGetitemTests):\n def test_loc_iloc_frame_single_dtype(self, data):\n if pa.types.is_string(data.dtype.arrow_dtype):\n pytest.mark.xfail(\n reason=\"https://github.com/pandas-dev/pandas/issues/27673\"\n )\n else:\n BaseGetitemTests.test_loc_iloc_frame_single_dtype(self, data)\n\n\nclass TestBaseGroupbyTests(BaseGroupbyTests):\n @xfail_bool_too_few_uniques\n @xfail_missing_list_dict_encode\n @pytest.mark.parametrize(\"as_index\", [True, False])\n def test_groupby_extension_agg(self, as_index, data_for_grouping):\n BaseGroupbyTests.test_groupby_extension_agg(self, as_index, data_for_grouping)\n\n @xfail_bool_too_few_uniques\n @xfail_missing_list_dict_encode\n def test_groupby_extension_no_sort(self, data_for_grouping):\n BaseGroupbyTests.test_groupby_extension_no_sort(self, data_for_grouping)\n\n @xfail_missing_list_dict_encode\n def test_groupby_extension_transform(self, data_for_grouping):\n if pa.types.is_boolean(data_for_grouping.dtype.arrow_dtype):\n valid = data_for_grouping[~data_for_grouping.isna()]\n df = pd.DataFrame({\"A\": [1, 1, 3, 3, 1, 4], \"B\": valid})\n\n result = df.groupby(\"B\").A.transform(len)\n # Expected grouping is different as we only have two non-null values\n expected = pd.Series([3, 3, 3, 3, 3, 3], name=\"A\")\n\n self.assert_series_equal(result, expected)\n else:\n BaseGroupbyTests.test_groupby_extension_transform(self, data_for_grouping)\n\n @xfail_missing_list_dict_encode\n def test_groupby_extension_apply(\n self, data_for_grouping, groupby_apply_op # noqa: F811\n ):\n BaseGroupbyTests.test_groupby_extension_apply(\n self, data_for_grouping, groupby_apply_op\n )\n\n\nclass TestBaseInterfaceTests(BaseInterfaceTests):\n @pytest.mark.xfail(\n reason=\"view or self[:] returns a shallow copy in-place edits are not backpropagated\"\n )\n def test_view(self, data):\n BaseInterfaceTests.test_view(self, data)\n\n def test_array_interface(self, data):\n if pa.types.is_list(data.dtype.arrow_dtype):\n pytest.xfail(\"Not sure whether this test really holds for list\")\n else:\n BaseInterfaceTests.test_array_interface(self, data)\n\n @xfail_list_setitem_not_implemented\n def test_copy(self, data):\n BaseInterfaceTests.test_array_interface(self, data)\n\n\nclass TestBaseMethodsTests(BaseMethodsTests):\n\n # https://github.com/pandas-dev/pandas/issues/22843\n @pytest.mark.skip(reason=\"Incorrect expected\")\n @pytest.mark.parametrize(\"dropna\", [True, False])\n def test_value_counts(self, all_data, dropna, dtype):\n pass\n\n @xfail_list_equals_not_implemented\n @pytest.mark.parametrize(\"box\", [pd.array, pd.Series, pd.DataFrame])\n def test_equals(self, data, na_value, as_series, box): # noqa: F811\n if PANDAS_GE_1_1_0:\n BaseMethodsTests.test_equals(self, data, na_value, as_series, box)\n\n @xfail_missing_list_dict_encode\n def test_value_counts_with_normalize(self, data):\n if PANDAS_GE_1_1_0:\n BaseMethodsTests.test_value_counts_with_normalize(self, data)\n\n def test_combine_le(self, data_repeated):\n # GH 20825\n # Test that combine works when doing a <= (le) comparison\n # Fletcher returns 'fletcher_chunked[bool]' instead of np.bool as dtype\n orig_data1, orig_data2 = data_repeated(2)\n if pa.types.is_list(orig_data1.dtype.arrow_dtype):\n return pytest.skip(\"__le__ not implemented for list scalars with None\")\n s1 = pd.Series(orig_data1)\n s2 = pd.Series(orig_data2)\n result = s1.combine(s2, lambda x1, x2: x1 <= x2)\n expected = pd.Series(\n orig_data1._from_sequence(\n [a <= b for (a, b) in zip(list(orig_data1), list(orig_data2))]\n )\n )\n self.assert_series_equal(result, expected)\n\n val = s1.iloc[0]\n result = s1.combine(val, lambda x1, x2: x1 <= x2)\n expected = pd.Series(\n orig_data1._from_sequence([a <= val for a in list(orig_data1)])\n )\n self.assert_series_equal(result, expected)\n\n def test_combine_add(self, data_repeated, dtype):\n if dtype.name in [\n \"fletcher_chunked[date64[ms]]\",\n \"fletcher_continuous[date64[ms]]\",\n ]:\n pytest.skip(\n \"unsupported operand type(s) for +: 'datetime.date' and 'datetime.date\"\n )\n else:\n BaseMethodsTests.test_combine_add(self, data_repeated)\n\n @xfail_bool_too_few_uniques\n def test_argsort(self, data_for_sorting):\n BaseMethodsTests.test_argsort(self, data_for_sorting)\n\n @xfail_bool_too_few_uniques\n def test_argmin_argmax(self, data_for_sorting, data_missing_for_sorting, na_value):\n if PANDAS_GE_1_1_0:\n BaseMethodsTests.test_argmin_argmax(\n self, data_for_sorting, data_missing_for_sorting, na_value\n )\n else:\n pass\n\n @pytest.mark.parametrize(\"ascending\", [True, False])\n @xfail_bool_too_few_uniques\n @xfail_missing_list_dict_encode\n def test_sort_values(self, data_for_sorting, ascending, sort_by_key):\n if PANDAS_GE_1_1_0:\n BaseMethodsTests.test_sort_values(\n self, data_for_sorting, ascending, sort_by_key\n )\n else:\n BaseMethodsTests.test_sort_values(self, data_for_sorting, ascending)\n\n @pytest.mark.parametrize(\"na_sentinel\", [-1, -2])\n @xfail_bool_too_few_uniques\n @xfail_missing_list_dict_encode\n def test_factorize(self, data_for_grouping, na_sentinel):\n BaseMethodsTests.test_factorize(self, data_for_grouping, na_sentinel)\n\n @pytest.mark.parametrize(\"na_sentinel\", [-1, -2])\n @xfail_bool_too_few_uniques\n @xfail_missing_list_dict_encode\n def test_factorize_equivalence(self, data_for_grouping, na_sentinel):\n BaseMethodsTests.test_factorize_equivalence(\n self, data_for_grouping, na_sentinel\n )\n\n @pytest.mark.parametrize(\"ascending\", [True, False])\n @xfail_missing_list_dict_encode\n def test_sort_values_frame(self, data_for_sorting, ascending):\n BaseMethodsTests.test_sort_values_frame(self, data_for_sorting, ascending)\n\n @xfail_bool_too_few_uniques\n def test_searchsorted(self, data_for_sorting, as_series): # noqa: F811\n BaseMethodsTests.test_searchsorted(self, data_for_sorting, as_series)\n\n @pytest.mark.parametrize(\"box\", [pd.Series, lambda x: x])\n @pytest.mark.parametrize(\"method\", [lambda x: x.unique(), pd.unique])\n @xfail_missing_list_dict_encode\n def test_unique(self, data, box, method):\n BaseMethodsTests.test_unique(self, data, box, method)\n\n @xfail_missing_list_dict_encode\n def test_factorize_empty(self, data):\n BaseMethodsTests.test_factorize_empty(self, data)\n\n def test_fillna_copy_frame(self, data_missing):\n if pa.types.is_list(data_missing.dtype.arrow_dtype):\n pytest.xfail(\"pandas' fillna cannot cope with lists as a scalar\")\n else:\n BaseMethodsTests.test_fillna_copy_frame(self, data_missing)\n\n def test_fillna_copy_series(self, data_missing):\n if pa.types.is_list(data_missing.dtype.arrow_dtype):\n pytest.xfail(\"pandas' fillna cannot cope with lists as a scalar\")\n else:\n BaseMethodsTests.test_fillna_copy_series(self, data_missing)\n\n @xfail_list_setitem_not_implemented\n def test_combine_first(self, data):\n BaseMethodsTests.test_combine_first(self, data)\n\n @xfail_list_setitem_not_implemented\n def test_shift_0_periods(self, data):\n if PANDAS_GE_1_1_0:\n BaseMethodsTests.test_shift_0_periods(self, data)\n\n def test_shift_fill_value(self, data):\n if pa.types.is_list(data.dtype.arrow_dtype):\n pytest.xfail(\"pandas' isna cannot cope with lists\")\n else:\n BaseMethodsTests.test_shift_fill_value(self, data)\n\n def test_hash_pandas_object_works(self, data, as_frame): # noqa: F811\n if pa.types.is_list(data.dtype.arrow_dtype):\n pytest.xfail(\"Fails on hashing ndarrays\")\n else:\n BaseMethodsTests.test_hash_pandas_object_works(self, data, as_frame)\n\n @xfail_list_setitem_not_implemented\n def test_where_series(self, data, na_value, as_frame): # noqa: F811\n BaseMethodsTests.test_where_series(self, data, na_value, as_frame)\n\n\nclass TestBaseMissingTests(BaseMissingTests):\n @pytest.mark.parametrize(\"method\", [\"ffill\", \"bfill\"])\n def test_fillna_series_method(self, data_missing, method):\n BaseMissingTests.test_fillna_series_method(self, data_missing, method)\n\n def test_fillna_frame(self, data_missing):\n if pa.types.is_list(data_missing.dtype.arrow_dtype):\n pytest.xfail(\"pandas' fillna cannot cope with lists as a scalar\")\n else:\n BaseMissingTests.test_fillna_frame(self, data_missing)\n\n def test_fillna_scalar(self, data_missing):\n if pa.types.is_list(data_missing.dtype.arrow_dtype):\n pytest.xfail(\"pandas' fillna cannot cope with lists as a scalar\")\n else:\n BaseMissingTests.test_fillna_scalar(self, data_missing)\n\n def test_fillna_series(self, data_missing):\n if pa.types.is_list(data_missing.dtype.arrow_dtype):\n pytest.xfail(\"pandas' fillna cannot cope with lists as a scalar\")\n else:\n BaseMissingTests.test_fillna_series(self, data_missing)\n\n\nclass TestBaseReshapingTests(BaseReshapingTests):\n def test_concat_mixed_dtypes(self, data, dtype):\n arrow_dtype = data.dtype.arrow_dtype\n if (\n pa.types.is_integer(arrow_dtype)\n or pa.types.is_floating(arrow_dtype)\n or pa.types.is_boolean(arrow_dtype)\n ):\n # https://github.com/pandas-dev/pandas/issues/21792\n pytest.skip(\"pd.concat(int64, fletcher_chunked[int64] yields int64\")\n elif pa.types.is_temporal(arrow_dtype):\n # https://github.com/pandas-dev/pandas/issues/33331\n pytest.xfail(\"pd.concat(temporal, categorical) mangles dates\")\n else:\n BaseReshapingTests.test_concat_mixed_dtypes(self, data)\n\n def test_merge_on_extension_array(self, data):\n if pa.types.is_list(data.dtype.arrow_dtype):\n pytest.xfail(\"pandas tries to hash scalar lists\")\n else:\n BaseReshapingTests.test_merge_on_extension_array(self, data)\n\n def test_merge_on_extension_array_duplicates(self, data):\n if pa.types.is_list(data.dtype.arrow_dtype):\n pytest.xfail(\"pandas tries to hash scalar lists\")\n else:\n BaseReshapingTests.test_merge_on_extension_array_duplicates(self, data)\n\n @xfail_list_setitem_not_implemented\n def test_ravel(self, data):\n BaseReshapingTests.test_ravel(self, data)\n\n @xfail_list_setitem_not_implemented\n @pytest.mark.xfail(reason=\"Views don't update their parent #96\")\n def test_transpose(self, data):\n if hasattr(BaseReshapingTests, \"test_transpose\"):\n BaseReshapingTests.test_transpose(self, data)\n\n\nclass TestBaseSetitemTests(BaseSetitemTests):\n @xfail_list_setitem_not_implemented\n def test_setitem_scalar_series(self, data, box_in_series):\n BaseSetitemTests.test_setitem_scalar_series(self, data, box_in_series)\n\n @xfail_list_setitem_not_implemented\n def test_setitem_sequence(self, data, box_in_series):\n BaseSetitemTests.test_setitem_sequence(self, data, box_in_series)\n\n @xfail_list_setitem_not_implemented\n def test_setitem_empty_indxer(self, data, box_in_series):\n BaseSetitemTests.test_setitem_empty_indxer(self, data, box_in_series)\n\n @xfail_list_setitem_not_implemented\n def test_setitem_sequence_broadcasts(self, data, box_in_series):\n BaseSetitemTests.test_setitem_sequence_broadcasts(self, data, box_in_series)\n\n @pytest.mark.parametrize(\"setter\", [\"loc\", \"iloc\"])\n @xfail_list_setitem_not_implemented\n def test_setitem_scalar(self, data, setter):\n BaseSetitemTests.test_setitem_scalar(self, data, setter)\n\n @xfail_list_setitem_not_implemented\n def test_setitem_loc_scalar_mixed(self, data):\n BaseSetitemTests.test_setitem_loc_scalar_mixed(self, data)\n\n @xfail_list_setitem_not_implemented\n def test_setitem_loc_scalar_single(self, data):\n BaseSetitemTests.test_setitem_loc_scalar_single(self, data)\n\n @xfail_list_setitem_not_implemented\n def test_setitem_loc_scalar_multiple_homogoneous(self, data):\n BaseSetitemTests.test_setitem_loc_scalar_multiple_homogoneous(self, data)\n\n @xfail_list_setitem_not_implemented\n def test_setitem_iloc_scalar_mixed(self, data):\n BaseSetitemTests.test_setitem_iloc_scalar_mixed(self, data)\n\n @xfail_list_setitem_not_implemented\n def test_setitem_iloc_scalar_single(self, data):\n BaseSetitemTests.test_setitem_iloc_scalar_single(self, data)\n\n @xfail_list_setitem_not_implemented\n def test_setitem_iloc_scalar_multiple_homogoneous(self, data):\n BaseSetitemTests.test_setitem_iloc_scalar_multiple_homogoneous(self, data)\n\n @xfail_list_setitem_not_implemented\n def test_setitem_nullable_mask(self, data):\n if not PANDAS_GE_1_1_0:\n BaseSetitemTests.test_setitem_nullable_mask(self, data)\n\n @pytest.mark.parametrize(\"as_callable\", [True, False])\n @pytest.mark.parametrize(\"setter\", [\"loc\", None])\n @xfail_list_setitem_not_implemented\n def test_setitem_mask_aligned(self, data, as_callable, setter):\n BaseSetitemTests.test_setitem_mask_aligned(self, data, as_callable, setter)\n\n @pytest.mark.parametrize(\"setter\", [\"loc\", None])\n @xfail_list_setitem_not_implemented\n def test_setitem_mask_broadcast(self, data, setter):\n BaseSetitemTests.test_setitem_mask_broadcast(self, data, setter)\n\n @xfail_list_setitem_not_implemented\n def test_setitem_slice(self, data, box_in_series):\n if PANDAS_GE_1_1_0:\n BaseSetitemTests.test_setitem_slice(self, data, box_in_series)\n\n @xfail_list_setitem_not_implemented\n def test_setitem_loc_iloc_slice(self, data):\n if PANDAS_GE_1_1_0:\n BaseSetitemTests.test_setitem_loc_iloc_slice(self, data)\n\n @xfail_list_setitem_not_implemented\n def test_setitem_slice_array(self, data):\n BaseSetitemTests.test_setitem_slice_array(self, data)\n\n @xfail_list_setitem_not_implemented\n @pytest.mark.parametrize(\n \"mask\",\n [\n np.array([True, True, True, False, False]),\n pd.array([True, True, True, False, False], dtype=\"boolean\"),\n pd.array([True, True, True, pd.NA, pd.NA], dtype=\"boolean\"),\n ],\n ids=[\"numpy-array\", \"boolean-array\", \"boolean-array-na\"],\n )\n def test_setitem_mask(self, data, mask, box_in_series):\n if PANDAS_GE_1_1_0:\n BaseSetitemTests.test_setitem_mask(self, data, mask, box_in_series)\n\n @pytest.mark.xfail(reason=\"Views don't update their parent #96\")\n def test_setitem_preserves_views(self, data):\n pass\n\n @xfail_list_setitem_not_implemented\n def test_setitem_mask_boolean_array_with_na(self, data, box_in_series):\n if PANDAS_GE_1_1_0:\n BaseSetitemTests.test_setitem_mask_boolean_array_with_na(\n self, data, box_in_series\n )\n\n @pytest.mark.parametrize(\n \"idx\",\n [[0, 1, 2], pd.array([0, 1, 2], dtype=\"Int64\"), np.array([0, 1, 2])],\n ids=[\"list\", \"integer-array\", \"numpy-array\"],\n )\n @pytest.mark.xfail(reason=\"https://github.com/xhochy/fletcher/issues/110\")\n def test_setitem_integer_array(self, data, idx, box_in_series):\n if PANDAS_GE_1_1_0:\n BaseSetitemTests.test_setitem_integer_array(self, data, idx, box_in_series)\n\n\nclass TestBaseParsingTests(BaseParsingTests):\n @pytest.mark.parametrize(\"engine\", [\"c\", \"python\"])\n def test_EA_types(self, engine, data):\n pytest.mark.xfail(\n \"pandas doesn't yet support registering ExtentionDtypes via a pattern\"\n )\n\n\nclass TestBasePrintingTests(BasePrintingTests):\n pass\n\n\nclass TestBaseBooleanReduceTests(BaseBooleanReduceTests):\n @pytest.mark.parametrize(\"skipna\", [True, False])\n def test_reduce_series(self, data, all_boolean_reductions, skipna):\n if pa.types.is_boolean(data.dtype.arrow_dtype):\n BaseBooleanReduceTests.test_reduce_series(\n self, data, all_boolean_reductions, skipna\n )\n else:\n pytest.skip(\"Boolean reductions are only tested with boolean types\")\n\n\nclass TestBaseNoReduceTests(BaseNoReduceTests):\n @pytest.mark.parametrize(\"skipna\", [True, False])\n def test_reduce_series_numeric(self, data, all_numeric_reductions, skipna):\n arrow_dtype = data.dtype.arrow_dtype\n if (\n pa.types.is_integer(arrow_dtype)\n or pa.types.is_floating(arrow_dtype)\n or pa.types.is_decimal(arrow_dtype)\n ):\n pytest.skip(\"Numeric arrays implement reductions, so don't raise\")\n else:\n BaseNoReduceTests.test_reduce_series_numeric(\n self, data, all_numeric_reductions, skipna\n )\n\n @pytest.mark.parametrize(\"skipna\", [True, False])\n def test_reduce_series_boolean(self, data, all_boolean_reductions, skipna):\n if pa.types.is_boolean(data.dtype.arrow_dtype):\n pytest.skip(\"BooleanArray does define boolean reductions, so don't raise\")\n else:\n BaseNoReduceTests.test_reduce_series_boolean(\n self, data, all_boolean_reductions, skipna\n )\n\n\nclass TestBaseNumericReduceTests(BaseNumericReduceTests):\n @pytest.mark.parametrize(\"skipna\", [True, False])\n def test_reduce_series(self, data, all_numeric_reductions, skipna):\n if all_numeric_reductions == \"prod\":\n # Shorten in the case of prod to avoid overflows\n data = data[:2]\n arrow_dtype = data.dtype.arrow_dtype\n if (\n pa.types.is_integer(arrow_dtype)\n or pa.types.is_floating(arrow_dtype)\n or pa.types.is_decimal(arrow_dtype)\n ):\n BaseNumericReduceTests.test_reduce_series(\n self, data, all_numeric_reductions, skipna\n )\n else:\n pytest.skip(\"Reduce not implemented on non-numeric types\")\n\n\nclass TestBaseComparisonOpsTests(BaseComparisonOpsTests):\n def check_opname(self, s, op_name, other, exc=None):\n super().check_opname(s, op_name, other, exc=None)\n\n def _compare_other(self, s, data, op_name, other):\n self.check_opname(s, op_name, other)\n\n def test_compare_scalar(self, data, all_compare_operators):\n if pa.types.is_list(data.dtype.arrow_dtype):\n pytest.xfail(\"pandas cannot cope with lists as scalar\")\n else:\n # FIXME: Upstream always compares againt 0\n op_name = all_compare_operators\n s = pd.Series(data)\n self._compare_other(s, data, op_name, data[0])\n\n def test_compare_array(self, data, all_compare_operators):\n if pa.types.is_list(data.dtype.arrow_dtype):\n pytest.xfail(\"Comparision of list not implemented yet\")\n else:\n BaseComparisonOpsTests.test_compare_array(self, data, all_compare_operators)\n\n def _check_op(self, s, op, other, op_name, exc=NotImplementedError):\n if exc is None:\n result = op(s, other)\n # We return fletcher booleans to support nulls\n expected = s.combine(other, op)\n if not isinstance(expected.dtype, FletcherBaseDtype):\n expected = pd.Series(type(s.values)(expected.values))\n self.assert_series_equal(result, expected)\n else:\n with pytest.raises(exc):\n op(s, other)\n\n\nclass TestBaseArithmeticOpsTests(BaseArithmeticOpsTests):\n # TODO: Instead of skipping other types, we should set the correct exceptions here\n series_scalar_exc: Optional[Type[TypeError]] = None\n frame_scalar_exc: Optional[Type[TypeError]] = None\n series_array_exc: Optional[Type[TypeError]] = None\n divmod_exc: Optional[Type[TypeError]] = None\n\n def _check_op(self, s, op, other, op_name, exc=NotImplementedError):\n if exc is None:\n result = op(s, other)\n expected = s.combine(other, op)\n\n # Combine always returns an int64 for integral arrays but for\n # operations on smaller integer types, we expect also smaller int types\n # in the result of the non-combine operations.\n if hasattr(expected.dtype, \"arrow_dtype\"):\n arrow_dtype = expected.dtype.arrow_dtype\n if pa.types.is_integer(arrow_dtype):\n # In the case of an operand with a higher bytesize, we also expect the\n # output to be int64.\n other_is_np_int64 = (\n isinstance(other, pd.Series)\n and isinstance(other.values, np.ndarray)\n and other.dtype.char in (\"q\", \"l\")\n )\n if (\n pa.types.is_integer(arrow_dtype)\n and pa.types.is_integer(s.dtype.arrow_dtype)\n and not other_is_np_int64\n ):\n expected = expected.astype(s.dtype)\n\n self.assert_series_equal(result, expected)\n else:\n with pytest.raises(exc):\n op(s, other)\n\n @skip_non_artithmetic_type\n def test_arith_series_with_scalar(self, data, all_arithmetic_operators):\n BaseArithmeticOpsTests.test_arith_series_with_scalar(\n self, data, all_arithmetic_operators\n )\n\n @skip_non_artithmetic_type\n def test_arith_series_with_array(self, data, all_arithmetic_operators):\n BaseArithmeticOpsTests.test_arith_series_with_array(\n self, data, all_arithmetic_operators\n )\n\n @skip_non_artithmetic_type\n def test_divmod(self, data):\n BaseArithmeticOpsTests.test_divmod(self, data)\n\n @skip_non_artithmetic_type\n def test_divmod_series_array(self, data, data_for_twos):\n BaseArithmeticOpsTests.test_divmod(self, data)\n\n @skip_non_artithmetic_type\n def test_add_series_with_extension_array(self, data):\n BaseArithmeticOpsTests.test_add_series_with_extension_array(self, data)\n\n def test_error(self, data, all_arithmetic_operators):\n arrow_dtype = data.dtype.arrow_dtype\n if (\n pa.types.is_integer(arrow_dtype)\n or pa.types.is_floating(arrow_dtype)\n or pa.types.is_decimal(arrow_dtype)\n ):\n pytest.skip(\"Numeric does not error on ops\")\n else:\n pytest.xfail(\"Should error here\")\n\n def _check_divmod_op(self, s, op, other, exc=None):\n super()._check_divmod_op(s, op, other, None)\n",
"import numba\nimport numpy as np\nimport pyarrow as pa\nimport pytest\n\nfrom fletcher._algorithms import isnull, str_length\nfrom fletcher.string_array import (\n NumbaStringArray,\n NumbaStringArrayBuilder,\n buffers_as_arrays,\n)\n\n\n@numba.jit(nogil=True, nopython=True)\ndef null_count(sa):\n result = 0\n\n for i in range(sa.size):\n result += sa.isnull(i)\n\n return result\n\n\n@pytest.mark.parametrize(\n (\"array\", \"expected\"),\n [\n ([\"foo\", \"bar\", \"baz\"], 0),\n ([\"foo\", \"bar\", None], 1),\n ([\"foo\", None, \"baz\"], 1),\n ([None, \"bar\", \"baz\"], 1),\n ([\"foo\", None, None], 2),\n ],\n)\ndef test_null_count(array, expected):\n assert null_count(NumbaStringArray.make(array)) == expected # type: ignore\n\n\n@pytest.mark.parametrize(\n (\"array\", \"expected\"),\n [\n ([\"foo\", \"bar\", \"baz\"], [False, False, False]),\n ([\"foo\", \"bar\", None], [False, False, True]),\n ([\"foo\", None, \"baz\"], [False, True, False]),\n ([None, \"bar\", \"baz\"], [True, False, False]),\n ([\"foo\", None, None], [False, True, True]),\n ([\"föö\", None], [False, True]),\n ],\n)\n@pytest.mark.parametrize(\"offset\", [0, 1])\ndef test_isnull(array, expected, offset):\n array = pa.array(array, pa.string())[offset:]\n np.testing.assert_array_equal(\n isnull(NumbaStringArray.make(array)), # type: ignore\n np.asarray(expected[offset:], dtype=np.bool),\n )\n\n\n@pytest.mark.parametrize(\n (\"array\", \"expected\"),\n [\n ([\"f\", \"fo\", \"foo\"], [1, 2, 3]),\n ([\"foo\", \"bar\", None], [3, 3, 0]),\n ([\"foo\", None, \"baz\"], [3, 0, 3]),\n ([None, \"bar\", \"baz\"], [0, 3, 3]),\n ([\"foo\", None, None], [3, 0, 0]),\n ([None, None, None], [0, 0, 0]),\n pytest.param([\"föö\"], [3], marks=pytest.mark.xfail),\n ],\n)\n@pytest.mark.parametrize(\"offset\", [0, 1])\ndef test_str_length(array, expected, offset):\n array = pa.array(array, pa.string())[offset:]\n np.testing.assert_array_equal(\n str_length(NumbaStringArray.make(array)), # type: ignore\n np.asarray(expected[offset:], dtype=np.int32),\n )\n\n\ndef test_decode_example():\n strings = [\"foo\", \"bar\", \"baz\"]\n expected = strings[1].encode(\"utf32\")\n expected_view = memoryview(expected)\n expected_arr = np.asarray(expected_view).view(np.uint32)\n\n # remove endianness marker\n expected_arr = expected_arr.view(np.uint32)[1:]\n\n np.testing.assert_almost_equal(\n NumbaStringArray.make(strings).decode(1), expected_arr # type: ignore\n )\n\n\n@pytest.mark.parametrize(\n \"data\",\n [\n [\"foo\"],\n [\"foo\", None],\n [None, None, None, None],\n [\"foo\", \"bar\"],\n [\"foo\", \"bar\", \"baz\"],\n ],\n)\ndef test_string_builder_simple(data):\n builder = NumbaStringArrayBuilder(2, 6)\n\n for s in data:\n if s is None:\n builder.finish_null()\n continue\n\n for c in s:\n builder.put_byte(ord(c))\n\n builder.finish_string()\n\n builder.finish()\n\n expected = pa.array(data, pa.string())\n missing, offsets, data = buffers_as_arrays(expected)\n\n np.testing.assert_array_equal(builder.offsets, offsets)\n np.testing.assert_array_equal(builder.data, data)\n"
] |
[
[
"pandas.tests.extension.base.BaseMethodsTests.test_argmin_argmax",
"pandas.tests.extension.base.BaseSetitemTests.test_setitem_slice",
"pandas.tests.extension.base.BaseMethodsTests.test_combine_add",
"pandas.tests.extension.base.BaseSetitemTests.test_setitem_mask_boolean_array_with_na",
"pandas.tests.extension.base.BaseSetitemTests.test_setitem_nullable_mask",
"pandas.tests.extension.base.BaseSetitemTests.test_setitem_loc_iloc_slice",
"pandas.tests.extension.base.BaseReshapingTests.test_ravel",
"pandas.tests.extension.base.BaseSetitemTests.test_setitem_integer_array",
"pandas.tests.extension.base.BaseSetitemTests.test_setitem_empty_indxer",
"pandas.tests.extension.base.BaseMissingTests.test_fillna_scalar",
"pandas.tests.extension.base.BaseMethodsTests.test_shift_0_periods",
"pandas.tests.extension.base.BaseMethodsTests.test_shift_fill_value",
"pandas.tests.extension.base.BaseMissingTests.test_fillna_frame",
"pandas.tests.extension.base.BaseArithmeticOpsTests.test_arith_series_with_array",
"pandas.tests.extension.base.BaseMethodsTests.test_hash_pandas_object_works",
"pandas.tests.extension.base.BaseGroupbyTests.test_groupby_extension_transform",
"pandas.tests.extension.base.BaseNoReduceTests.test_reduce_series_numeric",
"pandas.tests.extension.base.BaseMethodsTests.test_fillna_copy_series",
"pandas.tests.extension.base.BaseComparisonOpsTests.test_compare_array",
"pandas.tests.extension.base.BaseGroupbyTests.test_groupby_extension_agg",
"pandas.DataFrame",
"pandas.tests.extension.base.BaseSetitemTests.test_setitem_iloc_scalar_multiple_homogoneous",
"pandas.tests.extension.base.BaseSetitemTests.test_setitem_mask",
"pandas.tests.extension.base.BaseReshapingTests.test_merge_on_extension_array_duplicates",
"pandas.tests.extension.base.BaseConstructorsTests.test_from_dtype",
"pandas.tests.extension.base.BaseMethodsTests.test_sort_values",
"pandas.tests.extension.base.BaseMethodsTests.test_value_counts_with_normalize",
"pandas.tests.extension.base.BaseMethodsTests.test_fillna_copy_frame",
"pandas.tests.extension.base.BaseInterfaceTests.test_view",
"pandas.tests.extension.base.BaseSetitemTests.test_setitem_scalar",
"pandas.tests.extension.base.BaseReshapingTests.test_merge_on_extension_array",
"pandas.tests.extension.base.BaseMethodsTests.test_searchsorted",
"pandas.tests.extension.base.BaseMethodsTests.test_sort_values_frame",
"pandas.tests.extension.base.BaseArithmeticOpsTests.test_divmod",
"pandas.tests.extension.base.BaseMethodsTests.test_where_series",
"numpy.array",
"pandas.tests.extension.base.BaseNoReduceTests.test_reduce_series_boolean",
"pandas.array",
"pandas.tests.extension.base.BaseMethodsTests.test_unique",
"pandas.tests.extension.base.BaseMissingTests.test_fillna_series",
"pandas.tests.extension.base.BaseSetitemTests.test_setitem_mask_broadcast",
"pandas.tests.extension.base.BaseSetitemTests.test_setitem_loc_scalar_single",
"pandas.tests.extension.base.BaseMethodsTests.test_combine_first",
"pandas.tests.extension.base.BaseSetitemTests.test_setitem_mask_aligned",
"pandas.tests.extension.base.BaseSetitemTests.test_setitem_scalar_series",
"pandas.tests.extension.base.BaseMethodsTests.test_factorize_equivalence",
"pandas.tests.extension.base.BaseMethodsTests.test_factorize",
"pandas.tests.extension.base.BaseSetitemTests.test_setitem_sequence",
"pandas.tests.extension.base.BaseArithmeticOpsTests.test_arith_series_with_scalar",
"pandas.tests.extension.base.BaseSetitemTests.test_setitem_iloc_scalar_single",
"pandas.tests.extension.base.BaseReshapingTests.test_concat_mixed_dtypes",
"pandas.tests.extension.base.BaseMethodsTests.test_factorize_empty",
"pandas.tests.extension.base.BaseSetitemTests.test_setitem_slice_array",
"pandas.tests.extension.base.BaseSetitemTests.test_setitem_sequence_broadcasts",
"pandas.tests.extension.base.BaseGroupbyTests.test_groupby_extension_no_sort",
"pandas.tests.extension.base.BaseArithmeticOpsTests.test_add_series_with_extension_array",
"pandas.tests.extension.base.BaseMissingTests.test_fillna_series_method",
"pandas.tests.extension.base.BaseConstructorsTests.test_series_constructor_scalar_with_index",
"pandas.tests.extension.base.BaseGetitemTests.test_loc_iloc_frame_single_dtype",
"pandas.tests.extension.base.BaseReshapingTests.test_transpose",
"pandas.tests.extension.base.BaseNumericReduceTests.test_reduce_series",
"pandas.date_range",
"pandas.tests.extension.base.BaseMethodsTests.test_argsort",
"pandas.tests.extension.base.BaseSetitemTests.test_setitem_loc_scalar_multiple_homogoneous",
"pandas.tests.extension.base.BaseInterfaceTests.test_array_interface",
"pandas.tests.extension.base.BaseBooleanReduceTests.test_reduce_series",
"pandas.tests.extension.base.BaseSetitemTests.test_setitem_loc_scalar_mixed",
"pandas.Series",
"pandas.tests.extension.base.BaseSetitemTests.test_setitem_iloc_scalar_mixed",
"pandas.tests.extension.base.BaseGroupbyTests.test_groupby_extension_apply",
"pandas.tests.extension.base.BaseMethodsTests.test_equals"
],
[
"numpy.testing.assert_array_equal",
"numpy.asarray"
]
] |
DariusTorabian/image-classifier
|
[
"9a19dd97ecd6c4c4b0d4c35317df0f5c377fb434"
] |
[
"src/predict.py"
] |
[
"'''\nThis module has all relevant functions to make predictions using a previously\ntrained model.\n'''\nimport os\nimport numpy as np\nimport tensorflow.keras as keras\nfrom tensorflow.keras.preprocessing import image\nfrom tensorflow.keras.models import load_model\nimport cv2\n\nmodel = load_model('../models/app_ban_ora_selftrained')\n\ndef decode_prediction(prediction):\n '''\n Decodes predictions and returns a result string.\n '''\n if np.where(prediction == np.amax(prediction))[1] == 2:\n prob_orange = round(prediction[0][2] * 100, 2)\n label = f\"I am {prob_orange} % sure this is an orange \\N{tangerine}!\"\n if np.where(prediction == np.amax(prediction))[1] == 1:\n prob_banana = round(prediction[0][1] * 100, 2)\n label = f\"I am {prob_banana} % sure this is a banana \\N{banana}!\"\n if np.where(prediction == np.amax(prediction))[1] == 0:\n prob_apple = round(prediction[0][0] * 100, 2)\n label = f\"I am {prob_apple} % sure this is an apple \\N{red apple}!\"\n return label \n\ndef predict(frame):\n '''\n Takes a frame as input, makes a prediction, decoodes it\n and returns a result string.\n '''\n img = cv2.resize(frame, (224, 224))\n img = cv2.cvtColor(np.float32(img), cv2.COLOR_BGR2RGB)\n img = img.reshape(1, 224, 224, 3)\n prediction = model.predict(img)\n label = decode_prediction(prediction)\n return label\n"
] |
[
[
"tensorflow.keras.models.load_model",
"numpy.float32",
"numpy.amax"
]
] |
hit-thusz-RookieCJ/FullSubNet-plus
|
[
"a6c89083cd083e729ca3def9a291743e8c3b516b"
] |
[
"speech_enhance/fullsubnet/inferencer/inferencer.py"
] |
[
"import torch\nimport time\n\nfrom audio_zen.acoustics.feature import mag_phase\nfrom audio_zen.acoustics.mask import decompress_cIRM\nfrom audio_zen.inferencer.base_inferencer import BaseInferencer\n\n# for log\nfrom utils.logger import log\nprint=log\n\ndef cumulative_norm(input):\n eps = 1e-10\n device = input.device\n data_type = input.dtype\n n_dim = input.ndim\n\n assert n_dim in (3, 4)\n\n if n_dim == 3:\n n_channels = 1\n batch_size, n_freqs, n_frames = input.size()\n else:\n batch_size, n_channels, n_freqs, n_frames = input.size()\n input = input.reshape(batch_size * n_channels, n_freqs, n_frames)\n\n step_sum = torch.sum(input, dim=1) # [B, T]\n step_pow_sum = torch.sum(torch.square(input), dim=1)\n\n cumulative_sum = torch.cumsum(step_sum, dim=-1) # [B, T]\n cumulative_pow_sum = torch.cumsum(step_pow_sum, dim=-1) # [B, T]\n\n entry_count = torch.arange(n_freqs, n_freqs * n_frames + 1, n_freqs, dtype=data_type, device=device)\n entry_count = entry_count.reshape(1, n_frames) # [1, T]\n entry_count = entry_count.expand_as(cumulative_sum) # [1, T] => [B, T]\n\n cum_mean = cumulative_sum / entry_count # B, T\n cum_var = (cumulative_pow_sum - 2 * cum_mean * cumulative_sum) / entry_count + cum_mean.pow(2) # B, T\n cum_std = (cum_var + eps).sqrt() # B, T\n\n cum_mean = cum_mean.reshape(batch_size * n_channels, 1, n_frames)\n cum_std = cum_std.reshape(batch_size * n_channels, 1, n_frames)\n\n x = (input - cum_mean) / cum_std\n\n if n_dim == 4:\n x = x.reshape(batch_size, n_channels, n_freqs, n_frames)\n\n return x\n\n\nclass Inferencer(BaseInferencer):\n def __init__(self, config, checkpoint_path, output_dir):\n super().__init__(config, checkpoint_path, output_dir)\n\n @torch.no_grad()\n def mag(self, noisy, inference_args):\n noisy_complex = self.torch_stft(noisy)\n noisy_mag, noisy_phase = mag_phase(noisy_complex) # [B, F, T] => [B, 1, F, T]\n\n enhanced_mag = self.model(noisy_mag.unsqueeze(1)).squeeze(1)\n\n enhanced = self.torch_istft((enhanced_mag, noisy_phase), length=noisy.size(-1), use_mag_phase=True)\n enhanced = enhanced.detach().squeeze(0).cpu().numpy()\n\n return enhanced\n\n @torch.no_grad()\n def scaled_mask(self, noisy, inference_args):\n noisy_complex = self.torch_stft(noisy)\n noisy_mag, noisy_phase = mag_phase(noisy_complex)\n\n # [B, F, T] => [B, 1, F, T] => model => [B, 2, F, T] => [B, F, T, 2]\n noisy_mag = noisy_mag.unsqueeze(1)\n scaled_mask = self.model(noisy_mag)\n scaled_mask = scaled_mask.permute(0, 2, 3, 1)\n\n enhanced_complex = noisy_complex * scaled_mask\n enhanced = self.torch_istft(enhanced_complex, length=noisy.size(-1), use_mag_phase=False)\n enhanced = enhanced.detach().squeeze(0).cpu().numpy()\n\n return enhanced\n\n @torch.no_grad()\n def sub_band_crm_mask(self, noisy, inference_args):\n pad_mode = inference_args[\"pad_mode\"]\n n_neighbor = inference_args[\"n_neighbor\"]\n\n noisy = noisy.cpu().numpy().reshape(-1)\n noisy_D = self.librosa_stft(noisy)\n\n noisy_real = torch.tensor(noisy_D.real, device=self.device)\n noisy_imag = torch.tensor(noisy_D.imag, device=self.device)\n noisy_mag = torch.sqrt(torch.square(noisy_real) + torch.square(noisy_imag)) # [F, T]\n n_freqs, n_frames = noisy_mag.size()\n\n noisy_mag = noisy_mag.reshape(1, 1, n_freqs, n_frames)\n noisy_mag_padded = self._unfold(noisy_mag, pad_mode, n_neighbor) # [B, N, C, F_s, T] <=> [1, 257, 1, 31, T]\n noisy_mag_padded = noisy_mag_padded.squeeze(0).squeeze(1) # [257, 31, 200] <=> [B, F_s, T]\n\n pred_crm = self.model(noisy_mag_padded).detach() # [B, 2, T] <=> [F, 2, T]\n pred_crm = pred_crm.permute(0, 2, 1).contiguous() # [B, T, 2]\n\n lim = 9.99\n pred_crm = lim * (pred_crm >= lim) - lim * (pred_crm <= -lim) + pred_crm * (torch.abs(pred_crm) < lim)\n pred_crm = -10 * torch.log((10 - pred_crm) / (10 + pred_crm))\n\n enhanced_real = pred_crm[:, :, 0] * noisy_real - pred_crm[:, :, 1] * noisy_imag\n enhanced_imag = pred_crm[:, :, 1] * noisy_real + pred_crm[:, :, 0] * noisy_imag\n\n enhanced_real = enhanced_real.cpu().numpy()\n enhanced_imag = enhanced_imag.cpu().numpy()\n enhanced = self.librosa_istft(enhanced_real + 1j * enhanced_imag, length=len(noisy))\n return enhanced\n\n @torch.no_grad()\n def full_band_crm_mask(self, noisy, inference_args):\n noisy_complex = self.torch_stft(noisy)\n noisy_mag, _ = mag_phase(noisy_complex)\n\n noisy_mag = noisy_mag.unsqueeze(1)\n t1 = time.time()\n pred_crm = self.model(noisy_mag)\n t2 = time.time()\n pred_crm = pred_crm.permute(0, 2, 3, 1)\n\n pred_crm = decompress_cIRM(pred_crm)\n enhanced_real = pred_crm[..., 0] * noisy_complex.real - pred_crm[..., 1] * noisy_complex.imag\n enhanced_imag = pred_crm[..., 1] * noisy_complex.real + pred_crm[..., 0] * noisy_complex.imag\n enhanced_complex = torch.stack((enhanced_real, enhanced_imag), dim=-1)\n enhanced = self.torch_istft(enhanced_complex, length=noisy.size(-1))\n enhanced = enhanced.detach().squeeze(0).cpu().numpy()\n\n #\n rtf = (t2 - t1) / (len(enhanced) * 1.0 / self.acoustic_config[\"sr\"])\n print(f\"model rtf: {rtf}\")\n\n return enhanced\n\n @torch.no_grad()\n def overlapped_chunk(self, noisy, inference_args):\n sr = self.acoustic_config[\"sr\"]\n\n noisy = noisy.squeeze(0)\n\n num_mics = 8\n chunk_length = sr * inference_args[\"chunk_length\"]\n chunk_hop_length = chunk_length // 2\n num_chunks = int(noisy.shape[-1] / chunk_hop_length) + 1\n\n win = torch.hann_window(chunk_length, device=noisy.device)\n\n prev = None\n enhanced = None\n # 模拟语音的静音段，防止一上来就给语音，处理的不好\n for chunk_idx in range(num_chunks):\n if chunk_idx == 0:\n pad = torch.zeros((num_mics, 256), device=noisy.device)\n\n chunk_start_position = chunk_idx * chunk_hop_length\n chunk_end_position = chunk_start_position + chunk_length\n\n # concat([(8, 256), (..., ... + chunk_length)])\n noisy_chunk = torch.cat((pad, noisy[:, chunk_start_position:chunk_end_position]), dim=1)\n enhanced_chunk = self.model(noisy_chunk.unsqueeze(0))\n enhanced_chunk = torch.squeeze(enhanced_chunk)\n enhanced_chunk = enhanced_chunk[256:]\n\n # Save the prior half chunk,\n cur = enhanced_chunk[:chunk_length // 2]\n\n # only for the 1st chunk,no overlap for the very 1st chunk prior half\n prev = enhanced_chunk[chunk_length // 2:] * win[chunk_length // 2:]\n else:\n # use the previous noisy data as the pad\n pad = noisy[:, (chunk_idx * chunk_hop_length - 256):(chunk_idx * chunk_hop_length)]\n\n chunk_start_position = chunk_idx * chunk_hop_length\n chunk_end_position = chunk_start_position + chunk_length\n\n noisy_chunk = torch.cat((pad, noisy[:8, chunk_start_position:chunk_end_position]), dim=1)\n enhanced_chunk = self.model(noisy_chunk.unsqueeze(0))\n enhanced_chunk = torch.squeeze(enhanced_chunk)\n enhanced_chunk = enhanced_chunk[256:]\n\n # 使用这个窗函数来对拼接的位置进行平滑？\n enhanced_chunk = enhanced_chunk * win[:len(enhanced_chunk)]\n\n tmp = enhanced_chunk[:chunk_length // 2]\n cur = tmp[:min(len(tmp), len(prev))] + prev[:min(len(tmp), len(prev))]\n prev = enhanced_chunk[chunk_length // 2:]\n\n if enhanced is None:\n enhanced = cur\n else:\n enhanced = torch.cat((enhanced, cur), dim=0)\n\n enhanced = enhanced[:noisy.shape[1]]\n return enhanced.detach().squeeze(0).cpu().numpy()\n\n @torch.no_grad()\n def time_domain(self, noisy, inference_args):\n noisy = noisy.to(self.device)\n enhanced = self.model(noisy)\n return enhanced.detach().squeeze().cpu().numpy()\n\n\nif __name__ == '__main__':\n a = torch.rand(10, 2, 161, 200)\n print(cumulative_norm(a).shape)\n"
] |
[
[
"torch.zeros",
"torch.rand",
"torch.cat",
"torch.stack",
"torch.arange",
"torch.square",
"torch.hann_window",
"torch.no_grad",
"torch.sum",
"torch.abs",
"torch.squeeze",
"torch.tensor",
"torch.log",
"torch.cumsum"
]
] |
ujwalk93/models
|
[
"c08fe7a6c4d58a536167d6e4e5dfb6875c7bd6b5"
] |
[
"official/vision/image_classification/common.py"
] |
[
"# Copyright 2018 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"Common util functions and classes used by both keras cifar and imagenet.\"\"\"\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport os\n\nfrom absl import flags\nimport numpy as np\nimport tensorflow as tf\n\nfrom tensorflow.python.keras.optimizer_v2 import gradient_descent as gradient_descent_v2\nimport tensorflow_model_optimization as tfmot\nfrom official.utils.flags import core as flags_core\nfrom official.utils.misc import keras_utils\n\nFLAGS = flags.FLAGS\nBASE_LEARNING_RATE = 0.1 # This matches Jing's version.\nTRAIN_TOP_1 = 'training_accuracy_top_1'\nLR_SCHEDULE = [ # (multiplier, epoch to start) tuples\n (1.0, 5), (0.1, 30), (0.01, 60), (0.001, 80)\n]\n\n\ndef learning_rate_schedule(current_epoch,\n current_batch,\n steps_per_epoch,\n batch_size):\n \"\"\"Handles linear scaling rule, gradual warmup, and LR decay.\n\n Scale learning rate at epoch boundaries provided in LR_SCHEDULE by the\n provided scaling factor.\n\n Args:\n current_epoch: integer, current epoch indexed from 0.\n current_batch: integer, current batch in the current epoch, indexed from 0.\n steps_per_epoch: integer, number of steps in an epoch.\n batch_size: integer, total batch sized.\n\n Returns:\n Adjusted learning rate.\n \"\"\"\n initial_lr = BASE_LEARNING_RATE * batch_size / 256\n epoch = current_epoch + float(current_batch) / steps_per_epoch\n warmup_lr_multiplier, warmup_end_epoch = LR_SCHEDULE[0]\n if epoch < warmup_end_epoch:\n # Learning rate increases linearly per step.\n return initial_lr * warmup_lr_multiplier * epoch / warmup_end_epoch\n for mult, start_epoch in LR_SCHEDULE:\n if epoch >= start_epoch:\n learning_rate = initial_lr * mult\n else:\n break\n return learning_rate\n\n\nclass LearningRateBatchScheduler(tf.keras.callbacks.Callback):\n \"\"\"Callback to update learning rate on every batch (not epoch boundaries).\n\n N.B. Only support Keras optimizers, not TF optimizers.\n\n Attributes:\n schedule: a function that takes an epoch index and a batch index as input\n (both integer, indexed from 0) and returns a new learning rate as\n output (float).\n \"\"\"\n\n def __init__(self, schedule, batch_size, steps_per_epoch):\n super(LearningRateBatchScheduler, self).__init__()\n self.schedule = schedule\n self.steps_per_epoch = steps_per_epoch\n self.batch_size = batch_size\n self.epochs = -1\n self.prev_lr = -1\n\n def on_epoch_begin(self, epoch, logs=None):\n if not hasattr(self.model.optimizer, 'learning_rate'):\n raise ValueError('Optimizer must have a \"learning_rate\" attribute.')\n self.epochs += 1\n\n def on_batch_begin(self, batch, logs=None):\n \"\"\"Executes before step begins.\"\"\"\n lr = self.schedule(self.epochs,\n batch,\n self.steps_per_epoch,\n self.batch_size)\n if not isinstance(lr, (float, np.float32, np.float64)):\n raise ValueError('The output of the \"schedule\" function should be float.')\n if lr != self.prev_lr:\n self.model.optimizer.learning_rate = lr # lr should be a float here\n self.prev_lr = lr\n tf.compat.v1.logging.debug(\n 'Epoch %05d Batch %05d: LearningRateBatchScheduler '\n 'change learning rate to %s.', self.epochs, batch, lr)\n\n\nclass PiecewiseConstantDecayWithWarmup(\n tf.keras.optimizers.schedules.LearningRateSchedule):\n \"\"\"Piecewise constant decay with warmup schedule.\"\"\"\n\n def __init__(self, batch_size, epoch_size, warmup_epochs, boundaries,\n multipliers, compute_lr_on_cpu=True, name=None):\n super(PiecewiseConstantDecayWithWarmup, self).__init__()\n if len(boundaries) != len(multipliers) - 1:\n raise ValueError('The length of boundaries must be 1 less than the '\n 'length of multipliers')\n\n base_lr_batch_size = 256\n steps_per_epoch = epoch_size // batch_size\n\n self.rescaled_lr = BASE_LEARNING_RATE * batch_size / base_lr_batch_size\n self.step_boundaries = [float(steps_per_epoch) * x for x in boundaries]\n self.lr_values = [self.rescaled_lr * m for m in multipliers]\n self.warmup_steps = warmup_epochs * steps_per_epoch\n self.compute_lr_on_cpu = compute_lr_on_cpu\n self.name = name\n\n self.learning_rate_ops_cache = {}\n\n def __call__(self, step):\n if tf.executing_eagerly():\n return self._get_learning_rate(step)\n\n # In an eager function or graph, the current implementation of optimizer\n # repeatedly call and thus create ops for the learning rate schedule. To\n # avoid this, we cache the ops if not executing eagerly.\n graph = tf.compat.v1.get_default_graph()\n if graph not in self.learning_rate_ops_cache:\n if self.compute_lr_on_cpu:\n with tf.device('/device:CPU:0'):\n self.learning_rate_ops_cache[graph] = self._get_learning_rate(step)\n else:\n self.learning_rate_ops_cache[graph] = self._get_learning_rate(step)\n return self.learning_rate_ops_cache[graph]\n\n def _get_learning_rate(self, step):\n \"\"\"Compute learning rate at given step.\"\"\"\n with tf.compat.v1.name_scope(self.name, 'PiecewiseConstantDecayWithWarmup',\n [self.rescaled_lr, self.step_boundaries,\n self.lr_values, self.warmup_steps,\n self.compute_lr_on_cpu]):\n def warmup_lr(step):\n return self.rescaled_lr * (\n tf.cast(step, tf.float32) / tf.cast(self.warmup_steps, tf.float32))\n def piecewise_lr(step):\n return tf.compat.v1.train.piecewise_constant(\n step, self.step_boundaries, self.lr_values)\n return tf.cond(step < self.warmup_steps,\n lambda: warmup_lr(step),\n lambda: piecewise_lr(step))\n\n def get_config(self):\n return {\n 'rescaled_lr': self.rescaled_lr,\n 'step_boundaries': self.step_boundaries,\n 'lr_values': self.lr_values,\n 'warmup_steps': self.warmup_steps,\n 'compute_lr_on_cpu': self.compute_lr_on_cpu,\n 'name': self.name\n }\n\n\ndef get_optimizer(learning_rate=0.1):\n \"\"\"Returns optimizer to use.\"\"\"\n # The learning_rate is overwritten at the beginning of each step by callback.\n return gradient_descent_v2.SGD(learning_rate=learning_rate, momentum=0.9)\n\n\n# TODO(hongkuny,haoyuzhang): make cifar model use_tensor_lr to clean up code.\ndef get_callbacks(\n steps_per_epoch,\n learning_rate_schedule_fn=None,\n pruning_method=None,\n enable_checkpoint_and_export=False,\n model_dir=None):\n \"\"\"Returns common callbacks.\"\"\"\n time_callback = keras_utils.TimeHistory(FLAGS.batch_size, FLAGS.log_steps)\n callbacks = [time_callback]\n\n if not FLAGS.use_tensor_lr and learning_rate_schedule_fn:\n lr_callback = LearningRateBatchScheduler(\n learning_rate_schedule_fn,\n batch_size=FLAGS.batch_size,\n steps_per_epoch=steps_per_epoch)\n callbacks.append(lr_callback)\n\n if FLAGS.enable_tensorboard:\n tensorboard_callback = tf.keras.callbacks.TensorBoard(\n log_dir=FLAGS.model_dir)\n callbacks.append(tensorboard_callback)\n\n if FLAGS.profile_steps:\n profiler_callback = keras_utils.get_profiler_callback(\n FLAGS.model_dir,\n FLAGS.profile_steps,\n FLAGS.enable_tensorboard,\n steps_per_epoch)\n callbacks.append(profiler_callback)\n\n is_pruning_enabled = pruning_method is not None\n if is_pruning_enabled:\n callbacks.append(tfmot.sparsity.keras.UpdatePruningStep())\n if model_dir is not None:\n callbacks.append(tfmot.sparsity.keras.PruningSummaries(\n log_dir=model_dir, profile_batch=0))\n\n if enable_checkpoint_and_export:\n if model_dir is not None:\n ckpt_full_path = os.path.join(model_dir, 'model.ckpt-{epoch:04d}')\n callbacks.append(\n tf.keras.callbacks.ModelCheckpoint(ckpt_full_path,\n save_weights_only=True))\n return callbacks\n\n\ndef build_stats(history, eval_output, callbacks):\n \"\"\"Normalizes and returns dictionary of stats.\n\n Args:\n history: Results of the training step. Supports both categorical_accuracy\n and sparse_categorical_accuracy.\n eval_output: Output of the eval step. Assumes first value is eval_loss and\n second value is accuracy_top_1.\n callbacks: a list of callbacks which might include a time history callback\n used during keras.fit.\n\n Returns:\n Dictionary of normalized results.\n \"\"\"\n stats = {}\n if eval_output:\n stats['accuracy_top_1'] = eval_output[1].item()\n stats['eval_loss'] = eval_output[0].item()\n\n if history and history.history:\n train_hist = history.history\n # Gets final loss from training.\n stats['loss'] = train_hist['loss'][-1].item()\n # Gets top_1 training accuracy.\n if 'categorical_accuracy' in train_hist:\n stats[TRAIN_TOP_1] = train_hist['categorical_accuracy'][-1].item()\n elif 'sparse_categorical_accuracy' in train_hist:\n stats[TRAIN_TOP_1] = train_hist['sparse_categorical_accuracy'][-1].item()\n\n if not callbacks:\n return stats\n\n # Look for the time history callback which was used during keras.fit\n for callback in callbacks:\n if isinstance(callback, keras_utils.TimeHistory):\n timestamp_log = callback.timestamp_log\n stats['step_timestamp_log'] = timestamp_log\n stats['train_finish_time'] = callback.train_finish_time\n if len(timestamp_log) > 1:\n stats['avg_exp_per_second'] = (\n callback.batch_size * callback.log_steps *\n (len(callback.timestamp_log)-1) /\n (timestamp_log[-1].timestamp - timestamp_log[0].timestamp))\n return stats\n\n\ndef define_keras_flags(\n dynamic_loss_scale=True,\n model=False,\n optimizer=False,\n pretrained_filepath=False):\n \"\"\"Define flags for Keras models.\"\"\"\n flags_core.define_base(clean=True, num_gpu=True, run_eagerly=True,\n train_epochs=True, epochs_between_evals=True,\n distribution_strategy=True)\n flags_core.define_performance(num_parallel_calls=False,\n synthetic_data=True,\n dtype=True,\n all_reduce_alg=True,\n num_packs=True,\n tf_gpu_thread_mode=True,\n datasets_num_private_threads=True,\n dynamic_loss_scale=dynamic_loss_scale,\n loss_scale=True,\n fp16_implementation=True,\n tf_data_experimental_slack=True,\n enable_xla=True,\n force_v2_in_keras_compile=True,\n training_dataset_cache=True)\n flags_core.define_image()\n flags_core.define_benchmark()\n flags_core.define_distribution()\n flags.adopt_module_key_flags(flags_core)\n\n flags.DEFINE_boolean(name='enable_eager', default=False, help='Enable eager?')\n flags.DEFINE_boolean(name='skip_eval', default=False, help='Skip evaluation?')\n # TODO(b/135607288): Remove this flag once we understand the root cause of\n # slowdown when setting the learning phase in Keras backend.\n flags.DEFINE_boolean(\n name='set_learning_phase_to_train', default=True,\n help='If skip eval, also set Keras learning phase to 1 (training).')\n flags.DEFINE_boolean(\n name='explicit_gpu_placement', default=False,\n help='If not using distribution strategy, explicitly set device scope '\n 'for the Keras training loop.')\n flags.DEFINE_boolean(name='use_trivial_model', default=False,\n help='Whether to use a trivial Keras model.')\n flags.DEFINE_boolean(name='report_accuracy_metrics', default=True,\n help='Report metrics during training and evaluation.')\n flags.DEFINE_boolean(name='use_tensor_lr', default=False,\n help='Use learning rate tensor instead of a callback.')\n flags.DEFINE_boolean(\n name='enable_tensorboard', default=False,\n help='Whether to enable Tensorboard callback.')\n flags.DEFINE_integer(\n name='train_steps', default=None,\n help='The number of steps to run for training. If it is larger than '\n '# batches per epoch, then use # batches per epoch. This flag will be '\n 'ignored if train_epochs is set to be larger than 1. ')\n flags.DEFINE_string(\n name='profile_steps', default=None,\n help='Save profiling data to model dir at given range of global steps. The '\n 'value must be a comma separated pair of positive integers, specifying '\n 'the first and last step to profile. For example, \"--profile_steps=2,4\" '\n 'triggers the profiler to process 3 steps, starting from the 2nd step. '\n 'Note that profiler has a non-trivial performance overhead, and the '\n 'output file can be gigantic if profiling many steps.')\n flags.DEFINE_boolean(\n name='batchnorm_spatial_persistent', default=True,\n help='Enable the spacial persistent mode for CuDNN batch norm kernel.')\n flags.DEFINE_boolean(\n name='enable_get_next_as_optional', default=False,\n help='Enable get_next_as_optional behavior in DistributedIterator.')\n flags.DEFINE_boolean(\n name='enable_checkpoint_and_export', default=False,\n help='Whether to enable a checkpoint callback and export the savedmodel.')\n flags.DEFINE_string(\n name='tpu', default='', help='TPU address to connect to.')\n flags.DEFINE_integer(\n name='steps_per_loop',\n default=500,\n help='Number of steps per training loop. Only training step happens '\n 'inside the loop. Callbacks will not be called inside. Will be capped at '\n 'steps per epoch.')\n flags.DEFINE_boolean(\n name='use_tf_while_loop',\n default=True,\n help='Whether to build a tf.while_loop inside the training loop on the '\n 'host. Setting it to True is critical to have peak performance on '\n 'TPU.')\n flags.DEFINE_boolean(\n name='use_tf_keras_layers', default=False,\n help='Whether to use tf.keras.layers instead of tf.python.keras.layers.'\n 'It only changes imagenet resnet model layers for now. This flag is '\n 'a temporal flag during transition to tf.keras.layers. Do not use this '\n 'flag for external usage. this will be removed shortly.')\n\n if model:\n flags.DEFINE_string('model', 'resnet50_v1.5',\n 'Name of model preset. (mobilenet, resnet50_v1.5)')\n if optimizer:\n flags.DEFINE_string('optimizer', 'resnet50_default',\n 'Name of optimizer preset. '\n '(mobilenet_default, resnet50_default)')\n # TODO(kimjaehong): Replace as general hyper-params not only for mobilenet.\n flags.DEFINE_float('initial_learning_rate_per_sample', 0.00007,\n 'Initial value of learning rate per sample for '\n 'mobilenet_default.')\n flags.DEFINE_float('lr_decay_factor', 0.94,\n 'Learning rate decay factor for mobilenet_default.')\n flags.DEFINE_float('num_epochs_per_decay', 2.5,\n 'Number of epochs per decay for mobilenet_default.')\n if pretrained_filepath:\n flags.DEFINE_string('pretrained_filepath', '',\n 'Pretrained file path.')\n\n\ndef get_synth_data(height, width, num_channels, num_classes, dtype):\n \"\"\"Creates a set of synthetic random data.\n\n Args:\n height: Integer height that will be used to create a fake image tensor.\n width: Integer width that will be used to create a fake image tensor.\n num_channels: Integer depth that will be used to create a fake image tensor.\n num_classes: Number of classes that should be represented in the fake labels\n tensor\n dtype: Data type for features/images.\n\n Returns:\n A tuple of tensors representing the inputs and labels.\n\n \"\"\"\n # Synthetic input should be within [0, 255].\n inputs = tf.random.truncated_normal([height, width, num_channels],\n dtype=dtype,\n mean=127,\n stddev=60,\n name='synthetic_inputs')\n labels = tf.random.uniform([1],\n minval=0,\n maxval=num_classes - 1,\n dtype=tf.int32,\n name='synthetic_labels')\n return inputs, labels\n\n\ndef define_pruning_flags():\n \"\"\"Define flags for pruning methods.\"\"\"\n flags.DEFINE_string('pruning_method', None,\n 'Pruning method.'\n 'None (no pruning) or polynomial_decay.')\n flags.DEFINE_float('pruning_initial_sparsity', 0.0,\n 'Initial sparsity for pruning.')\n flags.DEFINE_float('pruning_final_sparsity', 0.5,\n 'Final sparsity for pruning.')\n flags.DEFINE_integer('pruning_begin_step', 0,\n 'Begin step for pruning.')\n flags.DEFINE_integer('pruning_end_step', 100000,\n 'End step for pruning.')\n flags.DEFINE_integer('pruning_frequency', 100,\n 'Frequency for pruning.')\n\n\ndef get_synth_input_fn(height, width, num_channels, num_classes,\n dtype=tf.float32, drop_remainder=True):\n \"\"\"Returns an input function that returns a dataset with random data.\n\n This input_fn returns a data set that iterates over a set of random data and\n bypasses all preprocessing, e.g. jpeg decode and copy. The host to device\n copy is still included. This used to find the upper throughput bound when\n tuning the full input pipeline.\n\n Args:\n height: Integer height that will be used to create a fake image tensor.\n width: Integer width that will be used to create a fake image tensor.\n num_channels: Integer depth that will be used to create a fake image tensor.\n num_classes: Number of classes that should be represented in the fake labels\n tensor\n dtype: Data type for features/images.\n drop_remainder: A boolean indicates whether to drop the remainder of the\n batches. If True, the batch dimension will be static.\n\n Returns:\n An input_fn that can be used in place of a real one to return a dataset\n that can be used for iteration.\n \"\"\"\n # pylint: disable=unused-argument\n def input_fn(is_training, data_dir, batch_size, *args, **kwargs):\n \"\"\"Returns dataset filled with random data.\"\"\"\n inputs, labels = get_synth_data(height=height,\n width=width,\n num_channels=num_channels,\n num_classes=num_classes,\n dtype=dtype)\n # Cast to float32 for Keras model.\n labels = tf.cast(labels, dtype=tf.float32)\n data = tf.data.Dataset.from_tensors((inputs, labels)).repeat()\n\n # `drop_remainder` will make dataset produce outputs with known shapes.\n data = data.batch(batch_size, drop_remainder=drop_remainder)\n data = data.prefetch(buffer_size=tf.data.experimental.AUTOTUNE)\n return data\n\n return input_fn\n\n\ndef set_cudnn_batchnorm_mode():\n \"\"\"Set CuDNN batchnorm mode for better performance.\n\n Note: Spatial Persistent mode may lead to accuracy losses for certain\n models.\n \"\"\"\n if FLAGS.batchnorm_spatial_persistent:\n os.environ['TF_USE_CUDNN_BATCHNORM_SPATIAL_PERSISTENT'] = '1'\n else:\n os.environ.pop('TF_USE_CUDNN_BATCHNORM_SPATIAL_PERSISTENT', None)\n"
] |
[
[
"tensorflow.keras.callbacks.TensorBoard",
"tensorflow.compat.v1.name_scope",
"tensorflow.compat.v1.get_default_graph",
"tensorflow.python.keras.optimizer_v2.gradient_descent.SGD",
"tensorflow.random.uniform",
"tensorflow.keras.callbacks.ModelCheckpoint",
"tensorflow.executing_eagerly",
"tensorflow.device",
"tensorflow.random.truncated_normal",
"tensorflow.compat.v1.train.piecewise_constant",
"tensorflow.compat.v1.logging.debug",
"tensorflow.data.Dataset.from_tensors",
"tensorflow.cast"
]
] |
V-ea/ssd.pytorch.v1
|
[
"00a706cc5172dd8af2a07d02d28dc1934b767035"
] |
[
"ssd.py"
] |
[
"import torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom torch.autograd import Variable\nfrom layers import *\nfrom data import voc, coco, sixray\nimport os\n\n\nclass SSD(nn.Module):\n \"\"\"Single Shot Multibox Architecture\n The network is composed of a base VGG network followed by the\n added multibox conv layers. Each multibox layer branches into\n 1) conv2d for class conf scores\n 2) conv2d for localization predictions\n 3) associated priorbox layer to produce default bounding\n boxes specific to the layer's feature map size.\n See: https://arxiv.org/pdf/1512.02325.pdf for more details.\n\n Args:\n phase: (string) Can be \"test\" or \"train\"\n size: input image size\n base: VGG16 layers for input, size of either 300 or 500\n extras: extra layers that feed to multibox loc and conf layers\n head: \"multibox head\" consists of loc and conf conv layers\n \"\"\"\n\n def __init__(self, phase, size, base, extras, head, num_classes):\n super(SSD, self).__init__()\n self.phase = phase\n self.num_classes = num_classes\n self.cfg = (coco, voc, sixray)[num_classes == 3] # change\n self.priorbox = PriorBox(self.cfg)\n self.priors = Variable(self.priorbox.forward(), volatile=True)\n self.size = size\n\n # SSD network\n self.vgg = nn.ModuleList(base)\n # Layer learns to scale the l2 normalized features from conv4_3\n self.L2Norm = L2Norm(512, 20)\n self.extras = nn.ModuleList(extras)\n\n self.loc = nn.ModuleList(head[0])\n self.conf = nn.ModuleList(head[1])\n\n if phase == 'test':\n self.softmax = nn.Softmax(dim=-1)\n self.detect = Detect(num_classes, 0, 200, 0.01, 0.45)\n\n def forward(self, x):\n \"\"\"Applies network layers and ops on input image(s) x.\n\n Args:\n x: input image or batch of images. Shape: [batch,3,300,300].\n\n Return:\n Depending on phase:\n test:\n Variable(tensor) of output class label predictions,\n confidence score, and corresponding location predictions for\n each object detected. Shape: [batch,topk,7]\n\n train:\n list of concat outputs from:\n 1: confidence layers, Shape: [batch*num_priors,num_classes]\n 2: localization layers, Shape: [batch,num_priors*4]\n 3: priorbox layers, Shape: [2,num_priors*4]\n \"\"\"\n sources = list()\n loc = list()\n conf = list()\n\n # 第23层就是conv4_3这层\n # apply vgg up to conv4_3 relu\n for k in range(23):\n x = self.vgg[k](x)\n\n # l2norm然后记录到source\n s = self.L2Norm(x)\n sources.append(s)\n\n # 然后继续到fc7那层记录最后的输出到source\n # apply vgg up to fc7\n for k in range(23, len(self.vgg)):\n x = self.vgg[k](x)\n sources.append(x)\n\n # apply extra layers and cache source layer outputs\n for k, v in enumerate(self.extras):\n x = F.relu(v(x), inplace=True)\n if k % 2 == 1:\n sources.append(x)\n\n # apply multibox head to source layers\n for (x, l, c) in zip(sources, self.loc, self.conf):\n loc.append(l(x).permute(0, 2, 3, 1).contiguous())\n conf.append(c(x).permute(0, 2, 3, 1).contiguous())\n\n loc = torch.cat([o.view(o.size(0), -1) for o in loc], 1)\n conf = torch.cat([o.view(o.size(0), -1) for o in conf], 1)\n if self.phase == \"test\":\n output = self.detect(\n loc.view(loc.size(0), -1, 4), # loc preds\n self.softmax(conf.view(conf.size(0), -1,\n self.num_classes)), # conf preds\n self.priors.type(type(x.data)) # default boxes\n )\n else:\n output = (\n loc.view(loc.size(0), -1, 4),\n conf.view(conf.size(0), -1, self.num_classes),\n self.priors\n )\n return output\n\n def load_weights(self, base_file):\n other, ext = os.path.splitext(base_file)\n if ext == '.pkl' or '.pth':\n print('Loading weights into state dict...')\n self.load_state_dict(torch.load(base_file,\n map_location=lambda storage, loc: storage))\n print('Finished!')\n else:\n print('Sorry only .pth and .pkl files supported.')\n\n\n# This function is derived from torchvision VGG make_layers()\n# https://github.com/pytorch/vision/blob/master/torchvision/models/vgg.py\ndef vgg(cfg, i, batch_norm=False):\n layers = []\n in_channels = i\n for v in cfg:\n if v == 'M':\n layers += [nn.MaxPool2d(kernel_size=2, stride=2)]\n elif v == 'C':\n layers += [nn.MaxPool2d(kernel_size=2, stride=2, ceil_mode=True)]\n else:\n conv2d = nn.Conv2d(in_channels, v, kernel_size=3, padding=1)\n if batch_norm:\n layers += [conv2d, nn.BatchNorm2d(v), nn.ReLU(inplace=True)]\n else:\n layers += [conv2d, nn.ReLU(inplace=True)]\n in_channels = v\n pool5 = nn.MaxPool2d(kernel_size=3, stride=1, padding=1)\n conv6 = nn.Conv2d(512, 1024, kernel_size=3, padding=6, dilation=6)\n conv7 = nn.Conv2d(1024, 1024, kernel_size=1)\n layers += [pool5, conv6,\n nn.ReLU(inplace=True), conv7, nn.ReLU(inplace=True)]\n return layers\n\n\ndef add_extras(cfg, i, batch_norm=False):\n # Extra layers added to VGG for feature scaling\n layers = []\n in_channels = i\n flag = False\n for k, v in enumerate(cfg):\n if in_channels != 'S':\n if v == 'S':\n layers += [nn.Conv2d(in_channels, cfg[k + 1],\n kernel_size=(1, 3)[flag], stride=2, padding=1)]\n else:\n layers += [nn.Conv2d(in_channels, v, kernel_size=(1, 3)[flag])]\n flag = not flag\n in_channels = v\n return layers\n\n\ndef multibox(vgg, extra_layers, cfg, num_classes):\n loc_layers = []\n conf_layers = []\n vgg_source = [21, -2]\n for k, v in enumerate(vgg_source):\n loc_layers += [nn.Conv2d(vgg[v].out_channels,\n cfg[k] * 4, kernel_size=3, padding=1)]\n conf_layers += [nn.Conv2d(vgg[v].out_channels,\n cfg[k] * num_classes, kernel_size=3, padding=1)]\n for k, v in enumerate(extra_layers[1::2], 2):\n loc_layers += [nn.Conv2d(v.out_channels, cfg[k]\n * 4, kernel_size=3, padding=1)]\n conf_layers += [nn.Conv2d(v.out_channels, cfg[k]\n * num_classes, kernel_size=3, padding=1)]\n return vgg, extra_layers, (loc_layers, conf_layers)\n\n\nbase = {\n '300': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'C', 512, 512, 512, 'M',\n 512, 512, 512],\n '512': [],\n}\nextras = {\n '300': [256, 'S', 512, 128, 'S', 256, 128, 256, 128, 256],\n '512': [],\n}\nmbox = {\n '300': [4, 6, 6, 6, 4, 4], # number of boxes per feature map location\n '512': [],\n}\n\n\ndef build_ssd(phase, size=300, num_classes=21):\n if phase != \"test\" and phase != \"train\":\n print(\"ERROR: Phase: \" + phase + \" not recognized\")\n return\n if size != 300:\n print(\"ERROR: You specified size \" + repr(size) + \". However, \" +\n \"currently only SSD300 (size=300) is supported!\")\n return\n base_, extras_, head_ = multibox(vgg(base[str(size)], 3),\n add_extras(extras[str(size)], 1024),\n mbox[str(size)], num_classes)\n return SSD(phase, size, base_, extras_, head_, num_classes)\n"
] |
[
[
"torch.nn.Softmax",
"torch.nn.ModuleList",
"torch.nn.MaxPool2d",
"torch.nn.BatchNorm2d",
"torch.nn.ReLU",
"torch.nn.Conv2d",
"torch.load"
]
] |
hyqus/Deep-Reinforcement-Learning-for-Automated-Stock-Trading-Ensemble-Strategy-ICAIF-2020
|
[
"319eeed3c2608a24f367fc95d36e0099a41725c6"
] |
[
"env/env_stocktrading.py"
] |
[
"import os\r\nimport numpy as np\r\nimport pandas as pd\r\nfrom gym.utils import seeding\r\nimport gym\r\nfrom gym import spaces\r\nimport matplotlib\r\nmatplotlib.use('Agg')\r\nimport matplotlib.pyplot as plt\r\nimport pickle\r\nfrom stable_baselines3.common.vec_env import DummyVecEnv, SubprocVecEnv\r\nfrom stable_baselines3.common import logger\r\n\r\n\r\nclass StockTradingEnv(gym.Env):\r\n \"\"\"A stock trading environment for OpenAI gym\"\"\"\r\n metadata = {'render.modes': ['human']}\r\n\r\n def __init__(self, \r\n df, \r\n stock_dim,\r\n hmax, \r\n initial_amount,\r\n buy_cost_pct,\r\n sell_cost_pct,\r\n reward_scaling,\r\n state_space,\r\n action_space,\r\n tech_indicator_list,\r\n turbulence_threshold=None,\r\n make_plots = False, \r\n print_verbosity = 10,\r\n day = 0, \r\n initial=True,\r\n previous_state=[],\r\n model_name = '',\r\n mode='',\r\n iteration=''):\r\n self.day = day\r\n self.df = df\r\n self.stock_dim = stock_dim\r\n self.hmax = hmax\r\n self.initial_amount = initial_amount\r\n self.buy_cost_pct = buy_cost_pct\r\n self.sell_cost_pct = sell_cost_pct\r\n self.reward_scaling = reward_scaling\r\n self.state_space = state_space\r\n self.action_space = action_space\r\n self.tech_indicator_list = tech_indicator_list\r\n self.action_space = spaces.Box(low = -1, high = 1,shape = (self.action_space,)) \r\n self.observation_space = spaces.Box(low=-np.inf, high=np.inf, shape = (self.state_space,))\r\n self.data = self.df.loc[self.day,:]\r\n self.terminal = False \r\n self.make_plots = make_plots\r\n self.print_verbosity = print_verbosity\r\n self.turbulence_threshold = turbulence_threshold\r\n self.initial = initial\r\n self.previous_state = previous_state\r\n self.model_name=model_name\r\n self.mode=mode \r\n self.iteration=iteration\r\n # initalize state\r\n self.state = self._initiate_state()\r\n \r\n # initialize reward\r\n self.reward = 0\r\n self.turbulence = 0\r\n self.cost = 0\r\n self.trades = 0\r\n self.episode = 0\r\n # memorize all the total balance change\r\n self.asset_memory = [self.initial_amount]\r\n self.rewards_memory = []\r\n self.actions_memory=[]\r\n self.date_memory=[self._get_date()]\r\n #self.reset()\r\n self._seed()\r\n \r\n\r\n\r\n def _sell_stock(self, index, action):\r\n def _do_sell_normal():\r\n # perform sell action based on the sign of the action\r\n if self.state[index+self.stock_dim+1] > 0:\r\n sell_num_shares = min(abs(action),self.state[index+self.stock_dim+1])\r\n sell_amount = self.state[index+1]* sell_num_shares * (1- self.sell_cost_pct)\r\n #update balance\r\n self.state[0] += sell_amount\r\n\r\n self.state[index+self.stock_dim+1] -= min(abs(action), self.state[index+self.stock_dim+1])\r\n self.cost +=self.state[index+1]*min(abs(action),self.state[index+self.stock_dim+1]) * \\\r\n self.sell_cost_pct\r\n self.trades+=1\r\n else:\r\n sell_num_shares = 0\r\n pass\r\n return sell_num_shares\r\n \r\n # perform sell action based on the sign of the action\r\n if self.turbulence_threshold is not None:\r\n if self.turbulence>=self.turbulence_threshold:\r\n # if turbulence goes over threshold, just clear out all positions \r\n if self.state[index+self.stock_dim+1] > 0:\r\n sell_num_shares = self.state[index+self.stock_dim+1]\r\n sell_amount = self.state[index+1]*sell_num_shares* (1- self.sell_cost_pct)\r\n #update balance\r\n self.state[0] += sell_amount\r\n self.state[index+self.stock_dim+1] =0\r\n self.cost += self.state[index+1]*self.state[index+self.stock_dim+1]* \\\r\n self.sell_cost_pct\r\n self.trades+=1\r\n else:\r\n sell_num_shares = 0\r\n pass\r\n else:\r\n sell_num_shares = _do_sell_normal()\r\n else:\r\n sell_num_shares = _do_sell_normal()\r\n\r\n return sell_num_shares\r\n\r\n \r\n def _buy_stock(self, index, action):\r\n\r\n def _do_buy():\r\n available_amount = self.state[0] // self.state[index+1]\r\n # print('available_amount:{}'.format(available_amount))\r\n \r\n #update balance\r\n buy_num_shares = min(available_amount, action)\r\n buy_amount = self.state[index+1]* buy_num_shares * (1+ self.buy_cost_pct)\r\n self.state[0] -= buy_amount\r\n\r\n self.state[index+self.stock_dim+1] += min(available_amount, action)\r\n \r\n self.cost+=self.state[index+1]*min(available_amount, action)* \\\r\n self.buy_cost_pct\r\n self.trades+=1\r\n\r\n return buy_num_shares\r\n # perform buy action based on the sign of the action\r\n if self.turbulence_threshold is None:\r\n buy_num_shares = _do_buy()\r\n else:\r\n if self.turbulence< self.turbulence_threshold:\r\n buy_num_shares = _do_buy()\r\n else:\r\n pass\r\n\r\n return buy_num_shares\r\n\r\n def _make_plot(self):\r\n plt.plot(self.asset_memory,'r')\r\n plt.savefig('results/account_value_trade_{}.png'.format(self.episode))\r\n plt.close()\r\n\r\n def step(self, actions):\r\n self.terminal = self.day >= len(self.df.index.unique())-1\r\n if self.terminal:\r\n # print(f\"Episode: {self.episode}\")\r\n if self.make_plots:\r\n self._make_plot() \r\n end_total_asset = self.state[0]+ \\\r\n sum(np.array(self.state[1:(self.stock_dim+1)])*np.array(self.state[(self.stock_dim+1):(self.stock_dim*2+1)]))\r\n df_total_value = pd.DataFrame(self.asset_memory)\r\n tot_reward = self.state[0]+sum(np.array(self.state[1:(self.stock_dim+1)])*np.array(self.state[(self.stock_dim+1):(self.stock_dim*2+1)]))- self.initial_amount \r\n df_total_value.columns = ['account_value']\r\n df_total_value['date'] = self.date_memory\r\n df_total_value['daily_return']=df_total_value['account_value'].pct_change(1)\r\n if df_total_value['daily_return'].std() !=0:\r\n sharpe = (252**0.5)*df_total_value['daily_return'].mean()/ \\\r\n df_total_value['daily_return'].std()\r\n df_rewards = pd.DataFrame(self.rewards_memory)\r\n df_rewards.columns = ['account_rewards']\r\n df_rewards['date'] = self.date_memory[:-1]\r\n if self.episode % self.print_verbosity == 0:\r\n print(f\"day: {self.day}, episode: {self.episode}\")\r\n print(f\"begin_total_asset: {self.asset_memory[0]:0.2f}\")\r\n print(f\"end_total_asset: {end_total_asset:0.2f}\")\r\n print(f\"total_reward: {tot_reward:0.2f}\")\r\n print(f\"total_cost: {self.cost:0.2f}\")\r\n print(f\"total_trades: {self.trades}\")\r\n if df_total_value['daily_return'].std() != 0:\r\n print(f\"Sharpe: {sharpe:0.3f}\")\r\n print(\"=================================\")\r\n\r\n if (self.model_name!='') and (self.mode!=''):\r\n df_actions = self.save_action_memory()\r\n df_actions.to_csv('results/actions_{}_{}_{}.csv'.format(self.mode,self.model_name, self.iteration))\r\n df_total_value.to_csv('results/account_value_{}_{}_{}.csv'.format(self.mode,self.model_name, self.iteration),index=False)\r\n df_rewards.to_csv('results/account_rewards_{}_{}_{}.csv'.format(self.mode,self.model_name, self.iteration),index=False)\r\n plt.plot(self.asset_memory,'r')\r\n plt.savefig('results/account_value_{}_{}_{}.png'.format(self.mode,self.model_name, self.iteration),index=False)\r\n plt.close()\r\n\r\n # Add outputs to logger interface\r\n logger.record(\"environment/portfolio_value\", end_total_asset)\r\n logger.record(\"environment/total_reward\", tot_reward)\r\n logger.record(\"environment/total_reward_pct\", (tot_reward / (end_total_asset - tot_reward)) * 100)\r\n logger.record(\"environment/total_cost\", self.cost)\r\n logger.record(\"environment/total_trades\", self.trades)\r\n\r\n return self.state, self.reward, self.terminal, {}\r\n\r\n else:\r\n\r\n actions = actions * self.hmax #actions initially is scaled between 0 to 1\r\n actions = (actions.astype(int)) #convert into integer because we can't by fraction of shares\r\n if self.turbulence_threshold is not None:\r\n if self.turbulence>=self.turbulence_threshold:\r\n actions=np.array([-self.hmax]*self.stock_dim)\r\n begin_total_asset = self.state[0]+ \\\r\n sum(np.array(self.state[1:(self.stock_dim+1)])*np.array(self.state[(self.stock_dim+1):(self.stock_dim*2+1)]))\r\n #print(\"begin_total_asset:{}\".format(begin_total_asset))\r\n \r\n argsort_actions = np.argsort(actions)\r\n \r\n sell_index = argsort_actions[:np.where(actions < 0)[0].shape[0]]\r\n buy_index = argsort_actions[::-1][:np.where(actions > 0)[0].shape[0]]\r\n\r\n for index in sell_index:\r\n # print(f\"Num shares before: {self.state[index+self.stock_dim+1]}\")\r\n # print(f'take sell action before : {actions[index]}')\r\n actions[index] = self._sell_stock(index, actions[index])*(-1)\r\n # print(f'take sell action after : {actions[index]}')\r\n # print(f\"Num shares after: {self.state[index+self.stock_dim+1]}\")\r\n\r\n for index in buy_index:\r\n # print('take buy action: {}'.format(actions[index]))\r\n actions[index] = self._buy_stock(index, actions[index])\r\n\r\n self.actions_memory.append(actions)\r\n\r\n self.day += 1\r\n self.data = self.df.loc[self.day,:] \r\n if self.turbulence_threshold is not None: \r\n self.turbulence = self.data['turbulence'].values[0]\r\n self.state = self._update_state()\r\n \r\n end_total_asset = self.state[0]+ \\\r\n sum(np.array(self.state[1:(self.stock_dim+1)])*np.array(self.state[(self.stock_dim+1):(self.stock_dim*2+1)]))\r\n self.asset_memory.append(end_total_asset)\r\n self.date_memory.append(self._get_date())\r\n self.reward = end_total_asset - begin_total_asset \r\n self.rewards_memory.append(self.reward)\r\n self.reward = self.reward*self.reward_scaling\r\n\r\n return self.state, self.reward, self.terminal, {}\r\n\r\n def reset(self): \r\n if self.initial:\r\n self.asset_memory = [self.initial_amount]\r\n else:\r\n previous_total_asset = self.previous_state[0]+ \\\r\n sum(np.array(self.previous_state[1:(self.stock_dim+1)])*np.array(self.previous_state[(self.stock_dim+1):(self.stock_dim*2+1)]))\r\n self.asset_memory = [previous_total_asset]\r\n\r\n self.day = 0\r\n self.data = self.df.loc[self.day,:]\r\n self.turbulence = 0\r\n self.cost = 0\r\n self.trades = 0\r\n self.terminal = False \r\n # self.iteration=self.iteration\r\n self.rewards_memory = []\r\n self.actions_memory=[]\r\n self.date_memory=[self._get_date()]\r\n #initiate state\r\n self.state = self._initiate_state()\r\n self.episode+=1\r\n\r\n return self.state\r\n \r\n def render(self, mode='human',close=False):\r\n return self.state\r\n\r\n def _initiate_state(self):\r\n if self.initial:\r\n # For Initial State\r\n if len(self.df.tic.unique())>1:\r\n # for multiple stock\r\n state = [self.initial_amount] + \\\r\n self.data.close.values.tolist() + \\\r\n [0]*self.stock_dim + \\\r\n sum([self.data[tech].values.tolist() for tech in self.tech_indicator_list ], [])\r\n else:\r\n # for single stock\r\n state = [self.initial_amount] + \\\r\n [self.data.close] + \\\r\n [0]*self.stock_dim + \\\r\n sum([[self.data[tech]] for tech in self.tech_indicator_list ], [])\r\n else:\r\n #Using Previous State\r\n if len(self.df.tic.unique())>1:\r\n # for multiple stock\r\n state = [self.previous_state[0]] + \\\r\n self.data.close.values.tolist() + \\\r\n self.previous_state[(self.stock_dim+1):(self.stock_dim*2+1)] + \\\r\n sum([self.data[tech].values.tolist() for tech in self.tech_indicator_list ], [])\r\n else:\r\n # for single stock\r\n state = [self.previous_state[0]] + \\\r\n [self.data.close] + \\\r\n self.previous_state[(self.stock_dim+1):(self.stock_dim*2+1)] + \\\r\n sum([[self.data[tech]] for tech in self.tech_indicator_list ], [])\r\n return state\r\n\r\n def _update_state(self):\r\n if len(self.df.tic.unique())>1:\r\n # for multiple stock\r\n state = [self.state[0]] + \\\r\n self.data.close.values.tolist() + \\\r\n list(self.state[(self.stock_dim+1):(self.stock_dim*2+1)]) + \\\r\n sum([self.data[tech].values.tolist() for tech in self.tech_indicator_list ], [])\r\n\r\n else:\r\n # for single stock\r\n state = [self.state[0]] + \\\r\n [self.data.close] + \\\r\n list(self.state[(self.stock_dim+1):(self.stock_dim*2+1)]) + \\\r\n sum([[self.data[tech]] for tech in self.tech_indicator_list ], [])\r\n \r\n return state\r\n\r\n def _get_date(self):\r\n if len(self.df.tic.unique())>1:\r\n date = self.data.date.unique()[0]\r\n else:\r\n date = self.data.date\r\n return date\r\n\r\n def save_asset_memory(self):\r\n date_list = self.date_memory\r\n asset_list = self.asset_memory\r\n #print(len(date_list))\r\n #print(len(asset_list))\r\n df_account_value = pd.DataFrame({'date':date_list,'account_value':asset_list})\r\n return df_account_value\r\n\r\n def save_action_memory(self):\r\n if len(self.df.tic.unique())>1:\r\n # date and close price length must match actions length\r\n date_list = self.date_memory[:-1]\r\n df_date = pd.DataFrame(date_list)\r\n df_date.columns = ['date']\r\n \r\n action_list = self.actions_memory\r\n df_actions = pd.DataFrame(action_list)\r\n df_actions.columns = self.data.tic.values\r\n df_actions.index = df_date.date\r\n #df_actions = pd.DataFrame({'date':date_list,'actions':action_list})\r\n else:\r\n date_list = self.date_memory[:-1]\r\n action_list = self.actions_memory\r\n df_actions = pd.DataFrame({'date':date_list,'actions':action_list})\r\n return df_actions\r\n\r\n def _seed(self, seed=None):\r\n self.np_random, seed = seeding.np_random(seed)\r\n return [seed]\r\n\r\n\r\n def get_sb_env(self):\r\n e = DummyVecEnv([lambda: self])\r\n obs = e.reset()\r\n return e, obs\r\n \r\n"
] |
[
[
"matplotlib.use",
"numpy.array",
"pandas.DataFrame",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.close",
"numpy.where",
"numpy.argsort"
]
] |
chiffa/BioFlow
|
[
"2cfee5cc57ccfb75e13f73efd7835978c2fff8ea"
] |
[
"bioflow/algorithms_bank/sampling_policies.py"
] |
[
"\"\"\"\nThis module defines the policies that will be used in order to sample the information flow\npatterns to compare with.\n\nThe general approach is a function that takes in any eventual parameters and outputs a list of\npairs of DB_Ids for which the flow will be calculated.\n\"\"\"\nimport random\nimport hashlib\nimport json\nimport numpy as np\nfrom typing import Union, List, Tuple\nimport collections.abc\n\nfrom bioflow.utils.log_behavior import get_logger\nfrom bioflow.utils.general_utils import _is_int\n\nlog = get_logger(__name__)\n\n\ndef matched_sample_distribution(floats_arr: np.array, samples_no: int,\n granularity: int = 100, logmode: bool = False) -> np.array:\n \"\"\"\n Tries to guess a distribution of floats and sample from it.\n uses np.histogram with the number of bins equal to the granularity parameter. For each\n sample, selects which bin to sample and then picks from the bin a float according to a\n uniform distribution. if logmode is enabled, histogram will be in the log-space, as well as\n the sampling.\n\n :param floats_arr: array of floats for which to match the distribution\n :param samples_no: number of random samples to retrieve\n :param granularity: granularity at which to operate\n :param logmode: if sample in log-space\n :return: samples drawn from the empirically matched distribution\n \"\"\"\n\n if logmode:\n floats_arr = np.log(floats_arr) # will crash if any are 0\n\n hist, bin_edges = np.histogram(floats_arr, bins=granularity, density=True)\n pad = np.arange(granularity)\n locations = np.choice(pad, samples_no, p=hist)\n\n samples = []\n\n for i in locations:\n samples.append(np.random.uniform(bin_edges[i], bin_edges[i+1]))\n\n if logmode:\n return np.exp(samples)\n\n else:\n return samples\n\n\ndef _reduce_distribution(floats_arr: np.array):\n \"\"\"\n Basically gets a distribution in the [0, 1] in 100 bins, rounds to the nearest 0.01. Used for\n hashing and distribution matching\n\n :param floats_arr: floats for which to calculate the rounded distribution\n :return: rounded distribution\n \"\"\"\n normalized_arr = floats_arr / np.max(floats_arr)\n bins = np.linspace(0, 1.001, 101) # because floats round funny\n hist, bin_edges = np.histogram(normalized_arr, bins=bins, density=True)\n rounded_hist = np.array(hist * 100).astype(np.int)\n\n return rounded_hist\n\n\ndef _characterize_set(sample: Union[List[int], List[Tuple[int, float]]]):\n \"\"\"\n None-robust helper function to characterize a sample set by its length, nature of items in\n teh sample and eventual distribution of weights within the sample.\n\n :param sample: sample to characterize\n :return: set length (0 if None), 1 if items are ids, 2 if ids and weights (0 if\n None), rounded distribution ([] if None or items are ids)\n \"\"\"\n if sample is None:\n return 0, 0, []\n\n if len(sample) == 1:\n if _is_int(sample[0]):\n return 1, 1, []\n else:\n return 1, 2, []\n\n if _is_int(sample[0]):\n rounded_hist = [1] * 100\n rounded_hist = np.array(rounded_hist).astype(np.int)\n return len(sample), 1, rounded_hist.tolist()\n\n else:\n rounded_hist = _reduce_distribution(np.array(sample).astype(np.float)[:, 1])\n\n return len(sample), 2, rounded_hist.tolist()\n\n\ndef characterize_flow_parameters(sample: Union[List[int], List[Tuple[int, float]]],\n secondary_sample: Union[List[int], List[Tuple[int, float]], None],\n sparse_rounds: int):\n \"\"\"\n Characterizes the primary and secondary sets and computes their hash, that can be used ot\n match similar samples for random sampling.\n\n :param sample: primary set\n :param secondary_sample: secondary set\n :param sparse_rounds: if sparse rounds are to be performed\n :return: first set length, shape, hist, second set length, shape, hist, sparse rounds, hash\n \"\"\"\n\n prim_len, prim_shape, prim_hist = _characterize_set(sample)\n sec_len, sec_shape, sec_hist = _characterize_set(secondary_sample)\n\n _hash = hashlib.md5(json.dumps([prim_len, prim_shape, prim_hist,\n sec_len, sec_shape, sec_hist,\n sparse_rounds]).encode('utf-8')).hexdigest()\n\n log.debug('hashed a flow parameters from:\\n'\n '%d/%d/%s; \\n'\n '%d/%d/%s; \\n'\n '%d \\n'\n 'to %s' % (prim_len, prim_shape, prim_hist,\n sec_len, sec_shape, sec_hist,\n sparse_rounds, _hash))\n\n return prim_len, prim_shape, prim_hist, sec_len, sec_shape, sec_hist, sparse_rounds, _hash\n\n\ndef _sample_floats(floats, float_sampling_method='exact', matched_distro_precision: int = 100):\n \"\"\"\n A wrapper methods to sample a float distribution according to a method\n\n :param floats:\n :param float_sampling_method: exact (permutation of weights) | distro (trying to match the\n empirical distribution) | logdistro (trying to match the empirical distribution in the log\n space)\n :param matched_distro_precision: how closely to try to match the distribution (granularity\n parameter pass-through to the matched_sample_distribution)\n :return: sample of floats\n \"\"\"\n\n if float_sampling_method == 'exact':\n ret_floats = floats.copy()\n np.random.shuffle(ret_floats)\n return ret_floats\n\n if float_sampling_method == 'distro':\n return matched_sample_distribution(floats, len(floats), granularity=matched_distro_precision)\n\n if float_sampling_method == 'logdistro':\n return matched_sample_distribution(floats, len(floats),\n granularity=matched_distro_precision, logmode=True)\n\n\ndef matched_sampling(sample, secondary_sample,\n background, samples, float_sampling_method='exact'):\n \"\"\"\n The general random sampling strategy that sample sets of the same size and shape as primary\n and secondary sample set and, if they are weighted, try to match the random sample weights\n according to the\n\n\n :param sample: primary sample set\n :param secondary_sample: secondary sample_set\n :param background: background of ids (and potentially weights) from which to sample\n :param samples: random samples wanted\n :param sampling_mode: exact/distro/logdistro. the sampling parametrization method ingesting\n all the parameters in a single string argument in the general case, here, a pass- through\n parameter for the _sample_floats function if samples are weighted and the distribution of\n weights is being matched.\n :return:\n \"\"\"\n\n # What if we have an overlap between the items in the primary and the secondary\n # samples? => sampling will always try to separate the two, the sampling will crash if there\n # is not enough bacground to separate the two.\n\n if _is_int(background[0]):\n background_ids = np.array(background)\n background_whg = np.ones_like(background_ids).astype(np.float)\n\n else:\n background_ids = np.array(background)[:, 0]\n background_whg = np.array(background)[:, 1]\n\n log.debug('debug sum %s, type: %s, all:%s' % (np.sum(background_whg),\n type(background_whg),\n background_whg))\n\n background_whg /= np.sum(background_whg)\n\n if secondary_sample is None:\n\n if _is_int(sample[0]): # it should never be an int, but for safety ...\n for i in range(0, samples):\n selected = np.random.choice(background_ids, len(sample), p=background_whg,\n replace=False)\n yield i, selected, None\n\n else:\n for i in range(0, samples):\n id_loads = np.random.choice(background_ids, len(sample), p=background_whg,\n replace=False)\n float_part = _sample_floats(np.array(sample)[:, 1], float_sampling_method)\n ids_and_floats = [(_id, _float) for _id, _float in zip(id_loads, float_part)]\n yield i, ids_and_floats, None\n\n else:\n\n if _is_int(sample[0]):\n for i in range(0, samples):\n selected = np.random.choice(background_ids,\n len(sample)+len(secondary_sample),\n p=background_whg, replace=False)\n np.random.shuffle(selected)\n yield i, selected[:len(sample)], selected[-len(secondary_sample):]\n\n else:\n\n for i in range(0, samples):\n selected = np.random.choice(background_ids,\n len(sample)+len(secondary_sample),\n p=background_whg, replace=False)\n np.random.shuffle(selected)\n\n id_loads = selected[:len(sample)]\n float_part = _sample_floats(np.array(sample)[:, 1], float_sampling_method)\n ids_and_floats = [(_id, _float) for _id, _float in zip(id_loads, float_part)]\n\n\n sec_id_loads = selected[-len(secondary_sample):]\n sec_float_part = _sample_floats(np.array(secondary_sample)[:, 1], float_sampling_method)\n sec_ids_and_floats = [(_id, _float) for _id, _float\n in zip(sec_id_loads, sec_float_part)]\n\n yield i, ids_and_floats, sec_ids_and_floats"
] |
[
[
"numpy.max",
"numpy.histogram",
"numpy.choice",
"numpy.array",
"numpy.ones_like",
"numpy.log",
"numpy.sum",
"numpy.exp",
"numpy.random.shuffle",
"numpy.random.uniform",
"numpy.arange",
"numpy.linspace"
]
] |
eublefar/flowtron
|
[
"fe14d3a725b68a22e8e431c6674b2a9cb78b87d6"
] |
[
"inference.py"
] |
[
"###############################################################################\n#\n# Copyright (c) 2020, NVIDIA CORPORATION. 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###############################################################################\nimport matplotlib\nmatplotlib.use(\"Agg\")\nimport matplotlib.pylab as plt\n\nimport os\nimport argparse\nimport json\nimport sys\nimport numpy as np\nimport torch\n\n\nfrom flowtron import Flowtron\nfrom torch.utils.data import DataLoader\nfrom data import Data\nfrom train import update_params\n\nsys.path.insert(0, \"tacotron2\")\nsys.path.insert(0, \"tacotron2/waveglow\")\nfrom glow import WaveGlow\nfrom scipy.io.wavfile import write\n\n\ndef infer(flowtron_path, waveglow_path, output_dir, text, speaker_id, n_frames,\n sigma, gate_threshold, seed):\n torch.manual_seed(seed)\n torch.cuda.manual_seed(seed)\n\n # load waveglow\n waveglow = torch.load(waveglow_path)['model'].cuda().eval()\n waveglow.cuda().half()\n for k in waveglow.convinv:\n k.float()\n waveglow.eval()\n\n # load flowtron\n model = Flowtron(**model_config).cuda()\n state_dict = torch.load(flowtron_path, map_location='cpu')['state_dict']\n model.load_state_dict(state_dict)\n model.eval()\n print(\"Loaded checkpoint '{}')\" .format(flowtron_path))\n\n ignore_keys = ['training_files', 'validation_files']\n trainset = Data(\n data_config['training_files'],\n **dict((k, v) for k, v in data_config.items() if k not in ignore_keys))\n speaker_vecs = trainset.get_speaker_id(speaker_id).cuda()\n text = trainset.get_text(text).cuda()\n speaker_vecs = speaker_vecs[None]\n text = text[None]\n\n with torch.no_grad():\n residual = torch.cuda.FloatTensor(1, 80, n_frames).normal_() * sigma\n mels, attentions = model.infer(\n residual, speaker_vecs, text, gate_threshold=gate_threshold)\n\n for k in range(len(attentions)):\n attention = torch.cat(attentions[k]).cpu().numpy()\n fig, axes = plt.subplots(1, 2, figsize=(16, 4))\n axes[0].imshow(mels[0].cpu().numpy(), origin='bottom', aspect='auto')\n axes[1].imshow(attention[:, 0].transpose(), origin='bottom', aspect='auto')\n fig.savefig(os.path.join(output_dir, 'sid{}_sigma{}_attnlayer{}.png'.format(speaker_id, sigma, k)))\n plt.close(\"all\")\n\n with torch.no_grad():\n audio = waveglow.infer(mels.half(), sigma=0.8).float()\n\n audio = audio.cpu().numpy()[0]\n # normalize audio for now\n audio = audio / np.abs(audio).max()\n print(audio.shape)\n\n write(os.path.join(output_dir, 'sid{}_sigma{}.wav'.format(speaker_id, sigma)),\n data_config['sampling_rate'], audio)\n\n\nif __name__ == \"__main__\":\n parser = argparse.ArgumentParser()\n parser.add_argument('-c', '--config', type=str,\n help='JSON file for configuration')\n parser.add_argument('-p', '--params', nargs='+', default=[])\n parser.add_argument('-f', '--flowtron_path',\n help='Path to flowtron state dict', type=str)\n parser.add_argument('-w', '--waveglow_path',\n help='Path to waveglow state dict', type=str)\n parser.add_argument('-t', '--text', help='Text to synthesize', type=str)\n parser.add_argument('-i', '--id', help='Speaker id', type=int)\n parser.add_argument('-n', '--n_frames', help='Number of frames',\n default=400, type=int)\n parser.add_argument('-o', \"--output_dir\", default=\"results/\")\n parser.add_argument(\"-s\", \"--sigma\", default=0.5, type=float)\n parser.add_argument(\"-g\", \"--gate\", default=0.5, type=float)\n parser.add_argument(\"--seed\", default=1234, type=int)\n args = parser.parse_args()\n\n # Parse configs. Globals nicer in this case\n with open(args.config) as f:\n data = f.read()\n\n global config\n config = json.loads(data)\n update_params(config, args.params)\n\n data_config = config[\"data_config\"]\n global model_config\n model_config = config[\"model_config\"]\n\n # Make directory if it doesn't exist\n if not os.path.isdir(args.output_dir):\n os.makedirs(args.output_dir)\n os.chmod(args.output_dir, 0o775)\n\n torch.backends.cudnn.enabled = True\n torch.backends.cudnn.benchmark = False\n infer(args.flowtron_path, args.waveglow_path, args.output_dir, args.text,\n args.id, args.n_frames, args.sigma, args.gate, args.seed)\n"
] |
[
[
"matplotlib.use",
"torch.cat",
"torch.cuda.manual_seed",
"torch.no_grad",
"matplotlib.pylab.close",
"torch.manual_seed",
"matplotlib.pylab.subplots",
"torch.load",
"numpy.abs",
"torch.cuda.FloatTensor"
]
] |
hhain/sdap17
|
[
"8bd0b4cb60d6140141c834ffcac8835a888a0949"
] |
[
"notebooks/pawel_ueb2/utility.py"
] |
[
"## utility functions\r\n## including: labelling, annotation, continuous borders\r\nimport pandas as pd\r\nimport numpy as np\r\nimport matplotlib.pyplot as plt\r\n\r\n\r\n## create labels\r\ndef generate_class_label(data):\r\n \"\"\"\r\n generates class label on a copy of data using the columns\r\n State, From_X, From_Y, To_X, To_Y\r\n \"\"\"\r\n r_data = data.copy()\r\n \r\n r_data['target'] = \\\r\n r_data.State.astype(np.str) + \"_\"+ \\\r\n r_data.From_X.astype(np.str)+ \",\" + r_data.From_Y.astype(np.str)+ \"_\" + \\\r\n r_data.To_X.astype(np.str)+ \",\" + r_data.To_Y.astype(np.str)\r\n \r\n return r_data\r\n \r\ndef generate_class_label_and_drop(data):\r\n \"\"\"\r\n generates class label on a copy of data using the columns\r\n State, From_X, From_Y, To_X, To_Y\r\n \"\"\"\r\n r_data = data.copy()\r\n \r\n r_data['target'] = \\\r\n r_data.State.astype(np.str) + \"_\"+ \\\r\n r_data.From_X.astype(np.str)+ \",\" + r_data.From_Y.astype(np.str)+ \"_\" + \\\r\n r_data.To_X.astype(np.str)+ \",\" + r_data.To_Y.astype(np.str)\r\n \r\n r_data = r_data.drop('From_X', 1)\r\n r_data = r_data.drop('From_Y', 1)\r\n r_data = r_data.drop('To_Y', 1)\r\n r_data = r_data.drop('To_X', 1)\r\n r_data = r_data.drop('State', 1)\r\n r_data = r_data.drop('ID', 1)\r\n r_data = r_data.drop('Rng_ID', 1)\r\n \r\n r_data = r_data[ ~r_data['target'].str.contains(\"Pause\") ]\r\n r_data = r_data[ ~r_data['target'].str.contains(\"Enter\") ]\r\n r_data = r_data[ ~r_data['target'].str.contains(\"Leave\") ]\r\n \r\n return r_data.reset_index()\r\n\r\n\r\ndef generate_class_label_presence(data, state_variable =\"target\"):\r\n \"\"\"\r\n generates class label only for presence on a copy of data using only the columns\r\n Removes: Pause and merges 'Step' and 'Stand' to same class\r\n \"\"\"\r\n r_data = data.copy()\r\n\r\n r_data = r_data[ ~r_data['target'].str.contains(\"Pause\") ]\r\n r_data.loc[ r_data['target'].str.contains(\"Step\"), 'target' ] = \"Present\"\r\n r_data.loc[ r_data['target'].str.contains(\"Stand\"), 'target' ] = \"Present\"\r\n r_data.loc[ r_data['target'].str.contains(\"Walk\"), 'target' ] = \"Present\"\r\n \r\n # remove enter and leave\r\n r_data = r_data[ ~r_data['target'].str.contains(\"Enter\") ]\r\n r_data = r_data[ ~r_data['target'].str.contains(\"Leave\") ]\r\n \r\n r_data.loc[ ~r_data['target'].str.contains(\"Present\"), 'target' ] = \"Not Present\"\r\n \r\n return r_data.reset_index()\r\n\r\n\r\ndef generate_class_label_dyn_vs_empty(data, state_variable =\"target\"):\r\n \"\"\"\r\n generates class label only for presence on a copy of data using only the columns\r\n Removes: Pause and merges 'Step' and 'Stand' to same class\r\n \"\"\"\r\n r_data = data.copy()\r\n\r\n r_data = r_data[ ~r_data['target'].str.contains(\"Pause\") ]\r\n r_data.loc[ r_data['target'].str.contains(\"Walk\"), 'target' ] = \"Present\"\r\n r_data.loc[ r_data['target'].str.contains(\"Step\"), 'target' ] = \"Present\"\r\n r_data.loc[ r_data['target'].str.contains(\"Empty\"), 'target' ] = \"Not Present\"\r\n # remove enter and leave\r\n r_data = r_data[ ~r_data['target'].str.contains(\"Enter\") ]\r\n r_data = r_data[ ~r_data['target'].str.contains(\"Stand\") ]\r\n r_data = r_data[ ~r_data['target'].str.contains(\"Leave\") ]\r\n \r\n \r\n \r\n return r_data.reset_index()\r\n\r\n\r\n\r\ndef generate_class_label_presence_and_dynamic(data, state_variable =\"State\"):\r\n \"\"\"\r\n generates class label only for presence on a copy of data using only the columns\r\n Removes: Pause and merges 'Step' and 'Stand' to same class\r\n \"\"\"\r\n r_data = data.copy()\r\n\r\n r_data['target'] = r_data[state_variable].astype(np.str)\r\n \r\n r_data = r_data[ ~r_data['target'].str.contains(\"Pause\") ]\r\n r_data = r_data[ ~r_data['target'].str.contains(\"Enter\") ]\r\n r_data = r_data[ ~r_data['target'].str.contains(\"Leave\") ]\r\n \r\n r_data.loc[ r_data['target'].str.contains(\"Step\"), 'target' ] = \"Step\"\r\n r_data.loc[ r_data['target'].str.contains(\"Walki\"), 'target' ] = \"Walk\"\r\n r_data.loc[ r_data['target'].str.contains(\"Stand\"), 'target' ] = \"Stand\"\r\n r_data.loc[ r_data['target'].str.contains(\"Empty\"), 'target' ] = \"Empty\"\r\n \r\n \r\n return r_data\r\n\r\n\r\n\r\ndef get_contigous_borders(indices):\r\n \"\"\"\r\n helper function to derive contiguous borders from a list of indices\r\n \r\n Parameters\r\n ----------\r\n indicies : all indices at which a certain thing occurs\r\n \r\n \r\n Returns\r\n -------\r\n list of groups when the indices starts and ends (note: last element is the real last element of the group _not_ n+1)\r\n \"\"\"\r\n \r\n r =[ [indices[0]] ]\r\n prev = r[0][0]\r\n\r\n for ix,i in enumerate(indices):\r\n\r\n # distance bw last occurence and current > 1\r\n # then there is obviously a space\r\n if (i - prev) > 1:\r\n # add end\r\n r[-1].append(indices[ix-1])\r\n # add new start\r\n r.append([ indices[ix] ])\r\n\r\n prev = i\r\n\r\n r[-1].append( indices[-1] )\r\n \r\n return r\r\n\r\n \r\n\r\ndef get_contiguous_activity_borders(data, label):\r\n \"\"\"\r\n returns a dict with all starts ends of all labels provided in label variable\r\n \"\"\"\r\n\r\n labels = data[label].unique()\r\n \r\n r = {}\r\n \r\n for l in labels:\r\n \r\n a = data[data[label] == l].index.values\r\n \r\n r[l] = get_contigous_borders(a)\r\n \r\n r['length'] = data.shape[0]\r\n return(r)\r\n \r\ndef annotate(a):\r\n \"\"\"\r\n draws annotation into a sns heatmap using plt annotation\r\n \r\n a : dictonary with activity name and borders\r\n \"\"\"\r\n \r\n min_length = 4\r\n \r\n for k in a.keys():\r\n if k == \"length\":\r\n continue\r\n \r\n borders = a[k]\r\n \r\n for s,e in borders:\r\n \r\n # need to correct for coordinates starting at 0,0\r\n s_r = a['length'] - s\r\n e_r = a['length'] - e\r\n \r\n #print(s_r, e_r)\r\n \r\n plt.annotate(\"\",\r\n xy=(4, s_r), xycoords='data',\r\n xytext=(4, e_r), textcoords='data',\r\n arrowprops=dict(shrink=0.0, headwidth=10.0, headlength=1.0, width=0.25, shrinkA=0.0, shrinkB=0.0 ) \r\n #arrowprops=dict(arrowstyle=\"|-|\",\r\n # connectionstyle=\"arc3\"),\r\n )\r\n \r\n # only write text if enough space available\r\n if s_r - e_r < min_length:\r\n continue\r\n\r\n plt.annotate(k,\r\n xy=(7, s_r-((s_r-e_r)//2)-min_length//2), xycoords='data',\r\n xytext=(7, s_r-((s_r-e_r)//2)-min_length//2), textcoords='data',\r\n size=9\r\n )\r\n \r\n \r\ndef get_trx_groups(data, group_key=\"_ifft_0\"):\r\n lst = data.columns[data.columns.str.contains(group_key)]\r\n groups = [ [x[:-2]] for x in lst]\r\n return groups"
] |
[
[
"matplotlib.pyplot.annotate"
]
] |
andrewnc/gretel-synthetics
|
[
"17762ca9060ee6dce2e6dc1c37c87ac5ea4211e7"
] |
[
"src/gretel_synthetics/utils/header_clusters.py"
] |
[
"\"\"\"\nThis module enables the clustering of DataFrame headers into\nlike clusters based on correlations between columns\n\"\"\"\nfrom typing import List\n\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport pandas as pd\nimport scipy.cluster.hierarchy as sch\n\nfrom gretel_synthetics.utils import stats\n\nLEFT = 0\nRIGHT = 1\n\n\ndef _get_correlation_matrix(df, numeric_cat: List[str] = None):\n\n if numeric_cat is None:\n numeric_cat = []\n\n nominal_columns = list(df.select_dtypes(include=[\"object\", \"category\"]).columns)\n nominal_columns.extend(x for x in numeric_cat if x not in nominal_columns)\n\n corr_matrix = stats.calculate_correlation(df, nominal_columns=nominal_columns)\n\n return corr_matrix\n\n\ndef _get_leaves(tree, node, totcolcnt):\n\n return_list = []\n stack = []\n curr = node\n\n def _walk(node: int, side: int, save=False):\n # If it's a leaf, return a list with this leaf\n if node < totcolcnt:\n if save:\n return_list.append(node)\n return None\n # else perculate\n else:\n node = int(node - totcolcnt)\n child = int(tree[node][side])\n return child\n\n while True:\n if curr is not None:\n stack.append(curr)\n curr = _walk(curr, LEFT)\n elif stack:\n curr = stack.pop()\n curr = _walk(curr, RIGHT, save=True)\n else:\n break\n\n return return_list\n\n\ndef _traverse_node(tree, node, maxsize, totcolcnt):\n\n stack = []\n node_list = []\n curr = node\n\n def _walk(node: int, side: int):\n child = int(tree[node][side])\n child_size = 1\n idx = 0\n if child > totcolcnt:\n idx = child - totcolcnt\n child_size = tree[idx][3]\n\n if child_size > maxsize:\n return idx\n else:\n node_list.append(_get_leaves(tree, child, totcolcnt))\n return None\n\n while True:\n if curr is not None:\n stack.append(curr)\n curr = _walk(curr, LEFT)\n elif stack:\n curr = stack.pop()\n curr = _walk(curr, RIGHT)\n else:\n break\n\n return node_list\n\n\ndef _merge_clusters(\n clusters: List[List[int]], maxlen: int, columns: List[str], Lopt, plot=False\n) -> List[List[str]]:\n out = []\n tmp = []\n cluster_map = {} # maps a column name => cluster number\n cluster_number = 0\n for cluster in clusters:\n # if the size of adding the next cluster\n # exceeds the max size, flush\n if len(tmp) + len(cluster) > maxlen:\n for column_name in tmp:\n cluster_map[column_name] = cluster_number\n out.append(tmp)\n tmp = []\n cluster_number += 1\n tmp.extend(\n [columns[idx] for idx in cluster]\n ) # build the tmp with the actual column names\n\n # attach the final cluster\n if tmp:\n cluster_number += 1\n out.append(tmp)\n for column_name in tmp:\n cluster_map[column_name] = cluster_number\n\n if plot:\n labels = [x + \"(\" + str(cluster_map[x]) + \")\" for x in columns]\n plt.figure(figsize=(25, 8))\n plt.title(\"Field Header Correlation Cluster Hierarchy\")\n sch.dendrogram(Lopt, labels=labels, leaf_rotation=90.0)\n\n return out\n\n\ndef cluster(\n df: pd.DataFrame,\n header_prefix: List[str] = None,\n maxsize: int = 20,\n method: str = \"single\",\n numeric_cat: List[str] = None,\n plot=False,\n) -> List[List[str]]:\n \"\"\"\n Given an input dataframe, extract clusters of similar headers\n based on a set of heuristics.\n\n Args:\n df: The dataframe to cluster headers from.\n header_prefix: List of columns to remove before cluster generation.\n maxsize: The max number of header clusters to generate\n from the input dataframe.\n method: Linkage method used to compute header cluster\n distances. For more information please refer to the scipy\n docs, https://docs.scipy.org/doc/scipy/reference/generated/scipy.cluster.hierarchy.linkage.html#scipy-cluster-hierarchy-linkage.\n numeric_cat: A list of fields to define as categorical. The header\n clustering code will automatically define pandas \"object\" and\n \"category\" columns as categorical. The ``numeric_cat`` parameter\n may be used to define additional categorical fields that may\n not automatically get identified as such.\n plot: Plot header list as a dendogram.\n \"\"\"\n\n def prepare_response(\n col_list: List[List[str]], prefix: List[str] = None\n ) -> List[List[str]]:\n if prefix is not None:\n col_list[0] = prefix + col_list[0]\n return col_list\n\n if numeric_cat is None:\n numeric_cat = []\n\n if header_prefix is not None:\n try:\n df = df.drop(header_prefix, axis=1)\n except KeyError as err:\n raise ValueError(\"Header prefixes do not all exist in source DF\") from err\n\n # Bug(jm): if the number of columns left in the DF is just one\n # we just return that single column\n if df.shape[1] == 1:\n return prepare_response([list(df.columns)], header_prefix)\n\n # Start by getting the correlation matrix\n corr_matrix = _get_correlation_matrix(df, numeric_cat)\n\n # Change it into a distance matrix\n X = 1 - np.array(1 - abs(corr_matrix))\n\n # Cluster the columns\n L = sch.linkage(X, method=method)\n\n # Optimize the leaf ordering to minimize the distance between adjacent leaves\n Lopt = sch.optimal_leaf_ordering(L, X)\n\n columns = df.columns\n\n start = len(Lopt) - 1\n\n # Start at the top of the cluster hierachy with the final two clusters that were merged together\n # We will recursively work our way down, fetching the subclusters of a cluster if the current\n # cluster size > maxsize\n clusters = _traverse_node(Lopt, start, maxsize, len(columns))\n\n # At this point we have one list of column ids, where groups are seperated by -1, translate it into a list of\n # header lists, and if plot=True, plot the dendogram\n col_list = _merge_clusters(clusters, maxsize, columns, Lopt, plot)\n\n return prepare_response(col_list, header_prefix)\n"
] |
[
[
"scipy.cluster.hierarchy.dendrogram",
"scipy.cluster.hierarchy.linkage",
"scipy.cluster.hierarchy.optimal_leaf_ordering",
"matplotlib.pyplot.title",
"matplotlib.pyplot.figure"
]
] |
ringw/vispy
|
[
"764d07018498966bcfb39341bd844caf2adb5526"
] |
[
"examples/basics/visuals/image_transforms.py"
] |
[
"# -*- coding: utf-8 -*-\n# Copyright (c) 2014, Vispy Development Team.\n# Distributed under the (new) BSD License. See LICENSE.txt for more info.\n# vispy: gallery 2\n\n\"\"\"\nSimple demonstration of ImageVisual.\n\"\"\"\n\nimport numpy as np\nimport vispy.app\nfrom vispy import gloo\nfrom vispy import visuals\nfrom vispy.visuals.transforms import (AffineTransform, STTransform,\n arg_to_array, TransformSystem,\n LogTransform, PolarTransform,\n BaseTransform)\n\nimage = np.random.normal(size=(100, 100, 3))\nimage[20:80, 20:80] += 3.\nimage[50] += 3.\nimage[:, 50] += 3.\n\nimage = ((image-image.min()) *\n (253. / (image.max()-image.min()))).astype(np.ubyte)\n\n\nclass Canvas(vispy.app.Canvas):\n def __init__(self):\n vispy.app.Canvas.__init__(self, keys='interactive', size=(800, 800))\n\n self.images = [visuals.ImageVisual(image, method='impostor')\n for i in range(4)]\n self.images[0].transform = (STTransform(scale=(30, 30),\n translate=(600, 600)) *\n SineTransform() *\n STTransform(scale=(0.1, 0.1),\n translate=(-5, -5)))\n\n tr = AffineTransform()\n tr.rotate(30, (0, 0, 1))\n tr.rotate(40, (0, 1, 0))\n tr.scale((3, 3))\n self.images[1].transform = (STTransform(translate=(200, 600)) *\n tr *\n STTransform(translate=(-50, -50)))\n\n self.images[2].transform = (STTransform(scale=(3, -150),\n translate=(200, 100)) *\n LogTransform((0, 2, 0)) *\n STTransform(scale=(1, -0.01),\n translate=(-50, 1.3)))\n\n self.images[3].transform = (STTransform(scale=(400, 400),\n translate=(600, 300)) *\n PolarTransform() *\n STTransform(scale=(np.pi/200, 0.005),\n translate=(-3*np.pi/4., 0.1)))\n\n for img in self.images:\n img.tr_sys = TransformSystem(self)\n img.tr_sys.visual_to_document = img.transform\n\n self.show()\n\n def on_draw(self, ev):\n gloo.clear(color='black', depth=True)\n gloo.set_viewport(0, 0, *self.physical_size)\n # Create a TransformSystem that will tell the visual how to draw\n for img in self.images:\n img.draw(img.tr_sys)\n\n\n# A simple custom Transform\nclass SineTransform(BaseTransform):\n \"\"\"\n Add sine wave to y-value for wavy effect.\n \"\"\"\n glsl_map = \"\"\"\n vec4 sineTransform(vec4 pos) {\n return vec4(pos.x, pos.y + sin(pos.x), pos.z, 1);\n }\"\"\"\n\n glsl_imap = \"\"\"\n vec4 sineTransform(vec4 pos) {\n return vec4(pos.x, pos.y - sin(pos.x), pos.z, 1);\n }\"\"\"\n\n Linear = False\n\n @arg_to_array\n def map(self, coords):\n ret = coords.copy()\n ret[..., 1] += np.sin(ret[..., 0])\n return ret\n\n @arg_to_array\n def imap(self, coords):\n ret = coords.copy()\n ret[..., 1] -= np.sin(ret[..., 0])\n return ret\n\n def inverse(self):\n return InvSineTransform()\n\n\nclass InvSineTransform(BaseTransform):\n glsl_map = SineTransform.glsl_imap\n glsl_imap = SineTransform.glsl_map\n\n Linear = False\n\n map = SineTransform.imap\n imap = SineTransform.map\n\n def inverse(self):\n return SineTransform()\n\nif __name__ == '__main__':\n win = Canvas()\n import sys\n if sys.flags.interactive != 1:\n vispy.app.run()\n"
] |
[
[
"numpy.random.normal",
"numpy.sin"
]
] |
sphanit/CoHAN
|
[
"e81893068f6b63280d245a2755e3ad30142dff6a"
] |
[
"human_path_prediction/scripts/predict_goal.py"
] |
[
"#!/usr/bin/env python\n\n# Brief: This node subscribes to /tracked_humans and publishes the predicted goal to humans based on their trajectory\n# Author: Phani Teja Singamaneni\n\nimport numpy as np\nimport rospy\nimport tf\nfrom geometry_msgs.msg import Point, PoseStamped\nfrom human_msgs.msg import TrackedHumans, TrackedHuman, TrackedSegmentType\nfrom human_path_prediction.msg import PredictedGoal\nfrom scipy.stats import multivariate_normal\nfrom std_srvs.srv import SetBool, Trigger, TriggerResponse\nEPS = 1e-12\n\nclass PredictGoal(object):\n def __init__(self, human_num=1):\n self.human_num = human_num\n\n # laas_adream\n self.goals_x = [1.5, 7.0, 9.0, 10.5, 1.5, 10.3, 8.5]\n self.goals_y = [2.0, 8.0, 12.5, 15.0, 15.0, 1.5, -4.5]\n self.goal_num = 7\n\n # maze\n # self.goals_x = [1.5,1.5,1.5,1.5,1.5,7.5,25,42,42,41.5,42,37,22,15.5,28.5,37,23.5,10.5,15.5,31.5,20,25.5,7]\n # self.goals_y = [45,15,30,60,87,87,81.5,81.5,66,41.5,22,3,3,12.5,12.5,20.5,21.5,28.5,39.5,47,53,59,59]\n\n self.predicted_goal = PoseStamped()\n self.last_idx = 0\n self.changed = False\n self.current_poses = [[] for i in range(self.human_num)]\n self.prev_poses = [[] for i in range(self.human_num)]\n self.mv_nd = multivariate_normal(mean=0,cov=0.1)\n self.theta_phi = [[0]*self.goal_num for i in range(self.human_num)]\n self.window_size = 10\n self.probability_goal = [np.array([1.0/self.goal_num]*self.goal_num) for i in range(self.human_num)]\n self.probability_goal_window = [np.array([[1.0/self.goal_num]*self.goal_num]*self.window_size) for i in range(self.human_num)]\n self.done = False\n self.itr = 0\n\n NODE_NAME = \"human_goal_predict\"\n rospy.init_node(NODE_NAME)\n self.humans_sub_ = rospy.Subscriber(\"/tracked_humans\",TrackedHumans,self.tracked_humansCB)\n self.goal_pub_ = rospy.Publisher(NODE_NAME+\"/predicted_goal\",PredictedGoal, queue_size=2)\n self.goal_srv_ = rospy.Service(\"goal_changed\", Trigger, self.goal_changed)\n rospy.spin()\n\n def tracked_humansCB(self,msg):\n self.prev_poses = self.current_poses\n self.current_poses = [[] for i in range(self.human_num)]\n\n for human in msg.humans:\n for segment in human.segments:\n if segment.type == TrackedSegmentType.TORSO:\n self.current_poses[human.track_id-1].append(segment.pose.pose)\n if not self.done:\n self.prev_poses = self.current_poses\n\n for i in range(0,len(self.current_poses[0])):\n diff = np.linalg.norm([self.current_poses[0][i].position.x - self.prev_poses[0][i].position.x, self.current_poses[0][i].position.y - self.prev_poses[0][i].position.y])\n\n if diff > EPS or not self.done:\n dist = []\n for j in range(0,len(self.goals_x)):\n vec1 = np.array([self.goals_x[j],self.goals_y[j],0.0]) - np.array([self.current_poses[0][i].position.x,self.current_poses[0][i].position.y,0.0]) #Vector from current position to a goal\n rotation = (self.current_poses[0][i].orientation.x,self.current_poses[0][i].orientation.y,self.current_poses[0][i].orientation.z,self.current_poses[0][i].orientation.w)\n roll,pitch,yaw = tf.transformations.euler_from_quaternion(rotation)\n unit_vec = np.array([np.cos(yaw), np.sin(yaw),0.0])\n self.theta_phi[i][j] = (np.arccos(np.dot(vec1,unit_vec)/np.linalg.norm(vec1)))\n dist.append(np.linalg.norm([self.current_poses[0][i].position.x - self.goals_x[j],self.current_poses[0][i].position.y - self.goals_y[j]]))\n\n self.probability_goal_window[i][self.itr] = self.mv_nd.pdf(np.array(self.theta_phi[i]));\n\n self.probability_goal[i] = np.array([1.0]*self.goal_num)\n for k in range(0,len(self.probability_goal_window[i])):\n gf = np.exp((k-self.window_size)/5)\n self.probability_goal[i] = np.power(self.probability_goal_window[i][k],gf)* np.array(self.probability_goal[i]) # Linear prediction of goal\n\n for ln in range(0,len(self.goals_x)):\n self.probability_goal[i][ln] = (1/dist[ln])*self.probability_goal[i][ln];\n\n self.probability_goal[i] = (self.probability_goal[i]-np.min(self.probability_goal[i]))/(np.max(self.probability_goal[i])-np.min(self.probability_goal[i]))\n\n\n self.itr = self.itr + 1\n if self.itr == self.window_size:\n self.itr = 0\n\n self.done = True\n\n self.predict_goal()\n\n\n def predict_goal(self):\n idx = 0\n max_prob = 0.0\n p_goal = PredictedGoal()\n\n for i in range(0,len(self.current_poses[0])):\n for j in range(0,len(self.goals_x)):\n if(max_prob<self.probability_goal[i][j]):\n idx = j\n max_prob = self.probability_goal[i][j]\n\n self.predicted_goal.header.stamp = rospy.Time.now()\n self.predicted_goal.header.frame_id = 'map'\n self.predicted_goal.pose.position.x = self.goals_x[idx]\n self.predicted_goal.pose.position.y = self.goals_y[idx]\n self.predicted_goal.pose.position.z = 0.0\n self.predicted_goal.pose.orientation = self.current_poses[0][i].orientation\n\n if self.last_idx != idx:\n p_goal.changed = True\n self.changed = True\n\n self.last_idx = idx\n p_goal.goal = self.predicted_goal\n self.goal_pub_.publish(p_goal)\n\n\n def goal_changed(self,req):\n if self.changed:\n self.changed = False\n return TriggerResponse(True,\"Goal Changed\")\n return TriggerResponse(False, \"Goal not changed\")\n\nif __name__ == '__main__':\n predict_srv = PredictGoal(60)\n"
] |
[
[
"numpy.max",
"numpy.array",
"numpy.linalg.norm",
"numpy.sin",
"numpy.dot",
"numpy.exp",
"numpy.min",
"scipy.stats.multivariate_normal",
"numpy.power",
"numpy.cos"
]
] |
burgreen/proteus
|
[
"033bbd3fd0ff11d53d8e85b2da1af49e10af9c5d"
] |
[
"proteus/tests/HotStart_3P/test_HotStart_rans3p.py"
] |
[
"\"\"\"Tests for 2d flow around a cylinder with a conforming mesh and rans3p\"\"\"\nfrom builtins import range\nfrom builtins import object\nfrom proteus.iproteus import *\nfrom proteus import Comm\nfrom proteus import Context\nimport tables\nimport importlib\n\ncomm = Comm.get()\nProfiling.logLevel = 7\nProfiling.verbose = False\nimport numpy as np\n\n\nclass Test_HotStart_rans3p(object):\n\n @classmethod\n def setup_class(cls):\n cls._scriptdir = os.path.dirname(os.path.abspath(__file__))\n sys.path.insert(0,cls._scriptdir)\n @classmethod\n def teardown_class(cls):\n sys.path.remove(cls._scriptdir)\n pass\n\n def setup_method(self, method):\n \"\"\"Initialize the test problem. \"\"\"\n self.aux_names = []\n\n def teardown_method(self, method):\n pass\n\n\n def test_hotstart_p1(self):\n self.compare_name = \"T01P1_hotstart\"\n self.example_setting(\"T=0.1 vspaceOrder=1 onlySaveFinalSolution=True\",h5_filename=\"solution_p1\")\n self.example_setting(\"T=0.1 vspaceOrder=1 onlySaveFinalSolution=True isHotStart=True\", h5_filename=\"solution_p1\", check_result=True, isHotstart=True,hotstart_t=0.1)\n\n def test_hotstart_p2(self):\n self.compare_name = \"T01P2_hotstart\"\n self.example_setting(\"T=0.1 vspaceOrder=2 onlySaveFinalSolution=True\",h5_filename=\"solution_p2\")\n self.example_setting(\"T=0.1 vspaceOrder=2 onlySaveFinalSolution=True isHotStart=True\", h5_filename=\"solution_p2\", check_result=True, isHotstart=True,hotstart_t=0.1)\n\n\n def example_setting(self, pre_setting, h5_filename, check_result=False, isHotstart=False, hotstart_t=0.0):\n Context.contextOptionsString = pre_setting\n from . import NS_hotstart_so as my_so\n reload(my_so)\n # defined in iproteus\n opts.profile = False\n opts.gatherArchive = True\n opts.hotStart = isHotstart\n opts.hotStartTime = hotstart_t\n \n pList=[]\n nList=[]\n sList=[]\n for (pModule,nModule) in my_so.pnList:\n pList.append(\n importlib.import_module(\".\"+pModule,\n \"proteus.tests.HotStart_3P\"))\n nList.append(\n importlib.import_module(\".\"+nModule,\n \"proteus.tests.HotStart_3P\"))\n if pList[-1].name == None:\n pList[-1].name = pModule\n reload(pList[-1]) # Serious error\n reload(nList[-1])\n if my_so.sList == []:\n for i in range(len(my_so.pnList)):\n s = default_s\n sList.append(s)\n else:\n sList = my_so.sList\n my_so.name = h5_filename#\"_hotstart_\"+self.compare_name #save data with different filename\n # NUMERICAL SOLUTION #\n ns = proteus.NumericalSolution.NS_base(my_so,\n pList,\n nList,\n sList,\n opts)\n self.aux_names.append(ns.modelList[0].name)\n ns.calculateSolution(my_so.name)\n if check_result:\n # COMPARE VS SAVED FILES #\n expected_path = 'comparison_files/' + self.compare_name + '.h5'\n with tables.open_file(os.path.join(self._scriptdir, expected_path)) as expected, \\\n tables.open_file( my_so.name + '.h5') as actual:\n assert np.allclose(expected.root.u_t2,\n actual.root.u_t2,\n atol=1e-10)\n"
] |
[
[
"numpy.allclose"
]
] |
hhhaaahhhaa/s3prl
|
[
"a469787f05c42196c4d989555082f5fd9dcbe8a6"
] |
[
"s3prl/preprocess/split_long_utter_to_short.py"
] |
[
"# -*- coding: utf-8 -*- #\n\"\"\"*********************************************************************************************\"\"\"\n# FileName [ split_long_utter_to_short.py ]\n# Synopsis [ preprocess long audio / speech to shorter versions ]\n# Author [ Andy T. Liu (Andi611) ]\n# Copyright [ Copyleft(c), Speech Lab, NTU, Taiwan ]\n\"\"\"*********************************************************************************************\"\"\"\n\n\n###############\n# IMPORTATION #\n###############\nimport os\nimport torch\nimport argparse\nimport torchaudio\nfrom tqdm import tqdm\nfrom pathlib import Path\nfrom joblib import Parallel, delayed\ntorchaudio.set_audio_backend(\"sox_io\")\n\n\n#############################\n# PREPROCESS CONFIGURATIONS #\n#############################\ndef get_preprocess_args():\n \n parser = argparse.ArgumentParser(description='preprocess arguments for any dataset.')\n\n parser.add_argument('-i', '--input_path', default='/livingrooms/public/LibriLight/', type=str, help='Path to your LibriSpeech directory', required=False)\n parser.add_argument('-o', '--output_path', default='/livingrooms/public/LibriLight/', type=str, help='Path to store output', required=False)\n parser.add_argument('-s', '--split_size', default=60, type=int, help='Split size in seconds', required=False)\n parser.add_argument('-a', '--audio_extension', default='.flac', type=str, help='audio file type (.wav / .flac / .mp3 / etc)', required=False)\n parser.add_argument('-n', '--name', default='-splitted', type=str, help='Name to append on the original directory', required=False)\n parser.add_argument('--n_jobs', default=-1, type=int, help='Number of jobs used for computation', required=False)\n\n args = parser.parse_args()\n return args\n\n\n##################\n# SPLIT AND SAVE #\n##################\ndef split_and_save(input_file, current_split, args):\n wav, sr = torchaudio.load(input_file)\n \n # compute the size of each chunk\n chunk_size = args.split_size*sr\n quotient, remainder = divmod(wav.size(1), chunk_size)\n sections = [chunk_size for _ in range(quotient)]\n sections.append(remainder) # the remainder is the last chunk\n \n splitted_wav = torch.split(wav, split_size_or_sections=sections, dim=1)\n check_sum = 0\n for i, w in enumerate(splitted_wav):\n check_sum += w.size(1)\n file_name = os.path.basename(input_file).split('.')[0]\n new_file_name = file_name.replace(file_name, file_name+'-'+str(i))\n \n new_file_path = input_file.replace(current_split, current_split+args.name)\n new_file_path = new_file_path.replace(file_name, new_file_name)\n\n if args.input_path != args.output_path:\n new_file_path = new_file_path.replace(args.input_path, args.output_path)\n\n os.makedirs((os.path.dirname(new_file_path)), exist_ok=True)\n torchaudio.save(new_file_path, w, sr)\n assert check_sum == wav.size(1)\n\n\n###################\n# GENERATE SPLITS #\n###################\ndef generate_splits(args, tr_set, audio_extension):\n \n for i, s in enumerate(tr_set):\n if os.path.isdir(os.path.join(args.input_path, s.lower())):\n s = s.lower()\n elif os.path.isdir(os.path.join(args.input_path, s.upper())):\n s = s.upper()\n else:\n assert NotImplementedError\n\n print('')\n todo = list(Path(os.path.join(args.input_path, s)).rglob('*' + audio_extension)) # '*.flac'\n print(f'Preprocessing data in: {s}, {len(todo)} audio files found.')\n\n print('Splitting audio to shorter length...', flush=True)\n Parallel(n_jobs=args.n_jobs)(delayed(split_and_save)(str(file), s, args) for file in tqdm(todo))\n\n print('All done, saved at', args.output_path, 'exit.')\n\n\n########\n# MAIN #\n########\ndef main():\n\n # get arguments\n args = get_preprocess_args()\n \n if 'librilight' in args.input_path.lower():\n SETS = ['small', 'medium', 'large']\n elif 'librispeech' in args.input_path.lower():\n SETS = ['train-clean-100', 'train-clean-360', 'train-other-500', 'dev-clean', 'dev-other', 'test-clean', 'test-other']\n elif 'timit' in args.input_path.lower():\n SETS = ['TRAIN', 'TEST']\n else:\n raise NotImplementedError\n # change the SETS list to match your dataset, for example:\n # SETS = ['train', 'dev', 'test']\n # SETS = ['TRAIN', 'TEST']\n # SETS = ['train-clean-100', 'train-clean-360', 'train-other-500', 'dev-clean', 'dev-other', 'test-clean', 'test-other']\n \n # Select data sets\n for idx, s in enumerate(SETS):\n print('\\t', idx, ':', s)\n tr_set = input('Please enter the index of splits you wish to use preprocess. (seperate with space): ')\n tr_set = [SETS[int(t)] for t in tr_set.split(' ')]\n\n # Run split\n generate_splits(args, tr_set, args.audio_extension)\n\n\nif __name__ == '__main__':\n main()\n"
] |
[
[
"torch.split"
]
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.