repo_name
stringlengths 6
130
| hexsha
list | file_path
list | code
list | apis
list |
|---|---|---|---|---|
xinglong-zh/nas-cnn-rnn | [
"48b5a7523524a792c9b5500263f2d474ef5399b2"
] | [
"data.py"
] | [
"import os\nimport torch\nfrom os.path import dirname, realpath, abspath,join,exists\n\nfrom collections import Counter\n\nclass Dictionary(object):\n def __init__(self):\n self.word2idx = {}\n self.idx2word = []\n self.counter = Counter()\n self.total = 0\n\n def add_word(self, word):\n if word not in self.word2idx:\n self.idx2word.append(word)\n self.word2idx[word] = len(self.idx2word) - 1\n token_id = self.word2idx[word]\n self.counter[token_id] += 1\n self.total += 1\n return self.word2idx[word]\n\n def __len__(self):\n return len(self.idx2word)\n\n\nclass Corpus(object):\n def __init__(self, path):\n self.dictionary = Dictionary()\n dirPath = dirname(__file__)\n self.train = self.tokenize(join(dirPath,path, 'train.txt'))\n self.valid = self.tokenize(join(dirPath,path, 'valid.txt'))\n self.test = self.tokenize(join(dirPath,path, 'test.txt'))\n self.mytxt = self.tokenize(join(dirPath,path, 'myself.txt'))\n\n def tokenize(self, path):\n \"\"\"Tokenizes a text file.\"\"\"\n # print(path)\n assert exists(path)\n # Add words to the dictionary\n with open(path, 'r', encoding='utf-8') as f:\n tokens = 0\n for line in f:\n words = line.split() + ['<eos>']\n tokens += len(words)\n for word in words:\n self.dictionary.add_word(word)\n\n # Tokenize file content\n with open(path, 'r', encoding='utf-8') as f:\n ids = torch.LongTensor(tokens)\n token = 0\n for line in f:\n words = line.split() + ['<eos>']\n for word in words:\n ids[token] = self.dictionary.word2idx[word]\n token += 1\n\n return ids\n\n\nclass SentCorpus(object):\n def __init__(self, path):\n self.dictionary = Dictionary()\n self.train = self.tokenize(os.path.join(path, 'train.txt'))\n self.valid = self.tokenize(os.path.join(path, 'valid.txt'))\n self.test = self.tokenize(os.path.join(path, 'test.txt'))\n\n def tokenize(self, path):\n \"\"\"Tokenizes a text file.\"\"\"\n assert os.path.exists(path)\n # Add words to the dictionary\n with open(path, 'r', encoding='utf-8') as f:\n tokens = 0\n for line in f:\n words = line.split() + ['<eos>']\n tokens += len(words)\n for word in words:\n self.dictionary.add_word(word)\n\n # Tokenize file content\n sents = []\n with open(path, 'r', encoding='utf-8') as f:\n for line in f:\n if not line:\n continue\n words = line.split() + ['<eos>']\n sent = torch.LongTensor(len(words))\n for i, word in enumerate(words):\n sent[i] = self.dictionary.word2idx[word]\n sents.append(sent)\n\n return sents\n\n\nclass BatchSentLoader(object):\n def __init__(self, sents, batch_size, pad_id=0, cuda=False, volatile=False):\n self.sents = sents\n self.batch_size = batch_size\n self.sort_sents = sorted(sents, key=lambda x: x.size(0))\n self.cuda = cuda\n self.volatile = volatile\n self.pad_id = pad_id\n\n def __next__(self):\n if self.idx >= len(self.sort_sents):\n raise StopIteration\n\n batch_size = min(self.batch_size, len(self.sort_sents) - self.idx)\n batch = self.sort_sents[self.idx:self.idx + batch_size]\n max_len = max([s.size(0) for s in batch])\n tensor = torch.LongTensor(max_len, batch_size).fill_(self.pad_id)\n for i in range(len(batch)):\n s = batch[i]\n tensor[:s.size(0), i].copy_(s)\n if self.cuda:\n tensor = tensor.cuda()\n\n self.idx += batch_size\n\n return tensor\n\n next = __next__\n\n def __iter__(self):\n self.idx = 0\n return self\n\n\nif __name__ == '__main__':\n corpus = SentCorpus('../penn')\n loader = BatchSentLoader(corpus.test, 10)\n for i, d in enumerate(loader):\n print(i, d.size())\n"
] | [
[
"torch.LongTensor"
]
] |
CMessinides/thrones-sentiment-analysis | [
"56dfb664d5a2912cc32f377db432d7220e71cf07"
] | [
"scripts/transform.py"
] | [
"import json\nimport math\n\nimport pandas as pd\nfrom scipy import stats\n\nfrom lib.settings import DATA_DIR\nfrom lib.characters import ALL_NAMES\nfrom lib.episodes import getSequentialEpisodeNumber\n\nraw_comments = pd.read_csv(DATA_DIR / \"comments.csv\")\nraw_mentions = pd.read_csv(DATA_DIR / \"character-mentions.csv\")\nraw_sentiments = pd.read_csv(DATA_DIR / \"comment-sentiments.csv\")\n\npartial_comments = raw_comments[[\"ID\", \"Season\", \"Episode\"]]\ncomments = pd.merge(\n partial_comments,\n raw_sentiments,\n left_on=\"ID\",\n right_on=\"Comment ID\",\n validate=\"1:1\",\n)\nmentions = pd.merge(\n partial_comments, raw_mentions, left_on=\"ID\", right_on=\"Comment ID\", validate=\"1:m\"\n)\n\nagg_columns = {\n \"mean\": (\"Compound Score\", \"mean\"),\n \"n\": (\"Compound Score\", \"count\"),\n \"err\": (\"Compound Score\", \"sem\"),\n}\n\nagg_scores_overall = comments.groupby([\"Season\", \"Episode\"]).agg(**agg_columns)\nagg_scores_by_character = mentions.groupby([\"Name\", \"Season\", \"Episode\"]).agg(\n **agg_columns\n)\ntotal_mentions_by_episode = agg_scores_by_character.groupby(\n [\"Season\", \"Episode\"]\n).n.sum()\n\n# Setup the dict to collect the mean scores as lists of dicts\nmeans_data = {\"overall\": []}\nfor name in ALL_NAMES:\n means_data[name] = []\n\n\ndef create_means_entry(season, episode, mean, n, err):\n if n < 30:\n return None\n\n margin_of_err = stats.t.ppf(0.95, n - 1) * err\n\n return {\n \"season\": season,\n \"episode\": episode,\n \"x\": getSequentialEpisodeNumber(season, episode),\n \"y\": mean,\n \"n\": n,\n \"lower\": mean - margin_of_err,\n \"upper\": mean + margin_of_err,\n }\n\n\n# Collect overall scores from all comments\nfor row in agg_scores_overall.itertuples(name=\"Row\"):\n entry = create_means_entry(row[0][0], row[0][1], *row[1:])\n\n if entry == None:\n continue\n\n means_data[\"overall\"].append(entry)\n\nfor row in agg_scores_by_character.itertuples(name=\"Row\"):\n name = row[0][0]\n season = row[0][1]\n episode = row[0][2]\n n = row[2]\n\n if means_data[name] == None:\n means_data[name] = []\n\n entry = create_means_entry(season, episode, *row[1:])\n\n if entry == None:\n continue\n\n entry[\"proportion\"] = n / (total_mentions_by_episode[(season, episode)])\n\n means_data[name].append(entry)\n\njson.dump(means_data, open(DATA_DIR / \"mean-scores.json\", \"w\"), indent=2)\n\n# View the average score by character\navg_score_by_char = (\n mentions.groupby(\"Name\")\n .agg(mean=(\"Compound Score\", \"mean\"), n=(\"Compound Score\", \"count\"))\n .sort_values(\"mean\")\n)\n\n# Weight the characters' average scores by the natural log of the number of mentions\nweighted_avg_scores_by_char = (\n avg_score_by_char[\"mean\"] * avg_score_by_char[\"n\"].apply(math.log)\n).sort_values()\n\n# Export the views as CSV for the client\navg_score_by_char.to_csv(\n DATA_DIR / \"avg-score-by-character.csv\", index_label=\"name\", header=True\n)\nweighted_avg_scores_by_char.to_csv(\n DATA_DIR / \"weighted-avg-score-by-character.csv\",\n index_label=\"name\",\n header=[\"weigted_mean\"],\n)\n\n"
] | [
[
"pandas.read_csv",
"scipy.stats.t.ppf",
"pandas.merge"
]
] |
ancasag/labelGlandula | [
"ebc315bdc0cc3fca1e365ccf0e237cdace4d6f29"
] | [
"predict/detect.py"
] | [
"import cv2 as cv\nimport numpy as np\nimport xml.etree.ElementTree as ET\nfrom xml.dom import minidom\nfrom imutils import paths\nimport os\nfrom tqdm import tqdm\n\n\nconfThreshold = 0.4 # Confidence threshold\nnmsThreshold = 0.4 # Non-maximum suppression threshold\ninpWidth = 416 # Width of network's input image\ninpHeight = 416 # Height of network's input image\n\n\n# Get the names of the output layers\ndef getOutputsNames(net):\n # Get the names of all the layers in the network\n layersNames = net.getLayerNames()\n # Get the names of the output layers, i.e. the layers with unconnected outputs\n return [layersNames[i[0] - 1] for i in net.getUnconnectedOutLayers()]\n\n\n# Remove the bounding boxes with low confidence using non-maxima suppression\ndef postprocess(frame, outs, conf):\n frameHeight = frame.shape[0]\n frameWidth = frame.shape[1]\n\n classIds = []\n confidences = []\n boxes = []\n # Scan through all the bounding boxes output from the network and keep only the\n # ones with high confidence scores. Assign the box's class label as the class with the highest score.\n classIds = []\n confidences = []\n boxes = []\n for out in outs:\n for detection in out:\n scores = detection[5:]\n classId = np.argmax(scores)\n confidence = scores[classId]\n if confidence > conf:\n center_x = int(detection[0] * frameWidth)\n center_y = int(detection[1] * frameHeight)\n width = int(detection[2] * frameWidth)\n height = int(detection[3] * frameHeight)\n left = int(center_x - width / 2)\n top = int(center_y - height / 2)\n classIds.append(classId)\n confidences.append(float(confidence))\n boxes.append([left, top, width, height])\n\n # Perform non maximum suppression to eliminate redundant overlapping boxes with\n # lower confidences.\n newboxes = []\n newconfidences = []\n newclassIds = []\n indices = cv.dnn.NMSBoxes(boxes, confidences, conf, nmsThreshold)\n for i in indices:\n i = i[0]\n newboxes.append(boxes[i])\n newconfidences.append(confidences[i])\n newclassIds.append(classIds[i])\n return newboxes, newconfidences, newclassIds\n\n\nclass DownloadProgressBar(tqdm):\n def update_to(self, b=1, bsize=1, tsize=None):\n if tsize is not None:\n self.total = tsize\n self.update(b * bsize - self.n)\n\n\ndef prettify(elem):\n \"\"\"Return a pretty-printed XML string for the Element.\n \"\"\"\n rough_string = ET.tostring(elem, 'utf-8')\n reparsed = minidom.parseString(rough_string)\n return reparsed.toprettyxml(indent=\" \")\n\n\ndef generateXML(filename, outputPath, w, h, d, boxes, confidences, classIds, classes):\n top = ET.Element('annotation')\n childFolder = ET.SubElement(top, 'folder')\n childFolder.text = 'images'\n childFilename = ET.SubElement(top, 'filename')\n childFilename.text = filename[0:filename.rfind(\".\")]\n childPath = ET.SubElement(top, 'path')\n childPath.text = outputPath + \"/\" + filename\n childSource = ET.SubElement(top, 'source')\n childDatabase = ET.SubElement(childSource, 'database')\n childDatabase.text = 'Unknown'\n childSize = ET.SubElement(top, 'size')\n childWidth = ET.SubElement(childSize, 'width')\n childWidth.text = str(w)\n childHeight = ET.SubElement(childSize, 'height')\n childHeight.text = str(h)\n childDepth = ET.SubElement(childSize, 'depth')\n childDepth.text = str(d)\n childSegmented = ET.SubElement(top, 'segmented')\n childSegmented.text = str(0)\n for box, con, categoryID in zip(boxes, confidences, classIds):\n category = classes[categoryID]\n (x, y, wb, hb) = box\n childObject = ET.SubElement(top, 'object')\n childName = ET.SubElement(childObject, 'name')\n childName.text = category\n childPose = ET.SubElement(childObject, 'pose')\n childPose.text = 'Unspecified'\n childTruncated = ET.SubElement(childObject, 'truncated')\n childTruncated.text = '0'\n childDifficult = ET.SubElement(childObject, 'difficult')\n childDifficult.text = '0'\n childConfidence = ET.SubElement(childObject, 'confidence')\n childConfidence.text = str(con)\n childBndBox = ET.SubElement(childObject, 'bndbox')\n childXmin = ET.SubElement(childBndBox, 'xmin')\n childXmin.text = str(x)\n childYmin = ET.SubElement(childBndBox, 'ymin')\n childYmin.text = str(y)\n childXmax = ET.SubElement(childBndBox, 'xmax')\n childXmax.text = str(x + wb)\n childYmax = ET.SubElement(childBndBox, 'ymax')\n childYmax.text = str(y + hb)\n return prettify(top)\n\n\ndef mainImage(imagePath):\n generateXMLFromImage(imagePath)\n\n\ndef mainDataset(imagesPath, outputDataset, conf,pathPesos, fichNames, fichCfg):\n # Give the configuration and weight files for the model and\n # load the network using them.\n if os.path.exists(outputDataset) == False:\n os.mkdir(outputDataset)\n dirPath = os.path.dirname(os.path.realpath(__file__))\n classes = None\n with open(fichNames, 'rt') as f:\n classes = f.read().rstrip('\\n').split('\\n')\n\n\n images = list(paths.list_files(imagesPath, validExts=(\".jpg\", \".jpeg\", \".png\", \".bmp\", \".tiff\", \".tif\")))\n # for peso in modelWeights:\n #net = cv.dnn.readNetFromDarknet(fichCfg, pathPesos) # peso)\n net = cv.dnn.readNet(pathPesos, fichCfg)\n net.setPreferableBackend(cv.dnn.DNN_BACKEND_OPENCV)\n net.setPreferableTarget(cv.dnn.DNN_TARGET_CPU)\n palabra1 = \"width\"\n with open(fichCfg) as f:\n for linea in f:\n if palabra1 in linea:\n print(linea)\n\n # nomPeso = os.path.basename( pathPesos)#peso)\n # nombre = os.path.splitext(nomPeso)[0]\n for image in images:\n generateXMLFromImage(image, outputDataset, net, classes, conf) # +'/'+nombre, net)\n\n\ndef generateXMLFromImage(imagePath, output, net, classes, conf):\n im = cv.VideoCapture(imagePath)\n hasFrame, frame = im.read()\n blob = cv.dnn.blobFromImage(frame, 1 / 255, (inpWidth, inpHeight), [0, 0, 0], 1, crop=False)\n\n if os.path.exists(output) == False:\n os.mkdir(output)\n # Sets the input to the network\n net.setInput(blob)\n # Runs the forward pass to get output of the output layers\n outs = net.forward(getOutputsNames(net))\n\n # Remove the bounding boxes with low confidence\n boxes, confidences, classIds = postprocess(frame, outs, conf)\n wI, hI, d = frame.shape\n filename = os.path.basename(imagePath)\n file = open(output + '/' + os.path.splitext(filename)[0] + \".xml\", \"w\")\n file.write(generateXML(imagePath[0:imagePath.rfind(\".\")], \"\", wI, hI, d, boxes, confidences, classIds, classes))\n file.close()"
] | [
[
"numpy.argmax"
]
] |
PASpine/Xspine | [
"6d427adb30abda9e6408e37e2a802af4f6db2feb"
] | [
"utils.py"
] | [
"import sys\r\nimport os\r\nimport time\r\nimport math\r\nimport torch\r\nimport numpy as np\r\nfrom PIL import Image, ImageDraw, ImageFont\r\nfrom torchvision import transforms\r\nimport torch.nn.functional as F\r\n\r\nimport itertools\r\nimport struct # get_image_size\r\nimport imghdr # get_image_size\r\n\r\n\r\ndef sigmoid(x):\r\n return 1.0 / (math.exp(-x) + 1.)\r\n\r\n\r\ndef softmax(x):\r\n x = torch.exp(x - torch.max(x))\r\n x = x / x.sum()\r\n return x\r\n\r\n\r\ndef bbox_iou(box1, box2, x1y1x2y2=True):\r\n if x1y1x2y2:\r\n mx = min(box1[0], box2[0])\r\n Mx = max(box1[2], box2[2])\r\n my = min(box1[1], box2[1])\r\n My = max(box1[3], box2[3])\r\n w1 = box1[2] - box1[0]\r\n h1 = box1[3] - box1[1]\r\n w2 = box2[2] - box2[0]\r\n h2 = box2[3] - box2[1]\r\n else:\r\n mx = min(box1[0] - box1[2] / 2.0, box2[0] - box2[2] / 2.0)\r\n Mx = max(box1[0] + box1[2] / 2.0, box2[0] + box2[2] / 2.0)\r\n my = min(box1[1] - box1[3] / 2.0, box2[1] - box2[3] / 2.0)\r\n My = max(box1[1] + box1[3] / 2.0, box2[1] + box2[3] / 2.0)\r\n w1 = box1[2]\r\n h1 = box1[3]\r\n w2 = box2[2]\r\n h2 = box2[3]\r\n uw = Mx - mx\r\n uh = My - my\r\n cw = w1 + w2 - uw\r\n ch = h1 + h2 - uh\r\n if cw <= 0 or ch <= 0:\r\n return 0.0\r\n\r\n area1 = w1 * h1\r\n area2 = w2 * h2\r\n carea = cw * ch\r\n uarea = area1 + area2 - carea\r\n return (carea / (uarea + 1e-12)).item()\r\n\r\n\r\ndef bbox_ious(boxes1, boxes2, x1y1x2y2=True):\r\n if x1y1x2y2:\r\n mx = torch.min(boxes1[0], boxes2[0])\r\n Mx = torch.max(boxes1[2], boxes2[2])\r\n my = torch.min(boxes1[1], boxes2[1])\r\n My = torch.max(boxes1[3], boxes2[3])\r\n w1 = boxes1[2] - boxes1[0]\r\n h1 = boxes1[3] - boxes1[1]\r\n w2 = boxes2[2] - boxes2[0]\r\n h2 = boxes2[3] - boxes2[1]\r\n else:\r\n mx = torch.min(boxes1[0].item() - boxes1[2].item() / 2.0, boxes2[0].item() - boxes2[2].item() / 2.0)\r\n Mx = torch.max(boxes1[0].item() + boxes1[2].item() / 2.0, boxes2[0].item() + boxes2[2].item() / 2.0)\r\n my = torch.min(boxes1[1].item() - boxes1[3].item() / 2.0, boxes2[1].item() - boxes2[3].item() / 2.0)\r\n My = torch.max(boxes1[1].item() + boxes1[3].item() / 2.0, boxes2[1].item() + boxes2[3].item() / 2.0)\r\n w1 = boxes1[2].item()\r\n h1 = boxes1[3].item()\r\n w2 = boxes2[2].item()\r\n h2 = boxes2[3].item()\r\n uw = Mx - mx\r\n uh = My - my\r\n cw = w1 + w2 - uw\r\n ch = h1 + h2 - uh\r\n mask = ((cw <= 0) + (ch <= 0) > 0)\r\n area1 = w1 * h1\r\n area2 = w2 * h2\r\n carea = cw * ch\r\n carea[mask] = 0\r\n uarea = area1 + area2 - carea\r\n return carea / (uarea+ 1e-12)\r\n\r\ndef Bbox_iou(box1, box2, x1y1x2y2=True):\r\n \"\"\"\r\n Returns the IoU of two bounding boxes\r\n \"\"\"\r\n if not x1y1x2y2:\r\n # Transform from center and width to exact coordinates\r\n b1_x1, b1_x2 = box1[:, 0] - box1[:, 2] / 2, box1[:, 0] + box1[:, 2] / 2\r\n b1_y1, b1_y2 = box1[:, 1] - box1[:, 3] / 2, box1[:, 1] + box1[:, 3] / 2\r\n b2_x1, b2_x2 = box2[:, 0] - box2[:, 2] / 2, box2[:, 0] + box2[:, 2] / 2\r\n b2_y1, b2_y2 = box2[:, 1] - box2[:, 3] / 2, box2[:, 1] + box2[:, 3] / 2\r\n else:\r\n # Get the coordinates of bounding boxes\r\n b1_x1, b1_y1, b1_x2, b1_y2 = box1[:,0], box1[:,1], box1[:,2], box1[:,3]\r\n b2_x1, b2_y1, b2_x2, b2_y2 = box2[:,0], box2[:,1], box2[:,2], box2[:,3]\r\n\r\n # get the corrdinates of the intersection rectangle\r\n inter_rect_x1 = torch.max(b1_x1, b2_x1)\r\n inter_rect_y1 = torch.max(b1_y1, b2_y1)\r\n inter_rect_x2 = torch.min(b1_x2, b2_x2)\r\n inter_rect_y2 = torch.min(b1_y2, b2_y2)\r\n # Intersection area\r\n inter_area = torch.clamp(inter_rect_x2 - inter_rect_x1 + 1, min=0) * \\\r\n torch.clamp(inter_rect_y2 - inter_rect_y1 + 1, min=0)\r\n # Union Area\r\n b1_area = (b1_x2 - b1_x1 + 1) * (b1_y2 - b1_y1 + 1)\r\n b2_area = (b2_x2 - b2_x1 + 1) * (b2_y2 - b2_y1 + 1)\r\n\r\n iou = inter_area / (b1_area + b2_area - inter_area + 1e-16)\r\n\r\n return iou\r\n\r\ndef ensemble(boxes, en_thresh=0.0):\r\n if len(boxes) == 0:\r\n return None\r\n out_boxes = torch.zeros((3))\r\n cnt_valid = 0\r\n for i in range(len(boxes)):\r\n if len(boxes[i]) > 0:\r\n if boxes[i][0][0][2] > en_thresh:\r\n out_boxes[0] += boxes[i][0][0][0]\r\n out_boxes[1] += boxes[i][0][0][1]\r\n out_boxes[2] += boxes[i][0][0][2]\r\n cnt_valid += 1\r\n if cnt_valid == 0:\r\n print(\"prediction confidence smaller than en_thresh\")\r\n out_boxes = torch. tensor([0, 0, 1])\r\n return out_boxes\r\n else:\r\n out_boxes /= cnt_valid\r\n return out_boxes\r\n\r\n\r\n# def ensemble(boxes, en_thresh=0.0):\r\n# if len(boxes) == 0:\r\n# return None\r\n# out_boxes = torch.zeros((3))\r\n# cnt_valid = 0\r\n# for i in range(len(boxes)):\r\n# if boxes[i][2] > en_thresh:\r\n# out_boxes[0] += boxes[i][0]\r\n# out_boxes[1] += boxes[i][1]\r\n# out_boxes[2] += boxes[i][2]\r\n# cnt_valid += 1\r\n# if cnt_valid == 0:\r\n# print(\"prediction confidence smaller than en_thresh\")\r\n# return None\r\n# else:\r\n# out_boxes /= cnt_valid\r\n# return out_boxes\r\n\r\ndef convert2cpu(gpu_matrix):\r\n return torch.FloatTensor(gpu_matrix.size()).copy_(gpu_matrix)\r\n\r\n\r\ndef convert2cpu_long(gpu_matrix):\r\n return torch.LongTensor(gpu_matrix.size()).copy_(gpu_matrix)\r\n\r\n\r\ndef get_region_boxes(output, conf_thresh, num_classes, only_objectness=1, validation=False, device=None):\r\n\r\n all_boxes = []\r\n batch = output.size(0)\r\n h = output.size(2)\r\n w = output.size(3)\r\n\r\n output = output.view(batch , 3, h * w).transpose(0, 1).contiguous().view(3, batch * h * w)\r\n\r\n grid_x = torch.linspace(0, w - 1, w).repeat(h, 1).repeat(batch, 1, 1).view(\r\n batch * h * w).to(device) # type_as(output)\r\n grid_y = torch.linspace(0, h - 1, h).repeat(w, 1).t().repeat(batch, 1, 1).view(\r\n batch * h * w).to(device) # type_as(output)\r\n xs = torch.sigmoid(output[0].data) + grid_x\r\n ys = torch.sigmoid(output[1].data) + grid_y\r\n\r\n det_confs = torch.sigmoid(output[2].data)\r\n det_confs = det_confs.view(batch, h * w).cpu()\r\n xs = xs.view(batch, h * w).cpu()\r\n ys = ys.view(batch, h * w).cpu()\r\n # temp_confs = det_confs[det_confs > conf_thresh]\r\n for i in range(batch):\r\n boxes = []\r\n index = np.arange(h * w)\r\n max_conf = torch.max(det_confs[i])\r\n if max_conf < conf_thresh:\r\n print(\"no kp found\")\r\n break\r\n index = torch.from_numpy(index[det_confs[i] == max_conf])\r\n bcx = xs[i][index==1] / w\r\n bcy = ys[i][index==1] / h\r\n det_conf = det_confs[i][index == 1]\r\n for j in range(len(bcx)):\r\n box = [bcx[j], bcy[j],det_conf[j]]\r\n boxes.append(box)\r\n all_boxes.append(boxes)\r\n\r\n return all_boxes\r\n\r\n\r\ndef plot_boxes_cv2(img, boxes, savename=None, class_names=None, color=None):\r\n import cv2\r\n colors = torch.FloatTensor([[1, 0, 1], [0, 0, 1], [0, 1, 1], [0, 1, 0], [1, 1, 0], [1, 0, 0],[1, 1, 0]]);\r\n\r\n def get_color(c, x, max_val):\r\n ratio = float(x) / max_val * 5\r\n i = int(math.floor(ratio))\r\n j = int(math.ceil(ratio))\r\n ratio = ratio - i\r\n r = (1 - ratio) * colors[i][c] + ratio * colors[j][c]\r\n return int(r * 255)\r\n\r\n width = img.shape[1]\r\n height = img.shape[0]\r\n for i in range(len(boxes)):\r\n box = boxes[i]\r\n x1 = int(round((box[0] - box[2] / 2.0) * width))\r\n y1 = int(round((box[1] - box[3] / 2.0) * height))\r\n x2 = int(round((box[0] + box[2] / 2.0) * width))\r\n y2 = int(round((box[1] + box[3] / 2.0) * height))\r\n\r\n if color:\r\n rgb = color\r\n else:\r\n rgb = (255, 0, 0)\r\n if len(box) >= 7 and class_names:\r\n cls_conf = box[5]\r\n cls_id = box[6]\r\n print('%s: %f' % (class_names[cls_id], cls_conf))\r\n classes = len(class_names)\r\n offset = cls_id * 123457 % classes\r\n red = get_color(2, offset, classes)\r\n green = get_color(1, offset, classes)\r\n blue = get_color(0, offset, classes)\r\n if color is None:\r\n rgb = (red, green, blue)\r\n img = cv2.putText(img, class_names[cls_id], (x1, y1), cv2.FONT_HERSHEY_SIMPLEX, 1.2, rgb, 1)\r\n img = cv2.rectangle(img, (x1, y1), (x2, y2), rgb, 1)\r\n if savename:\r\n print(\"save plot results to %s\" % savename)\r\n cv2.imwrite(savename, img)\r\n return img\r\n\r\n\r\ndef plot_boxes(img, boxes, savename=None, class_names=None, GTfile = None):\r\n colors = torch.FloatTensor([[1, 0, 1], [0, 0, 1], [0, 1, 1], [0, 1, 0], [1, 1, 0], [1, 0, 0.5],[0.5,1,0],[0,0.5,1]]);\r\n\r\n def get_color(c, x, max_val):\r\n ratio = float(x) / max_val * 5\r\n i = int(math.floor(ratio))\r\n j = int(math.ceil(ratio))\r\n ratio = ratio - i\r\n r = (1 - ratio) * colors[i][c] + ratio * colors[j][c]\r\n return int(r * 255)\r\n\r\n width = img.width\r\n height = img.height\r\n draw = ImageDraw.Draw(img)\r\n if boxes is not None:\r\n for i in range(len(boxes)):\r\n box = boxes[i]\r\n x1 = (box[0] - box[2] / 2.0) * width\r\n y1 = (box[1] - box[3] / 2.0) * height\r\n x2 = (box[0] + box[2] / 2.0) * width\r\n y2 = (box[1] + box[3] / 2.0) * height\r\n\r\n rgb = (255, 0, 0)\r\n if len(box) >= 7 and class_names:\r\n cls_conf = box[5]\r\n cls_id = box[6]\r\n print('%s: %f' % (class_names[cls_id], cls_conf))\r\n classes = len(class_names)\r\n offset = cls_id * 123457 % classes\r\n red = get_color(2, offset, classes)\r\n green = get_color(1, offset, classes)\r\n blue = get_color(0, offset, classes)\r\n rgb = (red, green, blue)\r\n fo = ImageFont.truetype(\"consola.ttf\", size=10)\r\n draw.text((x1, y1), class_names[cls_id], fill=rgb, font=fo)\r\n draw.text((x1, y1),str(cls_conf.numpy()), fill=rgb, font=fo)\r\n draw.rectangle([x1, y1, x2, y2], outline=rgb)\r\n\r\n if GTfile is not None:\r\n tmp = torch.from_numpy(read_truths_args(GTfile, 6.0 / img.width).astype('float32'))\r\n for i in range(tmp.size(0)):\r\n x1 = (tmp[i][1] - tmp[i][3] / 2.0) * width\r\n y1 = (tmp[i][2] - tmp[i][4] / 2.0) * height\r\n x2 = (tmp[i][1] + tmp[i][3] / 2.0) * width\r\n y2 = (tmp[i][2] + tmp[i][4] / 2.0) * height\r\n rgb = (0,0,0)\r\n draw.text((x1, y1), class_names[int(tmp[i][0])], fill=rgb)\r\n draw.rectangle([x1, y1, x2, y2], outline=rgb)\r\n if savename:\r\n print(\"save plot results to %s\" % savename)\r\n img.save(savename)\r\n return img\r\n\r\n\r\ndef read_truths(lab_path):\r\n if not os.path.exists(lab_path):\r\n return np.array([])\r\n if os.path.getsize(lab_path):\r\n truths = np.loadtxt(lab_path)\r\n truths = truths.reshape(int(truths.size / 5), 5) # to avoid single truth problem\r\n return truths\r\n else:\r\n return np.array([])\r\n\r\n\r\ndef read_truths_args(lab_path, min_box_scale):\r\n truths = read_truths(lab_path)\r\n new_truths = []\r\n for i in range(truths.shape[0]):\r\n if truths[i][3] < min_box_scale:\r\n continue\r\n new_truths.append([truths[i][0], truths[i][1], truths[i][2], truths[i][3], truths[i][4]])\r\n return np.array(new_truths)\r\n\r\n\r\ndef load_class_names(namesfile):\r\n class_names = []\r\n with open(namesfile, 'r') as fp:\r\n lines = fp.readlines()\r\n for line in lines:\r\n line = line.rstrip()\r\n class_names.append(line)\r\n return class_names\r\n\r\n\r\ndef image2torch(img):\r\n width = img.width\r\n height = img.height\r\n img = torch.ByteTensor(torch.ByteStorage.from_buffer(img.tobytes()))\r\n img = img.view(height, width, 3).transpose(0, 1).transpose(0, 2).contiguous()\r\n img = img.view(1, 3, height, width)\r\n img = img.float().div(255.0)\r\n return img\r\n\r\n\r\ndef do_detect(model, img, conf_thresh, nms_thresh, device):\r\n model.eval()\r\n # transform_totensor = transforms.ToTensor()\r\n # img = transform_totensor(img)\r\n img = img.unsqueeze(0).to(device)\r\n all_boxes = []\r\n with torch.no_grad():\r\n out1, out2, out3 = model(img)\r\n Out = [out1, out2, out3]\r\n for i in range(len(Out)):\r\n all_boxes.append(get_region_boxes(Out[i], conf_thresh, 7, device=device))\r\n\r\n if len(all_boxes) > 0:\r\n # boxes = all_boxes[0][0] + all_boxes[1][0] + all_boxes[2][0]\r\n boxes = ensemble(all_boxes, en_thresh=0.0)\r\n else:\r\n boxes = torch.tensor([0,0,1])\r\n return boxes\r\n\r\ndef do_evaluate(pred_boxes, GTfile, width, height, num_classes):\r\n gt_boxes = torch.from_numpy(read_truths_args(GTfile, 6.0 / width).astype('float32'))\r\n num_GT_positive = np.zeros((num_classes), dtype = np.uint8)\r\n num_preds = np.zeros((num_classes), dtype = np.uint8)\r\n num_correct = np.zeros((num_classes), dtype = np.uint8)\r\n for j in range(len(pred_boxes)):\r\n num_preds[int(pred_boxes[j][-1])] += 1\r\n for i in range(gt_boxes.size(0)):\r\n num_GT_positive[int(gt_boxes[i][0])] += 1\r\n\r\n for i in range(gt_boxes.size(0)):\r\n for j in range(len(pred_boxes)):\r\n mx = min(pred_boxes[j][0] - pred_boxes[j][2] / 2.0, gt_boxes[i][1] - gt_boxes[i][3] / 2.0)\r\n Mx = max(pred_boxes[j][0] + pred_boxes[j][2] / 2.0, gt_boxes[i][1] + gt_boxes[i][3] / 2.0)\r\n my = min(pred_boxes[j][1] - pred_boxes[j][3] / 2.0, gt_boxes[i][2] - gt_boxes[i][4] / 2.0)\r\n My = max(pred_boxes[j][1] + pred_boxes[j][3] / 2.0, gt_boxes[i][2] + gt_boxes[i][4] / 2.0)\r\n w1 = pred_boxes[j][2]\r\n h1 = pred_boxes[j][3]\r\n w2 = gt_boxes[i][2]\r\n h2 = gt_boxes[i][3]\r\n uw = Mx - mx\r\n uh = My - my\r\n cw = w1 + w2 - uw\r\n ch = h1 + h2 - uh\r\n if cw <= 0 or ch <= 0:\r\n iou = 0.0\r\n else:\r\n area1 = w1 * h1\r\n area2 = w2 * h2\r\n carea = cw * ch\r\n uarea = area1 + area2 - carea\r\n iou = (carea / (uarea + 1e-12)).item()\r\n print(iou)\r\n if iou > 0.5 and gt_boxes[i][0] == pred_boxes[j][-1].float():\r\n num_correct[int(gt_boxes[i][0])] += 1\r\n break\r\n return num_preds, num_GT_positive, num_correct\r\n\r\n\r\ndef parse_config_info(configFile):\r\n infos = dict()\r\n with open(configFile, 'r') as fp:\r\n lines = fp.readlines()\r\n\r\n for line in lines:\r\n line = line.strip()\r\n if line == '' or line[0] == '#':\r\n continue\r\n key, value = line.split('=')\r\n key = key.strip()\r\n value = value.strip()\r\n infos[key] = value\r\n return infos\r\n\r\n\r\ndef scale_bboxes(bboxes, width, height):\r\n import copy\r\n dets = copy.deepcopy(bboxes)\r\n for i in range(len(dets)):\r\n dets[i][0] = dets[i][0] * width\r\n dets[i][1] = dets[i][1] * height\r\n dets[i][2] = dets[i][2] * width\r\n dets[i][3] = dets[i][3] * height\r\n return dets\r\n\r\n\r\ndef file_lines(thefilepath):\r\n count = 0\r\n thefile = open(thefilepath, 'r')\r\n while True:\r\n buffer = thefile.read(8192 * 1024)\r\n if not buffer:\r\n break\r\n count += buffer.count('\\n')\r\n thefile.close()\r\n return count\r\n\r\n\r\ndef get_image_size(fname):\r\n '''Determine the image type of fhandle and return its size.\r\n from draco'''\r\n with open(fname, 'rb') as fhandle:\r\n head = fhandle.read(24)\r\n if len(head) != 24:\r\n return\r\n if imghdr.what(fname) == 'png':\r\n check = struct.unpack('>i', head[4:8])[0]\r\n if check != 0x0d0a1a0a:\r\n return\r\n width, height = struct.unpack('>ii', head[16:24])\r\n elif imghdr.what(fname) == 'gif':\r\n width, height = struct.unpack('<HH', head[6:10])\r\n elif imghdr.what(fname) == 'jpeg' or imghdr.what(fname) == 'jpg':\r\n try:\r\n fhandle.seek(0) # Read 0xff next\r\n size = 2\r\n ftype = 0\r\n while not 0xc0 <= ftype <= 0xcf:\r\n fhandle.seek(size, 1)\r\n byte = fhandle.read(1)\r\n while ord(byte) == 0xff:\r\n byte = fhandle.read(1)\r\n ftype = ord(byte)\r\n size = struct.unpack('>H', fhandle.read(2))[0] - 2\r\n # We are at a SOFn block\r\n fhandle.seek(1, 1) # Skip `precision' byte.\r\n height, width = struct.unpack('>HH', fhandle.read(4))\r\n except Exception: # IGNORE:W0703\r\n return\r\n else:\r\n return\r\n return width, height\r\n\r\n\r\ndef logging(message):\r\n print('%s %s' % (time.strftime(\"%Y-%m-%d %H:%M:%S\", time.localtime()), message))\r\n\r\ndef load_conv_bn(buf, start, conv_model, bn_model):\r\n num_w = conv_model.weight.numel()\r\n num_b = bn_model.bias.numel()\r\n bn_model.bias.data.copy_(torch.from_numpy(buf[start:start+num_b])); start = start + num_b\r\n bn_model.weight.data.copy_(torch.from_numpy(buf[start:start+num_b])); start = start + num_b\r\n bn_model.running_mean.copy_(torch.from_numpy(buf[start:start+num_b])); start = start + num_b\r\n bn_model.running_var.copy_(torch.from_numpy(buf[start:start+num_b])); start = start + num_b\r\n conv_model.weight.data.copy_(torch.from_numpy(buf[start:start+num_w])); start = start + num_w\r\n return start\r\n\r\ndef load_conv(buf, start, conv_model):\r\n num_w = conv_model.weight.numel()\r\n num_b = conv_model.bias.numel()\r\n conv_model.bias.data.copy_(torch.from_numpy(buf[start:start+num_b])); start = start + num_b\r\n conv_model.weight.data.copy_(torch.from_numpy(buf[start:start+num_w])); start = start + num_w\r\n return start\r\n\r\n\r\ndef RoI_Align(inputs, rois, align_size):\r\n nB = inputs[0].size(0)\r\n output_feature = []\r\n for i in len(inputs):\r\n batch_boxes = rois[i][0]\r\n input = inputs[i]\r\n h = input.size(2)\r\n w = input.size(3)\r\n for b in nB:\r\n feature = input[b]\r\n boxes = batch_boxes[b]\r\n for box in boxes:\r\n x1 = np.floor((box[0] - box[2] / 2.0) * w)\r\n y1 = np.floor((box[1] - box[3] / 2.0) * h)\r\n x2 = np.ceil((box[0] + box[2] / 2.0) * w)\r\n y2 = np.ceil((box[1] + box[3] / 2.0) * h)\r\n output_feature.append(F.interpolate(feature[..., y1:y2, x1:x2], size=align_size, mode='bilinear'))\r\n\r\n return output_feature\r\n\r\n# 模型显存占用监测函数\r\n# model：输入的模型\r\n# input：实际中需要输入的Tensor变量\r\n# type_size 默认为 4 默认类型为 float32\r\n\r\ndef modelsize(model, input, type_size=4):\r\n para = sum([np.prod(list(p.size())) for p in model.parameters()])\r\n print('Model {} : params: {:4f}M'.format(model._get_name(), para * type_size / 1000 / 1000))\r\n\r\n input_ = input.clone()\r\n input_.requires_grad_(requires_grad=False)\r\n\r\n mods = list(model.modules())\r\n out_sizes = []\r\n\r\n for i in range(1, len(mods)):\r\n m = mods[i]\r\n if isinstance(m, torch.nn.ReLU):\r\n if m.inplace:\r\n continue\r\n out = m(input_)\r\n out_sizes.append(np.array(out.size()))\r\n input_ = out\r\n\r\n total_nums = 0\r\n for i in range(len(out_sizes)):\r\n s = out_sizes[i]\r\n nums = np.prod(np.array(s))\r\n total_nums += nums\r\n\r\n print('Model {} : intermedite variables: {:3f} M (without backward)'\r\n .format(model._get_name(), total_nums * type_size / 1000 / 1000))\r\n print('Model {} : intermedite variables: {:3f} M (with backward)'\r\n .format(model._get_name(), total_nums * type_size * 2 / 1000 / 1000))\r\n"
] | [
[
"torch.zeros",
"torch.sigmoid",
"numpy.array",
"numpy.ceil",
"torch.min",
"numpy.zeros",
"torch.max",
"torch.FloatTensor",
"torch.no_grad",
"torch.nn.functional.interpolate",
"torch.linspace",
"torch.clamp",
"torch.from_numpy",
"numpy.loadtxt",
"torch.tensor",
"numpy.arange",
"numpy.floor"
]
] |
SuchockiArtur/t-SNE-for-FaceNet | [
"575731e1687a2d2201ab147823910e87b1f55d7c"
] | [
"packages/classifier.py"
] | [
"from __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport math\nimport os\nimport pickle\n\nimport numpy as np\nimport tensorflow as tf\nfrom sklearn.svm import SVC\n\nfrom packages import facenet\n\n\nclass training:\n def __init__(self, datadir, modeldir,classifier_filename):\n self.datadir = datadir\n self.modeldir = modeldir\n self.classifier_filename = classifier_filename\n\n def main_train(self):\n with tf.Graph().as_default():\n with tf.Session() as sess:\n img_data = facenet.get_dataset(self.datadir)\n path, label = facenet.get_image_paths_and_labels(img_data)\n print('Classes: %d' % len(img_data))\n print('Images: %d' % len(path))\n\n facenet.load_model(self.modeldir)\n images_placeholder = tf.get_default_graph().get_tensor_by_name(\"input:0\")\n embeddings = tf.get_default_graph().get_tensor_by_name(\"embeddings:0\")\n phase_train_placeholder = tf.get_default_graph().get_tensor_by_name(\"phase_train:0\")\n embedding_size = embeddings.get_shape()[1]\n\n print('Extracting features of images for model')\n batch_size = 1000\n image_size = 160\n nrof_images = len(path)\n nrof_batches_per_epoch = int(math.ceil(1.0 * nrof_images / batch_size))\n emb_array = np.zeros((nrof_images, embedding_size))\n for i in range(nrof_batches_per_epoch):\n start_index = i * batch_size\n end_index = min((i + 1) * batch_size, nrof_images)\n paths_batch = path[start_index:end_index]\n images = facenet.load_data(paths_batch, False, False, image_size)\n feed_dict = {images_placeholder: images, phase_train_placeholder: False}\n emb_array[start_index:end_index, :] = sess.run(embeddings, feed_dict=feed_dict)\n\n classifier_file_name = os.path.expanduser(self.classifier_filename)\n\t\t\t\t\n # Training Started\n print('Training Started')\n model = SVC(kernel='linear', probability=True)\n model.fit(emb_array, label)\n\n class_names = [cls.name.replace('_', ' ') for cls in img_data]\n\n # Saving model\n with open(classifier_file_name, 'wb') as outfile:\n pickle.dump((model, class_names), outfile)\n return classifier_file_name\n"
] | [
[
"numpy.zeros",
"tensorflow.get_default_graph",
"tensorflow.Graph",
"tensorflow.Session",
"sklearn.svm.SVC"
]
] |
koverman47/Sequential-Dynamic-Blotto | [
"6867ebb47a6f822c5671c6db6b071d22fb3e80e0"
] | [
"search.py"
] | [
"#!/usr/bin/env python3\n\nimport sys\nimport math\nimport numpy as np\nfrom time import time\nfrom shapely.geometry import Point\nfrom shapely.geometry.polygon import Polygon\nfrom scipy.spatial import ConvexHull\nfrom utils import gen_kspace\nfrom node import Node\n\nclass Minimax:\n\n def __init__(self, A, R, V, K, x0, y0, max_depth):\n self.A = A\n self.R = R\n self.V = V\n self.K = K\n self.x0 = x0\n self.y0 = y0\n self.md = max_depth\n self.xspaces = {}\n self.yspaces = {}\n p = self.get_payoff(x0, y0)\n\n '''\n ' x_cand, y_cand, V\n '''\n def get_payoff(self, xC, yC):\n assert len(xC) == len(yC)\n assert len(xC) == len(self.V)\n\n d = xC - yC\n win = np.where(d > 0., 1, 0)\n los = np.where(d < 0., 1, 0)\n drw = np.where(d == 0., 1, 0)\n\n p1 = sum(self.V[np.where(win == 1)])\n p2 = sum(self.V[np.where(los == 1)])\n p3 = 0.5 * sum(xC[np.where(win == 0)])\n p4 = 0.5 * sum(yC[np.where(los == 0)])\n\n u = p1 - p2 - p3 + p4\n return u\n\n\n '''\n ' A, K, x\n '''\n def gen_xspace(self, x):\n n = len(x)\n m = len(self.K[0])\n\n I = np.eye(n)\n U = np.dot(x[0], I)\n for i in range(1, n):\n U = np.concatenate((U, np.dot(x[i], I)), axis=1)\n \n vsave = np.zeros((n, m))\n for i in range(m):\n k = self.K[:, i]\n LS = np.zeros((n, n))\n for j in range(n):\n if k[j] == 1:\n LS[:, j] = self.A[:, j]\n\n colsum = np.sum(LS, 0)\n d = np.ones(n) - colsum\n for j in range(n):\n LS[j, j] = d[j]\n \n LSF = LS.flatten('F')\n xv = np.dot(U, LSF)\n vsave[:, i] = xv\n\n xVsave = np.unique(vsave, axis=1)\n xVsave = np.round(xVsave, 4)\n twodee = xVsave[:2, :] \n indices = np.array(ConvexHull(twodee.T).vertices)\n xV = xVsave.T[indices]\n \n return xV.T\n\n '''\n ' xv, R\n '''\n def sample_action(self, xV, n, i):\n r = i % n\n c = math.floor(i / n)\n \n x = np.round(r * self.R, 4)\n y = np.round(c * self.R, 4)\n\n point = Point(x, y)\n poly = []\n xVT = xV.T\n for v in xVT:\n poly.append((v[0], v[1]))\n polygon = Polygon(poly)\n if polygon.contains(point) or point.intersects(polygon):\n return np.array([x, y, sum(xV[:, 1]) - x - y])\n #print(\"Outside of Polygon\")\n #print([x, y, sum(xV[:, 1]) - x - y])\n #print(\"\\n\")\n return False\n\n def get_num_nodes(self, node):\n c = 1\n if not node.children:\n return 0\n for child in node.children:\n c += 1 + self.get_num_nodes(child)\n return c\n\n def recover_solution(self, node):\n n = node\n d = 0\n path = [n]\n while n.children:\n i = -1\n if d % 2 == 0:\n i = n.children.index(max(n.children))\n n = n.children[i]\n path.append(n)\n else:\n i = n.children.index(min(n.children))\n n = n.children[i]\n d += 1\n return path\n \n def run(self):\n t1 = time()\n xV = self.gen_xspace(self.x0)\n ###\n XRes = sum(self.x0)\n L = int(XRes / self.R) + 1\n c = 0\n for i in range(L**2):\n x = self.sample_action(xV, L, i)\n if x is not False:\n c += 1\n #print(x, sum(x))\n print(x[0], x[1], x[2])\n print(c)\n sys.exit()\n ###\n yV = self.gen_xspace(self.y0)\n self.xspaces[str(self.x0)] = xV\n self.yspaces[str(self.y0)] = yV\n node = Node(self.x0, self.y0, 0, None)\n value = self.abpruning(node, 0, -1000, 1000, xV, yV)\n t2 = time()\n print(\"Time\", t2 - t1)\n print(value)\n path = self.recover_solution(node)\n print(path)\n print(\"Number of Nodes : %d\" % self.get_num_nodes(node))\n\n '''\n ' node, depth, alpha, beta, maximizer\n '''\n def abpruning(self, node, d, a, b, xV, yV, maximizer=True):\n if d == self.md:\n assert d % 2 == 0\n assert not node.children\n p = self.get_payoff(node.x, node.y)\n node.set_payoff(p)\n return node.p\n elif d == 0:\n if str(node.x) in self.xspaces:\n #print(\"Passed Checks\")\n xV = self.xspaces[str(node.x)]\n else:\n xV = self.gen_xspace(node.x)\n self.xspace[str(node.x)] = xV\n value = -1000\n XRes = sum(self.x0)\n L = int(XRes / self.R) + 1\n for i in range(L**2): # number of samples for x-space\n x = self.sample_action(xV, L, i)\n if x is False:\n continue\n print(x)\n n = Node(x, node.y, d+1, node)\n node.children.append(n)\n # Maximizer?\n assert value is not None\n value = max(value, self.abpruning(n, d+1, a, b, xV, yV))\n if value >= b:\n break\n a = max(a, value)\n node.set_payoff(value)\n return value\n elif d % 2 == 1:\n if str(node.y) in self.yspaces:\n #print(\"Passed Checks\")\n yV = self.yspaces[str(node.y)]\n else:\n yV = self.gen_xspace(node.y)\n self.yspaces[str(node.y)] = yV\n value = 1000\n YRes = sum(self.x0)\n L = int(YRes / self.R) + 1\n for i in range(L**2): # number of samples for y-space\n y = self.sample_action(yV, L, i)\n if y is False:\n continue\n n = Node(node.x, y, d+1, node)\n node.children.append(n)\n # Minimizer?\n assert value is not None\n result = self.abpruning(n, d+1, a, b, xV, yV)\n value = min(value, self.abpruning(n, d+1, a, b, xV, yV))\n if value <= a:\n break\n b = min(b, value)\n node.set_payoff(value)\n return node.p\n elif d % 2 == 0:\n if str(node.x) in self.xspaces:\n #print(\"Passed Checks\")\n xV = self.xspaces[str(node.x)]\n else:\n xV = self.gen_xspace(node.x)\n self.xspaces[str(node.x)] = xV\n value = -1000\n XRes = sum(self.x0)\n L = int(XRes / self.R) + 1\n for i in range(L**2): # number of samples for x-space\n x = self.sample_action(xV, L, i)\n if x is False:\n continue\n print(x)\n n = Node(x, node.y, d+1, node)\n node.children.append(n)\n # Maximizer?\n assert value is not None\n value = max(value, self.abpruning(n, d+1, a, b, xV, yV))\n if value >= b:\n break\n a = max(a, value)\n p = self.get_payoff(node.x, node.y)\n node.set_payoff(p + value)\n return node.p\n print(\"Returning False\")\n print(\"Depth : %d\" % d)\n\n\nif __name__ == \"__main__\":\n # Define vars\n md = 2\n A = np.array([[0, 0, 1], [1, 0, 0], [0, 1, 0]])\n R = 0.1\n V = np.array([1., 1., 1.])\n\n x0 = np.array([0.3, 0.6, 0.4])\n y0 = np.array([0., 0.2, 0.8])\n\n # Create K-space vertices\n K = np.array(gen_kspace(A))\n\n game = Minimax(A, R, V, K, x0, y0, 2 * md)\n game.run()\n"
] | [
[
"numpy.array",
"numpy.dot",
"numpy.zeros",
"numpy.round",
"numpy.sum",
"numpy.ones",
"numpy.eye",
"numpy.where",
"scipy.spatial.ConvexHull",
"numpy.unique"
]
] |
ziming-liu/ObjectDet | [
"6e25fa784114b9773b052d9d5465aa6fed93468a"
] | [
"mmdet/models/backbones/shareresnet_sumup0.py"
] | [
"import logging\n\nimport torch\nimport torch.nn as nn\nimport torch.utils.checkpoint as cp\nfrom mmcv.cnn import constant_init, kaiming_init\nfrom mmcv.runner import load_checkpoint\nfrom torch.nn.modules.batchnorm import _BatchNorm\n\nfrom mmdet.models.plugins import GeneralizedAttention\nfrom mmdet.models.utils import ConvModule\nfrom mmdet.ops import ContextBlock, DeformConv, ModulatedDeformConv\nfrom ..registry import BACKBONES\nfrom ..utils import build_conv_layer, build_norm_layer\nfrom torch.nn import functional as F\nclass BasicBlock(nn.Module):\n expansion = 1\n\n def __init__(self,\n inplanes,\n planes,\n stride=1,\n dilation=1,\n downsample=None,\n style='pytorch',\n with_cp=False,\n conv_cfg=None,\n norm_cfg=dict(type='BN'),\n dcn=None,\n gcb=None,\n gen_attention=None):\n super(BasicBlock, self).__init__()\n assert dcn is None, \"Not implemented yet.\"\n assert gen_attention is None, \"Not implemented yet.\"\n assert gcb is None, \"Not implemented yet.\"\n\n self.norm1_name, norm1 = build_norm_layer(norm_cfg, planes, postfix=1)\n self.norm2_name, norm2 = build_norm_layer(norm_cfg, planes, postfix=2)\n\n self.conv1 = build_conv_layer(\n conv_cfg,\n inplanes,\n planes,\n 3,\n stride=stride,\n padding=dilation,\n dilation=dilation,\n bias=False)\n self.add_module(self.norm1_name, norm1)\n self.conv2 = build_conv_layer(\n conv_cfg, planes, planes, 3, padding=1, bias=False)\n self.add_module(self.norm2_name, norm2)\n\n self.relu = nn.ReLU(inplace=True)\n self.downsample = downsample\n self.stride = stride\n self.dilation = dilation\n assert not with_cp\n\n @property\n def norm1(self):\n return getattr(self, self.norm1_name)\n\n @property\n def norm2(self):\n return getattr(self, self.norm2_name)\n\n def forward(self, x):\n identity = x\n\n out = self.conv1(x)\n out = self.norm1(out)\n out = self.relu(out)\n\n out = self.conv2(out)\n out = self.norm2(out)\n\n if self.downsample is not None:\n identity = self.downsample(x)\n\n out += identity\n out = self.relu(out)\n\n return out\n\n\nclass Bottleneck(nn.Module):\n expansion = 4\n\n def __init__(self,\n inplanes,\n planes,\n stride=1,\n dilation=1,\n downsample=None,\n style='pytorch',\n with_cp=False,\n conv_cfg=None,\n norm_cfg=dict(type='BN'),\n dcn=None,\n gcb=None,\n gen_attention=None):\n \"\"\"Bottleneck block for ResNet.\n If style is \"pytorch\", the stride-two layer is the 3x3 conv layer,\n if it is \"caffe\", the stride-two layer is the first 1x1 conv layer.\n \"\"\"\n super(Bottleneck, self).__init__()\n assert style in ['pytorch', 'caffe']\n assert dcn is None or isinstance(dcn, dict)\n assert gcb is None or isinstance(gcb, dict)\n assert gen_attention is None or isinstance(gen_attention, dict)\n\n self.inplanes = inplanes\n self.planes = planes\n self.stride = stride\n self.dilation = dilation\n self.style = style\n self.with_cp = with_cp\n self.conv_cfg = conv_cfg\n self.norm_cfg = norm_cfg\n self.dcn = dcn\n self.with_dcn = dcn is not None\n self.gcb = gcb\n self.with_gcb = gcb is not None\n self.gen_attention = gen_attention\n self.with_gen_attention = gen_attention is not None\n\n if self.style == 'pytorch':\n self.conv1_stride = 1\n self.conv2_stride = stride\n else:\n self.conv1_stride = stride\n self.conv2_stride = 1\n\n self.norm1_name, norm1 = build_norm_layer(norm_cfg, planes, postfix=1)\n self.norm2_name, norm2 = build_norm_layer(norm_cfg, planes, postfix=2)\n self.norm3_name, norm3 = build_norm_layer(\n norm_cfg, planes * self.expansion, postfix=3)\n\n self.conv1 = build_conv_layer(\n conv_cfg,\n inplanes,\n planes,\n kernel_size=1,\n stride=self.conv1_stride,\n bias=False)\n self.add_module(self.norm1_name, norm1)\n fallback_on_stride = False\n self.with_modulated_dcn = False\n if self.with_dcn:\n fallback_on_stride = dcn.get('fallback_on_stride', False)\n self.with_modulated_dcn = dcn.get('modulated', False)\n if not self.with_dcn or fallback_on_stride:\n self.conv2 = build_conv_layer(\n conv_cfg,\n planes,\n planes,\n kernel_size=3,\n stride=self.conv2_stride,\n padding=dilation,\n dilation=dilation,\n bias=False)\n else:\n assert conv_cfg is None, 'conv_cfg must be None for DCN'\n deformable_groups = dcn.get('deformable_groups', 1)\n if not self.with_modulated_dcn:\n conv_op = DeformConv\n offset_channels = 18\n else:\n conv_op = ModulatedDeformConv\n offset_channels = 27\n self.conv2_offset = nn.Conv2d(\n planes,\n deformable_groups * offset_channels,\n kernel_size=3,\n stride=self.conv2_stride,\n padding=dilation,\n dilation=dilation)\n self.conv2 = conv_op(\n planes,\n planes,\n kernel_size=3,\n stride=self.conv2_stride,\n padding=dilation,\n dilation=dilation,\n deformable_groups=deformable_groups,\n bias=False)\n self.add_module(self.norm2_name, norm2)\n self.conv3 = build_conv_layer(\n conv_cfg,\n planes,\n planes * self.expansion,\n kernel_size=1,\n bias=False)\n self.add_module(self.norm3_name, norm3)\n\n self.relu = nn.ReLU(inplace=True)\n self.downsample = downsample\n\n if self.with_gcb:\n gcb_inplanes = planes * self.expansion\n self.context_block = ContextBlock(inplanes=gcb_inplanes, **gcb)\n\n # gen_attention\n if self.with_gen_attention:\n self.gen_attention_block = GeneralizedAttention(\n planes, **gen_attention)\n\n @property\n def norm1(self):\n return getattr(self, self.norm1_name)\n\n @property\n def norm2(self):\n return getattr(self, self.norm2_name)\n\n @property\n def norm3(self):\n return getattr(self, self.norm3_name)\n\n def forward(self, x):\n\n def _inner_forward(x):\n identity = x\n\n out = self.conv1(x)\n out = self.norm1(out)\n out = self.relu(out)\n\n if not self.with_dcn:\n out = self.conv2(out)\n elif self.with_modulated_dcn:\n offset_mask = self.conv2_offset(out)\n offset = offset_mask[:, :18, :, :]\n mask = offset_mask[:, -9:, :, :].sigmoid()\n out = self.conv2(out, offset, mask)\n else:\n offset = self.conv2_offset(out)\n out = self.conv2(out, offset)\n out = self.norm2(out)\n out = self.relu(out)\n\n if self.with_gen_attention:\n out = self.gen_attention_block(out)\n\n out = self.conv3(out)\n out = self.norm3(out)\n\n if self.with_gcb:\n out = self.context_block(out)\n\n if self.downsample is not None:\n identity = self.downsample(x)\n\n out += identity\n\n return out\n\n if self.with_cp and x.requires_grad:\n out = cp.checkpoint(_inner_forward, x)\n else:\n out = _inner_forward(x)\n\n out = self.relu(out)\n\n return out\n\n\ndef make_res_layer(block,\n inplanes,\n planes,\n blocks,\n stride=1,\n dilation=1,\n style='pytorch',\n with_cp=False,\n conv_cfg=None,\n norm_cfg=dict(type='BN'),\n dcn=None,\n gcb=None,\n gen_attention=None,\n gen_attention_blocks=[]):\n downsample = None\n if stride != 1 or inplanes != planes * block.expansion:\n downsample = nn.Sequential(\n build_conv_layer(\n conv_cfg,\n inplanes,\n planes * block.expansion,\n kernel_size=1,\n stride=stride,\n bias=False),\n build_norm_layer(norm_cfg, planes * block.expansion)[1],\n )\n\n layers = []\n layers.append(\n block(\n inplanes=inplanes,\n planes=planes,\n stride=stride,\n dilation=dilation,\n downsample=downsample,\n style=style,\n with_cp=with_cp,\n conv_cfg=conv_cfg,\n norm_cfg=norm_cfg,\n dcn=dcn,\n gcb=gcb,\n gen_attention=gen_attention if\n (0 in gen_attention_blocks) else None))\n inplanes = planes * block.expansion\n for i in range(1, blocks):\n layers.append(\n block(\n inplanes=inplanes,\n planes=planes,\n stride=1,\n dilation=dilation,\n style=style,\n with_cp=with_cp,\n conv_cfg=conv_cfg,\n norm_cfg=norm_cfg,\n dcn=dcn,\n gcb=gcb,\n gen_attention=gen_attention if\n (i in gen_attention_blocks) else None))\n\n return nn.Sequential(*layers)\n\n\[email protected]_module\nclass shareResNet_sumup(nn.Module):\n \"\"\"ResNet backbone.\n\n Args:\n depth (int): Depth of resnet, from {18, 34, 50, 101, 152}.\n num_stages (int): Resnet stages, normally 4.\n strides (Sequence[int]): Strides of the first block of each stage.\n dilations (Sequence[int]): Dilation of each stage.\n out_indices (Sequence[int]): Output from which stages.\n style (str): `pytorch` or `caffe`. If set to \"pytorch\", the stride-two\n layer is the 3x3 conv layer, otherwise the stride-two layer is\n the first 1x1 conv layer.\n frozen_stages (int): Stages to be frozen (stop grad and set eval mode).\n -1 means not freezing any parameters.\n norm_cfg (dict): dictionary to construct and config norm layer.\n norm_eval (bool): Whether to set norm layers to eval mode, namely,\n freeze running stats (mean and var). Note: Effect on Batch Norm\n and its variants only.\n with_cp (bool): Use checkpoint or not. Using checkpoint will save some\n memory while slowing down the training speed.\n zero_init_residual (bool): whether to use zero init for last norm layer\n in resblocks to let them behave as identity.\n \"\"\"\n\n arch_settings = {\n 18: (BasicBlock, (2, 2, 2, 2,1,1,1)),\n 34: (BasicBlock, (3, 4, 6, 3,2,2,2)),\n 50: (Bottleneck, (3, 4, 6, 3,2,2,2)),\n 101: (Bottleneck, (3, 4, 23, 3,2,2,2)),\n 152: (Bottleneck, (3, 8, 36, 3,2,2,2))\n }\n\n def __init__(self,\n depth,\n num_stages=4,\n strides=(1, 2, 2, 2,2 ,2,1),\n dilations=(1, 1, 1, 1,1,1,2),\n out_indices=(0, 1, 2, 3,4,5,6),\n style='pytorch',\n frozen_stages=-1,\n conv_cfg=None,\n norm_cfg=dict(type='BN', requires_grad=True),\n norm_eval=True,\n multiple=False,\n dcn=None,\n num_branch=4,\n stage_with_dcn=(False, False, False, False,False, False, False),\n gcb=None,\n stage_with_gcb=(False, False, False, False,False, False, False),\n gen_attention=None,\n stage_with_gen_attention=((), (), (), (),(), (), ()),\n with_cp=False,\n zero_init_residual=True):\n super(shareResNet_sumup, self).__init__()\n if depth not in self.arch_settings:\n raise KeyError('invalid depth {} for resnet'.format(depth))\n self.depth = depth\n self.num_branch = num_branch\n self.num_stages = num_stages\n self.multiple = multiple\n assert num_stages >= 1 and num_stages <= 7\n self.strides = strides\n self.dilations = dilations\n assert len(strides) == len(dilations) == num_stages\n self.out_indices = out_indices\n assert max(out_indices) < num_stages\n self.style = style\n self.frozen_stages = frozen_stages\n self.conv_cfg = conv_cfg\n self.norm_cfg = norm_cfg\n self.with_cp = with_cp\n self.norm_eval = norm_eval\n self.dcn = dcn\n self.stage_with_dcn = stage_with_dcn\n if dcn is not None:\n assert len(stage_with_dcn) == num_stages\n self.gen_attention = gen_attention\n self.gcb = gcb\n self.stage_with_gcb = stage_with_gcb\n if gcb is not None:\n assert len(stage_with_gcb) == num_stages\n self.zero_init_residual = zero_init_residual\n self.block, stage_blocks = self.arch_settings[depth]\n self.stage_blocks = stage_blocks[:num_stages]\n self.inplanes = 64\n\n self._make_stem_layer()\n\n self.res_layers = []\n for i, num_blocks in enumerate(self.stage_blocks):\n stride = strides[i]\n dilation = dilations[i]\n dcn = self.dcn if self.stage_with_dcn[i] else None\n gcb = self.gcb if self.stage_with_gcb[i] else None\n planes = 64 * 2**i\n if i>=4:\n planes = 64 *2**3\n res_layer = make_res_layer(\n self.block,\n self.inplanes,\n planes,\n num_blocks,\n stride=stride,\n dilation=dilation,\n style=self.style,\n with_cp=with_cp,\n conv_cfg=conv_cfg,\n norm_cfg=norm_cfg,\n dcn=dcn,\n gcb=gcb,\n gen_attention=gen_attention,\n gen_attention_blocks=stage_with_gen_attention[i])\n self.inplanes = planes * self.block.expansion\n layer_name = 'layer{}'.format(i + 1)\n self.add_module(layer_name, res_layer)\n self.res_layers.append(layer_name)\n\n self._freeze_stages()\n\n self.feat_dim = self.block.expansion * 64 * 2**(\n len(self.stage_blocks) - 1)\n\n self.ipg_conv1 = make_res_layer(\n self.block,\n 64,\n 64,\n 1,\n stride=1,\n dilation=1,\n style=self.style,\n with_cp=with_cp,\n conv_cfg=conv_cfg,\n norm_cfg=norm_cfg,\n dcn=dcn,\n gcb=gcb,\n gen_attention=gen_attention,\n gen_attention_blocks=[])\n self.ipg_conv2 = make_res_layer(\n self.block,\n 64,\n 128,\n 1,\n stride=2,\n dilation=1,\n style=self.style,\n with_cp=with_cp,\n conv_cfg=conv_cfg,\n norm_cfg=norm_cfg,\n dcn=dcn,\n gcb=gcb,\n gen_attention=gen_attention,\n gen_attention_blocks=[])\n self.ipg_conv3 = make_res_layer(\n self.block,\n 64,\n 256,\n 1,\n stride=2,\n dilation=1,\n style=self.style,\n with_cp=with_cp,\n conv_cfg=conv_cfg,\n norm_cfg=norm_cfg,\n dcn=dcn,\n gcb=gcb,\n gen_attention=gen_attention,\n gen_attention_blocks=[])\n self.ipg_conv4 = make_res_layer(\n self.block,\n 64,\n 512,\n 1,\n stride=2,\n dilation=1,\n style=self.style,\n with_cp=with_cp,\n conv_cfg=conv_cfg,\n norm_cfg=norm_cfg,\n dcn=dcn,\n gcb=gcb,\n gen_attention=gen_attention,\n gen_attention_blocks=[])\n self.conv_sub_512 = ConvModule(\n 512, 512,\n 3,\n padding=1,\n conv_cfg=conv_cfg,\n norm_cfg=norm_cfg,\n inplace=False)\n self.conv_sub_1024 = ConvModule(\n 1024, 1024,\n 3,\n padding=1,\n conv_cfg=conv_cfg,\n norm_cfg=norm_cfg,\n inplace=False)\n self.conv_sub_2048 = ConvModule(\n 2048, 2048,\n 3,\n padding=1,\n conv_cfg=conv_cfg,\n norm_cfg=norm_cfg,\n inplace=False)\n self.conv_main_512 = ConvModule(\n 512, 512,\n 3,\n padding=1,\n conv_cfg=conv_cfg,\n norm_cfg=norm_cfg,\n inplace=False)\n self.conv_main_1024 = ConvModule(\n 1024, 1024,\n 3,\n padding=1,\n conv_cfg=conv_cfg,\n norm_cfg=norm_cfg,\n inplace=False)\n self.conv_main_2048 = ConvModule(\n 2048, 2048,\n 3,\n padding=1,\n conv_cfg=conv_cfg,\n norm_cfg=norm_cfg,\n inplace=False)\n\n self.conv_sum_512 = ConvModule(\n 512, 512,\n 3,\n padding=1,\n conv_cfg=conv_cfg,\n norm_cfg=norm_cfg,\n inplace=False)\n self.conv_sum_1024 = ConvModule(\n 1024, 1024,\n 3,\n padding=1,\n conv_cfg=conv_cfg,\n norm_cfg=norm_cfg,\n inplace=False)\n self.conv_sum_2048 = ConvModule(\n 2048, 2048,\n 3,\n padding=1,\n conv_cfg=conv_cfg,\n norm_cfg=norm_cfg,\n inplace=False)\n\n @property\n def norm1(self):\n return getattr(self, self.norm1_name)\n\n def _make_stem_layer(self):\n self.conv1 = build_conv_layer(\n self.conv_cfg,\n 3,\n 64,\n kernel_size=7,\n stride=2,\n padding=3,\n bias=False)\n self.norm1_name, norm1 = build_norm_layer(self.norm_cfg, 64, postfix=1)\n self.add_module(self.norm1_name, norm1)\n self.relu = nn.ReLU(inplace=True)\n self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)\n\n def _freeze_stages(self):\n if self.frozen_stages >= 0:\n self.norm1.eval()\n for m in [self.conv1, self.norm1]:\n for param in m.parameters():\n param.requires_grad = False\n\n for i in range(1, self.frozen_stages + 1):\n m = getattr(self, 'layer{}'.format(i))\n m.eval()\n for param in m.parameters():\n param.requires_grad = False\n\n def init_weights(self, pretrained=None):\n if isinstance(pretrained, str):\n logger = logging.getLogger()\n load_checkpoint(self, pretrained, strict=False, logger=logger)\n elif pretrained is None:\n for m in self.modules():\n if isinstance(m, nn.Conv2d):\n kaiming_init(m)\n elif isinstance(m, (_BatchNorm, nn.GroupNorm)):\n constant_init(m, 1)\n\n if self.dcn is not None:\n for m in self.modules():\n if isinstance(m, Bottleneck) and hasattr(\n m, 'conv2_offset'):\n constant_init(m.conv2_offset, 0)\n\n if self.zero_init_residual:\n for m in self.modules():\n if isinstance(m, Bottleneck):\n constant_init(m.norm3, 0)\n elif isinstance(m, BasicBlock):\n constant_init(m.norm2, 0)\n else:\n raise TypeError('pretrained must be a str or None')\n\n def forward(self, input):\n pyramid = []\n b, c, h, w = input.shape\n edge = max(h, w)\n range_ = edge - edge / 2\n #scale_factor = [(edge - range_ * i / self.num_branch - 1) / edge for i in range(self.num_branch)]\n #if self.without_ip:\n # for i in range(self.num_stages):\n # parimad.append(input.clone())\n #else:\n for i in range(self.num_branch):\n pyramid.append(F.interpolate(input.clone(), scale_factor=2**(-i), mode='nearest'))\n x = pyramid[0]\n x = self.conv1(x)\n x = self.norm1(x)\n x = self.relu(x)\n x = self.maxpool(x)\n outs = []\n for i, layer_name in enumerate(self.res_layers):\n res_layer = getattr(self, layer_name)\n x = res_layer(x)\n if i!=0 and i <= len(pyramid) and i<self.num_branch:\n x2 = pyramid[i]\n x2 = self.conv1(x2)\n x2 = self.norm1(x2)\n x2 = self.relu(x2)\n x2 = self.maxpool(x2)\n res_layer = getattr(self, self.res_layers[0])\n x2 = res_layer(x2)\n if i>3:\n x = self.conv_main_2048(x)\n x2 = self.conv_sub_2048(x2.repeat(1, 2 ** i, 1, 1))\n x = x + x2\n x = self.conv_sum_2048(x)\n else:\n if i==1:\n x = self.conv_main_512(x)\n x2 = self.conv_sub_512(x2.repeat(1, 2 ** i, 1, 1))\n x = x+x2\n x = self.conv_sum_512(x)\n elif i==2:\n x = self.conv_main_1024(x)\n x2 = self.conv_sub_1024(x2.repeat(1, 2 ** i, 1, 1))\n x = x + x2\n x = self.conv_sum_1024(x)\n elif i==3:\n x = self.conv_main_2048(x)\n x2 = self.conv_sub_2048(x2.repeat(1, 2 ** i, 1, 1))\n x = x + x2\n x = self.conv_sum_2048(x)\n if i in self.out_indices:\n outs.append(x)\n #print(len(outs))\n return tuple(outs)\n\n def train(self, mode=True):\n super(shareResNet_sumup, self).train(mode)\n self._freeze_stages()\n if mode and self.norm_eval:\n for m in self.modules():\n # trick: eval have effect on BatchNorm only\n if isinstance(m, _BatchNorm):\n m.eval()\n\n\n"
] | [
[
"torch.nn.MaxPool2d",
"torch.nn.Sequential",
"torch.nn.ReLU",
"torch.nn.Conv2d",
"torch.utils.checkpoint.checkpoint"
]
] |
greenfieldvision/psiz | [
"37068530a78e08792e827ee55cf55e627add115e"
] | [
"src/psiz/keras/sparse_dispatcher.py"
] | [
"# coding=utf-8\n# Copyright 2020 The Tensor2Tensor Authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n#\n# Modified by The PsiZ Authors (2021). Updated to use TensorFlow 2.x modules\n# (e.g., tf.math). Removed dependency on external module (common_layers).\n#\n# Copyright 2021 The PsiZ 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\"\"\"Module for TensorFlow dispatching.\n\nClasses:\n SparseDispatcher: A sparse dispatcer.\n\n\"\"\"\nimport tensorflow as tf\n# from tensorflow.python.framework import function\n\n\n# TODO do we need this, if so why does it break during eager?\n# @function.Defun(\n# python_grad_func=lambda x, dy: tf.convert_to_tensor(dy),\n# shape_func=lambda op: [op.inputs[0].get_shape()])\n# def convert_gradient_to_tensor(x):\n# \"\"\"Identity operation whose gradient is converted to a `Tensor`.\n# Currently, the gradient to `tf.concat` is particularly expensive to\n# compute if dy is an `IndexedSlices` (a lack of GPU implementation\n# forces the gradient operation onto CPU). This situation occurs when\n# the output of the `tf.concat` is eventually passed to `tf.gather`.\n# It is sometimes faster to convert the gradient to a `Tensor`, so as\n# to get the cheaper gradient for `tf.concat`. To do this, replace\n# `tf.concat(x)` with `convert_gradient_to_tensor(tf.concat(x))`.\n\n# Args:\n# x: A `Tensor`.\n# Returns:\n# The input `Tensor`.\n# \"\"\"\n# return x\n\n\nclass SparseDispatcher():\n \"\"\"Helper for implementing a mixture of experts.\n\n TODO: update doc strings for arbitrary length inputs\n\n The purpose of this class is to create input minibatches for the\n experts and to combine the results of the experts to form a unified\n output tensor.\n\n There are two functions:\n dispatch: take an input Tensor and create input Tensors for\n each expert.\n combine: take output Tensors from each expert and form a\n combined output Tensor. Outputs from different experts for\n the same batch element are summed together, weighted by the\n provided \"gates\".\n\n The class is initialized with a \"gates\" Tensor, which specifies\n which batch elements go to which experts, and the weights to use\n when combining the outputs. Batch element b is sent to expert e\n iff gates[b, e] != 0. The inputs and outputs are all\n two-dimensional [batch, depth]. Caller is responsible for\n collapsing additional dimensions prior to calling this class and\n reshaping the output to the original shape.\n See common_layers.reshape_like().\n\n Example use:\n gates: a float32 `Tensor` with shape `[batch_size, num_experts]`\n inputs: a float32 `Tensor` with shape `[batch_size, input_size]`\n experts: a list of length `num_experts` containing sub-networks.\n\n dispatcher = SparseDispatcher(num_experts, gates)\n expert_inputs = dispatcher.dispatch(inputs)\n expert_outputs = [\n experts[i](expert_inputs[i]) for i in range(num_experts)\n ]\n outputs = dispatcher.combine(expert_outputs)\n\n The preceding code sets the output for a particular example b to:\n output[b] = Sum_i(gates[b, i] * experts[i](inputs[b]))\n\n This class takes advantage of sparsity in the gate matrix by\n including in the `Tensor`s for expert i only the batch elements for\n which `gates[b, i] > 0`.\n\n \"\"\"\n\n def __init__(self, num_experts, gates):\n \"\"\"Create a SparseDispatcher.\n\n Args:\n num_experts: an integer.\n gates: a `Tensor` of shape `[batch_size, num_experts]`.\n\n Returns:\n a SparseDispatcher\n\n \"\"\"\n self._gates = gates\n self._num_experts = num_experts\n\n # Determine locations of nonzero values of `gates`. Structure\n # as a 2D Tensor of matrix indices, (i.e., shape=(n_nonzero, 2)),\n # where the first column is the expert index and the second column\n # is an index in to the minibatch position.\n where = tf.cast(\n tf.where(tf.transpose(gates) > 0),\n tf.int32\n )\n\n # Split `where` Tensor into two separate columns.\n self._expert_index, self._batch_index = tf.unstack(\n where, num=2, axis=1\n )\n\n # Determine minibatch sizes for each expert.\n self._part_sizes_tensor = tf.reduce_sum(\n tf.cast(gates > 0, tf.int32), [0]\n )\n\n # Grab nonzero gate values (in the same order as `where`).\n self._nonzero_gates = tf.gather(\n tf.reshape(self._gates, [-1]),\n self._batch_index * num_experts + self._expert_index,\n axis=0\n )\n\n # TODO maybe dispatch_multi vs dispatch single\n # @add_name_scope()\n def dispatch_single(self, inputs):\n \"\"\"Create one input Tensor for each expert.\n\n The `Tensor` for a expert `i` contains the slices of `inp`\n corresponding to the batch elements `b` where `gates[b, i] > 0`.\n\n Args:\n inputs: a `Tensor` of shape \"[batch_size, <extra_input_dims>]`\n\n Returns:\n a list of `num_experts` `Tensor`s with shapes\n `[expert_batch_size_i, <extra_input_dims>]`.\n\n \"\"\"\n inputs = tf.gather(inputs, self._batch_index, axis=0)\n return tf.split(inputs, self._part_sizes_tensor, 0)\n\n # @add_name_scope()\n def dispatch_multi(self, inputs):\n \"\"\"Create one input Tensor for each expert.\n\n The `Tensor` for a expert `i` contains the slices of `inp`\n corresponding to the batch elements `b` where `gates[b, i] > 0`.\n\n Args:\n inputs: a `Tensor` of shape \"[batch_size, <extra_input_dims>]`\n\n Returns:\n a list of `num_experts` `Tensor`s with shapes\n `[expert_batch_size_i, <extra_input_dims>]`.\n\n \"\"\"\n # Initialize empty list for each expert.\n expert_list = [[] for _ in range(self._num_experts)]\n # Loop over inputs, creating expert-specific list of `inputs`.\n for inp in inputs:\n inp = tf.gather(inp, self._batch_index, axis=0)\n inp = tf.split(inp, self._part_sizes_tensor, 0)\n for i_expert in range(self._num_experts):\n expert_list[i_expert].append(inp[i_expert])\n\n return expert_list\n\n # @add_name_scope()\n def combine(self, expert_out, multiply_by_gates=True):\n \"\"\"Sum together the expert output, weighted by the gates.\n\n The slice corresponding to a particular batch element `b` is computed\n as the sum over all experts `i` of the expert output, weighted by the\n corresponding gate values. If `multiply_by_gates` is set to False, the\n gate values are ignored.\n\n Args:\n expert_out: a list of `num_experts` `Tensor`s, each with\n shape `[expert_batch_size_i, <extra_output_dims>]`.\n multiply_by_gates: a boolean\n\n Returns:\n a `Tensor` with shape `[batch_size, <extra_output_dims>]`.\n\n \"\"\"\n # TODO potential issue, original file was concerned with tf.concat\n # efficiency. See tensor2tensor comments on\n # `common_layers.convert_gradient_to_tensor`.\n # stitched = common_layers.convert_gradient_to_tensor(\n # tf.concat(expert_out, 0)\n # )\n\n # Combine expert outputs.\n stitched = tf.concat(expert_out, 0)\n\n # Optionally weight expert outputs by gate value.\n if multiply_by_gates:\n stitched *= tf.expand_dims(self._nonzero_gates, 1)\n\n # For a given batch item, combine expert outputs using sum.\n combined = tf.math.unsorted_segment_sum(\n stitched, self._batch_index, tf.shape(self._gates)[0]\n )\n return combined\n\n def expert_to_gates(self):\n \"\"\"Gate values corresponding to the examples in the per-expert\n `Tensor`s.\n\n Returns:\n a list of `num_experts` one-dimensional `Tensor`s with type\n `tf.float32` and shapes `[expert_batch_size_i]`\n\n \"\"\"\n return tf.split(self._nonzero_gates, self._part_sizes_tensor, 0)\n\n def expert_to_batch_indices(self):\n \"\"\"Batch indices corresponding to the examples in the\n per-expert `Tensor`s.\n\n Returns:\n a list of `num_experts` one-dimensional `Tensor`s with type\n `tf.int64` and shapes `[expert_batch_size_i]`\n\n \"\"\"\n return tf.split(self._batch_index, self._part_sizes_tensor, 0)\n\n @property\n def part_sizes(self):\n return self._part_sizes_tensor\n"
] | [
[
"tensorflow.shape",
"tensorflow.concat",
"tensorflow.expand_dims",
"tensorflow.reshape",
"tensorflow.transpose",
"tensorflow.gather",
"tensorflow.split",
"tensorflow.unstack",
"tensorflow.cast"
]
] |
leonfoks/empymod | [
"6c5f158b6093f8dcc1dec63057e6d3fd523fdbee"
] | [
"empymod/kernel.py"
] | [
"r\"\"\"\n\n:mod:`kernel` -- Kernel calculation\n===================================\n\nKernel of ``empymod``, calculates the wavenumber-domain electromagnetic\nresponse. Plus analytical full- and half-space solutions.\n\nThe functions ``wavenumber``, ``angle_factor``, ``fullspace``, ``greenfct``,\n``reflections``, and ``fields`` are based on source files (specified in each\nfunction) from the source code distributed with [HuTS15]_, which can be found\nat `software.seg.org/2015/0001 <https://software.seg.org/2015/0001>`_. These\nfunctions are (c) 2015 by Hunziker et al. and the Society of Exploration\nGeophysicists, https://software.seg.org/disclaimer.txt. Please read the\nNOTICE-file in the root directory for more information regarding the involved\nlicenses.\n\n\"\"\"\n# Copyright 2016-2019 The empymod Developers.\n#\n# This file is part of empymod.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\"); you may not\n# use this file except in compliance with the License. You may obtain a copy\n# 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, WITHOUT\n# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the\n# License for the specific language governing permissions and limitations under\n# the License.\n\n\nimport numpy as np\nfrom scipy import special # Only used for halfspace solution\n\nnp.seterr(all='ignore')\n\n__all__ = ['wavenumber', 'angle_factor', 'fullspace', 'greenfct',\n 'reflections', 'fields', 'halfspace']\n\n\n# Wavenumber-frequency domain kernel\n\ndef wavenumber(zsrc, zrec, lsrc, lrec, depth, etaH, etaV, zetaH, zetaV, lambd,\n ab, xdirect, msrc, mrec, use_ne_eval):\n r\"\"\"Calculate wavenumber domain solution.\n\n Return the wavenumber domain solutions ``PJ0``, ``PJ1``, and ``PJ0b``,\n which have to be transformed with a Hankel transform to the frequency\n domain. ``PJ0``/``PJ0b`` and ``PJ1`` have to be transformed with Bessel\n functions of order 0 (:math:`J_0`) and 1 (:math:`J_1`), respectively.\n\n This function corresponds loosely to equations 105--107, 111--116,\n 119--121, and 123--128 in [HuTS15]_, and equally loosely to the file\n ``kxwmod.c``.\n\n [HuTS15]_ uses Bessel functions of orders 0, 1, and 2 (:math:`J_0, J_1,\n J_2`). The implementations of the *Fast Hankel Transform* and the\n *Quadrature-with-Extrapolation* in ``transform`` are set-up with Bessel\n functions of order 0 and 1 only. This is achieved by applying the\n recurrence formula\n\n .. math:: J_2(kr) = \\frac{2}{kr} J_1(kr) - J_0(kr) \\ .\n\n\n .. note::\n\n ``PJ0`` and ``PJ0b`` could theoretically be added here into one, and\n then be transformed in one go. However, ``PJ0b`` has to be multiplied\n by ``factAng`` later. This has to be done after the Hankel transform\n for methods which make use of spline interpolation, in order to work\n for offsets that are not in line with each other.\n\n This function is called from one of the Hankel functions in\n :mod:`transform`. Consult the modelling routines in :mod:`model` for a\n description of the input and output parameters.\n\n If you are solely interested in the wavenumber-domain solution you can call\n this function directly. However, you have to make sure all input arguments\n are correct, as no checks are carried out here.\n\n \"\"\"\n\n # ** CALCULATE GREEN'S FUNCTIONS\n # Shape of PTM, PTE: (nfreq, noffs, nfilt)\n PTM, PTE = greenfct(zsrc, zrec, lsrc, lrec, depth, etaH, etaV, zetaH,\n zetaV, lambd, ab, xdirect, msrc, mrec, use_ne_eval)\n\n # ** AB-SPECIFIC COLLECTION OF PJ0, PJ1, AND PJ0b\n\n # Pre-allocate output\n PJ0 = None\n PJ1 = None\n PJ0b = None\n\n # Calculate Ptot which is used in all cases\n Ptot = (PTM + PTE)/(4*np.pi)\n\n # If rec is magnetic switch sign (reciprocity MM/ME => EE/EM).\n if mrec:\n sign = -1\n else:\n sign = 1\n\n # Group into PJ0 and PJ1 for J0/J1 Hankel Transform\n if ab in [11, 12, 21, 22, 14, 24, 15, 25]: # Eqs 105, 106, 111, 112,\n # J2(kr) = 2/(kr)*J1(kr) - J0(kr) # 119, 120, 123, 124\n if ab in [14, 22]:\n sign *= -1\n PJ0b = sign/2*Ptot*lambd\n PJ1 = -sign*Ptot\n if ab in [11, 22, 24, 15]:\n if ab in [22, 24]:\n sign *= -1\n PJ0 = sign*(PTM - PTE)/(8*np.pi)*lambd\n\n elif ab in [13, 23, 31, 32, 34, 35, 16, 26]: # Eqs 107, 113, 114, 115,\n PJ1 = sign*Ptot*lambd*lambd # . 121, 125, 126, 127\n if ab in [34, 26]:\n PJ1 *= -1\n\n elif ab in [33, ]: # Eq 116\n PJ0 = sign*Ptot*lambd*lambd*lambd\n\n # Return PJ0, PJ1, PJ0b\n return PJ0, PJ1, PJ0b\n\n\ndef greenfct(zsrc, zrec, lsrc, lrec, depth, etaH, etaV, zetaH, zetaV, lambd,\n ab, xdirect, msrc, mrec, use_ne_eval):\n r\"\"\"Calculate Green's function for TM and TE.\n\n .. math:: \\tilde{g}^{tm}_{hh}, \\tilde{g}^{tm}_{hz},\n \\tilde{g}^{tm}_{zh}, \\tilde{g}^{tm}_{zz},\n \\tilde{g}^{te}_{hh}, \\tilde{g}^{te}_{zz}\n\n This function corresponds to equations 108--110, 117/118, 122; 89--94,\n A18--A23, B13--B15; 97--102 A26--A31, and B16--B18 in [HuTS15]_, and\n loosely to the corresponding files ``Gamma.F90``, ``Wprop.F90``,\n ``Ptotalx.F90``, ``Ptotalxm.F90``, ``Ptotaly.F90``, ``Ptotalym.F90``,\n ``Ptotalz.F90``, and ``Ptotalzm.F90``.\n\n The Green's functions are multiplied according to Eqs 105-107, 111-116,\n 119-121, 123-128; with the factors inside the integrals.\n\n This function is called from the function :mod:`kernel.wavenumber`.\n\n \"\"\"\n # GTM/GTE have shape (frequency, offset, lambda).\n # gamTM/gamTE have shape (frequency, offset, layer, lambda):\n\n # Reciprocity switches for magnetic receivers\n if mrec:\n if msrc: # If src is also magnetic, switch eta and zeta (MM => EE).\n # G^mm_ab(s, r, e, z) = -G^ee_ab(s, r, -z, -e)\n etaH, zetaH = -zetaH, -etaH\n etaV, zetaV = -zetaV, -etaV\n else: # If src is electric, swap src and rec (ME => EM).\n # G^me_ab(s, r, e, z) = -G^em_ba(r, s, e, z)\n zsrc, zrec = zrec, zsrc\n lsrc, lrec = lrec, lsrc\n\n for TM in [True, False]:\n\n # Continue if Green's function not required\n if TM and ab in [16, 26]:\n continue\n elif not TM and ab in [13, 23, 31, 32, 33, 34, 35]:\n continue\n\n # Define eta/zeta depending if TM or TE\n if TM:\n e_zH, e_zV, z_eH = etaH, etaV, zetaH # TM: zetaV not used\n else:\n e_zH, e_zV, z_eH = zetaH, zetaV, etaH # TE: etaV not used\n\n # Uppercase gamma\n if use_ne_eval:\n ez_ratio = (e_zH/e_zV)[:, None, :, None] # NOQA\n ez_prod = (z_eH*e_zH)[:, None, :, None] # NOQA\n lambd2 = use_ne_eval(\"lambd*lambd\")[None, :, None, :] # NOQA\n Gam = use_ne_eval(\"sqrt(ez_ratio*lambd2 + ez_prod)\")\n else:\n Gam = np.sqrt((e_zH/e_zV)[:, None, :, None] *\n (lambd*lambd)[None, :, None, :] +\n (z_eH*e_zH)[:, None, :, None])\n\n # Gamma in receiver layer\n lrecGam = Gam[:, :, lrec, :]\n\n # Reflection (coming from below (Rp) and above (Rm) rec)\n if depth.size > 1: # Only if more than 1 layer\n Rp, Rm = reflections(depth, e_zH, Gam, lrec, lsrc, use_ne_eval)\n\n # Field propagators\n # (Up- (Wu) and downgoing (Wd), in rec layer); Eq 74\n if lrec != depth.size-1: # No upgoing field prop. if rec in last\n ddepth = depth[lrec + 1] - zrec\n if use_ne_eval:\n Wu = use_ne_eval(\"exp(-lrecGam*ddepth)\")\n else:\n Wu = np.exp(-lrecGam*ddepth)\n else:\n Wu = np.zeros_like(lrecGam)\n if lrec != 0: # No downgoing field propagator if rec in first\n ddepth = zrec - depth[lrec]\n if use_ne_eval:\n Wd = use_ne_eval(\"exp(-lrecGam*ddepth)\")\n else:\n Wd = np.exp(-lrecGam*ddepth)\n else:\n Wd = np.zeros_like(lrecGam)\n\n # Field at rec level (coming from below (Pu) and above (Pd) rec)\n Pu, Pd = fields(depth, Rp, Rm, Gam, lrec, lsrc, zsrc, ab, TM,\n use_ne_eval)\n\n # Green's functions\n if lsrc == lrec: # Rec in src layer; Eqs 108, 109, 110, 117, 118, 122\n\n # Green's function depending on <ab>\n if depth.size == 1: # If only one layer, no reflections/fields\n green = np.zeros_like(lrecGam)\n elif ab in [13, 23, 31, 32, 14, 24, 15, 25]:\n green = Pu*Wu - Pd*Wd\n else:\n green = Pu*Wu + Pd*Wd\n\n # Direct field, if it is computed in the wavenumber domain\n if not xdirect:\n # Direct field\n directf = np.exp(-lrecGam*abs(zsrc - zrec))\n\n # Swap TM for certain <ab>\n if TM and ab in [11, 12, 13, 14, 15, 21, 22, 23, 24, 25]:\n directf *= -1\n\n # Multiply by zrec-zsrc-sign for certain <ab>\n if ab in [13, 14, 15, 23, 24, 25, 31, 32]:\n directf *= np.sign(zrec - zsrc)\n\n # Add direct field to Green's function\n green += directf\n\n else:\n\n # Calculate exponential factor\n if lrec == depth.size-1:\n ddepth = 0\n else:\n ddepth = depth[lrec+1] - depth[lrec]\n if use_ne_eval:\n fexp = use_ne_eval(\"exp(-lrecGam*ddepth)\")\n else:\n fexp = np.exp(-lrecGam*ddepth)\n\n # Sign-switch for Green calculation\n if TM and ab in [11, 12, 13, 21, 22, 23, 14, 24, 15, 25]:\n pmw = -1\n else:\n pmw = 1\n\n if lrec < lsrc: # Rec above src layer: Pd not used\n # Eqs 89-94, A18-A23, B13-B15\n green = Pu*(Wu + pmw*Rm[:, :, 0, :]*fexp*Wd)\n\n elif lrec > lsrc: # rec below src layer: Pu not used\n # Eqs 97-102 A26-A30, B16-B18\n green = Pd*(pmw*Wd + Rp[:, :, abs(lsrc-lrec), :]*fexp*Wu)\n\n # Store in corresponding variable\n if TM:\n gamTM, GTM = Gam, green\n else:\n gamTE, GTE = Gam, green\n\n # ** AB-SPECIFIC FACTORS AND CALCULATION OF PTOT'S\n # These are the factors inside the integrals\n # Eqs 105-107, 111-116, 119-121, 123-128\n\n # PTM, PTE\n if ab in [11, 12, 21, 22]:\n PTM = GTM*gamTM[:, :, lrec, :]/etaH[:, None, lrec, None]\n PTE = zetaH[:, None, lsrc, None]*GTE/gamTE[:, :, lsrc, :]\n elif ab in [14, 15, 24, 25]:\n PTM = ((etaH[:, lsrc]/etaH[:, lrec])[:, None, None] *\n GTM*gamTM[:, :, lrec, :]/gamTM[:, :, lsrc, :])\n PTE = GTE\n elif ab in [13, 23]:\n PTM = -((etaH[:, lsrc]/etaH[:, lrec]/etaV[:, lsrc])[:, None, None] *\n GTM*gamTM[:, :, lrec, :]/gamTM[:, :, lsrc, :])\n PTE = 0\n elif ab in [31, 32]:\n PTM = GTM/etaV[:, None, lrec, None]\n PTE = 0\n elif ab in [34, 35]:\n PTM = ((etaH[:, lsrc]/etaV[:, lrec])[:, None, None] *\n GTM/gamTM[:, :, lsrc, :])\n PTE = 0\n elif ab in [16, 26]:\n PTM = 0\n PTE = ((zetaH[:, lsrc]/zetaV[:, lsrc])[:, None, None] *\n GTE/gamTE[:, :, lsrc, :])\n elif ab in [33, ]:\n PTM = ((etaH[:, lsrc]/etaV[:, lsrc]/etaV[:, lrec])[:, None, None] *\n GTM/gamTM[:, :, lsrc, :])\n PTE = 0\n\n # Return Green's functions\n return PTM, PTE\n\n\ndef reflections(depth, e_zH, Gam, lrec, lsrc, use_ne_eval):\n r\"\"\"Calculate Rp, Rm.\n\n .. math:: R^\\pm_n, \\bar{R}^\\pm_n\n\n This function corresponds to equations 64/65 and A-11/A-12 in\n [HuTS15]_, and loosely to the corresponding files ``Rmin.F90`` and\n ``Rplus.F90``.\n\n This function is called from the function :mod:`kernel.greenfct`.\n\n \"\"\"\n\n # Loop over Rp, Rm\n for plus in [True, False]:\n\n # Switches depending if plus or minus\n if plus:\n pm = 1\n layer_count = np.arange(depth.size-2, min(lrec, lsrc)-1, -1)\n izout = abs(lsrc-lrec)\n minmax = max(lrec, lsrc)\n else:\n pm = -1\n layer_count = np.arange(1, max(lrec, lsrc)+1, 1)\n izout = 0\n minmax = -min(lrec, lsrc)\n\n # If rec in last and rec below src (plus) or\n # if rec in first and rec above src (minus), shift izout\n shiftplus = lrec < lsrc and lrec == 0 and not plus\n shiftminus = lrec > lsrc and lrec == depth.size-1 and plus\n if shiftplus or shiftminus:\n izout -= pm\n\n # Pre-allocate Ref\n Ref = np.zeros((Gam.shape[0], Gam.shape[1], abs(lsrc-lrec)+1,\n Gam.shape[3]), dtype=Gam.dtype)\n\n # Calculate the reflection\n for iz in layer_count:\n\n # Eqs 65, A-12\n e_zHa = e_zH[:, None, iz+pm, None]\n Gama = Gam[:, :, iz, :]\n e_zHb = e_zH[:, None, iz, None]\n Gamb = Gam[:, :, iz+pm, :]\n if use_ne_eval:\n rlocstr = \"(e_zHa*Gama - e_zHb*Gamb)/(e_zHa*Gama + e_zHb*Gamb)\"\n rloc = use_ne_eval(rlocstr)\n else:\n rloca = e_zHa*Gama\n rlocb = e_zHb*Gamb\n rloc = (rloca - rlocb)/(rloca + rlocb)\n\n # In first layer tRef = rloc\n if iz == layer_count[0]:\n tRef = rloc.copy()\n else:\n ddepth = depth[iz+1+pm]-depth[iz+pm]\n\n # Eqs 64, A-11\n if use_ne_eval:\n term = use_ne_eval(\"tRef*exp(-2*Gamb*ddepth)\")\n tRef = use_ne_eval(\"(rloc + term)/(1 + rloc*term)\")\n else:\n term = tRef*np.exp(-2*Gamb*ddepth) # NOQA\n tRef = (rloc + term)/(1 + rloc*term)\n\n # The global reflection coefficient is given back for all layers\n # between and including src- and rec-layer\n if lrec != lsrc and pm*iz <= minmax:\n Ref[:, :, izout, :] = tRef[:]\n izout -= pm\n\n # If lsrc = lrec, we just store the last values\n if lsrc == lrec and layer_count.size > 0:\n Ref = tRef\n\n # Store Ref in Rm/Rp\n if plus:\n Rm = Ref\n else:\n Rp = Ref\n\n # Return reflections (minus and plus)\n return Rm, Rp\n\n\ndef fields(depth, Rp, Rm, Gam, lrec, lsrc, zsrc, ab, TM, use_ne_eval):\n r\"\"\"Calculate Pu+, Pu-, Pd+, Pd-.\n\n .. math:: P^{u\\pm}_s, P^{d\\pm}_s, \\bar{P}^{u\\pm}_s, \\bar{P}^{d\\pm}_s;\n P^{u\\pm}_{s-1}, P^{u\\pm}_n, \\bar{P}^{u\\pm}_{s-1}, \\bar{P}^{u\\pm}_n;\n P^{d\\pm}_{s+1}, P^{d\\pm}_n, \\bar{P}^{d\\pm}_{s+1}, \\bar{P}^{d\\pm}_n\n\n This function corresponds to equations 81/82, 95/96, 103/104, A-8/A-9,\n A-24/A-25, and A-32/A-33 in [HuTS15]_, and loosely to the corresponding\n files ``Pdownmin.F90``, ``Pdownplus.F90``, ``Pupmin.F90``, and\n ``Pdownmin.F90``.\n\n This function is called from the function :mod:`kernel.greenfct`.\n\n \"\"\"\n\n # Variables\n nlsr = abs(lsrc-lrec)+1 # nr of layers btw and incl. src and rec layer\n rsrcl = 0 # src-layer in reflection (Rp/Rm), first if down\n izrange = range(2, nlsr)\n isr = lsrc\n last = depth.size-1\n\n # Booleans if src in first or last layer; swapped if up=True\n first_layer = lsrc == 0\n last_layer = lsrc == depth.size-1\n\n # Depths; dp and dm are swapped if up=True\n if lsrc != depth.size-1:\n ds = depth[lsrc+1]-depth[lsrc]\n dp = depth[lsrc+1]-zsrc\n dm = zsrc-depth[lsrc]\n\n # Rm and Rp; swapped if up=True\n Rmp = Rm\n Rpm = Rp\n\n # Boolean if plus or minus has to be calculated\n plusset = [13, 23, 33, 14, 24, 34, 15, 25, 35]\n if TM:\n plus = ab in plusset\n else:\n plus = ab not in plusset\n\n # Sign-switches\n pm = 1 # + if plus=True, - if plus=False\n if not plus:\n pm = -1\n pup = -1 # + if up=True, - if up=False\n mupm = 1 # + except if up=True and plus=False\n\n # Gamma of source layer\n iGam = Gam[:, :, lsrc, :]\n\n # Calculate down- and up-going fields\n for up in [False, True]:\n\n # No upgoing field if rec is in last layer or below src\n if up and (lrec == depth.size-1 or lrec > lsrc):\n Pu = np.zeros_like(iGam)\n continue\n # No downgoing field if rec is in first layer or above src\n if not up and (lrec == 0 or lrec < lsrc):\n Pd = np.zeros_like(iGam)\n continue\n\n # Swaps if up=True\n if up:\n if not last_layer:\n dp, dm = dm, dp\n else:\n dp = dm\n Rmp, Rpm = Rpm, Rmp\n first_layer, last_layer = last_layer, first_layer\n rsrcl = nlsr-1 # src-layer in refl. (Rp/Rm), last (nlsr-1) if up\n izrange = range(nlsr-2)\n isr = lrec\n last = 0\n pup = 1\n if not plus:\n mupm = -1\n\n # Calculate Pu+, Pu-, Pd+, Pd-\n if lsrc == lrec: # rec in src layer; Eqs 81/82, A-8/A-9\n if last_layer: # If src/rec are in top (up) or bottom (down) layer\n if use_ne_eval:\n P = use_ne_eval(\"Rmp*exp(-iGam*dm)\")\n else:\n P = Rmp*np.exp(-iGam*dm)\n else: # If src and rec are in any layer in between\n if use_ne_eval:\n Pstr = \"(exp(-iGam*dm) + pm*Rpm*exp(-iGam*(ds+dp)))\"\n Pstr += \"* Rmp/(1-Rmp*Rpm*exp(-2*iGam*ds))\"\n P = use_ne_eval(Pstr)\n else:\n P = np.exp(-iGam*dm) + pm*Rpm*np.exp(-iGam*(ds+dp))\n P *= Rmp/(1 - Rmp*Rpm*np.exp(-2*iGam*ds))\n\n else: # rec above (up) / below (down) src layer\n # # Eqs 95/96, A-24/A-25 for rec above src layer\n # # Eqs 103/104, A-32/A-33 for rec below src layer\n\n # First compute P_{s-1} (up) / P_{s+1} (down)\n iRpm = Rpm[:, :, rsrcl, :]\n if first_layer: # If src is in bottom (up) / top (down) layer\n if use_ne_eval:\n P = use_ne_eval(\"(1 + iRpm)*mupm*exp(-iGam*dp)\")\n else:\n P = (1 + iRpm)*mupm*np.exp(-iGam*dp)\n else:\n iRmp = Rmp[:, :, rsrcl, :]\n if use_ne_eval:\n Pstr = \"(mupm*exp(-iGam*dp) + \"\n Pstr += \"pm*mupm*iRmp*exp(-iGam*(ds+dm)))\"\n Pstr += \"*(1 + iRpm)/(1 - iRmp*iRpm * exp(-2*iGam*ds))\"\n P = use_ne_eval(Pstr)\n else:\n P = mupm*np.exp(-iGam*dp)\n P += pm*mupm*iRmp*np.exp(-iGam * (ds+dm))\n P *= (1 + iRpm)/(1 - iRmp*iRpm * np.exp(-2*iGam*ds))\n\n # If up or down and src is in last but one layer\n if up or (not up and lsrc+1 < depth.size-1):\n ddepth = depth[lsrc+1-1*pup]-depth[lsrc-1*pup]\n iRpm = Rpm[:, :, rsrcl-1*pup, :]\n miGam = Gam[:, :, lsrc-1*pup, :]\n if use_ne_eval:\n P = use_ne_eval(\"P/(1 + iRpm*exp(-2*miGam * ddepth))\")\n else:\n P /= (1 + iRpm*np.exp(-2*miGam * ddepth))\n\n # Second compute P for all other layers\n if nlsr > 2:\n for iz in izrange:\n ddepth = depth[isr+iz+pup+1]-depth[isr+iz+pup]\n iRpm = Rpm[:, :, iz+pup, :]\n piGam = Gam[:, :, isr+iz+pup, :]\n if use_ne_eval:\n P = use_ne_eval(\"P*(1 + iRpm)*exp(-piGam * ddepth)\")\n else:\n P *= (1 + iRpm)*np.exp(-piGam * ddepth)\n\n # If rec/src NOT in first/last layer (up/down)\n if isr+iz != last:\n ddepth = depth[isr+iz+1] - depth[isr+iz]\n iRpm = Rpm[:, :, iz, :]\n piGam2 = Gam[:, :, isr+iz, :]\n if use_ne_eval:\n Pstr = \"P/(1 + iRpm*exp(-2*piGam2 * ddepth))\"\n P = use_ne_eval(Pstr)\n else:\n P /= 1 + iRpm*np.exp(-2*piGam2 * ddepth)\n\n # Store P in Pu/Pd\n if up:\n Pu = P\n else:\n Pd = P\n\n # Return fields (up- and downgoing)\n return Pu, Pd\n\n\n# Angle Factor\n\ndef angle_factor(angle, ab, msrc, mrec):\n r\"\"\"Return the angle-dependent factor.\n\n The whole calculation in the wavenumber domain is only a function of the\n distance between the source and the receiver, it is independent of the\n angel. The angle-dependency is this factor, which can be applied to the\n corresponding parts in the wavenumber or in the frequency domain.\n\n The ``angle_factor`` corresponds to the sine and cosine-functions in Eqs\n 105-107, 111-116, 119-121, 123-128.\n\n This function is called from one of the Hankel functions in\n :mod:`transform`. Consult the modelling routines in :mod:`model` for a\n description of the input and output parameters.\n\n \"\"\"\n\n # 33/66 are completely symmetric and hence independent of angle\n if ab in [33, ]:\n return np.ones(angle.size)\n\n # Evaluation angle\n eval_angle = angle.copy()\n\n # Add pi if receiver is magnetic (reciprocity), but not if source is\n # electric, because then source and receiver are swapped, ME => EM:\n # G^me_ab(s, r, e, z) = -G^em_ba(r, s, e, z).\n if mrec and not msrc:\n eval_angle += np.pi\n\n # Define fct (cos/sin) and angles to be tested\n if ab in [11, 22, 15, 24, 13, 31, 26, 35]:\n fct = np.cos\n test_ang_1 = np.pi/2\n test_ang_2 = 3*np.pi/2\n else:\n fct = np.sin\n test_ang_1 = np.pi\n test_ang_2 = 2*np.pi\n\n if ab in [11, 22, 15, 24, 12, 21, 14, 25]:\n eval_angle *= 2\n\n # Get factor\n factAng = fct(eval_angle)\n\n # Ensure cos([pi/2, 3pi/2]) and sin([pi, 2pi]) are zero (floating pt issue)\n factAng[np.isclose(np.abs(eval_angle), test_ang_1, 1e-10, 1e-14)] = 0\n factAng[np.isclose(np.abs(eval_angle), test_ang_2, 1e-10, 1e-14)] = 0\n\n return factAng\n\n\n# Analytical solutions\n\ndef fullspace(off, angle, zsrc, zrec, etaH, etaV, zetaH, zetaV, ab, msrc,\n mrec):\n r\"\"\"Analytical full-space solutions in the frequency domain.\n\n .. math:: \\hat{G}^{ee}_{\\alpha\\beta}, \\hat{G}^{ee}_{3\\alpha},\n \\hat{G}^{ee}_{33}, \\hat{G}^{em}_{\\alpha\\beta},\n \\hat{G}^{em}_{\\alpha 3}\n\n This function corresponds to equations 45--50 in [HuTS15]_, and loosely to\n the corresponding files ``Gin11.F90``, ``Gin12.F90``, ``Gin13.F90``,\n ``Gin22.F90``, ``Gin23.F90``, ``Gin31.F90``, ``Gin32.F90``, ``Gin33.F90``,\n ``Gin41.F90``, ``Gin42.F90``, ``Gin43.F90``, ``Gin51.F90``, ``Gin52.F90``,\n ``Gin53.F90``, ``Gin61.F90``, and ``Gin62.F90``.\n\n This function is called from one of the modelling routines in :mod:`model`.\n Consult these modelling routines for a description of the input and output\n parameters.\n\n \"\"\"\n xco = np.cos(angle)*off\n yco = np.sin(angle)*off\n\n # Reciprocity switches for magnetic receivers\n if mrec:\n if msrc: # If src is also magnetic, switch eta and zeta (MM => EE).\n # G^mm_ab(s, r, e, z) = -G^ee_ab(s, r, -z, -e)\n etaH, zetaH = -zetaH, -etaH\n etaV, zetaV = -zetaV, -etaV\n else: # If src is electric, swap src and rec (ME => EM).\n # G^me_ab(s, r, e, z) = -G^em_ba(r, s, e, z)\n xco *= -1\n yco *= -1\n zsrc, zrec = zrec, zsrc\n\n # Calculate TE/TM-variables\n if ab not in [16, 26]: # Calc TM\n lGamTM = np.sqrt(zetaH*etaV)\n RTM = np.sqrt(off*off + ((zsrc-zrec)*(zsrc-zrec)*etaH/etaV)[:, None])\n uGamTM = np.exp(-lGamTM[:, None]*RTM)/(4*np.pi*RTM *\n np.sqrt(etaH/etaV)[:, None])\n\n if ab not in [13, 23, 31, 32, 33, 34, 35]: # Calc TE\n lGamTE = np.sqrt(zetaV*etaH)\n RTE = np.sqrt(off*off+(zsrc-zrec)*(zsrc-zrec)*(zetaH/zetaV)[:, None])\n uGamTE = np.exp(-lGamTE[:, None]*RTE)/(4*np.pi*RTE *\n np.sqrt(zetaH/zetaV)[:, None])\n\n # Calculate responses\n if ab in [11, 12, 21, 22]: # Eqs 45, 46\n\n # Define coo1, coo2, and delta\n if ab in [11, 22]:\n if ab in [11, ]:\n coo1 = xco\n coo2 = xco\n else:\n coo1 = yco\n coo2 = yco\n delta = 1\n else:\n coo1 = xco\n coo2 = yco\n delta = 0\n\n # Calculate response\n term1 = uGamTM*(3*coo1*coo2/(RTM*RTM) - delta)\n term1 *= 1/(etaV[:, None]*RTM*RTM) + (lGamTM/etaV)[:, None]/RTM\n term1 += uGamTM*zetaH[:, None]*coo1*coo2/(RTM*RTM)\n\n term2 = -delta*zetaH[:, None]*uGamTE\n\n term3 = -zetaH[:, None]*coo1*coo2/(off*off)*(uGamTM - uGamTE)\n\n term4 = -np.sqrt(zetaH)[:, None]*(2*coo1*coo2/(off*off) - delta)\n if np.any(zetaH.imag < 0): # We need the sqrt where Im > 0.\n term4 *= -1 # This if-statement corrects for it.\n term4 *= np.exp(-lGamTM[:, None]*RTM) - np.exp(-lGamTE[:, None]*RTE)\n term4 /= 4*np.pi*np.sqrt(etaH)[:, None]*off*off\n\n gin = term1 + term2 + term3 + term4\n\n elif ab in [13, 23, 31, 32]: # Eq 47\n\n # Define coo\n if ab in [13, 31]:\n coo = xco\n elif ab in [23, 32]:\n coo = yco\n\n # Calculate response\n term1 = (etaH/etaV)[:, None]*(zrec - zsrc)*coo/(RTM*RTM)\n term2 = 3/(RTM*RTM) + 3*lGamTM[:, None]/RTM + (lGamTM*lGamTM)[:, None]\n gin = term1*term2*uGamTM/etaV[:, None]\n\n elif ab in [33, ]: # Eq 48\n\n # Calculate response\n term1 = (((etaH/etaV)[:, None]*(zsrc - zrec)/RTM) *\n ((etaH/etaV)[:, None]*(zsrc - zrec)/RTM) *\n (3/(RTM*RTM) + 3*lGamTM[:, None]/RTM +\n (lGamTM*lGamTM)[:, None]))\n term2 = (-(etaH/etaV)[:, None]/RTM*(1/RTM + lGamTM[:, None]) -\n (etaH*zetaH)[:, None])\n gin = (term1 + term2)*uGamTM/etaV[:, None]\n\n elif ab in [14, 24, 15, 25]: # Eq 49\n\n # Define coo1, coo2, coo3, coo4, delta, and pm\n if ab in [14, 25]:\n coo1, coo2 = xco, yco\n coo3, coo4 = xco, yco\n delta = 0\n pm = -1\n elif ab in [24, 15]:\n coo1, coo2 = yco, yco\n coo3, coo4 = xco, xco\n delta = 1\n pm = 1\n\n # 15/25: Swap x/y\n if ab in[15, 25]:\n coo1, coo3 = coo3, coo1\n coo2, coo4 = coo4, coo2\n\n # 24/25: Swap src/rec\n if ab in[24, 25]:\n zrec, zsrc = zsrc, zrec\n\n # Calculate response\n def term(lGam, z_eH, z_eV, R, off, co1, co2):\n fac = (lGam*z_eH/z_eV)[:, None]/R*np.exp(-lGam[:, None]*R)\n term = 2/(off*off) + lGam[:, None]/R + 1/(R*R)\n return fac*(co1*co2*term - delta)\n termTM = term(lGamTM, etaH, etaV, RTM, off, coo1, coo2)\n termTE = term(lGamTE, zetaH, zetaV, RTE, off, coo3, coo4)\n mult = (zrec - zsrc)/(4*np.pi*np.sqrt(etaH*zetaH)[:, None]*off*off)\n gin = -mult*(pm*termTM + termTE)\n\n elif ab in [34, 35, 16, 26]: # Eqs 50, 51\n\n # Define coo\n if ab in [34, 16]:\n coo = yco\n else:\n coo = -xco\n\n # Define R, lGam, uGam, e_zH, and e_zV\n if ab in [34, 35]:\n coo *= -1\n R = RTM\n lGam = lGamTM\n uGam = uGamTM\n e_zH = etaH\n e_zV = etaV\n else:\n R = RTE\n lGam = lGamTE\n uGam = uGamTE\n e_zH = zetaH\n e_zV = zetaV\n\n # Calculate response\n gin = coo*(e_zH/e_zV)[:, None]/R*(lGam[:, None] + 1/R)*uGam\n\n # If rec is magnetic switch sign (reciprocity MM/ME => EE/EM).\n if mrec:\n gin *= -1\n\n return gin\n\n\ndef halfspace(off, angle, zsrc, zrec, etaH, etaV, freqtime, ab, signal,\n solution='dhs'):\n r\"\"\"Return frequency- or time-space domain VTI half-space solution.\n\n Calculates the frequency- or time-space domain electromagnetic response for\n a half-space below air using the diffusive approximation, as given in\n [SlHM10]_, where the electric source is located at [x=0, y=0, z=zsrc>=0],\n and the electric receiver at [x=cos(angle)*off, y=sin(angle)*off,\n z=zrec>=0].\n\n It can also be used to calculate the fullspace solution or the separate\n fields: direct field, reflected field, and airwave; always using the\n diffusive approximation. See ``solution``-parameter.\n\n This function is called from one of the modelling routines in :mod:`model`.\n Consult these modelling routines for a description of the input and\n solution parameters.\n\n \"\"\"\n xco = np.cos(angle)*off\n yco = np.sin(angle)*off\n res = np.real(1/etaH[0, 0])\n aniso = 1/np.sqrt(np.real(etaV[0, 0])*res)\n\n # Define sval/time and dtype depending on signal.\n if signal is None:\n sval = freqtime\n dtype = etaH.dtype\n else:\n time = freqtime\n if signal == -1: # Calculate DC\n time = np.r_[time[:, 0], 1e4][:, None]\n freqtime = time\n dtype = float\n\n # Other defined parameters\n rh = np.sqrt(xco**2 + yco**2) # Horizontal distance in space\n hp = abs(zrec + zsrc) # Physical vertical distance\n hm = abs(zrec - zsrc)\n hsp = hp*aniso # Scaled vertical distance\n hsm = hm*aniso\n rp = np.sqrt(xco**2 + yco**2 + hp**2) # Physical distance\n rm = np.sqrt(xco**2 + yco**2 + hm**2)\n rsp = np.sqrt(xco**2 + yco**2 + hsp**2) # Scaled distance\n rsm = np.sqrt(xco**2 + yco**2 + hsm**2)\n #\n mu_0 = 4e-7*np.pi # Magn. perm. of free space [H/m]\n tp = mu_0*rp**2/(res*4) # Diffusion time\n tm = mu_0*rm**2/(res*4)\n tsp = mu_0*rsp**2/(res*aniso**2*4) # Scaled diffusion time\n tsm = mu_0*rsm**2/(res*aniso**2*4)\n\n # delta-fct delta_\\alpha\\beta\n if ab in [11, 22, 33]:\n delta = 1\n else:\n delta = 0\n\n # Define alpha/beta; swap if necessary\n x = xco\n y = yco\n if ab == 11:\n y = x\n elif ab in [22, 23, 32]:\n x = y\n elif ab == 21:\n x, y = y, x\n\n # Define rev for 3\\alpha->\\alpha3 reciprocity\n if ab in [13, 23]:\n rev = -1\n elif ab in [31, 32]:\n rev = 1\n\n # Exponential diffusion functions for m=0,1,2\n\n if signal is None: # Frequency-domain\n f0p = np.exp(-2*np.sqrt(sval*tp))\n f0m = np.exp(-2*np.sqrt(sval*tm))\n fs0p = np.exp(-2*np.sqrt(sval*tsp))\n fs0m = np.exp(-2*np.sqrt(sval*tsm))\n\n f1p = np.sqrt(sval)*f0p\n f1m = np.sqrt(sval)*f0m\n fs1p = np.sqrt(sval)*fs0p\n fs1m = np.sqrt(sval)*fs0m\n\n f2p = sval*f0p\n f2m = sval*f0m\n fs2p = sval*fs0p\n fs2m = sval*fs0m\n\n elif abs(signal) == 1: # Time-domain step response\n # Replace F(m) with F(m-2)\n f0p = special.erfc(np.sqrt(tp/time))\n f0m = special.erfc(np.sqrt(tm/time))\n fs0p = special.erfc(np.sqrt(tsp/time))\n fs0m = special.erfc(np.sqrt(tsm/time))\n\n f1p = np.exp(-tp/time)/np.sqrt(np.pi*time)\n f1m = np.exp(-tm/time)/np.sqrt(np.pi*time)\n fs1p = np.exp(-tsp/time)/np.sqrt(np.pi*time)\n fs1m = np.exp(-tsm/time)/np.sqrt(np.pi*time)\n\n f2p = f1p*np.sqrt(tp)/time\n f2m = f1m*np.sqrt(tm)/time\n fs2p = fs1p*np.sqrt(tsp)/time\n fs2m = fs1m*np.sqrt(tsm)/time\n\n else: # Time-domain impulse response\n f0p = np.sqrt(tp/(np.pi*time**3))*np.exp(-tp/time)\n f0m = np.sqrt(tm/(np.pi*time**3))*np.exp(-tm/time)\n fs0p = np.sqrt(tsp/(np.pi*time**3))*np.exp(-tsp/time)\n fs0m = np.sqrt(tsm/(np.pi*time**3))*np.exp(-tsm/time)\n\n f1p = (tp/time - 0.5)/np.sqrt(tp)*f0p\n f1m = (tm/time - 0.5)/np.sqrt(tm)*f0m\n fs1p = (tsp/time - 0.5)/np.sqrt(tsp)*fs0p\n fs1m = (tsm/time - 0.5)/np.sqrt(tsm)*fs0m\n\n f2p = (tp/time - 1.5)/time*f0p\n f2m = (tm/time - 1.5)/time*f0m\n fs2p = (tsp/time - 1.5)/time*fs0p\n fs2m = (tsm/time - 1.5)/time*fs0m\n\n # Pre-allocate arrays\n gs0m = np.zeros(np.shape(x), dtype=dtype)\n gs0p = np.zeros(np.shape(x), dtype=dtype)\n gs1m = np.zeros(np.shape(x), dtype=dtype)\n gs1p = np.zeros(np.shape(x), dtype=dtype)\n gs2m = np.zeros(np.shape(x), dtype=dtype)\n gs2p = np.zeros(np.shape(x), dtype=dtype)\n g0p = np.zeros(np.shape(x), dtype=dtype)\n g1m = np.zeros(np.shape(x), dtype=dtype)\n g1p = np.zeros(np.shape(x), dtype=dtype)\n g2m = np.zeros(np.shape(x), dtype=dtype)\n g2p = np.zeros(np.shape(x), dtype=dtype)\n air = np.zeros(np.shape(f0p), dtype=dtype)\n\n if ab in [11, 12, 21, 22]: # 1. {alpha, beta}\n # Get indices for singularities\n izr = rh == 0 # index where rh = 0\n iir = np.invert(izr) # invert of izr\n izh = hm == 0 # index where hm = 0\n iih = np.invert(izh) # invert of izh\n\n # fab\n fab = rh**2*delta-x*y\n\n # TM-mode coefficients\n gs0p = res*aniso*(3*x*y - rsp**2*delta)/(4*np.pi*rsp**5)\n gs0m = res*aniso*(3*x*y - rsm**2*delta)/(4*np.pi*rsm**5)\n gs1p[iir] = (((3*x[iir]*y[iir] - rsp[iir]**2*delta)/rsp[iir]**4 -\n (x[iir]*y[iir] - fab[iir])/rh[iir]**4) *\n np.sqrt(mu_0*res)/(4*np.pi))\n gs1m[iir] = (((3*x[iir]*y[iir] - rsm[iir]**2*delta)/rsm[iir]**4 -\n (x[iir]*y[iir] - fab[iir])/rh[iir]**4) *\n np.sqrt(mu_0*res)/(4*np.pi))\n gs2p[iir] = ((mu_0*x[iir]*y[iir])/(4*np.pi*aniso*rsp[iir]) *\n (1/rsp[iir]**2 - 1/rh[iir]**2))\n gs2m[iir] = ((mu_0*x[iir]*y[iir])/(4*np.pi*aniso*rsm[iir]) *\n (1/rsm[iir]**2 - 1/rh[iir]**2))\n\n # TM-mode for numerical singularities rh=0 (hm!=0)\n gs1p[izr*iih] = -np.sqrt(mu_0*res)*delta/(4*np.pi*hsp**2)\n gs1m[izr*iih] = -np.sqrt(mu_0*res)*delta/(4*np.pi*hsm**2)\n gs2p[izr*iih] = -mu_0*delta/(8*np.pi*aniso*hsp)\n gs2m[izr*iih] = -mu_0*delta/(8*np.pi*aniso*hsm)\n\n # TE-mode coefficients\n g0p = res*(3*fab - rp**2*delta)/(2*np.pi*rp**5)\n g1m[iir] = (np.sqrt(mu_0*res)*(x[iir]*y[iir] - fab[iir]) /\n (4*np.pi*rh[iir]**4))\n g1p[iir] = (g1m[iir] + np.sqrt(mu_0*res)*(3*fab[iir] -\n rp[iir]**2*delta)/(2*np.pi*rp[iir]**4))\n g2p[iir] = mu_0*fab[iir]/(4*np.pi*rp[iir])*(2/rp[iir]**2 -\n 1/rh[iir]**2)\n g2m[iir] = -mu_0*fab[iir]/(4*np.pi*rh[iir]**2*rm[iir])\n\n # TE-mode for numerical singularities rh=0 (hm!=0)\n g1m[izr*iih] = np.zeros(np.shape(g1m[izr*iih]), dtype=dtype)\n g1p[izr*iih] = -np.sqrt(mu_0*res)*delta/(2*np.pi*hp**2)\n g2m[izr*iih] = mu_0*delta/(8*np.pi*hm)\n g2p[izr*iih] = mu_0*delta/(8*np.pi*hp)\n\n # Bessel functions for airwave\n def BI(gamH, hp, nr, xim):\n r\"\"\"Return BI_nr.\"\"\"\n return np.exp(-np.real(gamH)*hp)*special.ive(nr, xim)\n\n def BK(xip, nr):\n r\"\"\"Return BK_nr.\"\"\"\n if np.isrealobj(xip):\n # To keep it real in Laplace-domain [exp(-1j*0) = 1-0j].\n return special.kve(nr, xip)\n else:\n return np.exp(-1j*np.imag(xip))*special.kve(nr, xip)\n\n # Airwave calculation\n def airwave(sval, hp, rp, res, fab, delta):\n r\"\"\"Return airwave.\"\"\"\n # Parameters\n zeta = sval*mu_0\n gamH = np.sqrt(zeta/res)\n xip = gamH*(rp + hp)/2\n xim = gamH*(rp - hp)/2\n\n # Bessel functions\n BI0 = BI(gamH, hp, 0, xim)\n BI1 = BI(gamH, hp, 1, xim)\n BI2 = BI(gamH, hp, 2, xim)\n BK0 = BK(xip, 0)\n BK1 = BK(xip, 1)\n\n # Calculation\n P1 = (sval*mu_0)**(3/2)*fab*hp/(4*np.sqrt(res))\n P2 = 4*BI1*BK0 - (3*BI0 - 4*np.sqrt(res)*BI1/(np.sqrt(sval*mu_0) *\n (rp + hp)) + BI2)*BK1\n P3 = 3*fab/rp**2 - delta\n P4 = (sval*mu_0*hp*rp*(BI0*BK0 - BI1*BK1) +\n np.sqrt(res*sval*mu_0)*BI0*BK1 *\n (rp + hp) + np.sqrt(res*sval*mu_0)*BI1*BK0*(rp - hp))\n\n return (P1*P2 - P3*P4)/(4*np.pi*rp**3)\n\n # Airwave depending on signal\n if signal is None: # Frequency-domain\n air = airwave(sval, hp, rp, res, fab, delta)\n\n elif abs(signal) == 1: # Time-domain step response\n # Solution for step-response air-wave is not analytical, but uses\n # the Gaver-Stehfest method.\n K = 16\n\n # Coefficients Dk\n fn = np.vectorize(np.math.factorial)\n\n def coeff_dk(k, K):\n r\"\"\"Return coefficients Dk for k, K.\"\"\"\n n = np.arange(int((k+1)/2), np.min([k, K/2])+.5, 1, dtype=int)\n Dk = n**(K/2)*fn(2*n)\n Dk /= fn(n)*fn(n-1)*fn(k-n)*fn(2*n-k)*fn(K/2-n)\n return Dk.sum()*(-1)**(k+K/2)\n\n for k in range(1, K+1):\n sval = k*np.log(2)/time\n cair = airwave(sval, hp, rp, res, fab, delta)\n air += coeff_dk(k, K)*cair.real/k\n\n else: # Time-domain impulse response\n thp = mu_0*hp**2/(4*res)\n trh = mu_0*rh**2/(8*res)\n P1 = (mu_0**2*hp*np.exp(-thp/time))/(res*32*np.pi*time**3)\n P2 = 2*(delta - (x*y)/rh**2)*special.ive(1, trh/time)\n P3 = mu_0/(2*res*time)*(rh**2*delta - x*y)-delta\n P4 = special.ive(0, trh/time) - special.ive(1, trh/time)\n\n air = P1*(P2 - P3*P4)\n\n elif ab in [13, 23, 31, 32]: # 2. {3, alpha}, {alpha, 3}\n # TM-mode\n gs0m = 3*x*res*aniso**3*(zrec - zsrc)/(4*np.pi*rsm**5)\n gs0p = rev*3*x*res*aniso**3*hp/(4*np.pi*rsp**5)\n gs1m = (np.sqrt(mu_0*res)*3*aniso**2*x*(zrec - zsrc) /\n (4*np.pi*rsm**4))\n gs1p = rev*np.sqrt(mu_0*res)*3*aniso**2*x*hp/(4*np.pi*rsp**4)\n gs2m = mu_0*x*aniso*(zrec - zsrc)/(4*np.pi*rsm**3)\n gs2p = rev*mu_0*x*aniso*hp/(4*np.pi*rsp**3)\n\n elif ab == 33: # 3. {3, 3}\n # TM-mode\n gs0m = res*aniso**3*(3*hsm**2 - rsm**2)/(4*np.pi*rsm**5)\n gs0p = -res*aniso**3*(3*hsp**2 - rsp**2)/(4*np.pi*rsp**5)\n gs1m = np.sqrt(mu_0*res)*aniso**2*(3*hsm**2 - rsm**2)/(4*np.pi*rsm**4)\n gs1p = -np.sqrt(mu_0*res)*aniso**2*(3*hsp**2 - rsp**2)/(4*np.pi*rsp**4)\n gs2m = mu_0*aniso*(hsm**2 - rsm**2)/(4*np.pi*rsm**3)\n gs2p = -mu_0*aniso*(hsp**2 - rsp**2)/(4*np.pi*rsp**3)\n\n # Direct field\n direct_TM = gs0m*fs0m + gs1m*fs1m + gs2m*fs2m\n direct_TE = g1m*f1m + g2m*f2m\n direct = direct_TM + direct_TE\n\n # Reflection\n reflect_TM = gs0p*fs0p + gs1p*fs1p + gs2p*fs2p\n reflect_TE = g0p*f0p + g1p*f1p + g2p*f2p\n reflect = reflect_TM + reflect_TE\n\n # If switch-off, subtract switch-on from DC value\n if signal == -1:\n direct_TM = direct_TM[-1]-direct_TM[:-1]\n direct_TE = direct_TE[-1]-direct_TE[:-1]\n direct = direct[-1]-direct[:-1]\n\n reflect_TM = reflect_TM[-1]-reflect_TM[:-1]\n reflect_TE = reflect_TE[-1]-reflect_TE[:-1]\n reflect = reflect[-1]-reflect[:-1]\n\n air = air[-1]-air[:-1]\n\n # Return, depending on 'solution'\n if solution == 'dfs':\n return direct\n elif solution == 'dsplit':\n return direct, reflect, air\n elif solution == 'dtetm':\n return direct_TE, direct_TM, reflect_TE, reflect_TM, air\n else:\n return direct + reflect + air\n"
] | [
[
"numpy.exp",
"numpy.min",
"numpy.invert",
"numpy.sign",
"numpy.cos",
"numpy.imag",
"scipy.special.kve",
"numpy.sin",
"numpy.zeros_like",
"numpy.vectorize",
"numpy.log",
"numpy.seterr",
"numpy.sqrt",
"numpy.real",
"numpy.shape",
"scipy.special.ive",
"numpy.ones",
"numpy.any",
"numpy.isrealobj",
"numpy.abs"
]
] |
jbinder/nn-eval | [
"1aed1bb84683392569466071155bfa825fed36e0"
] | [
"test/unit_tests/normalizer/tools_test.py"
] | [
"import unittest\n\nimport numpy as np\n\nfrom normalizer.tools import get_normalizer\n\n\n# noinspection PyMethodMayBeStatic\nclass ToolsTest(unittest.TestCase):\n def test_normalize_valid_data(self):\n normalizer_names = ['Identity', 'Reciprocal', 'SklearnStandard']\n for normalizer_name in normalizer_names:\n normalizer = get_normalizer(normalizer_name, np.array([1, 2, 3]))\n self.assertIsNotNone(normalizer)\n"
] | [
[
"numpy.array"
]
] |
wwilla7/pAPRika | [
"11a45f144f9bdabaee3ed7ee47cdf93f982dad72"
] | [
"paprika/setup.py"
] | [
"\"\"\"\nThis class contains a simulation setup wrapper for use with the Property Estimator.\n\"\"\"\n\nimport logging\nimport os\nimport shutil\nimport subprocess as sp\nfrom pathlib import Path\n\nimport numpy as np\nimport parmed as pmd\nimport pkg_resources\nimport pytraj as pt\nimport simtk.openmm as openmm\nimport simtk.unit as unit\n\nfrom paprika import align\nfrom paprika.restraints import static_DAT_restraint, DAT_restraint\nfrom paprika.restraints.read_yaml import read_yaml\nfrom paprika.restraints.restraints import create_window_list\n\nlogger = logging.getLogger(__name__)\n_PI_ = np.pi\n\ndef _get_installed_benchmarks():\n _installed_benchmarks = {}\n\n for entry_point in pkg_resources.iter_entry_points(group=\"taproom.benchmarks\"):\n _installed_benchmarks[entry_point.name] = entry_point.load()\n return _installed_benchmarks\n\n\ndef read_openmm_system_from_xml(filename):\n with open(filename, \"rb\") as file:\n return openmm.XmlSerializer.deserialize(file.read().decode())\n\n\nclass Setup(object):\n \"\"\"\n The Setup class provides a wrapper function around the preparation of the host-guest system and the application of restraints.\n \"\"\"\n\n def __init__(self, host, guest=None,\n backend=\"openmm\", directory_path=\"benchmarks\",\n additional_benchmarks=None, generate_gaff_files=False, gaff_version=\"gaff2\",\n guest_orientation=None, build=True):\n self.host = host\n self.guest = guest if guest is not None else \"release\"\n self.backend = backend\n self.directory = Path(directory_path).joinpath(self.host).joinpath(f\"{self.guest}-{guest_orientation}\" if\n guest_orientation is not None else\n f\"{self.guest}\")\n self.desolvated_window_paths = []\n self.window_list = []\n\n if self.backend == \"amber\":\n # Generate `frcmod` and dummy atom files.\n raise NotImplementedError\n\n self.directory.mkdir(parents=True, exist_ok=True)\n installed_benchmarks = get_benchmarks()\n if additional_benchmarks is not None:\n installed_benchmarks.update(additional_benchmarks)\n\n host_yaml, guest_yaml = self.parse_yaml(installed_benchmarks, guest_orientation)\n\n self.benchmark_path = host_yaml.parent\n self.host_yaml = read_yaml(host_yaml)\n if guest:\n self.guest_yaml = read_yaml(guest_yaml[\"yaml\"])\n\n if build:\n # Here, we build desolvated windows and pass the files to the Property Estimator.\n # These files are stored in `self.desolvated_window_paths`.\n self.build_desolvated_windows(guest_orientation)\n if generate_gaff_files:\n generate_gaff(mol2_file=self.benchmark_path.joinpath(self.host_yaml[\"structure\"]),\n residue_name=self.host_yaml[\"resname\"],\n output_name=self.host,\n directory_path=self.directory,\n gaff=gaff_version)\n if guest:\n generate_gaff(mol2_file=self.benchmark_path.joinpath(\n self.guest).joinpath(self.guest_yaml[\"structure\"]),\n output_name=self.guest,\n residue_name=self.guest_yaml[\"name\"],\n directory_path=self.directory,\n gaff=gaff_version)\n if not build:\n self.populate_window_list(input_pdb=os.path.join(self.directory, f\"{self.host}-{self.guest}.pdb\" if self.guest is not None\n else f\"{self.host}.pdb\"))\n\n def parse_yaml(self, installed_benchmarks, guest_orientation):\n \"\"\"\n Read the YAML recipe for the host and guest.\n\n Returns\n -------\n\n \"\"\"\n try:\n if guest_orientation:\n\n host_yaml = installed_benchmarks[\"host_guest_systems\"][self.host][\"yaml\"][guest_orientation]\n else:\n host_yaml = installed_benchmarks[\"host_guest_systems\"][self.host][\"yaml\"][\"p\"]\n\n except KeyError:\n logger.error(f\"Cannot find YAML recipe for host: {self.host}\")\n logger.debug(installed_benchmarks)\n raise FileNotFoundError\n try:\n guest_yaml = installed_benchmarks[\"host_guest_systems\"][self.host][self.guest]\n except KeyError:\n if self.guest == \"release\":\n guest_yaml = None\n else:\n logger.error(f\"Cannot find YAML recipe for guest: {self.guest}\")\n logger.debug(installed_benchmarks)\n raise FileNotFoundError\n\n return host_yaml, guest_yaml\n\n def align(self, input_pdb):\n structure = pmd.load_file(str(input_pdb), structure=True)\n intermediate_pdb = self.directory.joinpath(f\"tmp.pdb\")\n destination_pdb = self.directory.joinpath(f\"{self.host}-{self.guest}.pdb\")\n\n if not self.guest == \"release\":\n # Align the host-guest complex so the first guest atom is at (0, 0, 0) and the second guest atom lies\n # along the positive z-axis.\n guest_angle_restraint_mask = self.guest_yaml[\"restraints\"][\"guest\"][-1][\"restraint\"][\n \"atoms\"\n ].split()\n aligned_structure = align.zalign(\n structure, guest_angle_restraint_mask[1], guest_angle_restraint_mask[2]\n )\n aligned_structure.save(str(intermediate_pdb), overwrite=True)\n\n else:\n # Create a PDB file just for the host.\n\n host = pmd.load_file(str(input_pdb), structure=True)\n host_coordinates = host[f\":{self.host_yaml['resname'].upper()}\"].coordinates\n # Cheap way to get the center of geometry\n offset_coordinates = pmd.geometry.center_of_mass(host_coordinates,\n masses=np.ones(len(host_coordinates)))\n\n # Find the principal components, take the two largest, and find the vector orthogonal to that\n # (should be cross-product right hand rule, I think). Use that vector to align with the z-axis.\n # This may not generalize to non-radially-symmetric host molecules.\n\n aligned_coords = np.empty_like(structure.coordinates)\n for atom in range(len(structure.atoms)):\n aligned_coords[atom] = structure.coordinates[atom] - offset_coordinates\n structure.coordinates = aligned_coords\n\n inertia_tensor = np.dot(structure.coordinates.transpose(), structure.coordinates)\n eigenvalues, eigenvectors = np.linalg.eig(inertia_tensor)\n order = np.argsort(eigenvalues)\n axis_3, axis_2, axis_1 = eigenvectors[:, order].transpose()\n\n dummy_axis = np.cross(axis_1, axis_2)\n\n self._add_dummy_to_PDB(input_pdb=input_pdb,\n output_pdb=intermediate_pdb,\n offset_coordinates=offset_coordinates,\n dummy_atom_tuples=[(0, 0, 0),\n (dummy_axis[0], dummy_axis[1], dummy_axis[2])])\n structure = pmd.load_file(str(intermediate_pdb), structure=True)\n\n for atom in structure.atoms:\n atom.mass = 1.0\n\n aligned_structure = align.zalign(\n structure, \":DM1\", \":DM2\"\n )\n aligned_structure[\"!:DM1&!:DM2\"].save(str(intermediate_pdb),\n overwrite=True)\n\n\n # Save aligned PDB file with CONECT records.\n positions_pdb = openmm.app.PDBFile(str(intermediate_pdb))\n topology_pdb = openmm.app.PDBFile(str(input_pdb))\n\n positions = positions_pdb.positions\n topology = topology_pdb.topology\n with open(destination_pdb, \"w\") as file:\n openmm.app.PDBFile.writeFile(topology, positions, file)\n os.remove(intermediate_pdb)\n\n def populate_window_list(self, input_pdb):\n logger.debug(\"Setting up dummy restraint to build window list.\")\n _dummy_restraint = self._create_dummy_restraint(\n initial_structure=str(input_pdb),\n )\n self.window_list = create_window_list([_dummy_restraint])\n return _dummy_restraint\n\n def build_desolvated_windows(self, guest_orientation):\n if self.guest != \"release\":\n if not guest_orientation:\n initial_structure = self.benchmark_path.joinpath(self.guest).joinpath(\n self.guest_yaml[\"complex\"]\n )\n else:\n base_name = Path(self.guest_yaml[\"complex\"]).stem\n orientation_structure = base_name + f\"-{guest_orientation}.pdb\"\n initial_structure = self.benchmark_path.joinpath(self.guest).joinpath(\n orientation_structure\n )\n\n else:\n initial_structure = self.directory.joinpath(self.benchmark_path.joinpath(self.host_yaml[\"structure\"]))\n host = pt.iterload(str(initial_structure), str(initial_structure))\n host.save(str(self.directory.joinpath(f\"{self.host}.pdb\")), overwrite=True, options='conect')\n initial_structure = str(self.directory.joinpath(f\"{self.host}.pdb\"))\n\n self.align(input_pdb=initial_structure)\n\n _dummy_restraint = self.populate_window_list(input_pdb=initial_structure)\n\n for window in self.window_list:\n logger.debug(f\"Translating guest in window {window}...\")\n self.directory.joinpath(\"windows\").joinpath(window).mkdir(\n parents=True, exist_ok=True\n )\n self.translate(window, topology_pdb=initial_structure, restraint=_dummy_restraint)\n\n window_pdb_file_name = f\"{self.host}-{self.guest}.pdb\"\n\n self.desolvated_window_paths.append(\n str(\n self.directory.joinpath(\"windows\")\n .joinpath(window)\n .joinpath(window_pdb_file_name)\n )\n )\n\n def _create_dummy_restraint(self, initial_structure):\n\n if self.guest != \"release\":\n windows = [\n self.host_yaml[\"calculation\"][\"windows\"][\"attach\"],\n self.host_yaml[\"calculation\"][\"windows\"][\"pull\"],\n None,\n ]\n else:\n windows = [\n None,\n None,\n self.host_yaml[\"calculation\"][\"windows\"][\"release\"]\n ]\n\n\n guest_restraint = DAT_restraint()\n guest_restraint.auto_apr = True\n guest_restraint.continuous_apr = True\n guest_restraint.amber_index = False if self.backend == \"openmm\" else True\n guest_restraint.topology = str(initial_structure)\n guest_restraint.mask1 = \"@1\"\n guest_restraint.mask2 = \"@2\"\n\n if self.guest != \"release\":\n restraint = self.guest_yaml[\"restraints\"][\"guest\"][0]\n guest_restraint.attach[\"target\"] = restraint[\"restraint\"][\"attach\"][\n \"target\"\n ]\n guest_restraint.attach[\"fc_final\"] = restraint[\"restraint\"][\"attach\"][\n \"force_constant\"\n ]\n guest_restraint.attach[\"fraction_list\"] = self.host_yaml[\"calculation\"][\n \"lambda\"\n ][\"attach\"]\n\n guest_restraint.pull[\"target_final\"] = self.host_yaml[\"calculation\"][\"target\"][\n \"pull\"\n ]\n guest_restraint.pull[\"num_windows\"] = windows[1]\n else:\n # Remember, the purpose of this *fake* restraint is *only* to figure out how many windows to make,\n # so we can use the Property Estimator to solvate the structures for us. To figure out how many winodws\n # we need, just setting the lambda values should be sufficient.\n guest_restraint.auto_apr = False\n guest_restraint.continuous_apr = False\n\n guest_restraint.release[\"target\"] = 1.0\n guest_restraint.release[\"fc_final\"] = 1.0\n guest_restraint.release[\"fraction_list\"] = self.host_yaml[\"calculation\"][\n \"lambda\"\n ][\"release\"]\n\n guest_restraint.initialize()\n\n return guest_restraint\n\n def translate(self, window, topology_pdb, restraint):\n window_path = self.directory.joinpath(\"windows\").joinpath(window)\n if window[0] == \"a\":\n # Copy the initial structure.\n source_pdb = self.directory.joinpath(f\"{self.host}-{self.guest}.pdb\")\n shutil.copy(source_pdb, window_path)\n elif window[0] == \"p\":\n # Translate the guest.\n source_pdb = self.directory.joinpath(f\"{self.host}-{self.guest}.pdb\")\n\n structure = pmd.load_file(str(source_pdb), structure=True)\n target_difference = (\n restraint.phase[\"pull\"][\"targets\"][int(window[1:])]\n - restraint.pull[\"target_initial\"]\n )\n for atom in structure.atoms:\n if atom.residue.name == self.guest.upper():\n atom.xz += target_difference\n\n intermediate_pdb = window_path.joinpath(f\"tmp.pdb\")\n destination_pdb = window_path.joinpath(f\"{self.host}-{self.guest}.pdb\")\n structure.save(str(intermediate_pdb), overwrite=True)\n\n\n input_pdb = openmm.app.PDBFile(str(intermediate_pdb))\n topology_pdb = openmm.app.PDBFile(str(topology_pdb))\n positions = input_pdb.positions\n topology = topology_pdb.topology\n with open(destination_pdb, \"w\") as file:\n openmm.app.PDBFile.writeFile(topology, positions, file)\n os.remove(intermediate_pdb)\n\n elif window[0] == \"r\":\n try:\n # Copy the final pull window, if it exists\n source_pdb = (\n self.directory.joinpath(\"windows\")\n .joinpath(f\"p{self.host_yaml['calculation']['windows']['pull']:03d}\")\n .joinpath(f\"{self.host}-{self.guest}.pdb\")\n )\n shutil.copy(source_pdb, window_path)\n except FileNotFoundError:\n # Copy the initial structure, assuming we are doing a standalone release calculation.\n shutil.copy(self.directory.joinpath(f\"{self.host}-{self.guest}.pdb\"),\n window_path)\n\n def _add_dummy_to_PDB(self, input_pdb, output_pdb, offset_coordinates,\n dummy_atom_tuples):\n input_pdb_file = openmm.app.PDBFile(input_pdb)\n\n positions = input_pdb_file.positions\n\n # When we pass in a guest, we have multiple coordinates and the function expects to address the first guest\n # atom coordinates.\n # When we pass in the center of mass of the host, we'll only have one set of coordinates.\n if len(np.shape(offset_coordinates)) < 2:\n offset_coordinates = [offset_coordinates, ]\n\n for index, dummy_atom_tuple in enumerate(dummy_atom_tuples):\n\n positions.append(\n openmm.Vec3(\n offset_coordinates[0][0] + dummy_atom_tuple[0],\n offset_coordinates[0][1] + dummy_atom_tuple[1],\n offset_coordinates[0][2] + dummy_atom_tuple[2],\n )\n * unit.angstrom\n )\n\n topology = input_pdb_file.topology\n for dummy_index in range(len(dummy_atom_tuples)):\n dummy_chain = topology.addChain(None)\n dummy_residue = topology.addResidue(f\"DM{dummy_index + 1}\", dummy_chain)\n topology.addAtom(f\"DUM\", None, dummy_residue)\n\n with open(output_pdb, \"w\") as file:\n openmm.app.PDBFile.writeFile(topology, positions, file)\n\n def _add_dummy_to_System(self, system, dummy_atom_tuples):\n [system.addParticle(mass=207) for _ in range(len(dummy_atom_tuples))]\n\n for force_index in range(system.getNumForces()):\n force = system.getForce(force_index)\n if not isinstance(force, openmm.NonbondedForce):\n continue\n force.addParticle(0.0, 1.0, 0.0)\n force.addParticle(0.0, 1.0, 0.0)\n force.addParticle(0.0, 1.0, 0.0)\n\n return system\n\n def add_dummy_atoms(\n self,\n reference_pdb=\"reference.pdb\",\n solvated_pdb=\"output.pdb\",\n solvated_xml=\"system.xml\",\n dummy_pdb=\"output.pdb\",\n dummy_xml=\"output.xml\",\n ):\n\n reference_structure = pmd.load_file(reference_pdb, structure=True)\n\n # Determine the offset coordinates for the new dummy atoms.\n if self.guest == \"release\":\n\n host_coordinates = reference_structure[f\":{self.host_yaml['resname'].upper()}\"].coordinates\n # Cheap way to get the center of geometry\n offset_coordinates = pmd.geometry.center_of_mass(host_coordinates,\n masses=np.ones(len(host_coordinates)))\n\n else:\n guest_angle_restraint_mask = self.guest_yaml[\"restraints\"][\"guest\"][-1][\"restraint\"][\n \"atoms\"\n ].split()\n\n offset_coordinates = reference_structure[f':{self.guest_yaml[\"name\"].upper()} | :{self.host_yaml[\"resname\"].upper()}']\\\n [guest_angle_restraint_mask[1]].coordinates\n\n # First add dummy atoms to structure\n logger.debug(f\"Adding dummy atoms to {solvated_pdb}\")\n try:\n\n self._add_dummy_to_PDB(solvated_pdb, dummy_pdb, offset_coordinates,\n dummy_atom_tuples=[(0, 0, -6.0),\n (0, 0, -9.0),\n (0, 2.2, -11.2)])\n except FileNotFoundError:\n logger.warning(f\"Missing {solvated_pdb}\")\n\n\n self._wrap(dummy_pdb)\n\n # Add dummy atoms to System\n if solvated_xml is not None:\n\n try:\n\n system = read_openmm_system_from_xml(solvated_xml)\n system = self._add_dummy_to_System(system, dummy_atom_tuples=[(0, 0, -6.0),\n (0, 0, -9.0),\n (0, 2.2, -11.2)])\n system_xml = openmm.XmlSerializer.serialize(system)\n with open(dummy_xml, \"w\") as file:\n file.write(system_xml)\n\n except FileNotFoundError:\n logger.warning(f\"Missing {solvated_xml}\")\n\n @staticmethod\n def _wrap(file, mask=\":DM3\"):\n logging.info(f\"Re-wrapping {file} to avoid pulling near periodic boundaries.\")\n structure = pmd.load_file(file, structure=True)\n\n anchor = structure[mask]\n anchor_z = anchor.atoms[0].xz\n\n for atom in structure.atoms:\n atom.xz -= anchor_z - 2.0\n\n structure.save(file, overwrite=True)\n\n\n def initialize_restraints(self, structure=\"output.pdb\"):\n\n if self.guest != \"release\":\n\n windows = [\n self.host_yaml[\"calculation\"][\"windows\"][\"attach\"],\n self.host_yaml[\"calculation\"][\"windows\"][\"pull\"],\n None,\n ]\n else:\n windows = [None,\n None,\n self.host_yaml[\"calculation\"][\"windows\"][\"release\"]\n ]\n\n static_restraints = []\n for restraint in self.host_yaml[\"restraints\"][\"static\"]:\n\n static = static_DAT_restraint(\n restraint_mask_list=restraint[\"restraint\"][\"atoms\"].split(),\n num_window_list=windows,\n ref_structure=str(structure),\n force_constant=restraint[\"restraint\"][\"force_constant\"],\n amber_index=False if self.backend == \"openmm\" else True,\n )\n static_restraints.append(static)\n\n conformational_restraints = []\n if self.host_yaml[\"restraints\"][\"conformational\"]:\n\n for conformational in self.host_yaml[\"restraints\"][\n \"conformational\"\n ]:\n\n mask = conformational[\"restraint\"][\"atoms\"].split()\n\n conformational_restraint = DAT_restraint()\n conformational_restraint.auto_apr = True\n conformational_restraint.continuous_apr = True\n conformational_restraint.amber_index = False if self.backend == \"openmm\" else True\n conformational_restraint.topology = str(structure)\n conformational_restraint.mask1 = mask[0]\n conformational_restraint.mask2 = mask[1]\n conformational_restraint.mask3 = mask[2] if len(mask) > 2 else None\n conformational_restraint.mask4 = mask[3] if len(mask) > 3 else None\n\n if self.guest != \"release\":\n\n conformational_restraint.attach[\"target\"] = conformational[\"restraint\"][\n \"target\"\n ]\n conformational_restraint.attach[\"fc_final\"] = conformational[\"restraint\"][\n \"force_constant\"\n ]\n conformational_restraint.attach[\"fraction_list\"] = self.host_yaml[\"calculation\"][\n \"lambda\"\n ][\"attach\"]\n\n conformational_restraint.pull[\"target_final\"] = conformational[\"restraint\"][\n \"target\"\n ]\n conformational_restraint.pull[\"num_windows\"] = windows[1]\n\n else:\n\n conformational_restraint.auto_apr = False\n conformational_restraint.continuous_apr = False\n\n conformational_restraint.release[\"target\"] = conformational[\"restraint\"][\n \"target\"\n ]\n conformational_restraint.release[\"fc_final\"] = conformational[\"restraint\"][\n \"force_constant\"\n ]\n conformational_restraint.release[\"fraction_list\"] = self.host_yaml[\"calculation\"][\n \"lambda\"\n ][\"release\"]\n\n\n conformational_restraint.initialize()\n conformational_restraints.append(conformational_restraint)\n else:\n logger.debug(\"Skipping conformational restraints...\")\n\n symmetry_restraints = []\n if self.guest != \"release\" and \"symmetry_correction\" in self.guest_yaml:\n for symmetry in self.guest_yaml[\"symmetry_correction\"][\"restraints\"]:\n symmetry_restraint = DAT_restraint()\n symmetry_restraint.auto_apr = True\n symmetry_restraint.continuous_apr = True\n symmetry_restraint.amber_index = False if self.backend == \"openmm\" else True\n symmetry_restraint.topology = str(structure)\n symmetry_restraint.mask1 = symmetry[\"atoms\"].split()[0]\n symmetry_restraint.mask2 = symmetry[\"atoms\"].split()[1]\n symmetry_restraint.mask3 = symmetry[\"atoms\"].split()[2]\n\n symmetry_restraint.attach[\"fc_final\"] = symmetry[\"force_constant\"]\n symmetry_restraint.attach[\"fraction_list\"] = [1.0] * len(self.host_yaml[\"calculation\"][\n \"lambda\"\n ][\"attach\"])\n # This target should be overridden by the custom values.\n symmetry_restraint.attach[\"target\"] = 999.99\n symmetry_restraint.custom_restraint_values[\"r2\"] = 91\n symmetry_restraint.custom_restraint_values[\"r3\"] = 91\n # 0 force constant between 91 degrees and 180 degrees.\n symmetry_restraint.custom_restraint_values[\"rk3\"] = 0.0\n symmetry_restraint.initialize()\n\n symmetry_restraints.append(symmetry_restraint)\n\n else:\n logger.debug(\"Skipping symmetry restraints...\")\n\n wall_restraints = []\n if self.guest != \"release\" and \"wall_restraints\" in self.guest_yaml:\n for wall in self.guest_yaml[\"wall_restraints\"][\"restraints\"]:\n wall_restraint = DAT_restraint()\n wall_restraint.auto_apr = True\n wall_restraint.continuous_apr = True\n wall_restraint.amber_index = False if self.backend == \"openmm\" else True\n wall_restraint.topology = str(structure)\n wall_restraint.mask1 = wall[\"atoms\"].split()[0]\n wall_restraint.mask2 = wall[\"atoms\"].split()[1]\n\n wall_restraint.attach[\"fc_final\"] = wall[\"force_constant\"]\n wall_restraint.attach[\"fraction_list\"] = [1.0] * len(self.host_yaml[\"calculation\"][\n \"lambda\"\n ][\"attach\"])\n wall_restraint.attach[\"target\"] = wall[\"target\"]\n # Minimum distance is 0 Angstrom\n wall_restraint.custom_restraint_values[\"r1\"] = 0\n wall_restraint.custom_restraint_values[\"r2\"] = 0\n # Harmonic force constant beyond target distance.\n wall_restraint.custom_restraint_values[\"rk2\"] = wall[\"force_constant\"]\n wall_restraint.custom_restraint_values[\"rk3\"] = wall[\"force_constant\"]\n wall_restraint.initialize()\n\n wall_restraints.append(wall_restraint)\n\n else:\n logger.debug(\"Skipping wall restraints...\")\n\n guest_restraints = []\n for restraint in [] if not hasattr(self, 'guest_yaml') else self.guest_yaml[\"restraints\"][\"guest\"]:\n mask = restraint[\"restraint\"][\"atoms\"].split()\n\n guest_restraint = DAT_restraint()\n guest_restraint.auto_apr = True\n guest_restraint.continuous_apr = True\n guest_restraint.amber_index = False if self.backend == \"openmm\" else True\n guest_restraint.topology = str(structure)\n guest_restraint.mask1 = mask[0]\n guest_restraint.mask2 = mask[1]\n guest_restraint.mask3 = mask[2] if len(mask) > 2 else None\n guest_restraint.mask4 = mask[3] if len(mask) > 3 else None\n\n guest_restraint.attach[\"target\"] = restraint[\"restraint\"][\"attach\"][\n \"target\"\n ]\n guest_restraint.attach[\"fc_final\"] = restraint[\"restraint\"][\"attach\"][\n \"force_constant\"\n ]\n guest_restraint.attach[\"fraction_list\"] = self.host_yaml[\"calculation\"][\n \"lambda\"\n ][\"attach\"]\n\n guest_restraint.pull[\"target_final\"] = restraint[\"restraint\"][\"pull\"][\n \"target\"\n ]\n guest_restraint.pull[\"num_windows\"] = windows[1]\n\n guest_restraint.initialize()\n guest_restraints.append(guest_restraint)\n\n return (\n static_restraints,\n conformational_restraints,\n symmetry_restraints,\n wall_restraints,\n guest_restraints,\n )\n\n def initialize_calculation(self, window, structure_path=\"output.pdb\",\n input_xml=\"system.xml\", output_xml=\"system.xml\"):\n if self.backend == \"amber\":\n # Write simulation input files in each directory\n raise NotImplementedError\n try:\n system = read_openmm_system_from_xml(input_xml)\n except FileNotFoundError:\n logger.warning(f\"Cannot read XML from {input_xml}\")\n\n # Apply the positional restraints.\n structure = pmd.load_file(structure_path, structure=True)\n\n for atom in structure.atoms:\n if atom.name == \"DUM\":\n positional_restraint = openmm.CustomExternalForce(\n \"k * ((x-x0)^2 + (y-y0)^2 + (z-z0)^2)\"\n )\n positional_restraint.addPerParticleParameter(\"k\")\n positional_restraint.addPerParticleParameter(\"x0\")\n positional_restraint.addPerParticleParameter(\"y0\")\n positional_restraint.addPerParticleParameter(\"z0\")\n # I haven't found a way to get this to use ParmEd's unit library here.\n # ParmEd correctly reports `atom.positions` as units of Ångstroms.\n # But then we can't access atom indices.\n # Using `atom.xx` works for coordinates, but is unitless.\n\n k = 500.0 * unit.kilocalories_per_mole / unit.angstroms ** 2\n x0 = 0.1 * atom.xx * unit.nanometers\n y0 = 0.1 * atom.xy * unit.nanometers\n z0 = 0.1 * atom.xz * unit.nanometers\n positional_restraint.addParticle(atom.idx, [k, x0, y0, z0])\n system.addForce(positional_restraint)\n positional_restraint.setForceGroup(15)\n\n for restraint in self.static_restraints:\n system = apply_openmm_restraints(system, restraint, window, ForceGroup=10)\n for restraint in self.conformational_restraints:\n system = apply_openmm_restraints(system, restraint, window, ForceGroup=11)\n for restraint in self.guest_restraints:\n system = apply_openmm_restraints(system, restraint, window, ForceGroup=12)\n for restraint in self.symmetry_restraints:\n system = apply_openmm_restraints(system, restraint, window, flat_bottom=True, ForceGroup=13)\n for restraint in self.wall_restraints:\n system = apply_openmm_restraints(system, restraint, window, flat_bottom=True, ForceGroup=14)\n\n system_xml = openmm.XmlSerializer.serialize(system)\n\n with open(output_xml, \"w\") as file:\n file.write(system_xml)\n\ndef get_benchmarks():\n \"\"\"\n Determine the installed benchmarks.\n\n \"\"\"\n installed_benchmarks = _get_installed_benchmarks()\n return installed_benchmarks\n\ndef apply_openmm_restraints(system, restraint, window, flat_bottom=False, ForceGroup=None):\n if window[0] == \"a\":\n phase = \"attach\"\n elif window[0] == \"p\":\n phase = \"pull\"\n elif window[0] == \"r\":\n phase = \"release\"\n window_number = int(window[1:])\n\n if flat_bottom and phase == \"attach\" and restraint.mask3:\n flat_bottom_force = openmm.CustomAngleForce('step(-(theta - theta_0)) * k * (theta - theta_0)^2')\n # If theta is greater than theta_0, then the argument to step is negative, which means the force is off.\n flat_bottom_force.addPerAngleParameter(\"k\")\n flat_bottom_force.addPerAngleParameter(\"theta_0\")\n\n theta_0 = 91.0 * unit.degrees\n k = (\n restraint.phase[phase][\"force_constants\"][window_number]\n * unit.kilocalories_per_mole\n / unit.radian ** 2\n )\n flat_bottom_force.addAngle(\n restraint.index1[0],\n restraint.index2[0],\n restraint.index3[0],\n [k, theta_0],\n )\n system.addForce(flat_bottom_force)\n if ForceGroup:\n flat_bottom_force.setForceGroup(ForceGroup)\n\n return system\n elif flat_bottom and phase == \"attach\" and not restraint.mask3:\n flat_bottom_force = openmm.CustomBondForce('step((r - r_0)) * k * (r - r_0)^2')\n # If x is greater than x_0, then the argument to step is positive, which means the force is on.\n flat_bottom_force.addPerBondParameter(\"k\")\n flat_bottom_force.addPerBondParameter(\"r_0\")\n\n r_0 = restraint.phase[phase][\"targets\"][window_number] * unit.angstrom\n k = (\n restraint.phase[phase][\"force_constants\"][window_number]\n * unit.kilocalories_per_mole\n / unit.radian ** 2\n )\n flat_bottom_force.addBond(\n restraint.index1[0],\n restraint.index2[0],\n [k, r_0],\n )\n system.addForce(flat_bottom_force)\n if ForceGroup:\n flat_bottom_force.setForceGroup(ForceGroup)\n\n return system\n\n elif flat_bottom and phase == \"pull\":\n return system\n elif flat_bottom and phase == \"release\":\n return system\n\n if restraint.mask2 and not restraint.mask3:\n if not restraint.group1 and not restraint.group2:\n bond_restraint = openmm.CustomBondForce(\"k * (r - r_0)^2\")\n bond_restraint.addPerBondParameter(\"k\")\n bond_restraint.addPerBondParameter(\"r_0\")\n\n r_0 = restraint.phase[phase][\"targets\"][window_number] * unit.angstroms\n k = (\n restraint.phase[phase][\"force_constants\"][window_number]\n * unit.kilocalories_per_mole\n / unit.angstrom ** 2\n )\n bond_restraint.addBond(restraint.index1[0], restraint.index2[0], [k, r_0])\n system.addForce(bond_restraint)\n else:\n bond_restraint = openmm.CustomCentroidBondForce(\n 2, \"k * (distance(g1, g2) - r_0)^2\"\n )\n bond_restraint.addPerBondParameter(\"k\")\n bond_restraint.addPerBondParameter(\"r_0\")\n r_0 = restraint.phase[phase][\"targets\"][window_number] * unit.angstroms\n k = (\n restraint.phase[phase][\"force_constants\"][window_number]\n * unit.kilocalories_per_mole\n / unit.angstrom ** 2\n )\n g1 = bond_restraint.addGroup(restraint.index1)\n g2 = bond_restraint.addGroup(restraint.index2)\n bond_restraint.addBond([g1, g2], [k, r_0])\n system.addForce(bond_restraint)\n\n if ForceGroup:\n bond_restraint.setForceGroup(ForceGroup)\n\n elif restraint.mask3 and not restraint.mask4:\n if not restraint.group1 and not restraint.group2 and not restraint.group3:\n angle_restraint = openmm.CustomAngleForce(\"k * (theta - theta_0)^2\")\n angle_restraint.addPerAngleParameter(\"k\")\n angle_restraint.addPerAngleParameter(\"theta_0\")\n\n theta_0 = restraint.phase[phase][\"targets\"][window_number] * unit.degrees\n k = (\n restraint.phase[phase][\"force_constants\"][window_number]\n * unit.kilocalories_per_mole\n / unit.radian ** 2\n )\n angle_restraint.addAngle(\n restraint.index1[0],\n restraint.index2[0],\n restraint.index3[0],\n [k, theta_0],\n )\n system.addForce(angle_restraint)\n else:\n # Probably needs openmm.CustomCentroidAngleForce (?)\n raise NotImplementedError\n if ForceGroup:\n angle_restraint.setForceGroup(ForceGroup)\n\n elif restraint.mask4:\n if (\n not restraint.group1\n and not restraint.group2\n and not restraint.group3\n and not restraint.group4\n ):\n dihedral_restraint = openmm.CustomTorsionForce(f\"k * min(min(abs(theta - theta_0), abs(theta - theta_0 + 2 * {_PI_})), abs(theta - theta_0 - 2 * {_PI_}))^2\")\n dihedral_restraint.addPerTorsionParameter(\"k\")\n dihedral_restraint.addPerTorsionParameter(\"theta_0\")\n\n theta_0 = restraint.phase[phase][\"targets\"][window_number] * unit.degrees\n k = (\n restraint.phase[phase][\"force_constants\"][window_number]\n * unit.kilocalories_per_mole\n / unit.radian ** 2\n )\n dihedral_restraint.addTorsion(\n restraint.index1[0],\n restraint.index2[0],\n restraint.index3[0],\n restraint.index4[0],\n [k, theta_0],\n )\n system.addForce(dihedral_restraint)\n else:\n # Probably needs openmm.CustomCentroidTorsionForce (?)\n raise NotImplementedError\n if ForceGroup:\n dihedral_restraint.setForceGroup(ForceGroup)\n return system\n\ndef generate_gaff(mol2_file, residue_name, output_name=None, need_gaff_atom_types=True, generate_frcmod=True,\n directory_path=\"benchmarks\", gaff=\"gaff2\"):\n\n if output_name is None:\n output_name = mol2_file.stem\n\n if need_gaff_atom_types:\n _generate_gaff_atom_types(mol2_file=mol2_file,\n residue_name=residue_name,\n output_name=output_name,\n gaff=gaff,\n directory_path=directory_path)\n logging.debug(\"Checking to see if we have a multi-residue MOL2 file that should be converted \"\n \"to single-residue...\")\n structure = pmd.load_file(os.path.join(directory_path, f\"{output_name}.{gaff}.mol2\"), structure=True)\n if len(structure.residues) > 1:\n structure[\":1\"].save(\"tmp.mol2\")\n if os.path.exists(\"tmp.mol2\"):\n os.rename(\"tmp.mol2\", os.path.join(directory_path, f\"{output_name}.{gaff}.mol2\"))\n logging.debug(\"Saved single-residue MOL2 file for `tleap`.\")\n else:\n raise RuntimeError(\"Unable to convert multi-residue MOL2 file to single-residue for `tleap`.\")\n\n if generate_frcmod:\n _generate_frcmod(mol2_file=f'{output_name}.{gaff}.mol2',\n gaff=gaff,\n output_name=output_name,\n directory_path=directory_path)\n else:\n raise NotImplementedError()\n\ndef _generate_gaff_atom_types(mol2_file, residue_name, output_name, gaff=\"gaff2\", directory_path=\"benchmarks\"):\n \n p = sp.Popen([\"antechamber\", \"-i\", str(mol2_file), \"-fi\", \"mol2\",\n \"-o\", f\"{output_name}.{gaff}.mol2\", \"-fo\", \"mol2\",\n \"-rn\", f\"{residue_name.upper()}\",\n \"-at\", f\"{gaff}\",\n \"-an\", \"no\",\n \"-dr\", \"no\",\n \"-pf\", \"yes\"], cwd=directory_path)\n p.communicate()\n\n files = [\"ANTECHAMBER_AC.AC\", \"ANTECHAMBER_AC.AC0\",\n \"ANTECHAMBER_BOND_TYPE.AC\", \"ANTECHAMBER_BOND_TYPE.AC0\",\n \"ATOMTYPE.INF\"]\n files = [directory_path.joinpath(i) for i in files]\n for file in files:\n if file.exists():\n logger.debug(f\"Removing temporary file: {file}\")\n file.unlink()\n \n if not os.path.exists(f\"{output_name}.{gaff}.mol2\"):\n # Try with the newer (AmberTools 19) version of `antechamber` which doesn't have the `-dr` flag\n p = sp.Popen([\"antechamber\", \"-i\", str(mol2_file), \"-fi\", \"mol2\",\n \"-o\", f\"{output_name}.{gaff}.mol2\", \"-fo\", \"mol2\",\n \"-rn\", f\"{residue_name.upper()}\",\n \"-at\", f\"{gaff}\",\n \"-an\", \"no\",\n \"-pf\", \"yes\"], cwd=directory_path)\n p.communicate()\n\n files = [\"ANTECHAMBER_AC.AC\", \"ANTECHAMBER_AC.AC0\",\n \"ANTECHAMBER_BOND_TYPE.AC\", \"ANTECHAMBER_BOND_TYPE.AC0\",\n \"ATOMTYPE.INF\"]\n files = [directory_path.joinpath(i) for i in files]\n for file in files:\n if file.exists():\n logger.debug(f\"Removing temporary file: {file}\")\n file.unlink()\n\n\ndef _generate_frcmod(mol2_file, gaff, output_name, directory_path=\"benchmarks\"):\n sp.Popen([\"parmchk2\", \"-i\", str(mol2_file), \"-f\", \"mol2\",\n \"-o\", f\"{output_name}.{gaff}.frcmod\",\n \"-s\", f\"{gaff}\"\n ], cwd=directory_path)"
] | [
[
"numpy.shape",
"numpy.linalg.eig",
"numpy.argsort",
"numpy.cross",
"numpy.empty_like"
]
] |
tkarna/galene | [
"a05463d3d0c9191c51893df4593d9ce0252d25fb"
] | [
"examples/extract_profiles.py"
] | [
"\"\"\"\nRead NEMO timeprofiles and individual profiles at observation time stamps.\n\"\"\"\nimport galene as ga\nimport iris\nimport numpy\n\nvar_list = ['temp', 'psal']\nobs_id = 'ices-ctd'\ndataset_id = 'run001'\n\nnemo_standard_name = {\n 'temp': 'sea_water_potential_temperature',\n 'salt': 'sea_water_practical_salinity',\n}\n\nnemo_var_name = {\n 'ssh': 'SSH_inst',\n}\n\nices_standard_name = {\n 'temp': 'sea_water_temperature',\n 'salt': 'sea_water_salinity',\n}\n\n\ndef extract_profile(model_profile, obs_profile, interpolate_depth=False):\n \"\"\"\n Extract a single profile from a Nemo model based on a obs profile\n\n Model profile is 4D: [time, depth, latitude, longitude]\n\n Observation profile is 1D: [depth]\n with scalar variables time, latitude, longitude\n \"\"\"\n # drop singular lat,lon coords\n m = ga.drop_singleton_dims(model_profile)\n\n # interpolate in time\n time_var = obs_profile.coord('time')\n target_date = time_var.units.num2date(time_var.points[0])\n target = [('time', target_date)]\n scheme = iris.analysis.Linear(extrapolation_mode='mask')\n m_prof = m.interpolate(target, scheme)\n\n def _drop_bad_values(c):\n valid_ix = numpy.isfinite(c.data)\n if numpy.ma.is_masked(c.data):\n valid_ix *= ~c.data.mask\n return m_prof[valid_ix]\n\n m_prof = _drop_bad_values(m_prof)\n\n if interpolate_depth:\n # interpolate in vertical\n target = [('depth', obs_profile.coord('depth').points)]\n scheme = iris.analysis.Linear(extrapolation_mode='mask')\n m_prof = m_prof.interpolate(target, scheme)\n m_prof = _drop_bad_values(m_prof)\n\n return m_prof\n\n\nfor var in var_list:\n dataset = ga.read_dataset(dataset_id, 'timeprofile', var)\n obs_dataset = ga.read_dataset(obs_id, 'profile', var)\n\n pairs = ga.find_station_pairs(obs_dataset, dataset)\n\n for key in pairs:\n o = pairs[key][obs_id]\n m = pairs[key][dataset_id]\n\n cube = extract_profile(m, o)\n ga.save_cube(cube)\n"
] | [
[
"numpy.ma.is_masked",
"numpy.isfinite"
]
] |
Brent1999/FastMOT | [
"7b9ef1398e78ac49131e810f703ceb68e2222744"
] | [
"fastmot/detector.py"
] | [
"from collections import defaultdict\nfrom pathlib import Path\nimport configparser\nimport abc\nimport numpy as np\nimport numba as nb\nimport cupy as cp\nimport cupyx.scipy.ndimage\nimport cv2\n\nfrom . import models\nfrom .utils import TRTInference\nfrom .utils.rect import as_rect, to_tlbr, get_size, area\nfrom .utils.rect import union, crop, multi_crop, iom, diou_nms\n\n\nDET_DTYPE = np.dtype(\n [('tlbr', float, 4),\n ('label', int),\n ('conf', float)],\n align=True\n)\n\n\nclass Detector(abc.ABC):\n @abc.abstractmethod\n def __init__(self, size):\n self.size = size\n\n def __call__(self, frame):\n self.detect_async(frame)\n return self.postprocess()\n\n @abc.abstractmethod\n def detect_async(self, frame):\n \"\"\"\n Asynchronous detection.\n \"\"\"\n raise NotImplementedError\n\n @abc.abstractmethod\n def postprocess(self):\n \"\"\"\n Synchronizes, applies postprocessing, and returns a record array\n of detections (DET_DTYPE).\n This function should be called after `detect_async`.\n \"\"\"\n raise NotImplementedError\n\n\nclass SSDDetector(Detector):\n def __init__(self, size, config):\n super().__init__(size)\n self.label_mask = np.zeros(len(models.LABEL_MAP), dtype=bool)\n self.label_mask[list(config['class_ids'])] = True\n\n self.model = getattr(models, config['model'])\n self.tile_overlap = config['tile_overlap']\n self.tiling_grid = config['tiling_grid']\n self.conf_thresh = config['conf_thresh']\n self.max_area = config['max_area']\n self.merge_thresh = config['merge_thresh']\n\n self.batch_size = int(np.prod(self.tiling_grid))\n self.tiles, self.tiling_region_size = self._generate_tiles()\n self.scale_factor = np.asarray(self.size) / self.tiling_region_size\n self.backend = TRTInference(self.model, self.batch_size)\n self.inp_handle = self.backend.input.host.reshape(self.batch_size, *self.model.INPUT_SHAPE)\n\n def detect_async(self, frame):\n self._preprocess(frame)\n self.backend.infer_async()\n\n def postprocess(self):\n det_out = self.backend.synchronize()[0]\n detections, tile_ids = self._filter_dets(det_out, self.tiles, self.model.TOPK,\n self.label_mask, self.max_area,\n self.conf_thresh, self.scale_factor)\n detections = self._merge_dets(detections, tile_ids)\n return detections\n\n def _preprocess(self, frame):\n frame = cv2.resize(frame, self.tiling_region_size)\n self._normalize(frame, self.tiles, self.inp_handle)\n\n def _generate_tiles(self):\n tile_size = np.asarray(self.model.INPUT_SHAPE[:0:-1])\n tiling_grid = np.asarray(self.tiling_grid)\n step_size = (1 - self.tile_overlap) * tile_size\n total_size = (tiling_grid - 1) * step_size + tile_size\n total_size = np.rint(total_size).astype(int)\n tiles = np.array([to_tlbr((c * step_size[0], r * step_size[1], *tile_size))\n for r in range(tiling_grid[1]) for c in range(tiling_grid[0])])\n return tiles, tuple(total_size)\n\n def _merge_dets(self, detections, tile_ids):\n detections = np.asarray(detections, dtype=DET_DTYPE).view(np.recarray)\n tile_ids = np.asarray(tile_ids)\n if len(detections) == 0:\n return detections\n detections = self._merge(detections, tile_ids, self.batch_size, self.merge_thresh)\n return detections.view(np.recarray)\n\n @staticmethod\n @nb.njit(parallel=True, fastmath=True, cache=True)\n def _normalize(frame, tiles, out):\n imgs = multi_crop(frame, tiles)\n for i in nb.prange(len(imgs)):\n bgr = imgs[i]\n # BGR to RGB\n rgb = bgr[..., ::-1]\n # HWC -> CHW\n chw = rgb.transpose(2, 0, 1)\n # Normalize to [-1.0, 1.0] interval\n out[i] = chw * (2 / 255.) - 1.\n\n @staticmethod\n @nb.njit(fastmath=True, cache=True)\n def _filter_dets(det_out, tiles, topk, label_mask, max_area, thresh, scale_factor):\n detections = []\n tile_ids = []\n for tile_idx in range(len(tiles)):\n tile = tiles[tile_idx]\n size = get_size(tile)\n tile_offset = tile_idx * topk\n for det_idx in range(topk):\n offset = (tile_offset + det_idx) * 7\n label = int(det_out[offset + 1])\n conf = det_out[offset + 2]\n if conf < thresh:\n break\n if label_mask[label]:\n tl = (det_out[offset + 3:offset + 5] * size + tile[:2]) * scale_factor\n br = (det_out[offset + 5:offset + 7] * size + tile[:2]) * scale_factor\n tlbr = as_rect(np.append(tl, br))\n if 0 < area(tlbr) <= max_area:\n detections.append((tlbr, label, conf))\n tile_ids.append(tile_idx)\n return detections, tile_ids\n\n @staticmethod\n @nb.njit(fastmath=True, cache=True)\n def _merge(dets, tile_ids, num_tile, thresh):\n # find duplicate neighbors across tiles\n neighbors = [[0 for _ in range(0)] for _ in range(len(dets))]\n for i, det in enumerate(dets):\n max_ioms = np.zeros(num_tile)\n for j, other in enumerate(dets):\n if tile_ids[i] != tile_ids[j] and det.label == other.label:\n overlap = iom(det.tlbr, other.tlbr)\n # use the detection with the greatest IoM from each tile\n if overlap >= thresh and overlap > max_ioms[tile_ids[j]]:\n max_ioms[tile_ids[j]] = overlap\n neighbors[i].append(j)\n\n # merge neighbors using depth-first search\n keep = set(range(len(dets)))\n stack = []\n for i in range(len(dets)):\n if len(neighbors[i]) > 0 and tile_ids[i] != -1:\n tile_ids[i] = -1\n stack.append(i)\n candidates = []\n while len(stack) > 0:\n for j in neighbors[stack.pop()]:\n if tile_ids[j] != -1:\n candidates.append(j)\n tile_ids[j] = -1\n stack.append(j)\n for k in candidates:\n dets[i].tlbr[:] = union(dets[i].tlbr, dets[k].tlbr)\n dets[i].conf = max(dets[i].conf, dets[k].conf)\n keep.discard(k)\n keep = np.asarray(list(keep))\n return dets[keep]\n\n\nclass YOLODetector(Detector):\n def __init__(self, size, config):\n super().__init__(size)\n self.model = getattr(models, config['model'])\n self.class_ids = config['class_ids']\n self.conf_thresh = config['conf_thresh']\n self.max_area = config['max_area']\n self.nms_thresh = config['nms_thresh']\n\n self.backend = TRTInference(self.model, 1)\n self.inp_handle, self.upscaled_sz, self.bbox_offset = self._create_letterbox()\n\n def detect_async(self, frame):\n self._preprocess(frame)\n self.backend.infer_async(from_device=True)\n\n def postprocess(self):\n det_out = self.backend.synchronize()\n det_out = np.concatenate(det_out).reshape(-1, 7)\n detections = self._filter_dets(det_out, self.upscaled_sz, self.class_ids, self.conf_thresh,\n self.nms_thresh, self.max_area, self.bbox_offset)\n detections = np.asarray(detections, dtype=DET_DTYPE).view(np.recarray)\n return detections\n\n def _preprocess(self, frame):\n frame_dev = cp.asarray(frame)\n # resize\n zoom = np.roll(self.inp_handle.shape, -1) / frame_dev.shape\n small_dev = cupyx.scipy.ndimage.zoom(frame_dev, zoom, order=1, mode='opencv', grid_mode=True)\n # BGR to RGB\n rgb_dev = small_dev[..., ::-1]\n # HWC -> CHW\n chw_dev = rgb_dev.transpose(2, 0, 1)\n # normalize to [0, 1] interval\n cp.multiply(chw_dev, 1 / 255., out=self.inp_handle)\n\n def _create_letterbox(self):\n src_size = np.asarray(self.size)\n dst_size = np.asarray(self.model.INPUT_SHAPE[:0:-1])\n if self.model.LETTERBOX:\n scale_factor = min(dst_size / src_size)\n scaled_size = np.rint(src_size * scale_factor).astype(int)\n img_offset = (dst_size - scaled_size) / 2\n roi = np.s_[:, img_offset[1]:scaled_size[1] + 1, img_offset[0]:scaled_size[0] + 1]\n upscaled_sz = np.rint(dst_size / scale_factor).astype(int)\n bbox_offset = (upscaled_sz - src_size) / 2\n else:\n roi = np.s_[:]\n upscaled_sz = src_size\n bbox_offset = np.zeros(2)\n inp_reshaped = self.backend.input.device.reshape(self.model.INPUT_SHAPE)\n inp_reshaped[:] = 0.5 # initial value for letterbox\n inp_handle = inp_reshaped[roi]\n return inp_handle, upscaled_sz, bbox_offset\n\n @staticmethod\n @nb.njit(fastmath=True, cache=True)\n def _filter_dets(det_out, size, class_ids, conf_thresh, nms_thresh, max_area, offset):\n \"\"\"\n det_out: a list of 3 tensors, where each tensor\n contains a multiple of 7 float32 numbers in\n the order of [x, y, w, h, box_confidence, class_id, class_prob]\n \"\"\"\n # drop detections with low score\n scores = det_out[:, 4] * det_out[:, 6]\n keep = np.where(scores >= conf_thresh)\n det_out = det_out[keep]\n\n # scale to pixel values\n det_out[:, :4] *= np.append(size, size)\n det_out[:, :2] -= offset\n\n keep = []\n for class_id in class_ids:\n class_idx = np.where(det_out[:, 5] == class_id)[0]\n class_dets = det_out[class_idx]\n class_keep = diou_nms(class_dets[:, :4], class_dets[:, 4], nms_thresh)\n keep.extend(class_idx[class_keep])\n keep = np.asarray(keep)\n nms_dets = det_out[keep]\n\n detections = []\n for i in range(len(nms_dets)):\n tlbr = to_tlbr(nms_dets[i, :4])\n # clip inside frame\n tlbr = np.maximum(tlbr, 0)\n tlbr = np.minimum(tlbr, np.append(size, size))\n label = int(nms_dets[i, 5])\n conf = nms_dets[i, 4] * nms_dets[i, 6]\n if 0 < area(tlbr) <= max_area:\n detections.append((tlbr, label, conf))\n return detections\n\n\nclass PublicDetector(Detector):\n def __init__(self, size, frame_skip, config):\n super().__init__(size)\n self.frame_skip = frame_skip\n self.seq_root = Path(__file__).parents[1] / config['sequence']\n self.conf_thresh = config['conf_thresh']\n self.max_area = config['max_area']\n\n seqinfo = configparser.ConfigParser()\n seqinfo.read(self.seq_root / 'seqinfo.ini')\n self.seq_size = (int(seqinfo['Sequence']['imWidth']), int(seqinfo['Sequence']['imHeight']))\n\n self.detections = defaultdict(list)\n self.frame_id = 0\n\n det_txt = self.seq_root / 'det' / 'det.txt'\n for mot_det in np.loadtxt(det_txt, delimiter=','):\n frame_id = int(mot_det[0]) - 1\n tlbr = to_tlbr(mot_det[2:6])\n conf = 1.0 # mot_det[6]\n label = 1 # mot_det[7] (person)\n # scale and clip inside frame\n tlbr[:2] = tlbr[:2] / self.seq_size * self.size\n tlbr[2:] = tlbr[2:] / self.seq_size * self.size\n tlbr = np.maximum(tlbr, 0)\n tlbr = np.minimum(tlbr, np.append(self.size, self.size))\n tlbr = as_rect(tlbr)\n if conf >= self.conf_thresh and area(tlbr) <= self.max_area:\n self.detections[frame_id].append((tlbr, label, conf))\n\n def detect_async(self, frame):\n pass\n\n def postprocess(self):\n detections = np.asarray(self.detections[self.frame_id], dtype=DET_DTYPE).view(np.recarray)\n self.frame_id += self.frame_skip\n return detections\n"
] | [
[
"numpy.concatenate",
"numpy.asarray",
"numpy.zeros",
"numpy.rint",
"numpy.roll",
"numpy.where",
"numpy.loadtxt",
"numpy.prod",
"numpy.append",
"numpy.dtype",
"numpy.maximum"
]
] |
visr/xarray | [
"9e8707d2041cfa038c31fc2284c1fe40bc3368e9"
] | [
"xarray/testing.py"
] | [
"\"\"\"Testing functions exposed to the user API\"\"\"\nfrom __future__ import absolute_import, division, print_function\n\nimport numpy as np\n\nfrom xarray.core import duck_array_ops\n\n\ndef _decode_string_data(data):\n if data.dtype.kind == 'S':\n return np.core.defchararray.decode(data, 'utf-8', 'replace')\n return data\n\n\ndef _data_allclose_or_equiv(arr1, arr2, rtol=1e-05, atol=1e-08,\n decode_bytes=True):\n if any(arr.dtype.kind == 'S' for arr in [arr1, arr2]) and decode_bytes:\n arr1 = _decode_string_data(arr1)\n arr2 = _decode_string_data(arr2)\n exact_dtypes = ['M', 'm', 'O', 'S', 'U']\n if any(arr.dtype.kind in exact_dtypes for arr in [arr1, arr2]):\n return duck_array_ops.array_equiv(arr1, arr2)\n else:\n return duck_array_ops.allclose_or_equiv(\n arr1, arr2, rtol=rtol, atol=atol)\n\n\ndef assert_equal(a, b):\n \"\"\"Like :py:func:`numpy.testing.assert_array_equal`, but for xarray\n objects.\n\n Raises an AssertionError if two objects are not equal. This will match\n data values, dimensions and coordinates, but not names or attributes\n (except for Dataset objects for which the variable names must match).\n Arrays with NaN in the same location are considered equal.\n\n Parameters\n ----------\n a : xarray.Dataset, xarray.DataArray or xarray.Variable\n The first object to compare.\n b : xarray.Dataset, xarray.DataArray or xarray.Variable\n The second object to compare.\n\n See also\n --------\n assert_identical, assert_allclose, Dataset.equals, DataArray.equals,\n numpy.testing.assert_array_equal\n \"\"\"\n import xarray as xr\n __tracebackhide__ = True # noqa: F841\n assert type(a) == type(b) # noqa\n if isinstance(a, (xr.Variable, xr.DataArray, xr.Dataset)):\n assert a.equals(b), '{}\\n{}'.format(a, b)\n else:\n raise TypeError('{} not supported by assertion comparison'\n .format(type(a)))\n\n\ndef assert_identical(a, b):\n \"\"\"Like :py:func:`xarray.testing.assert_equal`, but also matches the\n objects' names and attributes.\n\n Raises an AssertionError if two objects are not identical.\n\n Parameters\n ----------\n a : xarray.Dataset, xarray.DataArray or xarray.Variable\n The first object to compare.\n b : xarray.Dataset, xarray.DataArray or xarray.Variable\n The second object to compare.\n\n See also\n --------\n assert_equal, assert_allclose, Dataset.equals, DataArray.equals\n \"\"\"\n import xarray as xr\n __tracebackhide__ = True # noqa: F841\n assert type(a) == type(b) # noqa\n if isinstance(a, xr.DataArray):\n assert a.name == b.name\n assert_identical(a._to_temp_dataset(), b._to_temp_dataset())\n elif isinstance(a, (xr.Dataset, xr.Variable)):\n assert a.identical(b), '{}\\n{}'.format(a, b)\n else:\n raise TypeError('{} not supported by assertion comparison'\n .format(type(a)))\n\n\ndef assert_allclose(a, b, rtol=1e-05, atol=1e-08, decode_bytes=True):\n \"\"\"Like :py:func:`numpy.testing.assert_allclose`, but for xarray objects.\n\n Raises an AssertionError if two objects are not equal up to desired\n tolerance.\n\n Parameters\n ----------\n a : xarray.Dataset, xarray.DataArray or xarray.Variable\n The first object to compare.\n b : xarray.Dataset, xarray.DataArray or xarray.Variable\n The second object to compare.\n rtol : float, optional\n Relative tolerance.\n atol : float, optional\n Absolute tolerance.\n decode_bytes : bool, optional\n Whether byte dtypes should be decoded to strings as UTF-8 or not.\n This is useful for testing serialization methods on Python 3 that\n return saved strings as bytes.\n\n See also\n --------\n assert_identical, assert_equal, numpy.testing.assert_allclose\n \"\"\"\n import xarray as xr\n __tracebackhide__ = True # noqa: F841\n assert type(a) == type(b) # noqa\n kwargs = dict(rtol=rtol, atol=atol, decode_bytes=decode_bytes)\n if isinstance(a, xr.Variable):\n assert a.dims == b.dims\n allclose = _data_allclose_or_equiv(a.values, b.values, **kwargs)\n assert allclose, '{}\\n{}'.format(a.values, b.values)\n elif isinstance(a, xr.DataArray):\n assert_allclose(a.variable, b.variable, **kwargs)\n assert set(a.coords) == set(b.coords)\n for v in a.coords.variables:\n # can't recurse with this function as coord is sometimes a\n # DataArray, so call into _data_allclose_or_equiv directly\n allclose = _data_allclose_or_equiv(a.coords[v].values,\n b.coords[v].values, **kwargs)\n assert allclose, '{}\\n{}'.format(a.coords[v].values,\n b.coords[v].values)\n elif isinstance(a, xr.Dataset):\n assert set(a.data_vars) == set(b.data_vars)\n assert set(a.coords) == set(b.coords)\n for k in list(a.variables) + list(a.coords):\n assert_allclose(a[k], b[k], **kwargs)\n\n else:\n raise TypeError('{} not supported by assertion comparison'\n .format(type(a)))\n\n\ndef assert_combined_tile_ids_equal(dict1, dict2):\n assert len(dict1) == len(dict2)\n for k, v in dict1.items():\n assert k in dict2.keys()\n assert_equal(dict1[k], dict2[k])\n\n"
] | [
[
"numpy.core.defchararray.decode"
]
] |
JanCVanB/netflix | [
"e3ff4feab832846640dbb3daa5877ef84a00adaf"
] | [
"utils/data_io.py"
] | [
"\"\"\"Reading and writing tools for interfacing with the large data files\n\n.. moduleauthor:: Jan Van Bruggen <[email protected]>\n\"\"\"\nfrom __future__ import print_function\nimport numpy as np\n\n\ndef _generate_points_from_index(correct_index):\n from utils.data_paths import ALL_DATA_FILE_PATH, ALL_INDEX_FILE_PATH\n indices_generator = indices(ALL_INDEX_FILE_PATH)\n count = 0\n for point in data_points(ALL_DATA_FILE_PATH):\n index = next(indices_generator)\n if index == correct_index:\n if not count % 10000:\n print(count, 'points generated')\n count += 1\n yield point\n\n\ndef all_points():\n from utils.data_paths import ALL_DATA_FILE_PATH\n count = 0\n for data_point in data_points(ALL_DATA_FILE_PATH):\n if not count % 10000:\n print(count, 'points generated')\n count += 1\n yield data_point\n\n\ndef base_points():\n from utils.constants import BASE_INDEX\n for point in _generate_points_from_index(BASE_INDEX):\n yield point\n\n\ndef data_points(data_file_path):\n with open(data_file_path) as data_file:\n for line in data_file:\n yield line.strip().split()\n\n\ndef get_user_movie_time_rating(data_point):\n from utils.constants import (MOVIE_INDEX, RATING_INDEX, TIME_INDEX,\n USER_INDEX)\n user = data_point[USER_INDEX]\n movie = data_point[MOVIE_INDEX]\n time = data_point[TIME_INDEX]\n rating = data_point[RATING_INDEX]\n return user, movie, time, rating\n\n\ndef hidden_points():\n from utils.constants import HIDDEN_INDEX\n for point in _generate_points_from_index(HIDDEN_INDEX):\n yield point\n\n\ndef indices(index_file_path):\n with open(index_file_path) as index_file:\n for line in index_file:\n yield int(line.strip())\n\n\ndef probe_points():\n from utils.constants import PROBE_INDEX\n for point in _generate_points_from_index(PROBE_INDEX):\n yield point\n\n\ndef qual_points():\n from utils.constants import QUAL_INDEX\n for point in _generate_points_from_index(QUAL_INDEX):\n yield point\n\n\ndef valid_points():\n from utils.constants import VALID_INDEX\n for point in _generate_points_from_index(VALID_INDEX):\n yield point\n\n\ndef write_submission(ratings, submission_file_name):\n import os\n from utils.data_paths import SUBMISSIONS_DIR_PATH\n submission_file_path = os.path.join(SUBMISSIONS_DIR_PATH,\n submission_file_name)\n with open(submission_file_path, 'w+') as submission_file:\n submission_file.writelines(['{:.3f}\\n'.format(r) for r in ratings])\n\n\ndef load_numpy_array_from_file(file_name):\n return np.load(file_name)\n"
] | [
[
"numpy.load"
]
] |
EpicTrol/SCNU-AiMatch | [
"f67512be7aaf8aff1f8cda799d3e843e2f96a33e"
] | [
"one_hot_encoding.py"
] | [
"# -*- coding: UTF-8 -*-\nimport numpy as np\nimport captcha_setting\n\n\ndef encode(text):\n vector = np.zeros(captcha_setting.ALL_CHAR_SET_LEN * captcha_setting.MAX_CAPTCHA, dtype=float)\n def char2pos(c):\n if c =='_':\n k = 62\n return k\n k = ord(c)-48\n if k > 9:\n k = ord(c) - 65 + 10\n if k > 35:\n k = ord(c) - 97 + 26 + 10\n if k > 61:\n raise ValueError('error')\n return k\n for i, c in enumerate(text):\n idx = i * captcha_setting.ALL_CHAR_SET_LEN + char2pos(c)\n vector[idx] = 1.0\n return vector\n\ndef decode(vec):\n char_pos = vec.nonzero()[0]\n text=[]\n for i, c in enumerate(char_pos):\n char_at_pos = i #c/63\n char_idx = c % captcha_setting.ALL_CHAR_SET_LEN\n if char_idx < 10:\n char_code = char_idx + ord('0')\n elif char_idx <36:\n char_code = char_idx - 10 + ord('A')\n elif char_idx < 62:\n char_code = char_idx - 36 + ord('a')\n elif char_idx == 62:\n char_code = ord('_')\n else:\n raise ValueError('error')\n text.append(chr(char_code))\n return \"\".join(text)\n\nif __name__ == '__main__':\n e = encode(\"BK7H\")\n print(e[62:124])\n print(decode(e))"
] | [
[
"numpy.zeros"
]
] |
CoEich/gpt-neox | [
"49e60fe7ad14f6991a7fa678d3a0c330d09b9ff4"
] | [
"megatron/utils.py"
] | [
"# coding=utf-8\n\n# Copyright (c) 2021 Josh Levy-Kramer <[email protected]>.\n# This file is based on code by the authors denoted below and has been modified from its original version.\n#\n# Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n\"\"\"General utilities.\"\"\"\nimport os\nimport sys\nimport re\nimport time\nimport socket\nfrom typing import Dict, List\n\nimport requests\nimport wandb\nfrom wandb import UsageError\n\nimport torch\n\nfrom deepspeed.launcher.runner import fetch_hostfile, parse_inclusion_exclusion\n\nfrom megatron import print_rank_0\nfrom megatron import mpu\nfrom deepspeed import PipelineEngine, DeepSpeedEngine\nfrom collections import deque\n\n\ndef reduce_losses(losses):\n \"\"\"Reduce a tensor of losses across all GPUs.\"\"\"\n reduced_losses = torch.cat([loss.clone().detach().view(1) for loss in losses])\n torch.distributed.all_reduce(reduced_losses)\n reduced_losses = reduced_losses / torch.distributed.get_world_size()\n return reduced_losses\n\n\ndef report_memory(name):\n \"\"\"Simple GPU memory report.\"\"\"\n mega_bytes = 1024.0 * 1024.0\n string = name + \" memory (MB)\"\n string += \" | allocated: {}\".format(torch.cuda.memory_allocated() / mega_bytes)\n string += \" | max allocated: {}\".format(\n torch.cuda.max_memory_allocated() / mega_bytes\n )\n string += \" | reserved: {}\".format(torch.cuda.memory_reserved() / mega_bytes)\n string += \" | max reserved: {}\".format(\n torch.cuda.max_memory_reserved() / mega_bytes\n )\n print_rank_0(string)\n\ndef get_attn_mask(seq_length, device):\n \"\"\"\n Get triangular attention mask for a given sequence length / device.\n \"\"\"\n # lower triangular attention mask\n mask = torch.tril(torch.ones(\n (1, seq_length, seq_length), device=device)).view(\n 1, 1, seq_length, seq_length)\n \n # convert to binary\n return (mask < 0.5)\n\ndef get_ltor_masks_and_position_ids(data,\n eod_token,\n eod_mask_loss=False):\n \"\"\"Build masks and position id for left to right model.\"\"\"\n\n # Extract batch size and sequence length.\n batch_size, seq_length = data.size()\n\n # Attention mask (lower triangular).\n attention_mask = get_attn_mask(seq_length=seq_length, device=data.device)\n\n # Loss mask.\n loss_mask = torch.ones(data.size(), dtype=torch.float, device=data.device)\n if eod_mask_loss:\n loss_mask[data == eod_token] = 0.0\n\n # Position ids.\n position_ids = torch.arange(seq_length, dtype=torch.long, device=data.device)\n position_ids = position_ids.unsqueeze(0).expand_as(data)\n\n return attention_mask, loss_mask, position_ids\n\n\ndef local_rank():\n \"\"\" Local rank of process \"\"\"\n local_rank = os.environ.get(\"LOCAL_RANK\")\n if local_rank is None:\n print(\n \"utils.local_rank() environment variable LOCAL_RANK not set, defaulting to 0\",\n flush=True,\n )\n local_rank = 0\n return int(local_rank)\n\ndef is_bnb_available():\n \"\"\" True if bitsandbytes optimizers are available \"\"\"\n return importlib.util.find_spec(\"bitsandbytes\") is not None\n\ndef is_local_main():\n \"\"\" True if is the local main process \"\"\"\n return local_rank() == 0\n\n\ndef is_mp_rank_0():\n \"\"\"True if mp rank == 0\"\"\"\n return mpu.get_model_parallel_rank() == 0\n\n\ndef get_wandb_api_key(neox_args):\n \"\"\" Get Weights and Biases API key from ENV or .netrc file. Otherwise return None \"\"\"\n if \"WANDB_LOCAL\" in os.environ:\n return \"LOCAL\"\n if \"WANDB_API_KEY\" in os.environ:\n return os.environ[\"WANDB_API_KEY\"]\n\n wandb_token = requests.utils.get_netrc_auth(neox_args.wandb_host)\n\n if wandb_token is not None:\n return wandb_token[1]\n\n\ndef init_wandb(neox_args):\n # Wandb. (one worker per machine)\n if neox_args.use_wandb == False:\n return\n\n use_wandb = is_local_main() and (get_wandb_api_key(neox_args=neox_args) is not None)\n neox_args.update_value(\"use_wandb\", use_wandb)\n if neox_args.use_wandb:\n group_name = neox_args.wandb_group\n name = f\"{socket.gethostname()}-{local_rank()}\" if group_name else None\n try:\n wandb.init(\n project=neox_args.wandb_project,\n group=group_name,\n name=name,\n save_code=False,\n force=False,\n entity=neox_args.wandb_team,\n )\n except UsageError as e:\n neox_args.update_value(\"use_wandb\", False)\n print(e)\n print(\n \"Skipping wandb. Execute `wandb login` on local or main node machine to enable.\",\n flush=True,\n )\n wandb.config.update(neox_args.all_config)\n\n\ndef obtain_resource_pool(\n hostfile_path, include_arg, exclude_arg\n) -> Dict[str, List[int]]:\n \"\"\"\n Get dict of `resource_pool[hostname] = [list of GPU ranks]` using hostfile, include and exclude args.\n Modified from: `deepspeed.launcher.runner.main`\n \"\"\"\n resource_pool = fetch_hostfile(hostfile_path)\n if not resource_pool:\n resource_pool = {}\n device_count = torch.cuda.device_count()\n if device_count == 0:\n raise RuntimeError(\"Unable to proceed, no GPU resources available\")\n resource_pool[\"localhost\"] = device_count\n\n active_resources = parse_inclusion_exclusion(\n resource_pool, include_arg, exclude_arg\n )\n return active_resources\n\n\ndef natural_sort(l):\n convert = lambda text: int(text) if text.isdigit() else text.lower()\n alphanum_key = lambda key: [convert(c) for c in re.split(\"([0-9]+)\", key)]\n return sorted(l, key=alphanum_key)\n\n\ndef ddb(rank=0):\n \"\"\"\n Distributed Debugger that will insert a py debugger on rank `rank` and\n pause all other distributed processes until debugging is complete.\n :param rank:\n \"\"\"\n if torch.distributed.get_rank() == rank:\n from pdb import Pdb\n\n pdb = Pdb(skip=[\"torch.distributed.*\"])\n pdb.set_trace(sys._getframe().f_back)\n torch.distributed.barrier()\n\n\nclass Timer:\n \"\"\"Timer.\"\"\"\n\n def __init__(self, name):\n self.name_ = name\n self.elapsed_ = 0.0\n self.started_ = False\n self.start_time = time.time()\n\n def start(self):\n \"\"\"Start the timer.\"\"\"\n assert not self.started_, \"timer has already been started\"\n torch.cuda.synchronize()\n self.start_time = time.time()\n self.started_ = True\n\n def stop(self):\n \"\"\"Stop the timer.\"\"\"\n assert self.started_, \"timer is not started\"\n torch.cuda.synchronize()\n self.elapsed_ += time.time() - self.start_time\n self.started_ = False\n\n def reset(self):\n \"\"\"Reset timer.\"\"\"\n self.elapsed_ = 0.0\n self.started_ = False\n\n def elapsed(self, reset=True):\n \"\"\"Calculate the elapsed time.\"\"\"\n started_ = self.started_\n # If the timing in progress, end it first.\n if self.started_:\n self.stop()\n # Get the elapsed time.\n elapsed_ = self.elapsed_\n # Reset the elapsed time\n if reset:\n self.reset()\n # If timing was in progress, set it back.\n if started_:\n self.start()\n return elapsed_\n\n\nclass Timers:\n \"\"\"Group of timers.\"\"\"\n\n def __init__(self, use_wandb, tensorboard_writer):\n self.timers = {}\n self.use_wandb = use_wandb\n self.tensorboard_writer = tensorboard_writer\n\n def __call__(self, name):\n if name not in self.timers:\n self.timers[name] = Timer(name)\n return self.timers[name]\n\n def write(self, names, iteration, normalizer=1.0, reset=False):\n \"\"\"Write timers to a tensorboard writer\"\"\"\n # currently when using add_scalars,\n # torch.utils.add_scalars makes each timer its own run, which\n # polutes the runs list, so we just add each as a scalar\n assert normalizer > 0.0\n for name in names:\n value = self.timers[name].elapsed(reset=reset) / normalizer\n\n if self.tensorboard_writer:\n self.tensorboard_writer.add_scalar(f\"timers/{name}\", value, iteration)\n\n if self.use_wandb:\n wandb.log({f\"timers/{name}\": value}, step=iteration)\n\n def log(self, names, normalizer=1.0, reset=True):\n \"\"\"Log a group of timers.\"\"\"\n assert normalizer > 0.0\n string = \"time (ms)\"\n for name in names:\n elapsed_time = self.timers[name].elapsed(reset=reset) * 1000.0 / normalizer\n string += \" | {}: {:.2f}\".format(name, elapsed_time)\n if torch.distributed.is_initialized():\n if torch.distributed.get_rank() == 0:\n print(string, flush=True)\n else:\n print(string, flush=True)\n\n\ndef expand_attention_types(attention_config, num_layers):\n \"\"\"\n Expands an `attention_config` list in the following format:\n\n [\n [['attention_type_1', ..., `attention_type_n`], 12]\n ]\n\n to a flattened list of length `num_layers`.\n\n :param params_list:\n :return:\n \"\"\"\n # if only strings are found in the config, we assume it's already expanded\n if all([isinstance(i, str) for i in attention_config]):\n return attention_config\n newlist = []\n for item in attention_config:\n # instead of specifying a number - we can specify 'all' to extend this pattern across all layers\n if item[1] == \"all\":\n assert num_layers % len(item[0]) == 0, (\n f\"Number of layers ({num_layers}) is not divisible by the length \"\n f\"of pattern: {item[0]}\"\n )\n return item[0] * (num_layers // len(item[0]))\n for _ in range(item[1]):\n newlist.extend(item[0])\n return newlist\n\n\nclass OverflowMonitor:\n\n \"\"\"\n Checks if the past n iterations have been skipped due to overflow, and exits\n training if that happens.\n \"\"\"\n\n def __init__(self, optimizer, n=50):\n self.optimizer = optimizer\n self.n = n\n self.history = deque(maxlen=n)\n\n def check(self, skipped):\n self.history.append(skipped)\n if (\n self.optimizer.overflow\n and len(self.history) == self.n\n and all(self.history)\n ):\n raise Exception(\n f\"Skipped {self.n} iterations in a row due to Overflow - Exiting training.\"\n )\n\n\ndef get_noise_scale_logger(neox_args):\n if neox_args.log_gradient_noise_scale:\n if neox_args.zero_stage >= 1:\n raise NotImplementedError(\n \"Gradient Noise Scale logging does not work with zero stage 2+, as the \"\n \"gradients are distributed across ranks.\"\n )\n noise_scale_logger = GradientNoiseScale(\n model=model,\n batch_size_small=neox_args.train_batch_size,\n n_batches=neox_args.gradient_noise_scale_n_batches,\n cpu_offload=neox_args.gradient_noise_scale_cpu_offload,\n neox_args=neox_args,\n mpu=mpu,\n )\n else:\n noise_scale_logger = None\n return noise_scale_logger\n\n\ndef get_total_params(model):\n # Print number of parameters.\n if mpu.get_data_parallel_rank() == 0:\n params = sum([p.nelement() for p in model.parameters()])\n print(\n \" > number of parameters on model parallel rank {}: {}\".format(\n mpu.get_model_parallel_rank(), params\n ),\n flush=True,\n )\n else:\n params = 0\n\n total_n_parameters = torch.tensor([params]).cuda(torch.cuda.current_device())\n torch.distributed.all_reduce(total_n_parameters)\n total_n_parameters = total_n_parameters.item()\n return total_n_parameters\n\n\ndef setup_for_inference_or_eval(\n inference=True, get_key_value=True, overwrite_values=None\n):\n \"\"\"\n Initializes the model for evaluation or inference (doesn't load optimizer states, etc.) from command line args.\n\n inference: bool\n Whether to initialize in inference mode\n get_key_value: bool\n Whether to use key value caching in inference.\n overwrite_values: dict\n Optional Values to overwrite in the model config.\n \"\"\"\n\n from megatron.neox_arguments import NeoXArgs\n from megatron.initialize import initialize_megatron\n from megatron.training import setup_model_and_optimizer\n\n _overwrite_values = {\n \"checkpoint_activations\": False,\n \"partition_activations\": False,\n \"no_load_optim\": True,\n 'zero_optimization': None, # disable zero optimization (won't be used in inference, and loading zero optimizer can cause errors)\n }\n if overwrite_values:\n _overwrite_values.update(overwrite_values)\n neox_args = NeoXArgs.consume_neox_args(overwrite_values=_overwrite_values)\n neox_args.configure_distributed_args()\n neox_args.build_tokenizer()\n\n if neox_args.load is None:\n raise ValueError(\"`load` parameter must be supplied to load a model`\")\n\n # initialize megatron\n initialize_megatron(neox_args)\n\n # set up model and load checkpoint.\n model, _, _ = setup_model_and_optimizer(\n neox_args=neox_args, inference=inference, get_key_value=get_key_value\n ) # we use setup_model_and_optimizer instead of get_model in order to initialize deepspeed\n print_rank_0(\"Finished loading model\")\n return model, neox_args\n\n\nclass CharCounter:\n \"\"\"\n Wraps the data_iterator to count the number of characters in a batch\n \"\"\"\n\n def __init__(self, data_iterator, tokenizer):\n self.tokenizer = tokenizer\n self.data_iterator = data_iterator\n self.char_count = 0\n self.batch_count = 0\n self.token_count = 0\n self.total_time = 0\n\n def tokens_per_char(self):\n return self.token_count / self.char_count\n\n def __iter__(self):\n return self\n\n def __next__(self):\n start = time.time()\n batch = self.data_iterator.__next__()\n for b in batch[\"text\"]:\n self.token_count += len(b)\n self.char_count += len(self.tokenizer.detokenize(b.tolist()))\n self.batch_count += 1\n end = time.time()\n self.total_time += end - start\n return batch\n"
] | [
[
"torch.distributed.get_world_size",
"torch.cuda.synchronize",
"torch.arange",
"torch.cuda.max_memory_allocated",
"torch.cuda.memory_allocated",
"torch.cuda.device_count",
"torch.cuda.current_device",
"torch.distributed.is_initialized",
"torch.cuda.max_memory_reserved",
"torch.cuda.memory_reserved",
"torch.tensor",
"torch.distributed.all_reduce",
"torch.ones",
"torch.distributed.get_rank",
"torch.distributed.barrier"
]
] |
jainajinkya/snopt-python | [
"832a12c2422d23bbd7d3a476a3a3ae50ac7fc84f"
] | [
"solvers/solution.py"
] | [
"import os, sys\nimport numpy as np\n\n#-------------------------------------------------------------------------------#\nclass SQIC_solution(object):\n '''\n SQIC_solution class:\n '''\n def __init__ (self,name=''):\n self.setup(name)\n\n def setup(self,name):\n self.name = name\n self.x = None\n self.basis = None\n self.z = None\n self.bl = None\n self.bu = None\n self.info = 0\n self.iterations = 0\n self.numinf = 0\n self.suminf = 0.\n self.objective = 0.\n\n def __str__(self):\n text = ''.join('-' for j in range(82)) + '\\n'\n text+= ' SQIC Results for problem ' + self.name + '\\n'\n text+= ' EXIT code = ' + repr(self.info) + '\\n'\n text+= ' Final objective = ' + repr(self.objective) + '\\n'\n text+= ' Total # iterations = ' + repr(self.iterations) + '\\n'\n\n try:\n soln = ' state(j) low(j) x(j) upp(j) mul(j)\\n'\n form = ' {0:8d}{1:16.6e}{2:16.6e}{3:16.6e}{4:16.6e}'\n for hsj,blj,xj,buj,zj in np.nditer([self.basis,self.bl,self.x,self.bu,self.z]):\n soln+= form.format(hsj,blj,xj,buj,zj) + '\\n'\n soln+= ''.join('-' for j in range(82))\n text+= soln\n except:\n pass\n return text\n\n#-------------------------------------------------------------------------------#\nclass SNOPTA_solution(object):\n '''\n SNOPTA_solution class:\n '''\n def __init__ (self,name='',xnames=None,Fnames=None):\n self.setup(name,xnames,Fnames)\n\n def setup(self,name,xnames,Fnames):\n self.name = name\n self.xnames = xnames\n self.Fnames = Fnames\n\n self.x = None\n self.xstates = None\n self.xmul = None\n self.F = None\n self.Fstates = None\n self.Fmul = None\n self.info = 0\n\n self.iterations = 0\n self.major_itns = 0\n self.nS = 0\n self.num_inf = 0\n self.sum_inf = 0.\n self.objective = 0.\n\n def __str__(self):\n text = ''.join('-' for j in range(82)) + '\\n'\n text+= ' SNOPTA Results for problem ' + self.name + '\\n'\n text+= ' EXIT code = ' + repr(self.info) + '\\n'\n text+= ' Final objective = ' + repr(self.objective) + '\\n'\n text+= ' Total # iterations = ' + repr(self.iterations) + '\\n'\n\n form = '{:>8s}{:>10s}{:>16s}{:>16s}'\n text+= form.format('Name','xstate(j)','x(j)','xmul(j)') + '\\n'\n\n form = '{0:>8s}{1:10d}{2:16.6e}{3:16.6e}'\n\n n = self.x.size\n if len(self.xnames) == 1:\n arrays = zip([repr(j) for j in range(n)],self.xstates,self.x,self.xmul)\n else:\n arrays = zip(np.char.decode(self.xnames),self.xstates,self.x,self.xmul)\n\n for namej,hsj,xj,xmj in arrays:\n text+= form.format(namej,hsj,xj,xmj) + '\\n'\n\n\n form = '{:>8s}{:>10s}{:>16s}{:>16s}'\n text+= form.format('Name','Fstate(j)','F(j)','Fmul(j)') + '\\n'\n\n form = '{0:>8s}{1:10d}{2:16.6e}{3:16.6e}'\n\n n = self.F.size\n if len(self.Fnames) == 1:\n arrays = zip([repr(j) for j in range(n)],self.Fstates,self.F,self.Fmul)\n else:\n arrays = zip(np.char.decode(self.Fnames),self.Fstates,self.F,self.Fmul)\n\n for namej,hsj,xj,xmj in arrays:\n text+= form.format(namej,hsj,xj,xmj) + '\\n'\n\n return text\n\n#-------------------------------------------------------------------------------#\nclass SNOPT_solution(object):\n '''\n SNOPT_solution class:\n '''\n def __init__ (self,name='',Names=None):\n self.setup(name,Names)\n\n def setup(self,name,Names):\n self.name = name\n self.Names = Names\n self.states = None\n self.x = None\n self.pi = None\n self.rc = None\n self.info = 0\n\n self.iterations = 0\n self.major_itns = 0\n self.nS = 0\n self.num_inf = 0\n self.sum_inf = 0.\n self.objective = 0.\n\n def __str__(self):\n text = ''.join('-' for j in range(82)) + '\\n'\n text+= ' SNOPT Results for problem ' + self.name + '\\n'\n text+= ' EXIT code = ' + repr(self.info) + '\\n'\n text+= ' Final objective = ' + repr(self.objective) + '\\n'\n text+= ' Total # iterations = ' + repr(self.iterations) + '\\n'\n\n form = '{:>8s}{:>10s}{:>16s}{:>16s}'\n text+= form.format('Name','state(j)','x(j)','mul(j)') + '\\n'\n\n form = '{0:>8s}{1:10d}{2:16.6e}{3:16.6e}'\n if len(self.Names) == 1:\n n = self.x.size\n arrays = zip([repr(j) for j in range(n)],self.states,self.x,self.rc)\n else:\n arrays = zip(np.char.decode(self.Names),self.states,self.x,self.rc)\n\n for namej,hsj,xj,xmj in arrays:\n text+= form.format(namej,hsj,xj,xmj) + '\\n'\n\n return text\n\n#-------------------------------------------------------------------------------#\nclass DNOPT_solution(object):\n '''\n DNOPT_solution class:\n '''\n def __init__ (self,name='',Names=None):\n self.setup(name,Names)\n\n def setup(self,name,Names):\n self.name = name\n self.Names = Names\n self.states = None\n self.x = None\n self.y = None\n self.info = 0\n\n self.iterations = 0\n self.major_itns = 0\n self.num_inf = 0\n self.sum_inf = 0.\n self.objective = 0.\n\n self.f = None\n self.gObj = None\n self.fCon = None\n self.J = None\n self.H = None\n\n def __str__(self):\n text = ''.join('-' for j in range(82)) + '\\n'\n text+= ' DNOPT Results for problem ' + self.name + '\\n'\n text+= ' EXIT code = ' + repr(self.info) + '\\n'\n text+= ' Final objective = ' + repr(self.objective) + '\\n'\n text+= ' Total # iterations = ' + repr(self.iterations) + '\\n'\n\n form = '{:>8s}{:>10s}{:>16s}{:>16s}'\n text+= form.format('Name','state(j)','x(j)','mul(j)') + '\\n'\n\n form = '{0:>8s}{1:10d}{2:16.6e}{3:16.6e}'\n if len(self.Names) == 1:\n n = self.x.size\n arrays = zip([repr(j) for j in range(n)],self.states,self.x,self.y)\n else:\n arrays = zip(np.char.decode(self.Names),self.states,self.x,self.y)\n\n for namej,hsj,xj,xmj in arrays:\n text+= form.format(namej,hsj,xj,xmj) + '\\n'\n\n return text\n"
] | [
[
"numpy.char.decode",
"numpy.nditer"
]
] |
FredHutch/map_viruses | [
"92186d4024c67b708ee652f232e8878e403fb661"
] | [
"map_viruses.py"
] | [
"#!/usr/bin/python\n\"\"\"Wrapper script to align FASTQ file(s) against a set of viral genomes.\"\"\"\n\nimport os\nimport uuid\nimport time\nimport shutil\nimport logging\nimport argparse\nimport pandas as pd\nfrom lib.exec_helpers import align_reads\nfrom lib.exec_helpers import return_results\nfrom lib.exec_helpers import return_alignments\nfrom lib.exec_helpers import exit_and_clean_up\nfrom lib.exec_helpers import get_reference_database\nfrom lib.fastq_helpers import get_reads_from_url\nfrom lib.fastq_helpers import count_fastq_reads\nfrom lib.aln_helpers import parse_alignment\nfrom lib.aln_helpers import summarize_genomes\n\nif __name__ == \"__main__\":\n parser = argparse.ArgumentParser(description=\"\"\"\n Align a set of reads against a reference database with DIAMOND,\n calculate per-genome coverage metrics, and save the results.\n \"\"\")\n\n parser.add_argument(\"--input\",\n type=str,\n required=True,\n help=\"\"\"Location for input file(s). Comma-separated.\n (Supported: sra://, s3://, or ftp://).\"\"\")\n parser.add_argument(\"--ref-db\",\n type=str,\n required=True,\n help=\"\"\"DIAMOND-formatted reference database (ending .dmnd).\n (Supported: s3://, ftp://, or local path).\"\"\")\n parser.add_argument(\"--metadata\",\n type=str,\n required=True,\n help=\"TSV with metadata linking proteins and genomes.\")\n parser.add_argument(\"--output-path\",\n type=str,\n required=True,\n help=\"\"\"Folder to place results [ending with .json.gz].\n (Supported: s3://, or local path).\"\"\")\n parser.add_argument(\"--overwrite\",\n action=\"store_true\",\n help=\"\"\"Overwrite output files. Off by default.\"\"\")\n parser.add_argument(\"--blocks\",\n type=int,\n default=5,\n help=\"\"\"Number of blocks used when aligning.\n Value relates to the amount of memory used.\"\"\")\n parser.add_argument(\"--query-gencode\",\n type=int,\n default=11,\n help=\"Genetic code used to translate nucleotides.\")\n parser.add_argument(\"--threads\",\n type=int,\n default=16,\n help=\"Number of threads to use aligning.\")\n parser.add_argument(\"--keep-alignments\",\n action=\"store_true\",\n help=\"Return the raw alignment files.\")\n parser.add_argument(\"--temp-folder\",\n type=str,\n default='/share',\n help=\"Folder used for temporary files.\")\n\n args = parser.parse_args()\n\n # Make sure that the output path ends with .json.gz\n assert args.output_path.endswith(\".json.gz\")\n\n # Make sure that the input doesn't have any odd characters\n for k in [\",\", \"+\", \" \"]:\n assert k not in args.input\n\n # Make a temporary folder for all files to be placed in\n temp_folder = os.path.join(args.temp_folder, str(uuid.uuid4())[:8])\n assert os.path.exists(temp_folder) is False\n os.mkdir(temp_folder)\n\n # Set up logging\n log_fp = os.path.join(temp_folder, \"log.txt\")\n logFormatter = logging.Formatter(\n '%(asctime)s %(levelname)-8s [map_viruses.py] %(message)s'\n )\n rootLogger = logging.getLogger()\n rootLogger.setLevel(logging.INFO)\n\n # Write to file\n fileHandler = logging.FileHandler(log_fp)\n fileHandler.setFormatter(logFormatter)\n rootLogger.addHandler(fileHandler)\n # Also write to STDOUT\n consoleHandler = logging.StreamHandler()\n consoleHandler.setFormatter(logFormatter)\n rootLogger.addHandler(consoleHandler)\n\n # Get the reference database files\n try:\n db_fp = get_reference_database(\n args.ref_db,\n temp_folder,\n ending=\".dmnd\"\n )\n except:\n exit_and_clean_up(temp_folder)\n\n logging.info(\"Reference database: \" + db_fp)\n\n try:\n metadata_fp = get_reference_database(\n args.metadata,\n temp_folder\n )\n except:\n exit_and_clean_up(temp_folder)\n\n logging.info(\"Metadata file: \" + metadata_fp)\n\n try:\n metadata = pd.read_table(metadata_fp, sep='\\t')\n except:\n exit_and_clean_up(temp_folder)\n\n logging.info(\"Read in metadata file\")\n\n # Align each of the inputs and calculate the overall abundance\n\n # Keep track of the time elapsed to process the sample\n start_time = time.time()\n\n logging.info(\"Processing input argument: \" + args.input)\n\n # Capture each command in a try statement\n # Get the input reads\n try:\n read_fp = get_reads_from_url(args.input, temp_folder)\n except:\n exit_and_clean_up(temp_folder)\n\n # Run the alignment\n try:\n align_fp = align_reads(\n read_fp, # FASTQ file path\n db_fp, # Local path to DB\n temp_folder, # Folder for results\n query_gencode=args.query_gencode,\n threads=args.threads,\n blocks=args.blocks,\n )\n except:\n exit_and_clean_up(temp_folder)\n\n # Process the alignments, calculating genome coverage\n try:\n protein_abund = parse_alignment(align_fp)\n except:\n exit_and_clean_up(temp_folder)\n\n # From a set of alignments against proteins, summarize the genome\n protein_abund, genome_dat = summarize_genomes(protein_abund, metadata)\n\n # Count the total number of reads\n logging.info(\"Counting the total number of reads\")\n n_reads = count_fastq_reads(read_fp)\n logging.info(\"Reads in input file: {}\".format(n_reads))\n\n # If --keep-alignments is given, return the alignment file\n if args.keep_alignments:\n return_alignments(align_fp, args.output_path.replace(\".json.gz\", \".sam.gz\"))\n\n # Read in the logs\n logging.info(\"Reading in the logs\")\n logs = open(log_fp, 'rt').readlines()\n\n # Wrap up all of the results into a single JSON\n # and write it to the output folder\n output = {\n \"input\": args.input,\n \"output_path\": args.output_path,\n \"logs\": logs,\n \"ref_db\": db_fp,\n \"ref_db_url\": args.ref_db,\n \"results\": {\n \"proteins\": protein_abund,\n \"genomes\": genome_dat,\n },\n \"total_reads\": n_reads,\n \"time_elapsed\": time.time() - start_time\n }\n return_results(\n output, args.output_path, temp_folder\n )\n\n # Delete any files that were created for this sample\n logging.info(\"Removing temporary folder: \" + temp_folder)\n shutil.rmtree(temp_folder)\n\n # Stop logging\n logging.info(\"Done\")\n logging.shutdown()\n"
] | [
[
"pandas.read_table"
]
] |
shashanksira13/ITSP | [
"7fba20d04c327c5cbc276b89e32d949a61ffed48"
] | [
"MIL Simulation/image_gen.py"
] | [
"def image_generate():\r\n #This function doesn't have any parameter the input file from which the acceleration values are taken is called \r\n #'acc.csv'\r\n #Here t is the smapling time \r\n #The created images are saved by the name 'image_<num>.jpeg' where num is the serial number corresponding to the image \r\n #generated at different stages of image processing and the final csv file is named as 'image_final.csv'\r\n \r\n #Calling the required libraries\r\n #%matplotlib inline\r\n import numpy as np\r\n from matplotlib import pyplot as plt\r\n import PIL\r\n from PIL import Image \r\n\r\n \r\n \r\n #acc.csv file will contain the the x and y accerlation with sampling rate,t\r\n t = 1/50 #sampling time\r\n file = 'acc.csv' #input file\r\n data_x = [] #array to store x acceleration \r\n data_y = [] #array to store y acceleration\r\n num_points = 0 #number of data points \r\n\r\n with open(file, \"r\") as f: #,encoding = \"utf-16\" <--add this inside open() incase of encoding error\r\n for row in f:\r\n num_points += 1\r\n elements = row.split(',')\r\n data_x.append(float(elements[0]))\r\n data_y.append(float(elements[1]))\r\n\r\n data_x.reverse()\r\n data_y.reverse()\r\n #I've reversed the just in case if the file contains the data in the order of newest to oldest\r\n \r\n \r\n\r\n\r\n #The following block of code does the integration to convert the acc points into position points\r\n #Initialising the velocity and position to be zero\r\n #velocity[i] = velocity[i-1] + (acc[i]+acc[i-1])/2 * t\r\n #position[i] = position[i-1] + (velocity[i]+velocity[i-1])/2 * t\r\n velo_x = [0]\r\n velo_y = [0]\r\n pos_x = [0]\r\n pos_y = [0]\r\n\r\n velo_x.append(data_x[0]/2*t)\r\n velo_y.append(data_y[0]/2*t)\r\n\r\n\r\n for i in range(1,num_points):\r\n pos_x.append((velo_x[i]+velo_x[i-1])/2*t+pos_x[i-1])\r\n pos_y.append((velo_y[i]+velo_y[i-1])/2*t+pos_y[i-1])\r\n \r\n velo_x.append((data_x[i]+data_x[i-1])/2*t+velo_x[i-1])\r\n velo_y.append((data_y[i]+data_y[i-1])/2*t+velo_y[i-1])\r\n\r\n pos_x.append((velo_x[num_points]+velo_x[num_points-1])/2*t+pos_x[num_points-1])\r\n pos_y.append((velo_y[num_points]+velo_y[num_points-1])/2*t+pos_y[num_points-1])\r\n \r\n \r\n \r\n\r\n\r\n\r\n #This block of code converts the the sets of points into an image \r\n pos_x = np.asarray(pos_x)\r\n pos_y = np.asarray(pos_y)\r\n plt.plot(pos_x,pos_y,'ko')\r\n plt.axis('off')\r\n plt.savefig('image_colour.jpeg')\r\n\r\n\r\n \r\n #This block of code converts the image to into the desired size and the convert it into a monochrome image\r\n img = Image.open('image_colour.jpeg') # open colour image\r\n img = img.convert('L') # convert image to black and white\r\n img = img.resize((20, 20), PIL.Image.ANTIALIAS)\r\n img.save('image_bw.jpeg')\r\n\r\n\r\n \r\n #The following code converts the monochrome image into data points for a csv file\r\n img_array = (plt.imread('image_bw.jpeg'))\r\n final_array = np.zeros((28,28))\r\n final_array[4:24,4:24] = (1-img_array/255)\r\n return final_array\r\n #Here final_array is the final array\r\n"
] | [
[
"numpy.asarray",
"numpy.zeros",
"matplotlib.pyplot.savefig",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.axis",
"matplotlib.pyplot.imread"
]
] |
dianjixz/AutoDL | [
"48db4eb04d55ce69e93d4a3bdc24592bdb34a868"
] | [
"AutoDL_sample_code_submission/at_nlp/run_model.py"
] | [
"import numpy as np\nimport math\nimport gc\n\nimport tensorflow as tf\nfrom keras import backend as K\nfrom keras.preprocessing import sequence\nfrom keras.callbacks import EarlyStopping, LearningRateScheduler\n\nfrom at_toolkit.at_utils import autodl_nlp_install_download\n\nautodl_nlp_install_download()\n\nfrom log_utils import info\nfrom at_nlp.data_manager.data_sampler import DataGenerator\nfrom at_nlp.data_manager.sample_utils import downsampling_input_data\nfrom at_nlp.utils import color_msg, ohe2cat\nfrom at_nlp.model_manager.emb_utils import _load_emb\nfrom at_nlp.data_manager.sample_config import sample_strategy\nfrom at_nlp.generators.model_generator import ModelGenerator\nfrom at_nlp.generators.feature_generator import FeatureGenerator\nfrom at_nlp.generators.data_generator import DataGenerator as BatchDataGenerator\nfrom at_nlp.data_manager.preprocess_utils import _tokenize_chinese_words\nfrom at_nlp.evaluator import Evaluator\nfrom at_toolkit.at_evalator import ATEvaluator\n\nfrom Auto_NLP.second_stage_models.model_iter_second_stage import Model as Second_Stage_Model\n\nINIT_BATCH_SIZE = 32\nMAX_SVM_FIT_NUM = 20000\nMAX_BERT_FIT_NUM = 3000\nMAX_EPOCH_NUM = 120\n\nconfig = tf.ConfigProto()\nconfig.gpu_options.allow_growth = True # dynamically grow the memory used on the GPU\nconfig.log_device_placement = False # to log device placement (on which device the operation ran)\nconfig.gpu_options.per_process_gpu_memory_fraction = 0.9\nsess = tf.Session(config=config)\nK.set_session(sess)\n\n\nclass RunModel(object):\n def __init__(self, metadata, train_output_path=\"./\", test_input_path=\"./\"):\n self.done_training = False\n self.metadata = metadata\n self.train_output_path = train_output_path\n self.test_input_path = test_input_path\n\n self.multi_label = False\n self.multi_label_cnt_thred = 10\n self.fasttext_embeddings_index = None\n\n self.load_pretrain_emb = True\n if self.load_pretrain_emb:\n self.fasttext_embeddings_index = _load_emb(self.metadata[\"language\"])\n\n self.model = None\n self.accu_nn_tokenizer_x = True\n\n self.second_stage_model = Second_Stage_Model(self.metadata, fasttext_emb=self.fasttext_embeddings_index)\n\n ################# second stage model 相关 #########################\n self.use_second_stage_model = False\n self.start_second_stage_model = False\n self.second_stage_patience = 0\n self.second_stage_patience_max_num = 8\n ################# second stage model 相关 #########################\n\n self.call_num = 0\n ## run model 配置有一个采样器，一个模型选择器\n self.data_sampler = None\n self.model_selector = None\n self.imbalance_level = -1\n self.start_cnn_call_num = 3\n\n self.split_val_x = False\n self.imbalance_flow_control = 1\n self.feature_dict = {}\n self.vocab = {}\n self.time_record = {}\n self.imbalance_level = -1\n self.avg_word_per_sample = 0\n self.use_multi_svm = True\n self.max_length = 0\n self.ft_model_check_length = 0\n self.seq_len_std = 0\n\n self.val_x = []\n self.clean_val_x = []\n self.val_y = np.array([])\n self.build_tokenizer_x = []\n self.build_tokenizer_y = np.array([])\n\n self.first_stage_done = False\n self.second_stage_done = False\n self.third_stage_done = False\n self.start_first_stage_call_num = 3\n self.tokenize_test = False\n\n self.switch_new_model = True\n self.switch_new_feature_mode = False\n self.cur_model_train_start = False\n self.train_epoch = 0\n self.max_train_epoch = 3\n self.model_id = 0\n self.train_model_id = -1\n self.feature_id = -1\n\n self.best_auc = 0.0\n\n self.model_lib = ['text_cnn']\n\n self.feature_lib = ['char-level + 300dim-embedding',\n 'word-level + pretrained embedding300dim']\n\n self.use_ft_model = False\n\n self.callbacks = []\n normal_lr = LearningRateScheduler(self.lr_decay)\n step_lr = LearningRateScheduler(self.step_decay)\n self.callbacks_ = [normal_lr, step_lr]\n self.cur_lr = None\n\n self.test_result_list = [0] * 30\n self.cur_model_test_res = []\n self.svm_test_result = []\n self.model_weights_list = [[]] * 20\n self.hist_test = [[]] * 20\n\n self.is_best = False\n self.best_call_num = 0\n self.best_svm = 0.0\n self.best_cnt = []\n self.best_svm_scores = []\n\n self.batch_size = INIT_BATCH_SIZE\n\n def _show_runtime_info(self):\n info(color_msg(\"********************************************************\"))\n info(color_msg(\"current model_id is {}, model_name is {}\".format(self.model_id, self.model_lib[self.model_id])))\n info(color_msg(\n \"current feature_id is {}, feature_name is {}\".format(self.feature_id, self.feature_lib[self.feature_id])))\n info(color_msg(\"train_model_id is {}\".format(self.train_model_id)))\n info(color_msg(\"********************************************************\\n\"))\n\n def _set_sampling_strategy(self, y_train):\n strategy = sample_strategy['sample_iter_incremental_no_train_split']\n\n if y_train.shape[0] > 0: # 如果当前有增量数据进样\n if self.call_num == 0 or self.call_num >= self.start_cnn_call_num:\n strategy = sample_strategy['sample_iter_incremental_no_train_split']\n\n\n elif self.call_num < self.start_cnn_call_num:\n strategy = sample_strategy[\"sample_iter_incremental_with_train_split\"]\n\n\n if self.start_cnn_call_num == self.imbalance_flow_control and not self.split_val_x:\n strategy = sample_strategy[\"sample_from_full_data\"]\n\n\n else: # 当前已无增量数据\n if self.val_y.shape[0] > 0: # 如果已经有val数据集\n strategy = sample_strategy[\"sample_from_full_train_data\"]\n\n else:\n strategy = sample_strategy[\"sample_from_full_data\"]\n\n\n return strategy\n\n def do_data_sampling(self, y_train):\n strategy = self._set_sampling_strategy(y_train)\n return self.data_manager.sample_dataset_iter(add_val_to_train=strategy[\"add_val_to_train\"],\n update_train=strategy[\"update_train\"],\n use_full=strategy[\"use_full\"])\n\n def run_svm(self, model_name, train_x, train_y):\n self.feature_generator.tokenizer = None\n if self.metadata[\"language\"] == \"ZH\" and self.call_num <= 1:\n analyzer = \"char\"\n else:\n analyzer = \"word\"\n self.feature_generator.build_tokenizer(train_x, 'svm', analyzer)\n # 后处理，将文本数据转换为 tfidf feature\n if len(train_x) > MAX_SVM_FIT_NUM:\n train_x = train_x[:MAX_SVM_FIT_NUM]\n train_y = train_y[:MAX_SVM_FIT_NUM, :]\n\n train_data = self.feature_generator.postprocess_data(train_x)\n classifier = self.model_manager.select_classifier(model_name=model_name, feature_mode=None,\n data_feature=self.feature_generator.data_feature)\n\n self.svm_token = self.feature_generator.tokenizer\n if self.multi_label:\n classifier.fit(train_data, train_y)\n else:\n classifier.fit(train_data, ohe2cat(train_y))\n return classifier\n\n def prepare_nn_tokenizer(self, train_x):\n self.feature_generator.build_tokenizer(train_x, model_name='nn')\n self.feature_generator.set_data_feature()\n self.tokenizer = self.feature_generator.tokenizer\n\n def model_fit(self, train_x, train_y, model):\n num_epochs = 1\n bs_training_generator = BatchDataGenerator(train_x, train_y, batch_size=self.batch_size,\n language=self.metadata[\"language\"],\n max_length=self.feature_generator.max_length\n if self.feature_generator.max_length else 100,\n vocab=None,\n tokenizer=self.tokenizer,\n num_features=self.feature_generator.num_features)\n\n model.fit_generator(generator=bs_training_generator, verbose=1,\n epochs=num_epochs,\n callbacks=self.callbacks,\n shuffle=True)\n return model\n\n def init_generators(self, x_train, y_train):\n self.data_manager = DataGenerator(x_train, y_train, self.metadata, self.imbalance_level, self.multi_label)\n self.model_manager = ModelGenerator(load_pretrain_emb=self.load_pretrain_emb,\n fasttext_embeddings_index=self.fasttext_embeddings_index,\n multi_label=self.multi_label)\n # ZH 前期默认不切分词，后期需切词\n self.feature_generator = FeatureGenerator(self.metadata[\"language\"], do_seg=False,\n num_class=self.metadata[\"class_num\"])\n\n self.evaluator = Evaluator(self.clean_val_x, self.val_y)\n\n def process_val_data(self, val_diff_x, val_diff_y):\n # 处理增量val数据\n if val_diff_x:\n clean_val_x = self.feature_generator.preprocess_data(val_diff_x)\n if self.val_y.shape[0] > 0:\n self.val_x = np.concatenate([self.val_x, val_diff_x], axis=0)\n self.val_y = np.concatenate([self.val_y, val_diff_y], axis=0)\n self.clean_val_x = np.concatenate([self.clean_val_x, clean_val_x], axis=0)\n\n else:\n self.val_x = val_diff_x\n self.val_y = val_diff_y\n self.clean_val_x = clean_val_x\n return clean_val_x\n else:\n return None\n\n def _reset_train_status(self):\n self.cur_model_train_start = False\n self.switch_new_model = True\n self.cur_lr = None\n self.train_epoch = 0\n self.best_cnt = []\n self.model_weights_list[self.train_model_id] = self.evaluator.model_weights_list\n self.cur_model_test_res = []\n self.evaluator.max_epoch = 5\n self.evaluator._reset()\n\n def _clear_train_space(self):\n del self.model\n gc.collect()\n K.clear_session()\n\n def _init_nn_train_process(self):\n self.feature_id += 1\n self.train_model_id = self.model_id + self.feature_id * len(self.model_lib)\n self._show_runtime_info()\n\n self.model_weights_list[self.train_model_id] = []\n self.cur_model_train_start = True\n self.switch_new_model = False\n self.train_epoch = 0\n self.callbacks = []\n\n def do_evaluation(self, eval_svm=True, update_val=True, update_setting=True):\n if eval_svm:\n tokenizer = self.svm_token\n else:\n tokenizer = self.tokenizer\n\n if update_val:\n self.evaluator.update_val_data(self.clean_val_x, self.val_y)\n if update_setting:\n self.evaluator.update_setting(self.metadata[\"language\"],\n self.feature_generator.max_length,\n self.feature_generator.num_features,\n tokenizer)\n\n self.evaluator.valid_auc(is_svm=eval_svm, model=self.model, use_autodl_auc=True)\n\n def _train_nn_process(self, train_preprocessed_data, train_diff_y):\n self.model = self.model_fit(train_preprocessed_data, train_diff_y, self.model)\n if self.cur_model_train_start: # 如果当前模型正在训练，评估每一次模型结果\n if self.call_num == self.start_first_stage_call_num:\n self.do_evaluation(eval_svm=False, update_val=True, update_setting=True)\n else:\n self.do_evaluation(eval_svm=False, update_val=False, update_setting=False)\n self.evaluator.update_model_weights(self.model, self.train_epoch)\n\n self.train_epoch += 1\n\n def _ensemble_multi_models(self):\n if self.call_num <= self.start_first_stage_call_num:\n ensemble_condition = self.evaluator.best_auc > self.best_auc\n else:\n # 对于第二个NN模型结果，要求达到前一次NN模型效果的97%\n ensemble_condition = self.evaluator.best_auc > 0.97 * self.best_auc\n\n if ensemble_condition:\n self.is_best = True # 允许多模型融合\n self.best_auc = max(self.evaluator.best_auc, self.best_auc)\n\n else:\n self.is_best = False\n\n self.best_cnt.append(self.is_best)\n\n if self.call_num < self.start_first_stage_call_num:\n self.best_svm = self.best_auc\n self.best_svm_scores.append(self.best_svm)\n\n def is_stage_done(self):\n if self.model_id == len(self.model_lib) - 1:\n if self.feature_id == len(self.feature_lib) - 1:\n self.first_stage_done = True\n\n def meta_strategy(self):\n\n if self.max_length <= 156 and self.avg_word_per_sample <= 12:\n self.use_ft_model = False\n self.evaluator.max_epoch = 8\n self.feature_lib = ['char-level + 300dim-embedding',\n 'word-level + pretrained embedding300dim']\n\n elif self.max_length > 156:\n self.use_ft_model = False\n self.second_stage_patience_max_num = 8\n self.feature_lib = ['char-level + 300dim-embedding',\n 'word-level + pretrained embedding300dim']\n\n\n if self.imbalance_level == 2 and self.metadata[\"language\"] == \"EN\":\n self.feature_lib = ['char-level + 300dim-embedding']\n\n if self.metadata[\"language\"] == \"ZH\":\n self.feature_lib = ['word-level + pretrained embedding300dim',\n 'char-level + 300dim-embedding']\n self.second_stage_patience_max_num = 8\n\n if self.multi_label:\n self.feature_lib = ['char-level + 300dim-embedding']\n\n def _update_build_tokenizer_data(self):\n pass\n\n def prepare_clean_data(self, train_diff_x, val_diff_x, val_diff_y):\n # 前处理：根据给定的前处理方式 清洗文本数据, 默认default\n train_preprocessed_data = self.feature_generator.preprocess_data(train_diff_x)\n self.process_val_data(val_diff_x, val_diff_y)\n if self.call_num == 2 and self.metadata[\"language\"] == \"ZH\":\n self.clean_val_x = list(map(_tokenize_chinese_words, self.clean_val_x))\n\n if self.accu_nn_tokenizer_x:\n if self.call_num == 2 and self.metadata[\"language\"] == \"ZH\":\n self.build_tokenizer_x = train_preprocessed_data\n else:\n\n self.build_tokenizer_x = self.build_tokenizer_x + train_preprocessed_data\n\n return train_preprocessed_data\n\n\n def run_second_stage(self, remaining_time_budget):\n if not self.start_second_stage_model:\n self._clear_train_space()\n self.start_second_stage_model = True\n if self.imbalance_level == 2:\n self.second_stage_model.split_val = False\n\n if self.second_stage_model.model_id == len(\n self.second_stage_model.cand_models) and self.second_stage_model.data_id == self.second_stage_model.max_data:\n self.second_stage_done = True\n info(\"finish second stage!\")\n return\n if self.second_stage_patience >= self.second_stage_patience_max_num:\n self.second_stage_model.epoch = 1\n self.second_stage_patience = 0\n do_clean = True\n else:\n do_clean = False\n\n if self.second_stage_model.split_val:\n self.second_stage_model.train_iter((self.data_manager.meta_data_x, self.data_manager.meta_data_y),\n eval_dataset=(self.val_x, self.val_y),\n remaining_time_budget=remaining_time_budget,\n do_clean=do_clean)\n else:\n self.second_stage_model.train_iter((self.data_manager.meta_train_x, self.data_manager.meta_train_y),\n eval_dataset=(self.val_x, self.val_y),\n remaining_time_budget=remaining_time_budget,\n do_clean=do_clean)\n\n second_auc = self.second_stage_model.best_sco\n self.evaluator.best_auc = second_auc\n if second_auc == -1 or second_auc == 0.02:\n second_auc = 0.0\n if second_auc >= self.best_auc * 0.97 and second_auc > 0.0:\n\n self.use_second_stage_model = True\n if self.second_stage_model.Xtest is None and self.second_stage_model.FIRSTROUND:\n self.second_stage_model.START = True\n elif self.second_stage_model.Xtest is None and self.second_stage_model.new_data:\n self.second_stage_model.START = False\n return\n else:\n\n if self.second_stage_model.START == False and self.second_stage_model.FIRSTROUND == False and self.second_stage_model.LASTROUND:\n self.second_stage_model.is_best = False\n self.second_stage_model.LASTROUND = False\n elif self.second_stage_model.START == True: # 如果START模型没有超过当前\n self.second_stage_model.START = False\n\n self.use_second_stage_model = False\n return\n\n def run_first_stage_model(self, train_preprocessed_data, train_diff_y):\n if self.switch_new_model and not self.cur_model_train_start: # 如果切换模型，且当前模型没有开始训练\n self._clear_train_space()\n self._init_nn_train_process()\n self.model = self.model_manager.select_classifier(model_name=self.model_lib[self.model_id],\n feature_mode=self.feature_lib[self.feature_id],\n data_feature=self.feature_generator.data_feature)\n info(color_msg(\"start new nn model training!\"))\n\n if self.model_lib[self.model_id] == \"text_cnn\":\n if self.imbalance_level == 2 or self.metadata[\"class_num\"] >= 5:\n self.callbacks = []\n else:\n self.callbacks = [self.callbacks_[0]]\n else:\n self.callbacks = [self.callbacks_[1]]\n\n self._train_nn_process(train_preprocessed_data, train_diff_y)\n\n if self.train_model_id >= 1: # 训练了至少2个模型\n self._ensemble_multi_models()\n else:\n self._ensemble_multi_models()\n\n # 达到结束的条件\n if self.evaluator.decide_stop(train_epoch=self.train_epoch):\n self._reset_train_status()\n\n def train(self, x_train, y_train, remaining_time_budget=None):\n if self.done_training:\n return\n if not self.use_multi_svm and self.metadata[\"language\"] == \"EN\":\n self.start_first_stage_call_num = 1\n if not self.use_multi_svm and self.metadata[\"language\"] == \"ZH\":\n self.start_first_stage_call_num = 2\n if self.use_multi_svm and self.multi_label:\n self.start_first_stage_call_num = 2\n\n\n if self.call_num == 0:\n self.init_generators(x_train, y_train)\n if self.use_multi_svm:\n self.evaluator.max_epoch = 15\n if self.multi_label:\n self.evaluator.max_epoch = 18\n\n else:\n if self.call_num == 2 and self.metadata[\"language\"] == \"ZH\":\n self.feature_generator.do_seg = True\n\n if y_train.shape[0] > 0:\n self.data_manager.update_meta_data(x_train, y_train)\n\n # 数据采样\n train_diff_x, train_diff_y, val_diff_x, val_diff_y = self.do_data_sampling(y_train)\n\n ########################## 设定采用的预处理方式###########################################\n\n ########################## 数据前处理 ####################################################\n train_preprocessed_data = self.prepare_clean_data(train_diff_x, val_diff_x, val_diff_y)\n\n ############################ SVM 阶段模型 ############################\n if self.call_num < self.start_first_stage_call_num:\n self.model = self.run_svm('svm', train_preprocessed_data, train_diff_y)\n\n if self.val_y.shape[0] > 0:\n self.do_evaluation(eval_svm=True)\n self.evaluator.update_model_weights(self.model, self.train_epoch, is_svm=True)\n self._ensemble_multi_models()\n\n else:\n\n if self.call_num == self.start_first_stage_call_num:\n # 进行模型预选择\n self.meta_strategy()\n self.feature_generator.reset_tokenizer()\n # 设定文本长度及文本长度std，影响后处理pad长度设置\n self.feature_generator.max_length = self.max_length\n self.feature_generator.seq_len_std = self.seq_len_std\n self.prepare_nn_tokenizer(train_x=self.build_tokenizer_x)\n self.accu_nn_tokenizer_x = False\n\n ############################ 进入第二阶段模型 ############################\n if self.first_stage_done:\n if not self.multi_label:\n self.run_second_stage(remaining_time_budget)\n else:\n info(color_msg(\"do not run second stage model when multi_label is {}\".format(self.multi_label)))\n self.second_stage_done = False\n ############################ 进入第一阶段模型 ############################\n else:\n if self.switch_new_model and not self.cur_model_train_start:\n self.is_stage_done()\n if not self.first_stage_done:\n self.run_first_stage_model(train_preprocessed_data, train_diff_y)\n\n return\n\n def _update_multi_model_result(self, pred):\n if self.is_best:\n self.test_result_list[self.train_model_id] = pred\n result = np.mean(self.test_result_list[:self.train_model_id + 1], axis=0)\n else:\n if isinstance(self.test_result_list[self.train_model_id], int):\n result = self.test_result_list[0]\n else:\n result = np.mean(self.test_result_list[:self.train_model_id + 1], axis=0)\n return result\n\n def transform_test(self):\n if self.call_num < self.start_first_stage_call_num:\n x_test_feature = self.svm_token.transform(self.x_test_clean)\n return x_test_feature\n\n else:\n if not self.tokenize_test:\n x_test_feature = self.tokenizer.texts_to_sequences(self.x_test_clean)\n x_test = sequence.pad_sequences(x_test_feature,\n maxlen=self.feature_generator.max_length,\n padding='post')\n self.tokenize_test = True\n else:\n x_test = self.x_test\n return x_test\n\n def output_svm_result(self):\n result = self.model.predict_proba(self.x_test)\n if self.is_best:\n self.svm_test_result.append(result)\n elif self.call_num > 0:\n result = self.svm_test_result[-1]\n return result\n\n def output_second_stage_result(self):\n info(\"Output in second stage!\")\n # 第二阶段没有结束：只有两个选择：second_stage 模型 or 第一阶段最优模型\n if self.use_second_stage_model:\n self.second_stage_patience = 0\n info(color_msg(\"Use second_stage Model!!\"))\n second_stage_result = self.second_stage_model.test(self.x_test_raw)\n\n # info(color_msg(\"second_stage result is {}\".format(type(second_stage_result))))\n # if isinstance(second_stage_result, list):\n # info(color_msg(\"second_stage result is {}\".format(len(second_stage_result))))\n # if isinstance(second_stage_result, np.ndarray):\n # info(color_msg(\"second_stage result is {}\".format(second_stage_result.shape[0])))\n # if isinstance(second_stage_result, np.float):\n # info(color_msg(\"second_stage result is {}\".format(second_stage_result)))\n\n # 如果second_stage输出为空，返回第一个阶段结果\n if second_stage_result.shape[0] == 0:\n if isinstance(self.test_result_list[2], int):\n result = np.mean(self.test_result_list[:2], axis=0)\n else:\n result = np.mean(self.test_result_list[:3], axis=0)\n return result\n else:\n self.test_result_list[2] = second_stage_result\n result = np.mean(self.test_result_list[:3], axis=0)\n return result\n else:\n info(color_msg(\"Do Not Use second_stage Model!! second_stage_patience is {}\".format(self.second_stage_patience)))\n self.second_stage_patience += 1\n if self.start_second_stage_model:\n if isinstance(self.test_result_list[2], int):\n result = np.mean(self.test_result_list[:2], axis=0)\n else:\n result = np.mean(self.test_result_list[:3], axis=0)\n else:\n if self.train_model_id == 0:\n result = self.test_result_list[0]\n else:\n result = np.mean(self.test_result_list[:2], axis=0)\n return result\n\n def output_first_stage_result_with_svm(self, result):\n if self.is_best:\n if np.std([np.max(self.best_svm_scores), self.best_auc]) < 0.005:\n self.svm_test_result.append(result)\n result = np.mean(self.svm_test_result, axis=0)\n else:\n self.multi_label_cnt_thred-=1\n result = result\n else:\n if np.std([np.max(self.best_svm_scores), self.best_auc]) < 0.02:\n self.svm_test_result.append(result)\n result = np.mean(self.svm_test_result, axis=0)\n self.svm_test_result.pop(-1)\n else:\n result = self.svm_test_result[-1]\n return result\n\n def output_first_stage_result(self):\n result = self.model.predict(self.x_test,\n batch_size=self.batch_size * 16)\n self.cur_model_test_res.append(result)\n if self.train_model_id == 0 and not self.cur_model_train_start:\n self.test_result_list[0] = self.cur_model_test_res[-1]\n\n if self.train_model_id==1 and not self.cur_model_train_start:\n if isinstance(self.test_result_list[self.train_model_id], int):\n\n self.test_result_list[1] = self.test_result_list[0]\n\n if self.train_model_id >= 1:\n result = self._update_multi_model_result(result)\n\n if self.call_num == self.start_first_stage_call_num:\n if self.is_best:\n if np.std([np.max(self.best_svm_scores), self.best_auc]) < 0.008:\n self.svm_test_result.append(result)\n result = np.mean(self.svm_test_result, axis=0)\n else:\n result = result\n else:\n if np.std([np.max(self.best_svm_scores), self.best_auc]) < 0.02:\n self.svm_test_result.append(result)\n result = np.mean(self.svm_test_result, axis=0)\n self.svm_test_result.pop(-1)\n else:\n result = self.svm_test_result[-1]\n\n if self.multi_label:\n if self.train_model_id >= 1:\n result = self._update_multi_model_result(result)\n else:\n result = self.output_first_stage_result_with_svm(result)\n\n return result\n\n def test(self, x_test, remaining_time_budget):\n if self.call_num == 0:\n self.x_test_raw = x_test\n self.x_test_clean = self.feature_generator.preprocess_data(self.x_test_raw)\n\n if self.metadata[\"language\"] == \"ZH\" and self.call_num == 2:\n # feature.do_seg 已经更新\n self.x_test_clean = self.feature_generator.preprocess_data(self.x_test_raw)\n\n self.x_test = self.transform_test()\n\n # 输出svm 结果\n if self.call_num < self.start_first_stage_call_num:\n result = self.output_svm_result()\n\n elif self.second_stage_done:\n result = np.mean(self.test_result_list[:3], axis=0)\n\n elif self.first_stage_done:\n if self.multi_label:\n if self.multi_label_cnt_thred<0:\n result = self.cur_model_test_res[-1]\n return result\n else:\n result = self.svm_test_result[-1]\n else:\n result = self.output_second_stage_result()\n\n else:\n ## 当前为NN模型输出结果\n result = self.output_first_stage_result()\n\n self.done_training = False\n self.call_num += 1\n if self.call_num == MAX_EPOCH_NUM:\n self.done_training = True\n self.ft_model = None\n return result\n\n def lr_decay(self, epoch):\n if self.call_num == 1 or self.cur_lr is None:\n self.cur_lr = self.model_manager.lr\n if self.train_epoch % 3 == 0 and self.train_epoch > 0:\n self.cur_lr = 3 * self.cur_lr / 5\n self.cur_lr = max(self.cur_lr, 0.0001)\n lr = self.cur_lr\n return lr\n\n def step_decay(self, epoch):\n epoch = self.train_epoch // 3\n initial_lrate = self.model_manager.lr # 0.016 #0.0035 #\n drop = 0.65 # 0.65\n epochs_drop = 1.0 # 2.0\n if (self.train_epoch) <= 2:\n lrate = initial_lrate\n else:\n lrate = initial_lrate * math.pow(drop, math.floor((1 + epoch) / epochs_drop))\n lrate = max(lrate, 0.0001)\n return lrate\n"
] | [
[
"numpy.concatenate",
"numpy.max",
"numpy.array",
"tensorflow.Session",
"numpy.mean",
"tensorflow.ConfigProto"
]
] |
virati/SCC_Readout | [
"9d72a8cf34f437259a3db2c49a2e4d2032422af3"
] | [
"temp_BS.py"
] | [
"#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Wed Jul 8 13:42:23 2020\n\n@author: virati\n\"\"\"\n\nimport matplotlib.pyplot as plt\nimport numpy as np\n\n# returns 10 evenly spaced samples from 0.1 to 2*PI\nx = np.linspace(0.1, 2 * np.pi, 10)\n\nmarkerline, stemlines, baseline = plt.stem(x, np.cos(x), '-.')\n\n# setting property of baseline with color red and linewidth 2\nplt.setp(baseline, color='r', linewidth=2)\n\nplt.show()"
] | [
[
"matplotlib.pyplot.show",
"numpy.linspace",
"matplotlib.pyplot.setp",
"numpy.cos"
]
] |
Mlak300/KeyMessages | [
"f7785f768f471b406d9c0dd3d3b1cf6585a6c43a"
] | [
"main_detect.py"
] | [
"import time\r\nfrom absl import app, flags, logging\r\nfrom absl.flags import FLAGS\r\nimport cv2\r\nimport numpy as np\r\nimport tensorflow as tf\r\nimport glob\r\n# from yolov3_tf2.models import (\r\n# \tYoloV3, YoloV3Tiny\r\n# )\r\n# from yolov3_tf2.dataset import transform_images\r\nfrom yolov3_tf2.dataset import transform_images, load_tfrecord_dataset\r\nfrom yolov3_tf2.utils import draw_outputs\r\nfrom tensorflow.python.eager import def_function\r\nfrom tensorflow.python.framework import tensor_spec\r\nfrom tensorflow.python.util import nest\r\n\r\nflags.DEFINE_string('output', './serving/yolov3/1', 'path to saved_model')\r\nflags.DEFINE_string('classes', './data/images/classes.txt', 'path to classes file')\r\nflags.DEFINE_integer('num_classes', 50, 'number of classes in the model')\r\nflags.DEFINE_string('result_output', './data/output/ours/', 'path to output image')\r\n\r\n\r\ndef main(_argv):\r\n # if FLAGS.tiny:\r\n # \tyolo = YoloV3Tiny(classes=FLAGS.num_classes)\r\n # else:\r\n # \tyolo = YoloV3(classes=FLAGS.num_classes)\r\n #\r\n # yolo.load_weights(FLAGS.weights)\r\n # logging.info('weights loaded')\r\n #\r\n # tf.saved_model.save(yolo, FLAGS.output)\r\n # logging.info(\"model saved to: {}\".format(FLAGS.output))\r\n\r\n score_threshold = 0.45\r\n model = tf.saved_model.load(FLAGS.output)\r\n infer = model.signatures[tf.saved_model.DEFAULT_SERVING_SIGNATURE_DEF_KEY]\r\n logging.info(infer.structured_outputs)\r\n\r\n class_names = [c.strip() for c in open(FLAGS.classes).readlines()]\r\n logging.info('classes loaded')\r\n\r\n img_idx = 1\r\n for image_path in glob.glob(f'./data/images/validation/*.jpg'):\r\n # image_np = cv2.imread(image_path, 1) # load_image_into_numpy_array(image_path)\r\n # raw_img = tf.image.decode_image(open(FLAGS.image, 'rb').read(), channels=3)\r\n raw_img = tf.image.decode_image(open(image_path, 'rb').read(), channels=3)\r\n img = tf.expand_dims(raw_img, 0)\r\n img = transform_images(img, 416)\r\n\r\n t1 = time.time()\r\n outputs = infer(img)\r\n boxes, scores, classes, nums = outputs[\"yolo_nms\"], outputs[\r\n \"yolo_nms_1\"], outputs[\"yolo_nms_2\"], outputs[\"yolo_nms_3\"]\r\n t2 = time.time()\r\n logging.info('time: {}'.format(t2 - t1))\r\n\r\n logging.info('detections:')\r\n for i in range(nums[0]):\r\n logging.info('\\t{}, {}, {}'.format(class_names[int(classes[0][i])],\r\n scores[0][i].numpy(),\r\n boxes[0][i].numpy()))\r\n img2 = cv2.cvtColor(raw_img.numpy(), cv2.COLOR_RGB2BGR)\r\n img2 = draw_outputs(img2, (boxes, scores, classes, nums), class_names, score_threshold)\r\n cv2.imwrite(FLAGS.result_output + img_idx.__str__() + '_2.jpeg', img2)\r\n logging.info('output saved to: {}'.format(FLAGS.result_output + img_idx.__str__() + '_2.jpeg'))\r\n img_idx = img_idx + 1\r\n\r\n\r\nif __name__ == '__main__':\r\n try:\r\n app.run(main)\r\n except SystemExit:\r\n pass\r\n"
] | [
[
"tensorflow.saved_model.load",
"tensorflow.expand_dims"
]
] |
ananyaks/data_model | [
"ab3a827864e36e105bbb3fb50744e0f7ce046148"
] | [
"benchmark/postgres/util.py"
] | [
"#!/usr/bin/env python3\n\nimport os\nimport time\nimport yaml\nimport json\n\nimport numpy as np\nfrom resource import getrusage as resource_usage, RUSAGE_SELF\nfrom time import time as timestamp\n\npath_join = os.path.join\n\n_dir = os.path.dirname(os.path.realpath(__file__))\nworkload_dir = path_join(_dir, \"..\", \"workload\")\ndataset_info = path_join(workload_dir, \"dataset.yaml\")\ntrace_dir = path_join(workload_dir, \"trace\")\n\nimport sqlalchemy\nimport psycopg2\n\nDB = os.environ.get(\"DB\", \"zed\")\n\n\ndef db_conn(conn_str=f\"postgresql://{DB}:{DB}@localhost/{DB}\",\n use_sqlalchemy=False):\n if use_sqlalchemy:\n db = sqlalchemy.create_engine(conn_str)\n return db.connect()\n else:\n return psycopg2.connect(conn_str)\n\n\ndef workload_config(name, query=None):\n with open(path_join(workload_dir, name + \".yaml\")) as f:\n wc = yaml.load(f, Loader=yaml.Loader)\n if query is not None:\n qc = wc[\"query\"][query]\n if \"from\" in qc:\n qc = {**wc[\"query\"][qc[\"from\"]], **qc}\n return qc\n return wc\n\n\n# Note: copied from ../util.py\n\ndef unix_time(function, *args, **kwargs):\n '''Return `real`, `sys` and `user` elapsed time, like UNIX's command `time`\n You can calculate the amount of used CPU-time used by your\n function/callable by summing `user` and `sys`. `real` is just like the wall\n clock.\n Note that `sys` and `user`'s resolutions are limited by the resolution of\n the operating system's software clock (check `man 7 time` for more\n details).\n '''\n start_time, start_resources = timestamp(), resource_usage(RUSAGE_SELF)\n r = function(*args, **kwargs)\n end_resources, end_time = resource_usage(RUSAGE_SELF), timestamp()\n\n return {'return': r,\n 'real': end_time - start_time,\n 'sys': end_resources.ru_stime - start_resources.ru_stime,\n 'user': end_resources.ru_utime - start_resources.ru_utime}\n\n\ndef benchmark(fn, init_fn=None, *init_args, num_iter=10, **init_kwargs):\n '''Benchmarks fn a specified number of times (num_iter). Calls init_fn\n before each time it calls fn, to allow for custom per-iteration\n initialization.\n '''\n _real, _sys, _user = list(), list(), list()\n _return = None\n for _ in range(num_iter):\n if init_fn:\n (args, kwargs) = init_fn(*init_args, **init_kwargs)\n else:\n args = init_args\n kwargs = init_kwargs\n t = unix_time(fn, *args, **kwargs)\n _real.append(t[\"real\"])\n _sys.append(t[\"sys\"])\n _user.append(t[\"user\"])\n # take the last run only\n _return = t[\"return\"]\n\n return {\n \"return\": _return,\n \"real\": round(np.mean(_real), 5),\n \"user\": round(np.mean(_user), 5),\n \"sys\": round(np.mean(_sys), 5),\n }\n\n\ndef timed(fn):\n def timeit(*args, **kw):\n ts = time.time()\n result = fn(*args, **kw)\n te = time.time()\n if 'log_time' in kw:\n name = kw.get('log_name', fn.__name__.upper())\n kw['log_time'][name] = int((te - ts) * 1000)\n else:\n print('%r %2.2f s' % (fn.__name__, (te - ts) * 1))\n return result\n\n return timeit\n\n\ndef write_csv(rows: list, name: str):\n with open(name, \"w\") as f:\n header = \",\".join(map(str, rows[0].keys()))\n f.write(header + \"\\n\")\n for r in rows:\n f.write(\",\".join(map(str, r.values())))\n f.write(\"\\n\")\n\n\ndef read_trace(name):\n tr = list()\n with open(path_join(trace_dir, name)) as f:\n if name.endswith(\"ndjson\"):\n for line in f:\n tr.append(json.loads(line))\n else:\n raise NotImplemented\n return tr\n\n\ndef main():\n read_trace(\"network_log_search_30.ndjson\")\n\n\nif __name__ == '__main__':\n main()\n"
] | [
[
"numpy.mean"
]
] |
Dora-The-Kid/culture_network_0 | [
"ac3c3d2e0528f341fd50354300008c43df56e984"
] | [
"test_10_13.py"
] | [
"import matplotlib.pyplot as plt\nimport numpy as np\nfrom scipy import stats\nimport math\nimport pandas as pd\ndata_1 = np.array([260925,296296,299490])\ndata_2 = np.array([356846,338160,292290])\ndata = [\n [260925,296296,299490],\n [356846,338160,292290]\n]\ndata = np.array(data)\ndf = pd.DataFrame(data.T,columns=['ctrl','epsc_down'])\na =stats.levene(data_1, data_2)\nb = stats.ttest_ind(data_1,data_2,equal_var=True)\nplt.figure()\nf = df.boxplot(sym = 'o', #异常点形状\n vert = True, # 是否垂直\n whis=1.5, # IQR\n patch_artist = True, # 上下四分位框是否填充\n meanline = False,showmeans = True, # 是否有均值线及其形状\n showbox = True, # 是否显示箱线\n showfliers = True, #是否显示异常值\n notch = False, # 中间箱体是否缺口\n return_type='dict') # 返回类型为字典\n\nplt.title('duration')\nplt.show()\nprint(a,b)\ndef plot_sig(xstart,xend,ystart,yend,sig):\n for i in range(len(xstart)):\n x = np.ones((2))*xstart[i]\n y = np.arange(ystart[i],yend[i],yend[i]-ystart[i]-0.1)\n plt.plot(x,y,label=\"$y$\",color=\"black\",linewidth=1)\n\n x = np.arange(xstart[i],xend[i]+0.1,xend[i]-xstart[i])\n y = yend[i]+0*x\n plt.plot(x,y,label=\"$y$\",color=\"black\",linewidth=1)\n\n x0 = (xstart[i]+xend[i])/2\n y0=yend[i]\n plt.annotate(r'%s'%sig, xy=(x0, y0), xycoords='data', xytext=(-15, +1),\n textcoords='offset points', fontsize=16,color=\"red\")\n x = np.ones((2))*xend[i]\n y = np.arange(ystart[i],yend[i],yend[i]-ystart[i]-0.1)\n plt.plot(x,y,label=\"$y$\",color=\"black\",linewidth=1)\n plt.ylim(0,math.ceil(max(yend)+4)) #使用plt.ylim设置y坐标轴范围\n # plt.xlim(math.floor(xstart)-1,math.ceil(xend)+1)\n #plt.xlabel(\"随便画画\") #用plt.xlabel设置x坐标轴名称\n '''设置图例位置'''\n #plt.grid(True)\n plt.show()\nplot_sig([0.42,1.42],[1.42,2.42],[30,20],[30.8,20.8],'***')"
] | [
[
"numpy.array",
"matplotlib.pyplot.annotate",
"pandas.DataFrame",
"scipy.stats.ttest_ind",
"matplotlib.pyplot.title",
"matplotlib.pyplot.plot",
"scipy.stats.levene",
"matplotlib.pyplot.figure",
"numpy.ones",
"numpy.arange",
"matplotlib.pyplot.show"
]
] |
koukyo1994/pattern_recognition | [
"0bf835b98baa66cdb78aa46c677b8de91790a767"
] | [
"RL/openai/cartpole/util.py"
] | [
"import numpy as np\n\n\ndef discount_rewards(rewards, discount_rate):\n discounted_rewards = np.empty(len(rewards))\n cumulative_rewards = 0\n for step in reversed(range(len(rewards))):\n cumulative_rewards = rewards[step] + cumulative_rewards * discount_rate\n discounted_rewards[step] = cumulative_rewards\n return discounted_rewards\n\n\ndef discount_and_normalize_rewards(all_rewards, discount_rate):\n all_discounted_rewards = [discount_rewards(rewards, discount_rate)\n for rewards in all_rewards]\n flat_rewards = np.concatenate(all_discounted_rewards)\n reward_mean = flat_rewards.mean()\n reward_std = flat_rewards.std()\n return [(discounted_rewards - reward_mean) / reward_std\n for discounted_rewards in all_discounted_rewards]\n"
] | [
[
"numpy.concatenate"
]
] |
U0M0Z/tgpipe | [
"436b8166858f80d59dfedc07769ea1f5b0278423"
] | [
"tgboost/predict.py"
] | [
"import typing as t\n\nimport numpy as np\nimport pandas as pd # type: ignore\n\nfrom tgboost import __version__ as _version\nfrom tgboost.config.core import config\nfrom tgboost.processing.data_manager import load_pipeline\nfrom tgboost.processing.smiles_manager import SmilesEmbedder, SmilesWrapper\nfrom tgboost.processing.validation import validate_inputs\n\ntrans_file_name = f\"{config.app_config.transformer_pipeline_save_file}{_version}.pkl\"\nreg_file_name = f\"{config.app_config.regressor_pipeline_save_file}{_version}.pkl\"\n_xgbRegression_pipe = load_pipeline(file_name=reg_file_name)\n\nprint(reg_file_name)\n\n\ndef make_prediction(*, input_data: t.Union[pd.DataFrame, dict]) -> dict:\n \"\"\"Make a prediction using a saved model pipeline.\"\"\"\n\n transformer = SmilesWrapper(\n variables=[config.model_config.smiles_to_extract],\n param_scaler=config.model_config.scaler,\n )\n\n embedder = SmilesEmbedder(variables=[config.model_config.smiles_to_embed])\n\n df_input = pd.DataFrame(input_data)\n\n transformation = transformer.fit_transform(df_input)\n df_embedded = embedder.fit_transform(transformation)\n\n # df_embedded = embedder.fit_transform(transformer.fit_transform(df_input))\n\n validated_data, errors = validate_inputs(input_data=df_embedded)\n results = {\"predictions\": None, \"version\": _version, \"errors\": errors}\n\n tt_pred = validated_data[config.model_config.embedding_list].values.flatten()\n tt_pred = np.array(list(tt_pred))\n\n if not errors:\n predictions = _xgbRegression_pipe.predict(X=tt_pred)\n print(predictions)\n\n results = {\n \"predictions\": list(predictions), # type: ignore\n \"version\": _version,\n \"errors\": errors,\n }\n\n return results\n"
] | [
[
"pandas.DataFrame"
]
] |
juhi24/radcomp | [
"ccb727e4fa516ae708362ed1b05335de92f8c7fd",
"ccb727e4fa516ae708362ed1b05335de92f8c7fd"
] | [
"scripts/vertical/scr_store_pluvio.py",
"scripts/misc/scr_fix_rhi.py"
] | [
"# coding: utf-8\n\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport baecc.instruments.pluvio as pl\nfrom os import path\nfrom glob import glob\nfrom warnings import warn\nfrom datetime import datetime, timedelta\nfrom radcomp import CACHE_TMP_DIR\nfrom radcomp.vertical import case, classification, plotting, RESULTS_DIR\nfrom j24 import home, ensure_join\n\nplt.ioff()\nplt.close('all')\n\nCASE_SET = 'everything'\nn_eigens = 25\nn_clusters = 20\nreduced = True\n\nNAME = classification.scheme_name(basename='baecc_t', n_eigens=n_eigens,\n n_clusters=n_clusters, reduced=reduced)\nDATADIR = path.join(home(), 'DATA')\nSTORE_FILE = path.join(CACHE_TMP_DIR, CASE_SET + '.hdf')\nfig_dir = ensure_join(RESULTS_DIR, 'class_r_t', NAME, CASE_SET)\n\n\ndef dateparser(dstr):\n return datetime.strptime(dstr, '%y%m%d').date()\n\n\ndef time_start():\n vpdir = path.join(DATADIR, 'vprhi')\n datefile = path.join(vpdir, 'date.list')\n dates = pd.read_csv(datefile, dtype=str, header=None).iloc[:, 0]\n date_start = dates.apply(datetime.strptime, args=['%Y%m%d'])\n date_start.index = date_start.apply(lambda t: t.date())\n date_start.name = 'start'\n start = datetime(2014, 2, 1).date()\n end = datetime(2016, 5, 1).date()\n date_start = date_start.loc[start:end].copy()\n return date_start\n\n\ndef dates():\n date_start = time_start()\n date_end = date_start + timedelta(days=1) - timedelta(minutes=1)\n date_end.name = 'end'\n date_end.index = date_start.index\n date = pd.concat([date_start, date_end], axis=1)\n dates_t = pd.read_hdf(path.join(DATADIR, 't_fmi_14-17.h5'), 'data').index\n sdates_t = pd.Series(dates_t, index=dates_t)\n uniqdates_t = sdates_t.apply(lambda t: t.date()).unique()\n return date.loc[uniqdates_t].dropna()\n\n\ndef dates_str():\n d = dates()\n dt2str = lambda t: t.strftime('%Y-%m-%d %H:%M')\n return d.apply(lambda row: row.apply(dt2str))\n\n\ndef everycase():\n date = dates_str()\n dtpath = path.join(home(), '.radcomp', 'cases', 'everything.csv')\n date.to_csv(dtpath, mode='w', index=False, header=True)\n\n\ndef pluvglobs(dates, pattern):\n pluvglobpatterns = dates.apply(lambda t: t.strftime(pattern))\n globs = pluvglobpatterns.apply(glob)\n return globs.loc[globs.apply(lambda l: len(l)>1)]\n\n\ndef pluvs(pluvtype='200'):\n pluvtype = str(pluvtype)\n d = dates()['start']\n fnamefmt = 'pluvio{}_0?_%Y%m%d??.txt'.format(pluvtype)\n patt = path.join(DATADIR, 'Pluvio{}'.format(pluvtype), fnamefmt)\n globs = pluvglobs(d, patt)\n df = globs.apply(pl.Pluvio)\n df.name = 'pluvio{}'.format(pluvtype)\n return df\n\n\ndef store(store_file=STORE_FILE):\n cases = case.read_cases(CASE_SET)\n cases.index=list(map(dateparser, cases.index.values))\n df2 = pluvs(pluvtype='200')\n df4 = pluvs(pluvtype='400')\n data = pd.concat([cases, df2, df4], join='inner', axis=1)\n data.to_hdf(store_file, 'data')\n\n\ndef plot_case(c, *pluvs, **kws):\n try:\n c.load_classification(NAME)\n except ValueError:\n warn('ValueError while trying classification. Skipping case.')\n return None, None\n half_dt = c.mean_delta()/2\n fig, axarr = c.plot(n_extra_ax=1, **kws)\n axi = axarr[-2]\n for pluv in pluvs:\n i = pluv.intensity()\n iw = c.time_weighted_mean(i).shift(freq=half_dt)\n plotting.plot_data(iw, ax=axi, label=pluv.name)\n axi.yaxis.grid(True)\n axi.legend()\n axi.set_ylim(bottom=0, top=4)\n axi.set_ylabel(plotting.LABELS['intensity'])\n c.set_xlim(axi)\n for ax in axarr:\n ax.xaxis.grid(True)\n return fig, axarr\n\n\nif __name__ == '__main__':\n data = pd.read_hdf(STORE_FILE)\n for t, row in data.iterrows():\n c = row.case\n print(c.name())\n fig, axarr = plot_case(c, row.pluvio200, row.pluvio400, cmap='viridis')\n if fig is None:\n continue\n fig.savefig(path.join(fig_dir, c.name()+'.png'))\n plt.close(fig)\n\n\n\n\n",
"# coding: utf-8\n\nimport matplotlib.pyplot as plt\nimport pyart.io\nfrom os import path\n\n\nif __name__ == '__main__':\n filepath = path.expanduser('~/DATA/vprhi2/201504221810_IKA.RHI_HV.raw')\n radar = pyart.io.read(filepath)\n kdp_m = pyart.retrieve.kdp_maesaka(radar)#, check_outliers=False)\n radar.add_field('kdp_maesaka', kdp_m[0])\n fig, ax = plt.subplots(2, sharex=True, sharey=True)\n display = pyart.graph.RadarDisplay(radar)\n display.plot_rhi('kdp_maesaka', vmin=0, vmax=0.2, ax=ax[0], cmap='viridis')\n display.plot_rhi('specific_differential_phase', cmap='viridis', vmin=0, vmax=0.2, ax=ax[1])\n "
] | [
[
"pandas.concat",
"matplotlib.pyplot.close",
"pandas.read_hdf",
"pandas.Series",
"matplotlib.pyplot.ioff",
"pandas.read_csv"
],
[
"matplotlib.pyplot.subplots"
]
] |
gsalinaslopez/MagRSS | [
"615a6649572b044973f753d704d706d66ae12026"
] | [
"tf/nn/bpnn_2.py"
] | [
"from __future__ import absolute_import, division, print_function, unicode_literals\n\n# TensorFlow and tf.keras\nimport tensorflow as tf\nfrom tensorflow import keras\nfrom tensorflow import feature_column\nfrom tensorflow.keras import layers\nfrom sklearn.model_selection import train_test_split\n\n\n# Helper libraries\nimport numpy as np\nimport pandas as pd\nimport pathlib\nimport os\nimport sys\nimport argparse\n\nimport nnutils\n\n\n# setup and parse cli arguments\nparser = argparse.ArgumentParser(description='Back propagation NN that trains '\n 'on data generated by the MagRss app')\nparser.add_argument('--train_dir', type=str, default='m1')\nparser.add_argument('--train_file', type=str, default='master_0.csv')\nparser.add_argument('--dbm', action='store_true', help='set this flag to '\n 'include dbm entries into the featureset')\nparser.add_argument('--epochs', type=int, default=10)\nparser.add_argument('--batch_size', type=int, default=20)\nparser.add_argument('--early_stopping', nargs=2, default=argparse.SUPPRESS, \n metavar=('MONITOR', 'PATIENCE'))\nparser.add_argument('--features', nargs='+', type=str, \n default=argparse.SUPPRESS)\nparser.add_argument('--layer', nargs=4, dest='layers', action='append', \n metavar=('LAYER_TYPE', 'NUMBER_OF_NODES', \n 'KERNEL_REGULARIZER', 'DROPUT'))\nparser.add_argument('--tensorboard', action='store_true', \n help='set this flag to log history/scalar data from the ' \n 'model\\'s run')\nargs = vars(parser.parse_args())\nif args['layers'] is None:\n args['layers'] = [\n ['dense', '128', '0.001', '0.2'], ['dense', '128', '0.001', '0.2']] \nprint(args)\n\nprint('---------------------------------------------------------')\ntrain_files = nnutils._get_clean_train_filepaths(args['train_dir'])\n# print(train_files)\n# print(args['train_file'])\n# exit(0)\nfor train_file in train_files:\n if str(train_file) == args['train_file']:\n df = pd.read_csv(train_file)\ndf.fillna(0, inplace = True)\n\nprint(df.columns)\n\n# include/exclude cid dbm fields\nif not args['dbm']:\n dbm_columns = [column for column in df.columns if 'dbm' in column]\n df.drop(columns=dbm_columns, inplace=True)\n\n# set of features to be used for training\nif 'features' in args:\n f_col = [column for column in df.columns\n if column not in args['features'] \n and 'dbm' not in column and column != 'label']\n df.drop(columns=f_col, inplace=True)\nprint(df.columns)\n\ntrain, val = train_test_split(df, test_size=0.2)\n# train, val = train_test_split(train, test_size=0.2)\n\n\n# setup data arrays from pandas dataframe\nbatch_size = args['batch_size']\ntrain_ds = nnutils.dataframe_to_dataset_input_fn(\n df=train, batch_size=batch_size)\nval_ds = nnutils.dataframe_to_dataset_input_fn(\n df=val, shuffle=False, batch_size=batch_size)\n# test_ds = nnutils.dataframe_to_dataset_input_fn(\n# df=test, shuffle=False, batch_size=batch_size)\nsteps_per_epoch = len(train.index) // batch_size\nvalidation_steps = len(val) // batch_size\n\n# setup the features as numeric\nfeature_columns = [feature_column.numeric_column(str(f)) for f in train.columns\n if 'label' not in f]\nfeature_layer = tf.keras.layers.DenseFeatures(feature_columns)\n\nlr_schedule = tf.keras.optimizers.schedules.InverseTimeDecay(\n 0.001, \n decay_steps = steps_per_epoch * 1000, \n decay_rate=1, \n staircase=False)\noptimizer = tf.keras.optimizers.Adam(lr_schedule)\n\n# setup callbacks\ncallbacks = []\nif 'early_stopping' in args:\n monitor = str(args['early_stopping'][0])\n patience = int(args['early_stopping'][1])\n callbacks.append(\n tf.keras.callbacks.EarlyStopping(monitor=monitor, patience=patience))\n\n# if args['tensorboard']:\n# callbacks.append(nnutils.get_tensorboard_log_callback(train.columns, args))\n\n\nlayers = args['layers'].copy()\nh = {}\nmodel = nnutils.get_sequential_model(feature_layer=feature_layer, layers=layers)\nmodel.compile(optimizer=optimizer, loss='binary_crossentropy', \n metrics=['accuracy', 'binary_crossentropy'])\nh['drop'] = model.fit(\n train_ds, validation_data=val_ds, epochs=args['epochs'], \n steps_per_epoch=steps_per_epoch, validation_steps=validation_steps,\n callbacks=callbacks, verbose=2)\n# print(h['drop'])\n# model.summary()\n# nnutils.plot_train_history(h['drop'], 'drop')"
] | [
[
"tensorflow.keras.layers.DenseFeatures",
"tensorflow.keras.optimizers.schedules.InverseTimeDecay",
"sklearn.model_selection.train_test_split",
"pandas.read_csv",
"tensorflow.keras.optimizers.Adam",
"tensorflow.keras.callbacks.EarlyStopping"
]
] |
chiccheung/PRD_rPPG_method_3DCNN | [
"c2da5c523dc960644b444c14b1417a8ec86eba25"
] | [
"pyVHR/pyVHR/analysis/stats.py"
] | [
"import pandas as pd\nimport numpy as np\nimport os\nimport re \nimport matplotlib.pyplot as plt\nimport plotly.graph_objects as go\nimport scipy.stats as ss\nimport scikit_posthocs as sp\nfrom .stattests import friedman_aligned_ranks_test as ft\nimport Orange\n\nclass StatAnalysis():\n \"\"\" Statistics analysis for multiple datasets and multiple VHR methods\"\"\"\n \n def __init__(self, filepath='default'):\n \n if os.path.isdir(filepath): \n self.multidataset = True\n self.path = filepath + \"/\"\n self.datasetsList = os.listdir(filepath)\n elif os.path.isfile(filepath): \n self.multidataset = False\n self.datasetsList = [filepath]\n self.path = \"\"\n else: \n raise(\"Error: filepath is wrong!\")\n \n # -- get common methods\n self.__getMethods()\n self.metricSort = {'MAE':'min','RMSE':'min','CC':'max','PCC':'max'}\n self.scale = {'MAE':'log','RMSE':'log','CC':'linear','PCC':'linear'}\n\n def FriedmanTest(self, methods=None, metric='MAE'):\n \n # -- Method(s) \n if methods == None:\n methods = self.methods\n else:\n if set(methods) <= set(self.methods):\n raise(\"Some method is wrong!\")\n else:\n self.methods = methods\n \n # -- set metric\n self.metric = metric\n self.mag = self.metricSort[metric]\n \n # -- get data from dataset(s)\n # return Y = mat(n-datasets,k-methods) \n if self.multidataset:\n Y = self.__getData()\n else:\n Y = self.__getDataMono()\n self.ndataset = Y.shape[0]\n \n # -- Friedman test\n t,p,ranks,piv = ft(Y)\n self.avranks = list(np.divide(ranks, self.ndataset))\n \n return t,p,ranks,piv,self.ndataset\n \n def SignificancePlot(self, methods=None, metric='MAE'):\n\n # -- Method(s) \n if methods == None:\n methods = self.methods\n else:\n if set(methods) <= set(self.methods):\n raise(\"Some method is wrong!\")\n else:\n self.methods = methods\n \n # -- set metric\n self.metric = metric\n self.mag = self.metricSort[metric]\n \n # -- get data from dataset(s)\n if self.multidataset:\n Y = self.__getData()\n else:\n Y = self.__getDataMono()\n \n # -- Significance plot, a heatmap of p values\n methodNames = [x.upper() for x in self.methods]\n Ypd = pd.DataFrame(Y, columns=methodNames)\n ph = sp.posthoc_nemenyi_friedman(Ypd)\n cmap = ['1', '#fb6a4a', '#08306b', '#4292c6', '#c6dbef']\n heatmap_args = {'cmap': cmap, 'linewidths': 0.25, 'linecolor': '0.5', \n 'clip_on': False, 'square': True, 'cbar_ax_bbox': [0.85, 0.35, 0.04, 0.3]}\n\n plt.figure(figsize=(5,4))\n sp.sign_plot(ph, cbar=True, **heatmap_args)\n plt.title('p-vals')\n \n fname = 'SP_' + self.metric + '.pdf'\n plt.savefig(fname)\n plt.show()\n \n def computeCD(self, avranks=None, numDatasets=None, alpha='0.05', display=True):\n \"\"\"\n Returns critical difference for Nemenyi or Bonferroni-Dunn test according \n to given alpha (either alpha=”0.05” or alpha=”0.1”) for average ranks and \n number of tested datasets N. Test can be either “nemenyi” for for Nemenyi \n two tailed test or “bonferroni-dunn” for Bonferroni-Dunn test.\n See Orange package docs.\n \"\"\"\n if not numDatasets:\n numDatasets = self.ndataset\n if not avranks:\n avranks = self.avranks\n \n cd = Orange.evaluation.compute_CD(avranks, numDatasets, alpha=alpha) #tested on 30 datasets\n \n if self.mag == 'min':\n reverse = True\n else:\n reverse = False\n \n methodNames = [x.upper() for x in self.methods]\n if display:\n Orange.evaluation.graph_ranks(avranks, methodNames, cd=cd, width=6, textspace=1.5, reverse=reverse)\n name = 'CD Diagram (metric: ' + self.metric +')'\n plt.title(name) \n fname = 'CD_' + self.metric + '.pdf'\n plt.savefig(fname)\n \n plt.show()\n return cd\n\n def displayBoxPlot(self, methods=None, metric='MAE', scale=None, title=True):\n \n # -- Method(s) \n if methods == None:\n methods = self.methods\n else:\n if set(methods) <= set(self.methods):\n raise(\"Some method is wrong!\")\n else:\n self.methods = methods\n \n # -- set metric\n self.metric = metric\n self.mag = self.metricSort[metric]\n if scale == None:\n scale = self.scale[metric]\n \n # -- get data from dataset(s)\n if self.multidataset:\n Y = self.__getData()\n else:\n Y = self.__getDataMono()\n \n # -- display box plot\n self.boxPlot(methods, metric, Y, scale=scale, title=title)\n \n def boxPlot(self, methods, metric, Y, scale, title):\n \n # Y = mat(n-datasets,k-methods) \n \n k = len(methods)\n \n if not (k == Y.shape[1]):\n raise(\"error!\")\n\n offset = 50\n fig = go.Figure()\n\n methodNames = [x.upper() for x in self.methods]\n for i in range(k):\n yd = Y[:,i]\n name = methodNames[i]\n # -- set color for box\n if metric == 'MAE' or metric == 'RMSE':\n med = np.median(yd)\n col = str(min(200,5*int(med)+offset))\n if metric == 'CC' or metric == 'PCC':\n med = 1-np.abs(np.median(yd))\n col = str(int(200*med)+offset)\n\n # -- add box \n fig.add_trace(go.Box(\n y=yd,\n name=name,\n boxpoints='all',\n jitter=.7,\n #whiskerwidth=0.2,\n fillcolor=\"rgba(\"+col+\",\"+col+\",\"+col+\",0.5)\",\n line_color=\"rgba(0,0,255,0.5)\",\n marker_size=2,\n line_width=2)\n )\n\n gwidth = np.max(Y)/10\n \n if title:\n tit = \"Metric: \" + metric\n top = 40\n else:\n tit=''\n top = 10\n \n fig.update_layout(\n title=tit,\n yaxis_type=scale,\n xaxis_type=\"category\",\n yaxis=dict(\n autorange=True,\n showgrid=True,\n zeroline=True,\n #dtick=gwidth,\n gridcolor='rgb(255,255,255)',\n gridwidth=.1,\n zerolinewidth=2,\n titlefont=dict(size=30)\n ),\n font=dict(\n family=\"monospace\",\n size=16,\n color='rgb(20,20,20)'\n ),\n margin=dict(\n l=20,\n r=10,\n b=20,\n t=top,\n ),\n paper_bgcolor='rgb(250, 250, 250)',\n plot_bgcolor='rgb(243, 243, 243)',\n showlegend=False\n )\n\n fig.show()\n \n def saveStatsData(self, methods=None, metric='MAE', outfilename='statsData.csv'):\n Y = self.getStatsData(methods=methods, metric=metric, printTable=False)\n np.savetxt(outfilename, Y)\n \n def getStatsData(self, methods=None, metric='MAE', printTable=True):\n # -- Method(s) \n if methods == None:\n methods = self.methods\n else:\n if set(methods) <= set(self.methods):\n raise(\"Some method is wrong!\")\n else:\n self.methods = methods\n \n # -- set metric\n self.metric = metric\n self.mag = self.metricSort[metric]\n \n # -- get data from dataset(s)\n # return Y = mat(n-datasets,k-methods) \n if self.multidataset:\n Y = self.__getData()\n else:\n Y = self.__getDataMono()\n \n # -- add median and IQR\n I = ss.iqr(Y,axis=0)\n M = np.median(Y,axis=0)\n Y = np.vstack((Y,M))\n Y = np.vstack((Y,I))\n \n if printTable:\n methodNames = [x.upper() for x in self.methods]\n dataseNames = self.datasetNames\n dataseNames.append('Median')\n dataseNames.append('IQR')\n df = pd.DataFrame(Y, columns=methodNames, index=dataseNames)\n display(df)\n \n return Y\n\n def __getDataMono(self):\n mag = self.mag\n metric = self.metric\n methods = self.methods\n \n frame = self.dataFrame[0]\n # -- loop on methods\n Y = []\n for method in methods:\n vals = frame[frame['method'] == method][metric]\n if mag == 'min':\n data = [v[np.argmin(v)] for v in vals]\n else:\n data = [v[np.argmax(v)] for v in vals]\n Y.append(data)\n \n return np.array(Y).T\n\n def __getData(self):\n \n mag = self.mag\n metric = self.metric\n methods = self.methods\n \n # -- loop on datasets\n Y = []\n for frame in self.dataFrame:\n \n # -- loop on methods\n y = []\n for method in methods:\n vals = frame[frame['method'] == method][metric]\n if mag == 'min':\n data = [v[np.argmin(v)] for v in vals]\n else:\n data = [v[np.argmax(v)] for v in vals]\n\n y.append(data)\n \n y = np.array(y)\n Y.append(np.mean(y,axis=1)) \n return np.array(Y)\n \n def __getMethods(self):\n \n mets = []\n dataFrame = []\n N = len(self.datasetsList)\n \n # -- load dataframes\n self.datasetNames = []\n for file in self.datasetsList:\n filename = self.path + file\n self.datasetNames.append(file)\n data = pd.read_hdf(filename)\n mets.append(set(list(data['method'])))\n dataFrame.append(data)\n\n # -- method names intersection among datasets\n methods = set(mets[0])\n if N > 1:\n for m in range(1,N-1):\n methods.intersection(mets[m])\n\n methods = list(methods)\n methods.sort()\n self.methods = methods\n self.dataFrame = dataFrame\n\n \n"
] | [
[
"scipy.stats.iqr",
"numpy.divide",
"numpy.array",
"numpy.max",
"numpy.savetxt",
"numpy.argmin",
"numpy.median",
"matplotlib.pyplot.savefig",
"pandas.DataFrame",
"matplotlib.pyplot.title",
"numpy.mean",
"matplotlib.pyplot.figure",
"pandas.read_hdf",
"numpy.argmax",
"matplotlib.pyplot.show",
"numpy.vstack"
]
] |
mhauru/Gilt-TNR | [
"73c288d8f9a60d9cd7bdc2bda071ff536c7448cf"
] | [
"GiltTNR3D_envspec.py"
] | [
"import numpy as np\nimport sys\nimport os\nimport warnings\nimport logging\nimport logging.config\nimport configparser\nimport datetime\nimport GiltTNR3D\nfrom tntools import datadispenser, multilineformatter\nfrom tntools.yaml_config_parser import parse_argv\n\ntools_path = os.path.dirname(multilineformatter.__file__)\nlogging.config.fileConfig(tools_path + \"/logging_default.conf\")\nfilename = os.path.basename(__file__).replace(\".py\", \"\")\nnp.set_printoptions(precision=10)\n\nparinfo = {\n \"iters\": {\n \"default\": range(1, 6),\n },\n \"debug\": {\n \"default\": False\n },\n \"database\": {\n \"default\": \"data/GiltTNR3D/\"\n },\n \"envtype\": {\n \"default\": \"cube\"\n }\n}\n\n\ndef parse():\n pars = parse_argv(sys.argv)\n pars[\"algorithm\"] = \"GiltTNR3D\"\n return pars\n\n\ndef apply_default_pars(pars, parinfo):\n for k, v in parinfo.items():\n if k not in pars:\n pars[k] = v[\"default\"]\n return\n\n\ndef set_filehandler(logger, logfilename, pars):\n os.makedirs(os.path.dirname(logfilename), exist_ok=True)\n filehandler = logging.FileHandler(logfilename, mode='w')\n if pars[\"debug\"]:\n filehandler.setLevel(logging.DEBUG)\n else:\n filehandler.setLevel(logging.INFO)\n parser = configparser.ConfigParser(interpolation=None)\n parser.read(tools_path + '/logging_default.conf')\n fmt = parser.get('formatter_default', 'format')\n datefmt = parser.get('formatter_default', 'datefmt')\n formatter = multilineformatter.MultilineFormatter(fmt=fmt, datefmt=datefmt)\n filehandler.setFormatter(formatter)\n rootlogger.addHandler(filehandler)\n return\n\n\nif __name__ == \"__main__\":\n pars = parse()\n apply_default_pars(pars, parinfo)\n datadispenser.update_default_pars(\"As\", pars, iter_count=max(pars[\"iters\"]))\n\n if pars[\"debug\"]:\n warnings.filterwarnings('error')\n\n datetime_str = datetime.datetime.strftime(datetime.datetime.now(),\n '%Y-%m-%d_%H-%M-%S')\n title_str = '{}_{}'.format(filename, datetime_str)\n logfilename = \"logs/{}.log\".format(title_str)\n rootlogger = logging.getLogger()\n set_filehandler(rootlogger, logfilename, pars)\n\n # - Infoprint -\n infostr = \"\\n{}\\n\".format(\"=\"*70)\n infostr += \"Running {} with the following parameters:\".format(filename)\n for k,v in sorted(pars.items()):\n infostr += \"\\n%s = %s\"%(k, v)\n logging.info(infostr)\n\n dbname = pars[\"database\"]\n\n for it in pars[\"iters\"]:\n data = datadispenser.get_data(dbname, \"As\", pars, iter_count=it)\n As = data[0]\n if pars[\"envtype\"] == \"cube\":\n env = GiltTNR3D.build_gilt_cube_env(As, pars)\n elif pars[\"envtype\"] == \"square\":\n env = GiltTNR3D.build_gilt_square_env(As, pars, \"horz_across\")\n else:\n msg = \"Unknown envtype {}.\".format(pars[\"envtype\"])\n raise ValueError(msg)\n S, U = env.eig([0,1], [2,3], hermitian=True)\n S = S.abs().sqrt()\n S /= S.sum()\n GiltTNR3D.print_envspec(S)\n\n"
] | [
[
"numpy.set_printoptions"
]
] |
programmer1017/python | [
"3dce528be121ced032157c9d800b4770989889bf"
] | [
"matplotlib/legend/legend2.py"
] | [
"import matplotlib.pyplot as plt\n\nplt.plot([1, 2, 3, 4], [2, 3, 5, 10], label='Price ($)') # 그래프 1\nplt.plot([1, 2, 3, 4], [3, 5, 9, 7], label='Demand (#)') # 그래프 2\n\nplt.xlabel('X-Axis', labelpad = 10)\nplt.ylabel('Y-Axis')\n\n# plt.legend(loc='best',ncol = 1)\nplt.legend(loc='best', ncol = 2, fontsize = 10, frameon = False, shadow = False)\n\n# frameon: True일 경우 범례에 둥근 직사각형 모양의 테두리가 나타난다. (default: True)\n# shadow: True일 경우 frameon에 그림자 효과가 적용된다. (defualt: False)즉 frameon이 True이어야 한다.\n# fontsize: 말 그대로 범례의 폰트 크기를 조절한다. 단위는 pt.\n\n#ncol은 열의 개수(열: 세로)로써 ncol이 1이면 범례가 2개니까 1x2형식, ncol이 2이면 2x1 형식으로 범례가 나타난다.\n\n\nplt.show()"
] | [
[
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.legend",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.show"
]
] |
tangchunbo/machine-learning | [
"22f289d30d456d5d220bb34d846a61d6fa0fe81e"
] | [
"ml/linearRegression/RegressionMetrics.py"
] | [
"import numpy as np\nimport matplotlib.pyplot as plt\nfrom sklearn import datasets\nfrom SimpleLinearRegression1 import SimpleLinearRegression2\nfrom model_selection import train_test_split\nfrom math import sqrt\n# scikit-learn 中的指标\nfrom sklearn.metrics import mean_squared_error, mean_absolute_error\n\n# boston 房产\nboston = datasets.load_boston()\n# 506 条记录\n# 13个特征\n# print(boston.DESCR)\n# print(boston.feature_names)\n\n# 取房间数量作为特征值\n\nx = boston.data[:, 5]\ny = boston.target\n\nplt.scatter(x, y)\nplt.show()\n\n# 去除一些噪音\nx = x[y < 50]\ny = y[y < 50]\n\nplt.scatter(x, y)\nplt.show()\n\nx_train, x_test, y_train, y_test = train_test_split(x, y, seed=666)\n\nprint(x_train.shape)\nreg = SimpleLinearRegression2()\nreg.fit(x_train, y_train)\n\nplt.scatter(x_train, y_train)\nplt.plot(x_train, reg.predict(x_train), color='r')\nplt.show()\n\ny_predict = reg.predict(x_test)\n\n# MSE\n\nmse_test = np.sum((y_test - y_predict) ** 2) / len(y_test)\nprint(mse_test)\n\n# RMSE\nrmse_test = sqrt(mse_test)\nprint(rmse_test)\n\n# MAE\nmae_test = np.sum(np.absolute(y_test - y_predict)) / len(y_test)\nprint(mae_test)\n\n\nsk_mse_test = mean_squared_error(y_test, y_predict)\nprint(sk_mse_test)\n\nsk_mae_test = mean_absolute_error(y_predict, y_test)\nprint(sk_mae_test)\n"
] | [
[
"sklearn.metrics.mean_squared_error",
"numpy.sum",
"sklearn.metrics.mean_absolute_error",
"matplotlib.pyplot.show",
"numpy.absolute",
"matplotlib.pyplot.scatter",
"sklearn.datasets.load_boston"
]
] |
erezposner/pytorch-CycleGAN-and-pix2pix | [
"842873a541dbc945f050515a3f39bc9029cf7701"
] | [
"models/separated_cg_model.py"
] | [
"import torch\nfrom pytorch3d.io import load_objs_as_meshes, save_obj\nfrom pytorch3d.renderer import MeshRenderer, MeshRasterizer, PointLights, TexturedSoftPhongShader, \\\n look_at_view_transform, OpenGLPerspectiveCameras, RasterizationSettings, BlendParams, DirectionalLights, Materials, \\\n SoftSilhouetteShader\nfrom pytorch3d.renderer.mesh.shader import UVsCorrespondenceShader\nfrom pytorch3d.structures import Textures\nimport numpy as np\n\nfrom util.util import UnNormalize, Normalize\nfrom .base_model import BaseModel\nfrom . import networks\nfrom .FlameDecoder import FlameDecoder\nfrom types import SimpleNamespace\nfrom torchvision.transforms import transforms\nfrom PIL import Image\nfrom pathlib import Path\n\nfrom .face_part_seg.FacePartSegmentation import FacePartSegmentation\n# from .face_part_seg.model import BiSeNet\n# from .face_part_seg.test_face_seg import vis_parsing_maps\nfrom .mesh_making import make_mesh\nimport pickle\nimport cv2\nimport os\nimport torch.nn.functional as F\n\n\nclass separatedcgmodel(BaseModel):\n \"\"\" This class implements the pix2pix model, for learning a mapping from input images to output images given paired data.\n\n The model training requires '--dataset_mode aligned' dataset.\n By default, it uses a '--netG unet256' U-Net generator,\n a '--netD basic' discriminator (PatchGAN),\n and a '--gan_mode' vanilla GAN loss (the cross-entropy objective used in the orignal GAN paper).\n\n pix2pix paper: https://arxiv.org/pdf/1611.07004.pdf\n \"\"\"\n\n @staticmethod\n def modify_commandline_options(parser, is_train=True):\n \"\"\"Add new dataset-specific options, and rewrite default values for existing options.\n\n Parameters:\n parser -- original option parser\n is_train (bool) -- whether training phase or test phase. You can use this flag to add training-specific or test-specific options.\n\n Returns:\n the modified parser.\n\n For pix2pix, we do not use image buffer\n The training objective is: GAN Loss + lambda_L1 * ||G(A)-B||_1\n By default, we use vanilla GAN loss, UNet with batchnorm, and aligned datasets.\n \"\"\"\n # changing the default values to match the pix2pix paper (https://phillipi.github.io/pix2pix/)\n parser.set_defaults(norm='batch', netG='unet_256', dataset_mode='cg_aligned')\n if is_train:\n parser.set_defaults(pool_size=0, gan_mode='vanilla')\n parser.add_argument('--lambda_L1', type=float, default=50.0, help='weight for L1 loss')\n parser.add_argument('--lambda_silhouette', type=float, default=1e-5,\n help='weight for silhouette loss')\n parser.add_argument('--lambda_face_seg', type=float, default=1e-5,\n help='weight for face parts segmentation loss')\n parser.add_argument('--lambda_flame_regularizer', type=float, default=500, # 500.0\n help='weight for flame regularizer loss')\n\n return parser\n\n def __init__(self, opt):\n \"\"\"Initialize the pix2pix class.\n\n Parameters:\n opt (Option class)-- stores all the experiment flags; needs to be a subclass of BaseOptions\n \"\"\"\n BaseModel.__init__(self, opt)\n config = SimpleNamespace(batch_size=self.opt.batch_size, flame_model_path='./smpl_model/flame2020/male_model.pkl')\n\n self.flamelayer = FlameDecoder(config)\n self.flamelayer.cuda()\n # config.use_3D_translation = True # could be removed, depending on the camera model\n # config.use_face_contour = False\n self.face_parts_segmentation = FacePartSegmentation(self.device)\n\n # specify the training losses you want to print out. The training/test scripts will call <BaseModel.get_current_losses>\n # self.loss_names = ['G_GAN', 'G_L1', 'D_real', 'D_fake']\n self.loss_names = ['G_GAN', 'G_L1', 'D_real', 'D_fake', 'silhouette', '3d_face_part_segmentation']\n # specify the images you want to save/display. The training/test scripts will call <BaseModel.get_current_visuals>\n # self.visual_names = ['real_A', 'fake_Texture', 'fake_B', 'real_B','loss_G_L1_reducted']\n self.visual_names = ['real_A','fake_Texture', 'fake_B', 'real_B', 'loss_3d_face_part_segmentation_de']\n # self.visual_names = ['fake_Texture', 'fake_B', 'real_B']\n # specify the models you want to save to the disk. The training/test scripts will call <BaseModel.save_networks> and <BaseModel.load_networks>\n if self.isTrain:\n self.model_names = ['G', 'D', 'Global_shape']\n else: # during test time, only load G\n self.model_names = ['G', 'Global_shape']\n\n # initialize flame parameters\n self.shape_params_size = 300\n self.expression_params_size = 100\n self.neck_pose_params_size = 3\n self.jaw_pose_size = 3\n self.global_rot_size = 3\n self.transl_size = 3\n self.eyball_pose_size = 6\n # define networks (both generator and discriminator)\n # TODO opt.output_nc instead of 2 if generating images\n self.netGlobal_shape = networks.define_global_shape(self.shape_params_size, self.gpu_ids)\n\n self.netG = networks.define_G(opt.input_nc, opt.output_nc, opt.ngf, opt.netG, opt.norm,\n not opt.no_dropout, opt.init_type, opt.init_gain, self.gpu_ids)\n self.netF = networks.define_F(opt.input_nc, opt.output_flame_params, opt.ngf, opt.netG, opt.norm,\n not opt.no_dropout, opt.init_type, opt.init_gain, self.gpu_ids)\n\n # self.netGlobal_shape = torch.nn.Parameter(torch.randn((1, 1, self.shape_params_size)).to(self.device),\n # requires_grad=True)\n\n if self.isTrain: # define a discriminator; conditional GANs need to take both input and output images; Therefore, #channels for D is input_nc + output_nc\n self.netD = networks.define_D(opt.input_nc + opt.output_nc, opt.ndf, opt.netD,\n opt.n_layers_D, opt.norm, opt.init_type, opt.init_gain, self.gpu_ids)\n\n if self.isTrain:\n # define loss functions\n self.visual_names.append('loss_G_L1_reducted')\n self.criterionGAN = networks.GANLoss(opt.gan_mode, soft_labels=self.opt.soft_labels).to(self.device)\n self.criterionL1 = torch.nn.L1Loss(reduction='none')\n # self.CrossEntropyCriterion = torch.nn.CrossEntropyLoss(reduction='none')\n self.CrossEntropyCriterion1 = torch.nn.NLLLoss(reduction='none')\n self.CrossEntropyCriterion2 = torch.nn.L1Loss(reduction='none')\n\n self.criterionBCE = torch.nn.BCELoss(reduction='none')\n\n # initialize optimizers; schedulers will be automatically created by function <BaseModel.setup>.\n\n self.optimizer_G = torch.optim.Adam(self.netG.parameters(), lr=opt.lr, betas=(opt.beta1, 0.999))\n # self.optimizer_F = torch.optim.Adam(list(self.netF.parameters()) + [self.netGlobal_shape], lr=opt.lr,\n # betas=(opt.beta1, 0.999))\n self.optimizer_F = torch.optim.Adam(list(self.netF.parameters()) + list(self.netGlobal_shape.parameters()),\n lr=opt.lr,\n betas=(opt.beta1, 0.999))\n # self.optimizer_D = torch.optim.Adam(self.netD.parameters(), lr=opt.lr, betas=(opt.beta1, 0.999))\n self.optimizer_D = torch.optim.SGD(self.netD.parameters(),\n lr=opt.lr) # TODO Check is SGD is better than ADAM\n self.optimizers.append(self.optimizer_G)\n self.optimizers.append(self.optimizer_D)\n self.optimizers.append(self.optimizer_F)\n\n self.init_differential_renderer()\n self.set_default_weights()\n\n def init_differential_renderer(self):\n\n distance = 0.3\n R, T = look_at_view_transform(distance, 0, 0)\n cameras = OpenGLPerspectiveCameras(device=self.device, R=R, T=T)\n raster_settings = RasterizationSettings(\n image_size=self.opt.crop_size,\n blur_radius=0.0,\n faces_per_pixel=1,\n perspective_correct=True,\n cull_backfaces=True\n )\n silhouette_raster_settings = RasterizationSettings(\n image_size=self.opt.crop_size,\n blur_radius=0.0,\n faces_per_pixel=1,\n perspective_correct=True,\n )\n # Change specular color to green and change material shininess\n self.materials = Materials(\n device=self.device,\n ambient_color=[[1.0, 1.0, 1.0]],\n specular_color=[[0.0, 0.0, 0.0]],\n diffuse_color=[[1.0, 1.0, 1.0]],\n )\n bp = BlendParams(background_color=(0, 0, 0)) # black\n # bp = BlendParams(background_color=(1, 1, 1)) # white is default\n\n lights = PointLights(device=self.device, location=((0.0, 0.0, 2.0),))\n\n self.renderer = MeshRenderer(\n rasterizer=MeshRasterizer(\n cameras=cameras,\n raster_settings=raster_settings\n ),\n\n shader=TexturedSoftPhongShader(\n # blend_params=bp,\n device=self.device,\n lights=lights,\n cameras=cameras,\n )\n )\n import cv2\n\n # segmentation_texture_map = cv2.imread(str(Path('resources') / 'part_segmentation_map_2048_gray_n_h.png'))[...,\n segmentation_texture_map = cv2.imread(str(Path('resources') / 'Color_Map_Sag_symmetric.png'))[...,\n ::-1].astype(np.uint8)\n import matplotlib.pyplot as plt\n plt.imshow(segmentation_texture_map)\n plt.show()\n\n segmentation_texture_map = (torch.from_numpy(np.array(segmentation_texture_map))).unsqueeze(0).float()\n self.segmentation_3d_renderer = MeshRenderer(\n rasterizer=MeshRasterizer(\n cameras=cameras,\n raster_settings=raster_settings\n ),\n\n shader=UVsCorrespondenceShader(\n blend_params=bp,\n device=self.device,\n cameras=cameras,\n colormap=segmentation_texture_map\n )\n )\n\n # Create a silhouette mesh renderer by composing a rasterizer and a shader.\n self.silhouette_renderer = MeshRenderer(\n rasterizer=MeshRasterizer(\n cameras=cameras,\n raster_settings=silhouette_raster_settings\n ),\n shader=SoftSilhouetteShader(blend_params=BlendParams(sigma=1e-10, gamma=1e-4))\n )\n self.negative_silhouette_renderer = MeshRenderer(\n rasterizer=MeshRasterizer(\n cameras=cameras,\n raster_settings=raster_settings\n ),\n shader=SoftSilhouetteShader(blend_params=BlendParams(sigma=1e-10, gamma=1e-4))\n )\n self.texture_data = np.load('smpl_model/texture_data.npy', allow_pickle=True, encoding='latin1').item()\n self.verts_uvs1 = torch.tensor(self.texture_data['vt'], dtype=torch.float32).unsqueeze(0).cuda(\n self.device)\n self.faces_uvs1 = torch.tensor(self.texture_data['ft'].astype(np.int64), dtype=torch.int64).unsqueeze(0).cuda(\n self.device)\n\n def set_input(self, input):\n \"\"\"Unpack input data from the dataloader and perform necessary pre-processing steps.\n\n Parameters:\n input (dict): include the data itself and its metadata information.\n\n The option 'direction' can be used to swap images in domain A and domain B.\n \"\"\"\n AtoB = self.opt.direction == 'AtoB'\n self.real_A = input['A' if AtoB else 'B'].to(self.device)\n self.real_B = input['B' if AtoB else 'A'].to(self.device)\n self.true_flame_params = input['true_flame_params']\n for k in self.true_flame_params.keys():\n self.true_flame_params[k] = self.true_flame_params[k].to(self.device)\n self.silh = input['silh'].to(self.device)\n self.true_mask = input['true_mask'].to(self.device)\n\n self.true_mask = self.true_mask.clamp(0, 1)\n\n # self.real_C = input['C'].to(self.device)\n self.image_paths = input['A_paths' if AtoB else 'B_paths']\n\n def create_geo_from_flame_params(self, flame_param, base_flame_params=None, use_fix_params=False):\n scale = 0.0001\n # scale = 10\n\n if base_flame_params is None:\n base_flame_params = {}\n base_flame_params['shape_params'] = torch.zeros((1, 1, self.shape_params_size)).cuda()\n base_flame_params['expression_params'] = torch.zeros((1, 1, self.expression_params_size)).cuda()\n base_flame_params['neck_pose_params'] = torch.zeros((1, 1, self.neck_pose_params_size)).cuda()\n base_flame_params['jaw_pose'] = torch.zeros((1, 1, self.jaw_pose_size)).cuda()\n base_flame_params['global_rot'] = torch.zeros((1, 1, self.global_rot_size)).cuda()\n base_flame_params['transl'] = torch.zeros((1, 1, self.transl_size)).cuda()\n\n if use_fix_params:\n flame_param = torch.zeros((1, 418)).cuda()\n # Creating a batch of mean shapes\n ind = 0\n # if use_fix_params:\n # flame_param[:, ind:shape_params_size] = data['shape_params']\n # self.shape_params = flame_param[:, ind:self.shape_params_size] + base_flame_params['shape_params']\n self.shape_params = self.netGlobal_shape.module.global_shape\n\n ind += self.shape_params_size\n # if use_fix_params:\n # flame_param[:, ind:ind + expression_params_size] = data['expression_params']\n self.expression_params = flame_param[:, ind:ind + self.expression_params_size] + \\\n base_flame_params['expression_params'][0]\n # self.expression_params = base_flame_params['expression_params'][0]\n ind += self.expression_params_size\n # if use_fix_params:\n # flame_param[:, ind:ind + neck_pose_params_size] = data['neck_pose_params']\n self.neck_pose = flame_param[:, ind:ind + self.neck_pose_params_size] + base_flame_params['neck_pose_params'][0]\n ind += self.neck_pose_params_size\n # if use_fix_params:\n # flame_param[:, ind:ind + jaw_pose_size] = data['jaw_pose']\n self.jaw_pose = flame_param[:, ind:ind + self.jaw_pose_size] + base_flame_params['jaw_pose'][0]\n # self.jaw_pose = base_flame_params['jaw_pose'][0]\n ind += self.jaw_pose_size\n # if use_fix_params:\n # flame_param[:, ind:ind + global_rot_size] = data['global_rot']\n global_rot = flame_param[:, ind:ind + self.global_rot_size] * scale + base_flame_params['global_rot'][0]\n # global_rot = global_rot.clamp(-1, 1) # TODO check clamp rotation\n\n ind += self.global_rot_size\n\n self.pose_params = torch.cat([global_rot, self.jaw_pose], dim=1)\n # if use_fix_params:\n # flame_param[:, ind:ind + transl_size] = data['transl']\n self.transl = flame_param[:, ind:ind + self.transl_size] * scale + base_flame_params['transl'][0]\n\n # self.transl = self.transl.clamp(-.3, .3) # TODO check clamp translation\n ind += self.transl_size\n self.eyball_pose = flame_param[:, ind:ind + self.eyball_pose_size]\n ind += self.eyball_pose_size\n vertices = self.flamelayer(shape_params=self.shape_params[0], expression_params=self.expression_params,\n pose_params=self.pose_params, neck_pose=self.neck_pose, transl=self.transl,\n eye_pose=self.eyball_pose)\n return vertices\n\n def project_to_image_plane(self, vertices, texture_map):\n # self.renderer\n if False: # hardcoded example\n with torch.no_grad():\n transform = transforms.Compose([\n transforms.ToTensor(),\n ])\n\n direc = Path('bareteeth.000001.26_C/minibatch_0_Netural_0')\n tex = Image.open(direc / 'mesh.png')\n texture_map = transform(tex).unsqueeze(0)\n mesh = load_objs_as_meshes([direc / 'mesh.obj'], device=self.device)\n vertices = mesh.verts_padded()\n # final_obj = os.path.join('out/', 'final_model.obj')\n # import datetime\n # now = datetime.datetime.now()\n # final_obj = f'{self.save_dir}/web/images/{now.strftime(\"%Y-%m-%d_%H:%M:%S\")}_fake_mesh.obj'\n # final_obj = f'{self.save_dir}/web/images/{self.opt.epoch_count:03d}_fake_mesh.obj'\n # save_obj(final_obj, vertices[0], torch.from_numpy(self.flamelayer.faces.astype(np.int32)))\n self.estimated_texture_map = texture_map.permute(0, 2, 3, 1)\n texture = Textures(self.estimated_texture_map, faces_uvs=self.faces_uvs1, verts_uvs=self.verts_uvs1)\n\n self.estimated_mesh = make_mesh(vertices.squeeze(), self.flamelayer.faces, False, texture)\n # save_obj(final_obj, estimated_mesh.verts_packed(), torch.from_numpy(self.flamelayer.faces.astype(np.int32)),\n # verts_uvs=estimated_mesh.textures.verts_uvs_packed(), texture_map=self.estimated_texture_map,\n # faces_uvs=estimated_mesh.textures.faces_uvs_packed())\n\n images = self.renderer(self.estimated_mesh, materials=self.materials)\n silhouette_images = self.silhouette_renderer(self.estimated_mesh, materials=self.materials)[..., 3].unsqueeze(0)\n negative_silhouette_images = self.negative_silhouette_renderer(self.estimated_mesh, materials=self.materials)[\n ..., 3].unsqueeze(0)\n if self.opt.verbose:\n transforms.ToPILImage()(silhouette_images.squeeze().permute(0, 1).cpu()).save('out/silhouette.png')\n # transforms.ToPILImage()(images.squeeze().permute(2, 0, 1).cpu()).save('out/img.png')\n cull_backfaces_mask = (1 - (silhouette_images - negative_silhouette_images).abs())\n img = (images[0][..., :3].detach().cpu().numpy() * 255).astype(np.uint8)\n if self.opt.verbose:\n Image.fromarray(img).save('out/test1.png')\n images = Normalize(images)\n silhouette_images = silhouette_images.clamp(0, 1)\n segmented_3d_model_image = self.segmentation_3d_renderer(self.estimated_mesh)\n # Image.fromarray(\n # ((255 * segmentation_image[0, ..., :3]).squeeze().detach().cpu().numpy().astype(np.uint8))).save(\n # str('out/segmentatino_texture.png')\n # )\n return images[..., :3].permute(0, 3, 1, 2), silhouette_images, cull_backfaces_mask, segmented_3d_model_image[..., :3].permute(0, 3, 1, 2)\n\n def UnNormalize(self, img):\n return img * 0.5 + 0.5\n\n def Normalize(self, img):\n return (img - 0.5) / 0.5\n\n def forward(self):\n \"\"\"Run forward pass; called by both functions <optimize_parameters> and <test>.\"\"\"\n if True:\n self.uvs = self.netG(self.real_A) # RefinedTextureMap = G(TextureMap)\n use_uvs = False\n if use_uvs: # don't forget to set net output channels to 2\n # region use displacement with inital guess that is 0\n yv, xv = torch.meshgrid([torch.arange(0, self.real_A.shape[3]), torch.arange(0, self.real_A.shape[2])])\n xv = xv.unsqueeze(0).unsqueeze(0) / 127.5 - 1\n yv = yv.unsqueeze(0).unsqueeze(0) / 127.5 - 1\n uvs_init = torch.cat((xv, yv), 1).permute(0, 2, 3, 1).to(self.device)\n self.fake_Texture = F.grid_sample(self.real_A, uvs_init + self.uvs.permute(0, 2, 3, 1) / 10)\n else:\n self.fake_Texture = self.uvs\n # endregion\n # aaa = 255 * (\n # self.real_A * 0.5 + 0.5)\n # self.fake_B = self.project_to_image_plane(self.fake_geo_from_flame, aaa\n # )\n # cv2.imwrite('out/t.png',\n # (self.fake_B.detach().cpu().squeeze().permute(1, 2, 0).numpy()).astype(np.uint8))\n # torch.autograd.set_detect_anomaly(True)\n self.fake_flame = self.netF(self.real_B) # FlameParams = G(CapturedImg)\n if self.opt.constant_data:\n with open('bareteeth.000001.26_C/coma_2/flame_params.pkl', 'rb') as file:\n data = pickle.load(file)\n with torch.no_grad():\n self.fake_flame = data\n\n zero_out_estimated_geomtery = False\n self.fake_geo_from_flame = self.create_geo_from_flame_params(self.fake_flame,\n base_flame_params=self.true_flame_params,\n use_fix_params=zero_out_estimated_geomtery)\n\n # self.fake_B = self.project_to_image_plane(self.fake_geo_from_flame, UnNormalize(self.real_A))\n self.fake_B, self.fake_B_silhouette, self.cull_backfaces_mask, self.segmented_3d_model_image = self.project_to_image_plane(\n self.fake_geo_from_flame,\n UnNormalize(self.fake_Texture))\n else:\n self.fake_B = self.netG(self.real_A) # G(Texture)\n # with torch.no_grad(): #TODO check test or remove\n # self.fake_B = self.fake_B * self.cull_backfaces_mask\n # self.real_B = self.real_B * self.cull_backfaces_mask\n # eventually should produce self.fake_B\n\n def set_default_weights(self):\n\n self.weights = {}\n # Weight of the landmark distance term\n self.weights['lmk'] = 1.0\n\n # weights for different regularization terms\n self.weights['laplace'] = 100\n self.weights['euc_reg'] = 0.1\n\n # Weights for flame params regularizers\n self.weights['shape'] = 1e-3\n # Weight of the expression regularizer\n self.weights['expr'] = 1e-3\n # Weight of the neck pose (i.e. neck rotationh around the neck) regularizer\n self.weights['neck_pose'] = 100.0\n # Weight of the jaw pose (i.e. jaw rotation for opening the mouth) regularizer\n self.weights['jaw_pose'] = 1e-3\n\n def flame_regularizer_loss(self, vertices):\n # pose_params = torch.cat([self.global_rot, self.jaw_pose], dim=1)\n\n shape_params = self.shape_params\n flame_reg = self.weights['neck_pose'] * torch.sum(self.neck_pose ** 2) + self.weights[\n 'jaw_pose'] * torch.sum(\n self.jaw_pose ** 2) + \\\n self.weights['shape'] * torch.sum(shape_params ** 2) + self.weights['expr'] * torch.sum(\n self.expression_params ** 2)\n return flame_reg\n\n def backward_D(self):\n \"\"\"Calculate GAN loss for the discriminator\"\"\"\n # Fake; stop backprop to the generator by detaching fake_B\n fake_AB = torch.cat((self.real_A, self.fake_B),\n 1) # we use conditional GANs; we need to feed both input and output to the discriminator\n pred_fake = self.netD(fake_AB.detach())\n self.loss_D_fake = self.criterionGAN(pred_fake, False)\n # Real\n real_AB = torch.cat((self.real_A, self.real_B), 1)\n pred_real = self.netD(real_AB)\n self.loss_D_real = self.criterionGAN(pred_real, True)\n # combine loss and calculate gradients\n self.loss_D = (self.loss_D_fake + self.loss_D_real) * 0.5\n self.loss_D.backward()\n\n def backward_G(self):\n \"\"\"Calculate GAN and L1 loss for the generator\"\"\"\n # First, G(A) should fake the discriminator\n fake_AB = torch.cat((self.real_A, self.fake_B), 1)\n pred_fake = self.netD(fake_AB)\n self.loss_G_GAN = self.criterionGAN(pred_fake, True)\n # Second, G(A) = B\n\n self.loss_G_L1_reducted = self.criterionL1(self.fake_B,\n self.real_B) * self.rect_mask # * self.cull_backfaces_mask\n self.loss_G_L1 = self.loss_G_L1_reducted.abs().mean() * self.opt.lambda_L1\n self.loss_G_L1_reducted = self.loss_G_L1_reducted.abs().mean(1).unsqueeze(0).clamp(0, 255)\n # image_pil = transforms.ToPILImage()(self.loss_G_L1[0].cpu())\n # image_pil.save('out/s.png')\n\n self.loss_F_Reg = self.flame_regularizer_loss(self.fake_geo_from_flame) * self.opt.lambda_flame_regularizer\n # silhouette loss\n self.loss_silhouette = self.rect_mask.squeeze()[0] * self.criterionBCE(\n self.rect_mask.squeeze()[0] * self.fake_B_silhouette.squeeze(),\n self.rect_mask.squeeze()[0] * self.true_mask.squeeze())\n if self.opt.verbose:\n transforms.ToPILImage()(255 * self.loss_silhouette.cpu()).save('out/loss_silhouette.png')\n transforms.ToPILImage()(self.segmented_3d_model_image.cpu().squeeze() / 255).save('out/segmentatino_texture.png')\n transforms.ToPILImage()(self.real_B_seg.cpu().squeeze() / 255).save('out/real_B_seg_cat.png')\n eta = 0.01\n self.loss_silhouette = self.loss_silhouette.sum() * self.opt.lambda_silhouette\n self.segmented_3d_one_hot_model_image = torch.nn.functional.one_hot(\n (self.segmented_3d_model_image[:, 0, :, :]).long()).float().permute(0, 3, 1, 2)\n self.segmented_3d_one_hot_model_image[self.segmented_3d_one_hot_model_image == 0] = self.segmented_3d_one_hot_model_image[self.segmented_3d_one_hot_model_image == 0] + eta\n # self.segmented_3d_one_hot_model_image[self.segmented_3d_one_hot_model_image == 1] = self.segmented_3d_one_hot_model_image[self.segmented_3d_one_hot_model_image == 1] - eta\n self.loss_3d_face_part_segmentation = self.CrossEntropyCriterion1(\n torch.log(self.segmented_3d_one_hot_model_image),\n self.real_B_seg.long()) * self.opt.lambda_face_seg\n self.loss_3d_face_part_segmentation_de = self.loss_3d_face_part_segmentation.clamp(0, 255).unsqueeze(0) * 1000\n\n # self.loss_3d_face_part_segmentation = self.CrossEntropyCriterion2(self.segmented_3d_model_image[:, 0, :, :],\n # self.real_B_seg.float()) * self.opt.lambda_face_seg\n # self.loss_3d_face_part_segmentation_de = self.loss_3d_face_part_segmentation.clamp(0,255).unsqueeze(0) / 255\n # transforms.ToPILImage()(self.loss_3d_face_part_segmentation_de.cpu().squeeze()).save('out/loss_3d_face_part_segmentation.png')\n if self.opt.verbose:\n transforms.ToPILImage()(self.loss_3d_face_part_segmentation_de.cpu().squeeze()).save('out/loss_3d_face_part_segmentation_de.png')\n\n self.loss_3d_face_part_segmentation = self.loss_3d_face_part_segmentation.sum() * 100 # * self.opt.lambda_face_seg\n\n # self.loss_2d_face_part_segmentation = self.CrossEntropyCriterion(self.fake_B_seg,\n # self.real_B_seg.long()) * self.opt.lambda_face_seg\n # combine loss and calculate gradients\n self.loss_G = self.loss_G_GAN + self.loss_G_L1 + self.loss_F_Reg + self.loss_3d_face_part_segmentation # + self.loss_silhouette + self.loss_face_part_segmentation\n # self.loss_G = self.loss_F_Reg + self.loss_3d_face_part_segmentation#+ self.loss_silhouette + self.loss_face_part_segmentation\n self.loss_G.backward()\n\n def perform_face_part_segmentation(self, input_img, fname='seg'):\n segmentation_parts_dict = {'skin': 1,\n 'r_eyebrow': 2,\n 'l_eyebrow': 3,\n 'r_eye': 4,\n 'l_eye': 5,\n 'r_ear': 7,\n 'l_ear': 8,\n 'nose': 10,\n 'mouth': 11,\n 'u_lip': 12,\n 'l_lip': 13,\n 'neck': 14,\n 'cloth': 16,\n 'hair': 17,\n 'hat': 18,\n }\n real_un = UnNormalize(input_img).squeeze()\n tt = transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))\n real_un = F.interpolate(real_un.unsqueeze(0), (512, 512))\n img = tt(real_un.squeeze()).unsqueeze(0)\n\n # with torch.no_grad():\n out = self.face_parts_segmentation(img)\n parsing = out.squeeze(0).detach().cpu().numpy().argmax(0)\n # print(parsing)\n # visualize = True # TODO\n # if visualize:\n if self.opt.verbose:\n image = transforms.ToPILImage()(UnNormalize(input_img).squeeze().detach().cpu()).resize((512, 512),Image.BILINEAR)\n self.face_parts_segmentation.vis_parsing_maps(image, parsing, stride=1, save_im=True,save_path=f'out/{fname}.png')\n out = F.interpolate(out, (self.opt.crop_size, self.opt.crop_size))\n argmax_tensor = torch.argmax(out, dim=1)\n argmax_tensor[argmax_tensor == segmentation_parts_dict['r_eye']] = segmentation_parts_dict['l_eye']\n argmax_tensor[argmax_tensor == segmentation_parts_dict['r_ear']] = segmentation_parts_dict['l_ear']\n argmax_tensor[argmax_tensor == segmentation_parts_dict['r_eyebrow']] = segmentation_parts_dict['l_eyebrow']\n\n return out, argmax_tensor\n\n def mask_outputs(self):\n self.rect_mask = torch.zeros(self.fake_B.shape).cuda()\n self.rect_mask[..., 0:195, 40:200] = 1\n _, self.real_B_seg = self.perform_face_part_segmentation(self.real_B, fname='real_B_seg')\n self.real_B_seg[self.real_B_seg == 11] = 0\n self.fake_B_seg, _ = self.perform_face_part_segmentation(self.fake_B, fname='fake_B_seg')\n\n self.fake_B = Normalize(UnNormalize(self.fake_B) * self.rect_mask)\n self.real_B = Normalize(UnNormalize(self.real_B) * self.rect_mask)\n\n self.segmented_3d_model_image = self.segmented_3d_model_image * self.rect_mask[:, 0, ...]\n self.real_B_seg = self.real_B_seg * self.rect_mask[:, 0, ...]\n self.fake_B_seg = self.fake_B_seg * self.rect_mask[:, 0, ...]\n # self.mask = self.mask * self.true_mask\n\n def optimize_parameters(self):\n iteration = 2\n for i in range(iteration): # TODO test discriminator-generator balancing\n\n self.forward() # compute fake images: G(Texture) and G(Flame)\n self.mask_outputs()\n # update D\n if i == iteration - 1:\n self.set_requires_grad(self.netD, True) # enable backprop for D\n self.optimizer_D.zero_grad() # set D's gradients to zero\n self.backward_D() # calculate gradients for D\n self.optimizer_D.step() # update D's weights\n # update G\n self.set_requires_grad(self.netD, False) # D requires no gradients when optimizing G\n self.optimizer_G.zero_grad() # set G's gradients to zero\n self.optimizer_F.zero_grad() # set F's gradients to zero\n self.backward_G() # calculate graidents for G\n self.optimizer_G.step() # udpate G's weights\n self.optimizer_F.step() # udpate F's weights\n"
] | [
[
"torch.nn.NLLLoss",
"torch.zeros",
"torch.cat",
"numpy.array",
"torch.arange",
"torch.nn.functional.interpolate",
"torch.no_grad",
"numpy.load",
"torch.nn.L1Loss",
"torch.sum",
"torch.tensor",
"torch.nn.BCELoss",
"matplotlib.pyplot.show",
"torch.log",
"torch.argmax",
"matplotlib.pyplot.imshow"
]
] |
farhadmfar/ace | [
"c4fe4d4d9328a18b5c1ddcc79218605251520bf2"
] | [
"src/prepare_vocab.py"
] | [
"\"\"\"\r\nPrepare vocabulary and initial word vectors.\r\n\"\"\"\r\nimport json\r\nimport pickle\r\nimport argparse\r\nimport numpy as np\r\nfrom collections import Counter\r\n\r\nfrom utils import helper, vocab, constant\r\n\r\ndef parse_args():\r\n parser = argparse.ArgumentParser(description='Prepare vocab for causality identifier.')\r\n parser.add_argument('data_dir', help='MedCause directory.')\r\n parser.add_argument('vocab_dir', help='Output vocab directory.')\r\n parser.add_argument('--glove_dir', default='dataset/glove', help='GloVe directory.')\r\n parser.add_argument('--wv_file', default='glove.840B.300d.txt', help='GloVe vector file.')\r\n parser.add_argument('--wv_dim', type=int, default=300, help='GloVe vector dimension.')\r\n parser.add_argument('--min_freq', type=int, default=0, help='If > 0, use min_freq as the cutoff.')\r\n parser.add_argument('--lower', action='store_true', help='If specified, lowercase all words.')\r\n \r\n args = parser.parse_args()\r\n return args\r\n \r\n \r\n \r\ndef main():\r\n args = parse_args()\r\n \r\n # input files\r\n train_file = args.data_dir + '/MedCaus_train.txt'\r\n #train2_file = args.data_dir + '/Small_MedCaus_train.txt'\r\n dev_file = args.data_dir + '/MedCaus_dev.txt'\r\n test_file = args.data_dir + '/MedCaus_test.txt'\r\n wv_file = args.glove_dir + '/' + args.wv_file\r\n wv_dim = args.wv_dim\r\n\r\n # output files\r\n helper.ensure_dir(args.vocab_dir)\r\n vocab_file = args.vocab_dir + '/vocab.pkl'\r\n emb_file = args.vocab_dir + '/embedding.npy'\r\n \r\n # load files\r\n print(\"loading files...\")\r\n train_tokens = load_tokens(train_file)\r\n dev_tokens = load_tokens(dev_file)\r\n test_tokens = load_tokens(test_file)\r\n if args.lower:\r\n train_tokens, dev_tokens, test_tokens = [[t.lower() for t in tokens] for tokens in\\\r\n (train_tokens, dev_tokens, test_tokens)] \r\n \r\n # load glove\r\n print(\"loading glove...\")\r\n glove_vocab = vocab.load_glove_vocab(wv_file, wv_dim)\r\n print(\"{} words loaded from glove.\".format(len(glove_vocab)))\r\n \r\n \r\n print(\"building vocab...\")\r\n v = build_vocab(train_tokens, glove_vocab, args.min_freq)\r\n \r\n print(\"calculating oov...\")\r\n datasets = {'train': train_tokens, 'dev': dev_tokens, 'test': test_tokens}\r\n for dname, d in datasets.items():\r\n total, oov = count_oov(d, v)\r\n #print(\"{} oov: {}/{} ({:.2f}%)\".format(dname, oov, total, oov*100.0/total))\r\n \r\n print(\"building embeddings...\")\r\n embedding = vocab.build_embedding(wv_file, v, wv_dim)\r\n print(\"embedding size: {} x {}\".format(*embedding.shape))\r\n \r\n print(\"dumping to files...\")\r\n with open(vocab_file, 'wb') as outfile:\r\n pickle.dump(v, outfile)\r\n np.save(emb_file, embedding)\r\n print(\"all done.\")\r\n \r\ndef load_tokens(filename):\r\n with open(filename) as infile:\r\n data = json.load(infile)\r\n tokens = []\r\n for d in data:\r\n ts = d['tokens']\r\n #ss, se, os, oe = d['subj_start'], d['subj_end'], d['obj_start'], d['obj_end']\r\n # do not create vocab for entity words\r\n #ts[ss:se+1] = ['<PAD>']*(se-ss+1)\r\n #ts[os:oe+1] = ['<PAD>']*(oe-os+1)\r\n tokens += list(filter(lambda t: t!='<PAD>', ts))\r\n print(\"{} tokens from {} examples loaded from {}.\".format(len(tokens), len(data), filename))\r\n return tokens\r\n \r\ndef build_vocab(tokens, glove_vocab, min_freq):\r\n \"\"\" build vocab from tokens and glove words. \"\"\"\r\n counter = Counter(t for t in tokens)\r\n if min_freq > 0:\r\n v = sorted([t for t in counter if counter.get(t) >= min_freq], key=counter.get, reverse=True)\r\n else:\r\n v = sorted([t for t in counter if t in glove_vocab], key=counter.get, reverse=True)\r\n v = constant.VOCAB_PREFIX + v\r\n print(\"vocab built with {}/{} words.\".format(len(v), len(counter)))\r\n return v\r\n \r\ndef count_oov(tokens, vocab):\r\n c = Counter(t for t in tokens)\r\n total = sum(c.values())\r\n matched = sum(c[t] for t in vocab)\r\n return total, total-matched\r\n \r\n\r\nif __name__ == '__main__':\r\n main()"
] | [
[
"numpy.save"
]
] |
materialvision/data-efficient-gans | [
"eb1b2287a13952f23d6611709953fadfc539e9ab"
] | [
"DiffAugment-stylegan2/project_images.py"
] | [
"import argparse\nimport os\nimport shutil\nimport numpy as np\n\nimport dnnlib\nimport dnnlib.tflib as tflib\nimport pretrained_networks\nimport projector\nimport dataset_tool\nfrom training import dataset\nfrom training import misc\n\n\ndef project_image(proj, src_file, dst_dir, tmp_dir, video=False):\n\n data_dir = '%s/dataset' % tmp_dir\n if os.path.exists(data_dir):\n shutil.rmtree(data_dir)\n image_dir = '%s/images' % data_dir\n tfrecord_dir = '%s/tfrecords' % data_dir\n os.makedirs(image_dir, exist_ok=True)\n shutil.copy(src_file, image_dir + '/')\n dataset_tool.create_from_images(tfrecord_dir, image_dir, shuffle=0)\n dataset_obj = dataset.load_dataset(\n data_dir=data_dir, tfrecord_dir='tfrecords',\n max_label_size=0, repeat=False, shuffle_mb=0\n )\n\n print('Projecting image \"%s\"...' % os.path.basename(src_file))\n images, _labels = dataset_obj.get_minibatch_np(1)\n images = misc.adjust_dynamic_range(images, [0, 255], [-1, 1])\n proj.start(images)\n if video:\n video_dir = '%s/video' % tmp_dir\n os.makedirs(video_dir, exist_ok=True)\n while proj.get_cur_step() < proj.num_steps:\n print('\\r%d / %d ... ' % (proj.get_cur_step(), proj.num_steps), end='', flush=True)\n proj.step()\n if video:\n filename = '%s/%08d.png' % (video_dir, proj.get_cur_step())\n misc.save_image_grid(proj.get_images(), filename, drange=[-1,1])\n print('\\r%-30s\\r' % '', end='', flush=True)\n\n os.makedirs(dst_dir, exist_ok=True)\n filename = os.path.join(dst_dir, os.path.basename(src_file)[:-4] + '.png')\n misc.save_image_grid(proj.get_images(), filename, drange=[-1,1])\n filename = os.path.join(dst_dir, os.path.basename(src_file)[:-4] + '.npy')\n np.save(filename, proj.get_dlatents()[0])\n\n\ndef render_video(src_file, dst_dir, tmp_dir, num_frames, mode, size, fps, codec, bitrate):\n\n import PIL.Image\n import moviepy.editor\n\n def render_frame(t):\n frame = np.clip(np.ceil(t * fps), 1, num_frames)\n image = PIL.Image.open('%s/video/%08d.png' % (tmp_dir, frame))\n if mode == 1:\n canvas = image\n else:\n canvas = PIL.Image.new('RGB', (2 * src_size, src_size))\n canvas.paste(src_image, (0, 0))\n canvas.paste(image, (src_size, 0))\n if size != src_size:\n canvas = canvas.resize((mode * size, size), PIL.Image.LANCZOS)\n return np.array(canvas)\n\n src_image = PIL.Image.open(src_file)\n src_size = src_image.size[1]\n duration = num_frames / fps\n filename = os.path.join(dst_dir, os.path.basename(src_file)[:-4] + '.mp4')\n video_clip = moviepy.editor.VideoClip(render_frame, duration=duration)\n video_clip.write_videofile(filename, fps=fps, codec=codec, bitrate=bitrate)\n\n\ndef main():\n\n parser = argparse.ArgumentParser(description='Project real-world images into StyleGAN2 latent space')\n parser.add_argument('src_dir', help='Directory with aligned images for projection')\n parser.add_argument('dst_dir', help='Output directory')\n parser.add_argument('--tmp-dir', default='.stylegan2-tmp', help='Temporary directory for tfrecords and video frames')\n parser.add_argument('--network-pkl', default='gdrive:networks/stylegan2-ffhq-config-f.pkl', help='StyleGAN2 network pickle filename')\n parser.add_argument('--vgg16-pkl', default='networks/vgg16_zhang_perceptual.pkl', help='VGG16 network pickle filename')\n parser.add_argument('--num-steps', type=int, default=1000, help='Number of optimization steps')\n parser.add_argument('--initial-learning-rate', type=float, default=0.1, help='Initial learning rate')\n parser.add_argument('--initial-noise-factor', type=float, default=0.05, help='Initial noise factor')\n parser.add_argument('--verbose', type=bool, default=False, help='Verbose output')\n parser.add_argument('--video', type=bool, default=False, help='Render video of the optimization process')\n parser.add_argument('--video-mode', type=int, default=1, help='Video mode: 1 for optimization only, 2 for source + optimization')\n parser.add_argument('--video-size', type=int, default=1024, help='Video size (height in px)')\n parser.add_argument('--video-fps', type=int, default=25, help='Video framerate')\n parser.add_argument('--video-codec', default='libx264', help='Video codec')\n parser.add_argument('--video-bitrate', default='5M', help='Video bitrate')\n args = parser.parse_args()\n\n print('Loading networks from \"%s\"...' % args.network_pkl)\n _G, _D, Gs = pretrained_networks.load_networks(args.network_pkl)\n proj = projector.Projector(\n vgg16_pkl = args.vgg16_pkl,\n num_steps = args.num_steps,\n initial_learning_rate = args.initial_learning_rate,\n initial_noise_factor = args.initial_noise_factor,\n verbose = args.verbose\n )\n proj.set_network(Gs)\n\n src_files = sorted([os.path.join(args.src_dir, f) for f in os.listdir(args.src_dir) if f[0] not in '._'])\n for src_file in src_files:\n project_image(proj, src_file, args.dst_dir, args.tmp_dir, video=args.video)\n if args.video:\n render_video(\n src_file, args.dst_dir, args.tmp_dir, args.num_steps, args.video_mode,\n args.video_size, args.video_fps, args.video_codec, args.video_bitrate\n )\n shutil.rmtree(args.tmp_dir)\n\n\nif __name__ == '__main__':\n main()\n"
] | [
[
"numpy.array",
"numpy.ceil"
]
] |
wen-zhi/hashing | [
"c7e6a54f870d4a49d2e40ce7c53e1b160acd478d"
] | [
"hashing/dataset.py"
] | [
"import numpy as np\n\n\ndef load_mnist_gist(root):\n \"\"\"load 512D GIST descriptor of MNIST and split it.\n\n query: 100 per class (total: 1000)\n train: 600 per class (total: 6000)\n database: 6900 (in average) per class (total: 69000)\n\n # Parameters:\n root: str, directory of MNIST GIST descriptor (.npz).\n\n # Returns:\n query_data: tuple[array], (features, labels).\n train_data: tuple[array], (features, labels).\n database_data: tuple[array], (features, labels).\n \"\"\"\n mnist_gist = np.load(root)\n features, labels = mnist_gist['features'], mnist_gist['labels']\n assert features.shape == (70000, 512)\n assert labels.shape == (70000,)\n query_index, train_index, database_index = [], [], []\n for digit in range(10):\n digit_idx = np.flatnonzero(labels == digit)\n digit_idx = np.random.permutation(digit_idx)\n query_index.extend(digit_idx[:100])\n train_index.extend(digit_idx[100:700])\n database_index.extend(digit_idx[100:])\n query_data = features[query_index], labels[query_index]\n train_data = features[train_index], labels[train_index]\n database_data = features[database_index], labels[database_index]\n\n assert query_data[0].shape[0] == 1000\n assert train_data[0].shape[0] == 6000\n assert database_data[0].shape[0] == 69000\n\n return query_data, train_data, database_data\n"
] | [
[
"numpy.random.permutation",
"numpy.load",
"numpy.flatnonzero"
]
] |
asceenl/lasp | [
"7cc77b073a91eb7470b449604544d9f57faf32e9"
] | [
"test/benchmark.py"
] | [
"#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Mon Jan 15 19:45:33 2018\n\n@author: anne\n\"\"\"\nfrom pycallgraph import PyCallGraph\nfrom pycallgraph.output import GraphvizOutput\n\nimport numpy as np\nfrom beamforming import Fft\n\nnfft=2**17\n\nprint('nfft:',nfft)\nnchannels = 50\nnumber_run = 10\n\nt = np.linspace(0,1,nfft+1)\n\n# Using transpose to get the strides right\nx = np.random.randn(nchannels,nfft).T\n\n\nimport time\nstart = time.time()\nfor i in range(number_run):\n X = np.fft.rfft(x,axis=0)\nend = time.time()\nprint(\"Time numpy fft:\",end-start)\n# X =np.fft.fft(x)\n#X =np.fft.rfft(x)\n\nfft = Fft(nfft,nchannels)\n\nstart = time.time()\nfor i in range(number_run):\n # print('--- run %i' %i)\n fft.fft(x)\nend = time.time()\n\nprint(\"Time ASCEE fft:\",end-start)\n\n\n"
] | [
[
"numpy.linspace",
"numpy.fft.rfft",
"numpy.random.randn"
]
] |
duchesneaumathieu/loader | [
"4725a816588bc33827360aa94c108ec4e2b4649d"
] | [
"Classification/Mnist.py"
] | [
"import numpy as np\nimport pickle\nimport gzip\nimport os\n\nimport loader\nfrom loader.AbstractLoader import AbstractLoader\n\nclass Mnist(AbstractLoader):\n def __init__(self, name='Mnist', img=False, **kwargs):\n super(Mnist, self).__init__(name=name, **kwargs)\n \n self.path = os.path.join(loader.__path__[0], 'datasets', 'Mnist')\n f = gzip.open(os.path.join(self.path, 'mnist.pkl.gz'))\n data = pickle.load(f)\n \n if self.which_set == 'train': i = 0\n elif self.which_set == 'valid': i = 1\n elif self.which_set == 'test': i = 2\n \n self.x, self.y = data[i]\n self.img = img\n \n def get_infos(self, seed=0):\n np.random.seed(seed)\n infos = np.random.permutation(range(len(self.y)))\n np.random.seed(None)\n return infos\n \n def load(self, idx):\n return self.x[idx], self.y[idx]\n \n def preprocess(self, imgs, batch_infos=None):\n x, y_ = zip(*imgs)\n y = np.zeros((len(y_),10))\n y[(range(len(y_)), y_)] = 1\n if self.img: x = np.array(x).reshape((len(y_), 28, 28))\n return [np.array(x), np.array(y)]\n \n"
] | [
[
"numpy.random.seed",
"numpy.array"
]
] |
denimalpaca/great_expectations | [
"0f28f3c2b3cc6fae3bc5d257c6d4d13dbcf37df0"
] | [
"tests/test_utils.py"
] | [
"import logging\nimport os\nimport uuid\nfrom contextlib import contextmanager\nfrom pathlib import Path\nfrom typing import Generator, List, Union, cast\n\nimport numpy as np\nimport pandas as pd\nimport pytest\n\nlogger = logging.getLogger(__name__)\n\ntry:\n import sqlalchemy as sa\n from sqlalchemy.exc import SQLAlchemyError\n\nexcept ImportError:\n logger.debug(\n \"Unable to load SqlAlchemy context; install optional sqlalchemy dependency for support\"\n )\n sa = None\n reflection = None\n Table = None\n Select = None\n\nfrom great_expectations.data_context.store import (\n CheckpointStore,\n ProfilerStore,\n StoreBackend,\n)\nfrom great_expectations.data_context.store.util import (\n build_checkpoint_store_using_store_backend,\n build_configuration_store,\n delete_checkpoint_config_from_store_backend,\n delete_config_from_store_backend,\n load_checkpoint_config_from_store_backend,\n load_config_from_store_backend,\n save_checkpoint_config_to_store_backend,\n save_config_to_store_backend,\n)\nfrom great_expectations.data_context.types.base import BaseYamlConfig, CheckpointConfig\nfrom great_expectations.data_context.util import build_store_from_config\n\nlogger = logging.getLogger(__name__)\n\n\n# Taken from the following stackoverflow:\n# https://stackoverflow.com/questions/23549419/assert-that-two-dictionaries-are-almost-equal\ndef assertDeepAlmostEqual(expected, actual, *args, **kwargs):\n \"\"\"\n Assert that two complex structures have almost equal contents.\n\n Compares lists, dicts and tuples recursively. Checks numeric values\n using pyteset.approx and checks all other values with an assertion equality statement\n Accepts additional positional and keyword arguments and pass those\n intact to pytest.approx() (that's how you specify comparison\n precision).\n\n \"\"\"\n is_root = \"__trace\" not in kwargs\n trace = kwargs.pop(\"__trace\", \"ROOT\")\n try:\n # if isinstance(expected, (int, float, long, complex)):\n if isinstance(expected, (int, float, complex)):\n assert expected == pytest.approx(actual, *args, **kwargs)\n elif isinstance(expected, (list, tuple, np.ndarray)):\n assert len(expected) == len(actual)\n for index in range(len(expected)):\n v1, v2 = expected[index], actual[index]\n assertDeepAlmostEqual(v1, v2, __trace=repr(index), *args, **kwargs)\n elif isinstance(expected, dict):\n assert set(expected) == set(actual)\n for key in expected:\n assertDeepAlmostEqual(\n expected[key], actual[key], __trace=repr(key), *args, **kwargs\n )\n else:\n assert expected == actual\n except AssertionError as exc:\n exc.__dict__.setdefault(\"traces\", []).append(trace)\n if is_root:\n trace = \" -> \".join(reversed(exc.traces))\n exc = AssertionError(f\"{str(exc)}\\nTRACE: {trace}\")\n raise exc\n\n\ndef safe_remove(path):\n if path is not None:\n try:\n os.remove(path)\n except OSError as e:\n print(e)\n\n\ndef create_files_for_regex_partitioner(\n root_directory_path: str, directory_paths: list = None, test_file_names: list = None\n):\n if not directory_paths:\n return\n\n if not test_file_names:\n test_file_names: list = [\n \"alex_20200809_1000.csv\",\n \"eugene_20200809_1500.csv\",\n \"james_20200811_1009.csv\",\n \"abe_20200809_1040.csv\",\n \"will_20200809_1002.csv\",\n \"james_20200713_1567.csv\",\n \"eugene_20201129_1900.csv\",\n \"will_20200810_1001.csv\",\n \"james_20200810_1003.csv\",\n \"alex_20200819_1300.csv\",\n ]\n\n base_directories = []\n for dir_path in directory_paths:\n if dir_path is None:\n base_directories.append(dir_path)\n else:\n data_dir_path = os.path.join(root_directory_path, dir_path)\n os.makedirs(data_dir_path, exist_ok=True)\n base_dir = str(data_dir_path)\n # Put test files into the directories.\n for file_name in test_file_names:\n file_path = os.path.join(base_dir, file_name)\n with open(file_path, \"w\") as fp:\n fp.writelines([f'The name of this file is: \"{file_path}\".\\n'])\n base_directories.append(base_dir)\n\n\ndef create_files_in_directory(\n directory: str, file_name_list: List[str], file_content_fn=lambda: \"x,y\\n1,2\\n2,3\"\n):\n subdirectories = []\n for file_name in file_name_list:\n splits = file_name.split(\"/\")\n for i in range(1, len(splits)):\n subdirectories.append(os.path.join(*splits[:i]))\n subdirectories = set(subdirectories)\n\n for subdirectory in subdirectories:\n os.makedirs(os.path.join(directory, subdirectory), exist_ok=True)\n\n for file_name in file_name_list:\n file_path = os.path.join(directory, file_name)\n with open(file_path, \"w\") as f_:\n f_.write(file_content_fn())\n\n\ndef create_fake_data_frame():\n return pd.DataFrame(\n {\n \"x\": range(10),\n \"y\": list(\"ABCDEFGHIJ\"),\n }\n )\n\n\ndef validate_uuid4(uuid_string: str) -> bool:\n \"\"\"\n Validate that a UUID string is in fact a valid uuid4.\n Happily, the uuid module does the actual checking for us.\n It is vital that the 'version' kwarg be passed\n to the UUID() call, otherwise any 32-character\n hex string is considered valid.\n From https://gist.github.com/ShawnMilo/7777304\n\n Args:\n uuid_string: string to check whether it is a valid UUID or not\n\n Returns:\n True if uuid_string is a valid UUID or False if not\n \"\"\"\n try:\n val = uuid.UUID(uuid_string, version=4)\n except ValueError:\n # If it's a value error, then the string\n # is not a valid hex code for a UUID.\n return False\n\n # If the uuid_string is a valid hex code,\n # but an invalid uuid4,\n # the UUID.__init__ will convert it to a\n # valid uuid4. This is bad for validation purposes.\n\n return val.hex == uuid_string.replace(\"-\", \"\")\n\n\ndef get_sqlite_temp_table_names(engine):\n result = engine.execute(\n \"\"\"\nSELECT\n name\nFROM\n sqlite_temp_master\n\"\"\"\n )\n rows = result.fetchall()\n return {row[0] for row in rows}\n\n\ndef get_sqlite_table_names(engine):\n result = engine.execute(\n \"\"\"\nSELECT\n name\nFROM\n sqlite_master\n\"\"\"\n )\n rows = result.fetchall()\n return {row[0] for row in rows}\n\n\ndef build_in_memory_store_backend(\n module_name: str = \"great_expectations.data_context.store\",\n class_name: str = \"InMemoryStoreBackend\",\n **kwargs,\n) -> StoreBackend:\n logger.debug(\"Starting data_context/store/util.py#build_in_memory_store_backend\")\n store_backend_config: dict = {\"module_name\": module_name, \"class_name\": class_name}\n store_backend_config.update(**kwargs)\n return build_store_from_config(\n store_config=store_backend_config,\n module_name=module_name,\n runtime_environment=None,\n )\n\n\ndef build_tuple_filesystem_store_backend(\n base_directory: str,\n *,\n module_name: str = \"great_expectations.data_context.store\",\n class_name: str = \"TupleFilesystemStoreBackend\",\n **kwargs,\n) -> StoreBackend:\n logger.debug(\n f\"\"\"Starting data_context/store/util.py#build_tuple_filesystem_store_backend using base_directory:\n\"{base_directory}\"\"\"\n )\n store_backend_config: dict = {\n \"module_name\": module_name,\n \"class_name\": class_name,\n \"base_directory\": base_directory,\n }\n store_backend_config.update(**kwargs)\n return build_store_from_config(\n store_config=store_backend_config,\n module_name=module_name,\n runtime_environment=None,\n )\n\n\ndef build_tuple_s3_store_backend(\n bucket: str,\n *,\n module_name: str = \"great_expectations.data_context.store\",\n class_name: str = \"TupleS3StoreBackend\",\n **kwargs,\n) -> StoreBackend:\n logger.debug(\n f\"\"\"Starting data_context/store/util.py#build_tuple_s3_store_backend using bucket: {bucket}\n \"\"\"\n )\n store_backend_config: dict = {\n \"module_name\": module_name,\n \"class_name\": class_name,\n \"bucket\": bucket,\n }\n store_backend_config.update(**kwargs)\n return build_store_from_config(\n store_config=store_backend_config,\n module_name=module_name,\n runtime_environment=None,\n )\n\n\ndef build_checkpoint_store_using_filesystem(\n store_name: str,\n base_directory: str,\n overwrite_existing: bool = False,\n) -> CheckpointStore:\n store_config: dict = {\"base_directory\": base_directory}\n store_backend_obj: StoreBackend = build_tuple_filesystem_store_backend(\n **store_config\n )\n return build_checkpoint_store_using_store_backend(\n store_name=store_name,\n store_backend=store_backend_obj,\n overwrite_existing=overwrite_existing,\n )\n\n\ndef build_profiler_store_using_store_backend(\n store_name: str,\n store_backend: Union[StoreBackend, dict],\n overwrite_existing: bool = False,\n) -> ProfilerStore:\n return cast(\n ProfilerStore,\n build_configuration_store(\n class_name=\"ProfilerStore\",\n module_name=\"great_expectations.data_context.store\",\n store_name=store_name,\n store_backend=store_backend,\n overwrite_existing=overwrite_existing,\n ),\n )\n\n\ndef build_profiler_store_using_filesystem(\n store_name: str,\n base_directory: str,\n overwrite_existing: bool = False,\n) -> ProfilerStore:\n store_config: dict = {\"base_directory\": base_directory}\n store_backend_obj: StoreBackend = build_tuple_filesystem_store_backend(\n **store_config\n )\n store = build_profiler_store_using_store_backend(\n store_name=store_name,\n store_backend=store_backend_obj,\n overwrite_existing=overwrite_existing,\n )\n return store\n\n\ndef save_checkpoint_config_to_filesystem(\n store_name: str,\n base_directory: str,\n checkpoint_name: str,\n checkpoint_configuration: CheckpointConfig,\n):\n store_config: dict = {\"base_directory\": base_directory}\n store_backend_obj: StoreBackend = build_tuple_filesystem_store_backend(\n **store_config\n )\n save_checkpoint_config_to_store_backend(\n store_name=store_name,\n store_backend=store_backend_obj,\n checkpoint_name=checkpoint_name,\n checkpoint_configuration=checkpoint_configuration,\n )\n\n\ndef load_checkpoint_config_from_filesystem(\n store_name: str,\n base_directory: str,\n checkpoint_name: str,\n) -> CheckpointConfig:\n store_config: dict = {\"base_directory\": base_directory}\n store_backend_obj: StoreBackend = build_tuple_filesystem_store_backend(\n **store_config\n )\n return load_checkpoint_config_from_store_backend(\n store_name=store_name,\n store_backend=store_backend_obj,\n checkpoint_name=checkpoint_name,\n )\n\n\ndef delete_checkpoint_config_from_filesystem(\n store_name: str,\n base_directory: str,\n checkpoint_name: str,\n):\n store_config: dict = {\"base_directory\": base_directory}\n store_backend_obj: StoreBackend = build_tuple_filesystem_store_backend(\n **store_config\n )\n delete_checkpoint_config_from_store_backend(\n store_name=store_name,\n store_backend=store_backend_obj,\n checkpoint_name=checkpoint_name,\n )\n\n\ndef save_config_to_filesystem(\n configuration_store_class_name: str,\n configuration_store_module_name: str,\n store_name: str,\n base_directory: str,\n configuration_key: str,\n configuration: BaseYamlConfig,\n):\n store_config: dict = {\"base_directory\": base_directory}\n store_backend_obj: StoreBackend = build_tuple_filesystem_store_backend(\n **store_config\n )\n save_config_to_store_backend(\n class_name=configuration_store_class_name,\n module_name=configuration_store_module_name,\n store_name=store_name,\n store_backend=store_backend_obj,\n configuration_key=configuration_key,\n configuration=configuration,\n )\n\n\ndef load_config_from_filesystem(\n configuration_store_class_name: str,\n configuration_store_module_name: str,\n store_name: str,\n base_directory: str,\n configuration_key: str,\n) -> BaseYamlConfig:\n store_config: dict = {\"base_directory\": base_directory}\n store_backend_obj: StoreBackend = build_tuple_filesystem_store_backend(\n **store_config\n )\n return load_config_from_store_backend(\n class_name=configuration_store_class_name,\n module_name=configuration_store_module_name,\n store_name=store_name,\n store_backend=store_backend_obj,\n configuration_key=configuration_key,\n )\n\n\ndef delete_config_from_filesystem(\n configuration_store_class_name: str,\n configuration_store_module_name: str,\n store_name: str,\n base_directory: str,\n configuration_key: str,\n):\n store_config: dict = {\"base_directory\": base_directory}\n store_backend_obj: StoreBackend = build_tuple_filesystem_store_backend(\n **store_config\n )\n delete_config_from_store_backend(\n class_name=configuration_store_class_name,\n module_name=configuration_store_module_name,\n store_name=store_name,\n store_backend=store_backend_obj,\n configuration_key=configuration_key,\n )\n\n\ndef load_data_into_test_database(\n table_name: str,\n csv_path: str,\n connection_string: str,\n load_full_dataset: bool = False,\n) -> None:\n \"\"\"\n Utility method that is used in loading test data into databases that can be accessed through SqlAlchemy.\n This includes local Dockerized DBs like postgres, but also cloud-dbs like BigQuery and Redshift.\n \"\"\"\n import pandas as pd\n\n if sa:\n engine = sa.create_engine(connection_string)\n else:\n logger.debug(\n \"Attempting to load data in to tests SqlAlchemy database, but unable to load SqlAlchemy context; \"\n \"install optional sqlalchemy dependency for support.\"\n )\n return\n try:\n connection = engine.connect()\n print(f\"Dropping table {table_name}\")\n connection.execute(f\"DROP TABLE IF EXISTS {table_name}\")\n df = pd.read_csv(csv_path)\n if not load_full_dataset:\n # Improving test performance by only loading the first 10 rows of our test data into the db\n df = df.head(10)\n print(f\"Creating table {table_name} from {csv_path}\")\n df.to_sql(name=table_name, con=engine, index=False)\n except SQLAlchemyError as e:\n logger.error(\n f\"\"\"Docs integration tests encountered an error while loading test-data into test-database.\"\"\"\n )\n raise\n finally:\n connection.close()\n engine.dispose()\n\n\n@contextmanager\ndef set_directory(path: str) -> Generator:\n \"\"\"Sets the cwd within the context\n\n Args:\n path: The string representation of the desired path to cd into\n\n Yields:\n None\n \"\"\"\n origin = Path().absolute()\n try:\n os.chdir(path)\n yield\n finally:\n os.chdir(origin)\n"
] | [
[
"pandas.read_csv"
]
] |
jcdupuis-ulaval/gigul-pxrf-tools | [
"72bc7d6e29b89a2af43c6ecd006054c2fd509f43"
] | [
"proc/remove-background.py"
] | [
"# -*- coding: utf-8 -*-\r\n\"\"\"\r\nCreated on Tue Apr 7 13:44:00 2020\r\n\r\n@author: chdup58\r\n\"\"\"\r\n\r\nimport numpy as np\r\nimport matplotlib.pyplot as plt\r\nimport gigul_pxrf_tools as gigul\r\n\r\n# File setup for data and results################################\r\nfname ='TDCAEXD332727z'\r\nddir = '../data/'\r\nrdir = '../results/'\r\n# Filter parameters #############################################\r\nns=90 # Width of the window for noise estimate\r\nscale = 0.05 # SNR Threshold\r\no = 1 # Order of the noise approximation \r\n#################################################################\r\n# load the data file \r\nprint ('Processing file : '+ddir+fname+'.csv')\r\ndata=np.genfromtxt(ddir+fname+'.csv',delimiter=',',skip_header=1)\r\nm,n = data.shape\r\n\r\n# Merge data\r\nmerged_data = np.sum(data[:,1:n],axis=1)\r\n\r\n\r\n# first column is expected to be energy bins, start at second\r\n'''\r\nfor traceno in np.arange(1,n):\r\n # Prepare our data to be used in the filter #####################\r\n trace = data[:,traceno] # get the proper trace in our file \r\n ch = np.linspace(0,len(trace),num=len(trace)) # Assign channel numbers \r\n ch = ch[~np.isnan(trace)] # ignore the channels where there is no data\r\n trace = trace[~np.isnan(trace)] # ignore traces where there is no data\r\n#################################################################\r\n\r\n ynoise, trace_clean = gigul.remove_background(ns,scale,trace,o,rdir + 'CSV/'+fname+'_tr'+str(traceno),ch)\r\n gigul.show_clean_trace (ch,trace,ynoise,trace_clean,rdir+'PNG/'+fname+'_tr'+str(traceno))\r\n \r\nplt.close('all')\r\n'''"
] | [
[
"numpy.sum",
"numpy.genfromtxt"
]
] |
CARMinesDouai/MutiRobotExplorationPackages | [
"725f36eaa22adb33be7f5961db1a0f8e50fdadbd"
] | [
"noisy_odometry/scripts/view_distribution.py"
] | [
"from math import *\nimport numpy as np\nimport matplotlib\nimport matplotlib.pyplot as plt\n# 20cm translation distance\ndx=0.2\ndy=0.35\ntrans = sqrt(dx*dx + dy*dy)\n# rotation1 = 30 degree\ntheta1 = 30.0*pi/180.0\n# rotation2 = 45 degree\ntheta2 = 10.0*pi/180.0\n\nrot1 = atan2(dy, dx) - theta1\nrot2 = theta2-theta1-rot1\n\na1 = 0.05\na2 = 15.0*pi/180.0\na3 = 0.05\na4 = 0.01\nsd_rot1 = a1*abs(rot1) + a2*trans\nsd_rot2 = a1*abs(rot2) + a2*trans\nsd_trans = a3*trans + a4*(abs(rot1) + abs(rot2))\n\n\nx= []\ny = []\n\nfor i in range(0, 1000):\n t = trans + np.random.normal(0,sd_trans*sd_trans)\n r1 = rot1 + np.random.normal(0, sd_rot1*sd_rot1)\n r2 = rot2 + np.random.normal(0, sd_rot2*sd_rot2)\n x.append(t*cos(theta1+r1))\n y.append(t*sin(theta1+r1))\n\n\n\n#matplotlib.rcParams['axes.unicode_minus'] = False\nfig, ax = plt.subplots()\n#ax.plot(x, y)\nax.scatter(x, y)\nax.set_title('Gaussian noise of motion model with dx=0.2 and dy=0.35')\nplt.show()"
] | [
[
"matplotlib.pyplot.show",
"numpy.random.normal",
"matplotlib.pyplot.subplots"
]
] |
MikeDepies/NeatKotlin | [
"5059f9c5754a159ad49997c70a466ffa9840e10b"
] | [
"mario/NeatNetwork.py"
] | [
"from collections import defaultdict\n\nimport json\nimport math\nimport enum\nfrom time import sleep\nimport networkx as nx\nimport numpy as np\nfrom typing import Dict, List, Set, Tuple\nfrom networkx.algorithms.dag import descendants\nfrom numpy import ndarray, vectorize\n\n\ndef sigmoidal(x: float):\n # print(x)\n if (x < -4):\n x = -4\n elif x > 4:\n x = 4\n\n return 1 / (1 + math.exp(-4.9*x))\n\n\nclass NodeLocation:\n x: int\n y: int\n z: int\n\n def __init__(self, x, y, z):\n self.x = x\n self.y = y\n self.z = z\n\n def __str__(self):\n return str((self.x, self.y, self.z))\n\n def __repr__(self) -> str:\n return str((self.x, self.y, self.z))\n\n def __hash__(self) -> int:\n return ((self.x, self.y, self.z)).__hash__()\n\n def __eq__(self, other):\n return self.__dict__ == other.__dict__\n\n\nclass ConnectionLocation:\n x1: int\n y1: int\n z1: int\n x2: int\n y2: int\n z2: int\n weight: float\n\n def __init__(self, x1: int, y1: int, z1: int, x2: int, y2: int, z2: int, weight: float):\n self.x1 = x1\n self.y1 = y1\n self.z1 = z1\n self.x2 = x2\n self.y2 = y2\n self.z2 = z2\n self.weight = weight\n\ndef getConnectionIndex(source: NodeLocation, target: NodeLocation):\n if source.z == 0:\n return 0\n if source.z == 1 and target.z == 2:\n return 1\n if source.z == 1 and target.z == 6:\n return 2\n if source.z == 2 and target.z == 6:\n return 3\n if source.z == 2 and target.z == 3:\n return 4\n if source.z == 3 and target.z == 4:\n return 5\n if source.z == 3 and target.z == 6:\n return 6\n if source.z == 4 and target.z == 5:\n return 7\n if source.z == 4 and target.z == 6:\n return 8\n if source.z == 5 and target.z == 6:\n return 9\n if source.z == 2 and target.z == 2:\n return 10\n if source.z == 3 and target.z == 3:\n return 11\n if source.z == 4 and target.z == 4:\n return 12\n if source.z == 5 and target.z == 5:\n return 13\n else:\n print(\"test???\")\n# Identify input, hidden and output nodes\ndef constructNetwork(nodes: List[NodeLocation], connections: List[ConnectionLocation], layerShapes: List[List[int]], bias: NodeLocation = None):\n \n # computationOrder: List[NodeLocation] = list()\n # ndarray()\n inputNodes = list(filter(lambda n: n.z == 0, nodes))\n # if bias is not None:\n # inputNodes.append(bias)\n outputNodes = list(filter(lambda n: n.z == 3, nodes))\n print(\"Node values initializing...\")\n print(\"input nodes:\")\n print(len(inputNodes))\n print(\"outputnodes\")\n print(len(outputNodes))\n \n # for node in nodes:\n # nodeValuePre[node] = 0\n # nodeValuePost[node] = 0\n print(\"constructing graph representation\")\n # data = list(map(lambda c: (NodeLocation(c.x1, c.y1, c.z1),\n # NodeLocation(c.x2, c.y2, c.z2), c.weight), connections))\n print(\"construct graph\")\n connection = [np.zeros(layerShapes[1] + layerShapes[0]),\n np.zeros(layerShapes[2] + layerShapes[1]),\n np.zeros(layerShapes[6] + layerShapes[1]),\n np.zeros(layerShapes[6] + layerShapes[2]),\n np.zeros(layerShapes[3] + layerShapes[2]),\n np.zeros(layerShapes[4] + layerShapes[3]),\n np.zeros(layerShapes[6] + layerShapes[3]),\n np.zeros(layerShapes[5] + layerShapes[4]),\n np.zeros(layerShapes[6] + layerShapes[4]),\n np.zeros(layerShapes[6] + layerShapes[5]),\n np.zeros(layerShapes[2] + layerShapes[2]),\n np.zeros(layerShapes[3] + layerShapes[3]),\n np.zeros(layerShapes[4] + layerShapes[4]),\n np.zeros(layerShapes[5] + layerShapes[5]),\n ]\n # print(connection[0])\n values = [np.zeros([*layerShapes[0], 2]),\n np.zeros([*layerShapes[1], 2]),\n np.zeros([*layerShapes[2], 2]),\n np.zeros([*layerShapes[3], 2]),\n np.zeros([*layerShapes[4], 2]),\n np.zeros([*layerShapes[5], 2]),\n np.zeros([*layerShapes[6], 2])]\n graph = nx.MultiDiGraph()\n for c in connections:\n source = NodeLocation(c.x1, c.y1, c.z1)\n target = NodeLocation(c.x2, c.y2, c.z2)\n connectionIndex = getConnectionIndex(source, target)\n \n try:\n connection[connectionIndex][target.y, target.x, source.y, source.x ] = c.weight\n except:\n print(str(source) + \" to \" + str(target) + \" = \" + str(connectionIndex))\n print(\"Constructing topological order...\")\n print(\"Constructed Computable Network...\")\n # [15, 16]\n \n # print(computationOrder[0])\n \n \n # if (array[source.y, source.x, target.y, target.x] != 0):\n # print(array[source.y, source.x, target.y, target.x])\n # print(\"===0===\")\n # print(connection[0])\n # print(\"===1===\")\n # print(connection[1])\n # print(\"===2===\")\n # print(connection[2])\n # print(\"===3s===\")\n # print(connection[3])\n # sleep(10000)\n # for v in t:\n # print(connection[0][v[0], v[1], v[2], v[3]])\n # print(connection[2])\n # print(NodeLocation(0,0,0) == NodeLocation(0,0,0))\n # for n in inputNodes:\n # print(graph.has_node(n))\n # print(graph.has_node(outputNodes[0]))\n # nx.has_path(graph,n, outputNodes[0])\n return ComputableNetwork(inputNodes, outputNodes, graph, connection, values)\n\n\nclass ComputableNetwork:\n # nodeMap: Dict[NodeLocation, List[Tuple[NodeLocation, ConnectionLocation]]]\n inputNodes: List[NodeLocation]\n outputNodes: List[NodeLocation]\n graph: nx.MultiDiGraph\n inputNdArray: ndarray\n connection: List[ndarray]\n values: List[ndarray]\n\n def __init__(self, \n # nodeMap: Dict[NodeLocation, List[Tuple[NodeLocation, ConnectionLocation]]],\n inputNodes: List[NodeLocation],\n outputNodes: List[NodeLocation],\n graph: nx.MultiDiGraph,\n connection: List[ndarray],\n values: List[ndarray]):\n\n # self.nodeMap = nodeMap\n self.inputNodes = inputNodes\n self.outputNodes = outputNodes\n self.graph = graph\n self.connection = connection\n self.values = values\n\n def input(self, input: ndarray):\n self.inputNdArray = input / 255.0\n self.values[0][...,0] = self.inputNdArray\n self.values[0][...,1] = self.inputNdArray\n # print(self.inputNdArray)\n # for x in range(0, xSize):\n # for y in range(0, ySize):\n # for z in range(0, zSize):\n # self.nodeValuePre[NodeLocation(\n # x, y, z)] = input.item((x, y, z))\n\n def compute(self):\n\n\n # connection = [np.zeros(layerShapes[1] + layerShapes[0]),\n # np.zeros(layerShapes[2] + layerShapes[1]),\n # np.zeros(layerShapes[6] + layerShapes[1]),\n # np.zeros(layerShapes[6] + layerShapes[2]),\n # np.zeros(layerShapes[3] + layerShapes[2]),\n # np.zeros(layerShapes[4] + layerShapes[3]),\n # np.zeros(layerShapes[6] + layerShapes[3]),\n # np.zeros(layerShapes[5] + layerShapes[4]),\n # np.zeros(layerShapes[6] + layerShapes[4]),\n # np.zeros(layerShapes[6] + layerShapes[5]),\n # np.zeros(layerShapes[2] + layerShapes[2]),\n # np.zeros(layerShapes[3] + layerShapes[3]),\n # np.zeros(layerShapes[4] + layerShapes[4]),\n # np.zeros(layerShapes[5] + layerShapes[5]),\n # ]\n # # print(connection[0])\n # values = [np.zeros([*layerShapes[0], 2]),\n # np.zeros([*layerShapes[1], 2]),\n # np.zeros([*layerShapes[2], 2]),\n # np.zeros([*layerShapes[3], 2]),\n # np.zeros([*layerShapes[4], 2]),\n # np.zeros([*layerShapes[5], 2]),\n # np.zeros([*layerShapes[6], 2])]\n vectorizedSigmoidal = np.vectorize(sigmoidal)\n # layer 1\n v1: ndarray = (self.inputNdArray * self.connection[0]).sum((2, 3))\n self.values[1][..., 0] = v1\n self.values[1][..., 1] = vectorizedSigmoidal(v1)\n\n # layer 2\n v2: ndarray = (self.values[1][..., 1] * self.connection[1]).sum((2, 3))\n self.values[2][..., 0] = v2 + (self.values[2][..., 1] * self.connection[10]).sum((2, 3))\n self.values[2][..., 1] = vectorizedSigmoidal(self.values[2][..., 0])\n \n # layer 3\n v3: ndarray = (self.values[2][..., 1] * self.connection[4]).sum((2, 3))\n self.values[3][..., 0] = v3 + (self.values[3][..., 1] * self.connection[11]).sum((2, 3))\n self.values[3][..., 1] = vectorizedSigmoidal(self.values[3][..., 0])\n \n # layer 4\n v4: ndarray = (self.values[3][..., 1] * self.connection[5]).sum((2, 3))\n self.values[4][..., 0] = v4 + (self.values[4][..., 1] * self.connection[12]).sum((2, 3))\n self.values[4][..., 1] = vectorizedSigmoidal(self.values[4][..., 0])\n \n # layer 5\n v4: ndarray = (self.values[4][..., 1] * self.connection[7]).sum((2, 3))\n self.values[5][..., 0] = v4 + (self.values[5][..., 1] * self.connection[13]).sum((2, 3))\n self.values[5][..., 1] = vectorizedSigmoidal(self.values[5][..., 0])\n\n\n v6: ndarray = (self.values[1][..., 1] * self.connection[2]).sum((2, 3))\n v7: ndarray = (self.values[2][..., 1] * self.connection[3]).sum((2, 3))\n v8: ndarray = (self.values[3][..., 1] * self.connection[6]).sum((2, 3))\n v9: ndarray = (self.values[4][..., 1] * self.connection[8]).sum((2, 3))\n v10: ndarray = (self.values[5][..., 1] * self.connection[9]).sum((2, 3))\n sum = v10 + v6 + v7 + v8 + v9\n # print(\"=========\")\n # print(v3)\n # print(self.connection[2])\n # print(v4)\n # print(self.connection[3])\n # print(\"=========\")\n self.values[6][..., 0] = sum\n self.values[6][..., 1] = vectorizedSigmoidal(sum)\n # for v in self.values:\n # print(v[...,1])\n # for computationSet in self.computationOrder:\n # # print(\"Processing Generation:\")\n # # print(computationSet)\n # # print(v)\n # # print(vectorizedSigmoidal(v))\n # for source in computationSet:\n # if source.z > 0:\n # self.activateNode(source)\n # self.nodeValuePre[source] = 0\n # descendants = self.graph.neighbors(source)\n # # print(\"from: \" + str(source) + \": Activated\")\n # # print(self.nodePostValue(source))\n # # if source.z ==0:\n # # print(str(source) + \": \" + str(self.nodePostValue(source)))\n # # print(\"\\t\" + str(descendants))\n\n # for target in descendants:\n # # print(self.graph.has_edge(source, target))\n # weight = self.graph.get_edge_data(\n # source, target)[0][\"weight\"]\n # # apply activation on every types aside from the inputs\n # # z 0-2 are input channels\n # # print(weight)\n\n # self.nodeValuePre[target] += self.nodePostValue(\n # source) * weight\n # for outputNode in self.outputNodes:\n # self.activateNode(outputNode)\n # self.nodeValuePre[source] = 0\n\n def nodePostValue(self, node: NodeLocation):\n if (node.z == 0):\n return self.inputNdArray.item((node.y, node.x))\n else:\n return self.nodeValuePost[node]\n\n def nodePreValue(self, node: NodeLocation):\n if (node.z == 0):\n return self.inputNdArray.item((node.y, node.x))\n else:\n return self.nodeValuePre[node]\n\n def activateNode(self, node: NodeLocation):\n value = self.nodeValuePre[node]\n if (node.z == 0):\n value = self.inputNdArray.item((node.y, node.x))\n self.nodeValuePost[node] = sigmoidal(value)\n\n def output(self) -> ndarray:\n return self.values[6][..., 1]\n\n def draw(self):\n nx.draw_spring(self.graph)\n\n def write(self):\n nx.write_edgelist(self.graph, \"test.txt\")\n"
] | [
[
"numpy.vectorize",
"numpy.zeros"
]
] |
sarvai/proposals | [
"578c0094db52594cd85acb843df82fe3c19db46d"
] | [
"codes/deeplearning/data/datasets/coco_dataset.py"
] | [
"import numpy as np\nfrom .dataset import dataset\nfrom ..image import coco_image\n\nclass coco_dataset( dataset ):\n def __init__( self, cfg, cls, part, img_type=coco_image ):\n super().__init__( cfg, img_type )\n\n self._dset_tag = 'coco_%s_%s' % ( cls, part )\n\n c = cls[:2]\n if part == 'train2014' :\n p = 'tr14'\n elif part == 'val2014' :\n p = 'va14'\n else :\n p = 'te'\n\n self._dset_hash = 'C%s%s' % ( c, p )\n self._data_name = 'coco_%s' % ( cls )\n self._images = []\n\n def load( self, setting=None ):\n super().load( setting=setting )\n\n def reduce_to_pose( self ):\n keep = []\n for ind, image in enumerate(self._original_images) :\n labels, points = image.keypoints\n labels = labels.ravel()\n valid = np.where( labels > 0 )[0]\n\n if len( valid ) > 0 :\n keep.append( ind )\n\n self._original_images = self._original_images[keep]\n"
] | [
[
"numpy.where"
]
] |
veritaem/RL_udemy | [
"f817be686b85406fbddd961441c4970bf8b05045"
] | [
"DDPGHelpers.py"
] | [
"import numpy as np\r\n\r\nclass OUActionNoise():\r\n def __init__(self, mu, sigma=.15, theta=.2, dt=1e-2, x0=None):\r\n self.theta = theta\r\n self.mu = mu\r\n self.sigma = sigma\r\n self.dt = dt\r\n self.x0=x0\r\n self.reset()\r\n\r\n def __call__(self):\r\n x= self.x0 + self.theta * (self.mu - self.x0) * self.dt +\\\r\n self.sigma * np.sqrt(self.dt) * np.random.normal(size=self.mu.shape)\r\n self.x_prev=x\r\n\r\n def reset(self):\r\n return self.x0 if self.x0 is not None else np.zeros(self.mu)\r\n\r\nclass ReplayBuffer():\r\n def __init__(self, size, input_shape, n_actions):\r\n self.mem_size=size\r\n self.mem_count=0\r\n self.state_memory = np.zeros((self.mem_size, *input_shape))\r\n self.new_state_memory = np.zeros((self.mem_size, *input_shape))\r\n self.action_memory= np.zeroes((self.mem_size, n_actions))\r\n self.reward_memory= np.zeros(self.mem_size)\r\n self.terminal_memory= np.zeros(self.mem_size, dtype=np.bool)\r\n\r\n def store_transition(self, state, action, reward, state_, terminal):\r\n index = self.mem_count % self.mem_size\r\n self.state_memory[index]=state\r\n self.new_state_memory[index]=state_\r\n self.reward_memory[index]=reward\r\n self.action_memory[index]=action\r\n self.terminal_memory[index]=terminal\r\n self.mem_count+=1\r\n\r\n def sample_buffer(self, batch_size):\r\n max_mem =min(self.mem_count, self.mem_size)\r\n batch=np.random.choice(max_mem, batch_size)\r\n state=self.state_memory[batch]\r\n state_=self.new_state_memory[batch]\r\n action=self.action_memory[batch]\r\n reward=self.reward_memory[batch]\r\n terminal = self.terminal_memory[batch]\r\n\r\n return state, action, reward, state_, terminal\r\n\r\n\r\n\r\n\r\n\r\n\r\n"
] | [
[
"numpy.random.normal",
"numpy.random.choice",
"numpy.zeros",
"numpy.zeroes",
"numpy.sqrt"
]
] |
YouthJourney/Deep-Learning-For-Image-Process | [
"2d5f273baa73882f6ec61e13cc4ffca32b228657"
] | [
"Pytorch_Classification/Pytorch_VGG/predict.py"
] | [
"# -*- coding: UTF-8 -*-\r\n\"\"\"\r\nAuthor: LGD\r\nFileName: predict\r\nDateTime: 2021/1/26 15:36 \r\nSoftWare: PyCharm\r\n\"\"\"\r\nimport torch\r\nfrom Pytorch_VGG.model import vgg\r\nfrom torchvision import transforms\r\nimport matplotlib.pyplot as plt\r\nimport json\r\nfrom PIL import Image\r\n\r\ndata_transform = transforms.Compose([\r\n transforms.Resize((224, 224)),\r\n transforms.ToTensor(),\r\n transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))\r\n])\r\n\r\n# load image\r\nimg = Image.open('tulip.jpg')\r\nplt.imshow(img)\r\n# [N, C, H, W]\r\nimg = data_transform(img)\r\n# expand batch dimension\r\nimg = torch.unsqueeze(img, dim=0)\r\n\r\n# read class_indict\r\ntry:\r\n json_file = open('class_indices.json', 'r')\r\n class_indict = json.load(json_file)\r\nexcept Exception as e:\r\n print(e)\r\n exit(-1)\r\n\r\n# create model\r\nmodel = vgg(model_name=\"vgg16\", num_classes=5)\r\n# load model weights\r\nmodel.load_state_dict(torch.load('vgg16Net.pth'))\r\nmodel.eval()\r\nwith torch.no_grad():\r\n # predict class\r\n outputs = torch.squeeze(model(img))\r\n predict = torch.softmax(outputs, dim=0)\r\n predict_cla = torch.argmax(predict).numpy()\r\nprint(class_indict[str(predict_cla)])\r\nplt.show()\r\n"
] | [
[
"torch.no_grad",
"torch.softmax",
"torch.unsqueeze",
"torch.load",
"matplotlib.pyplot.show",
"torch.argmax",
"matplotlib.pyplot.imshow"
]
] |
adriaanph/katdal | [
"a3d01a08c5e74b6143caef02e499f2073056acd7"
] | [
"katdal/ms_extra.py"
] | [
"################################################################################\n# Copyright (c) 2011-2019, National Research Foundation (Square Kilometre Array)\n#\n# Licensed under the BSD 3-Clause License (the \"License\"); you may not use\n# this file except in compliance with the License. You may obtain a copy\n# of the License at\n#\n# https://opensource.org/licenses/BSD-3-Clause\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n################################################################################\n\n\"\"\"Create MS compatible data and write this data into a template MeasurementSet.\"\"\"\n#\n# Ludwig Schwardt\n# 25 March 2008\n#\n\nimport os\nimport os.path\nfrom copy import deepcopy\n\nimport numpy as np\nfrom pkg_resources import parse_version\nimport casacore\nfrom casacore import tables\n\n# Perform python-casacore version checks\npyc_ver = parse_version(casacore.__version__)\nreq_ver = parse_version(\"2.2.1\")\nif not pyc_ver >= req_ver:\n raise ImportError(f\"python-casacore {req_ver} is required, but the current version is {pyc_ver}. \"\n f\"Note that python-casacore {req_ver} requires at least casacore 2.3.0.\")\n\n\ndef open_table(name, readonly=False, verbose=False, **kwargs):\n \"\"\"Open casacore Table.\"\"\"\n return tables.table(name, readonly=readonly, ack=verbose, **kwargs)\n\n\ndef create_ms(filename, table_desc=None, dm_info=None):\n \"\"\"Create an empty MS with the default expected sub-tables and columns.\"\"\"\n with tables.default_ms(filename, table_desc, dm_info) as main_table:\n # Add the optional SOURCE subtable\n source_path = os.path.join(os.getcwd(), filename, 'SOURCE')\n with tables.default_ms_subtable('SOURCE', source_path) as source_table:\n # Add the optional REST_FREQUENCY column to appease exportuvfits\n # (it only seems to need the column keywords)\n rest_freq_desc = tables.makearrcoldesc(\n 'REST_FREQUENCY', 0, valuetype='DOUBLE', ndim=1,\n keywords={'MEASINFO': {'Ref': 'LSRK', 'type': 'frequency'},\n 'QuantumUnits': 'Hz'})\n source_table.addcols(rest_freq_desc)\n main_table.putkeyword('SOURCE', 'Table: ' + source_path)\n\n\ndef std_scalar(comment, valueType='integer', option=0, **kwargs):\n \"\"\"Description for standard scalar column.\"\"\"\n return dict(comment=comment, valueType=valueType, dataManagerType='StandardStMan',\n dataManagerGroup='StandardStMan', option=option, maxlen=0, **kwargs)\n\n\ndef std_array(comment, valueType, ndim, **kwargs):\n \"\"\"Description for standard array column with variable shape (used for smaller arrays).\"\"\"\n return dict(comment=comment, valueType=valueType, ndim=ndim, dataManagerType='StandardStMan',\n dataManagerGroup='StandardStMan', _c_order=True, option=0, maxlen=0, **kwargs)\n\n\ndef fixed_array(comment, valueType, shape, **kwargs):\n \"\"\"Description for direct array column with fixed shape (used for smaller arrays).\"\"\"\n return dict(comment=comment, valueType=valueType, shape=np.asarray(shape, dtype=np.int32), ndim=len(shape),\n dataManagerType='StandardStMan', dataManagerGroup='StandardStMan',\n _c_order=True, option=5, maxlen=0, **kwargs)\n\n\ndef tiled_array(comment, valueType, ndim, dataManagerGroup, **kwargs):\n \"\"\"Description for array column with tiled storage manager (used for bigger arrays).\"\"\"\n return dict(comment=comment, valueType=valueType, ndim=ndim, dataManagerType='TiledShapeStMan',\n dataManagerGroup=dataManagerGroup, _c_order=True, option=0, maxlen=0, **kwargs)\n\n\ndef define_hypercolumn(desc):\n \"\"\"Add hypercolumn definitions to table description.\"\"\"\n desc['_define_hypercolumn_'] = {v['dataManagerGroup']: dict(HCdatanames=[k], HCndim=v['ndim'] + 1)\n for k, v in desc.items() if v['dataManagerType'] == 'TiledShapeStMan'}\n\n\n# Map MeasurementSet string types to numpy types\nMS_TO_NP_TYPE_MAP = {\n 'INT': np.int32,\n 'FLOAT': np.float32,\n 'DOUBLE': np.float64,\n 'BOOLEAN': np.bool,\n 'COMPLEX': np.complex64,\n 'DCOMPLEX': np.complex128\n}\n\n\ndef kat_ms_desc_and_dminfo(nbl, nchan, ncorr, model_data=False):\n \"\"\"\n Creates Table Description and Data Manager Information objects that\n describe a MeasurementSet suitable for holding MeerKAT data.\n\n Creates additional DATA, IMAGING_WEIGHT and possibly\n MODEL_DATA and CORRECTED_DATA columns.\n\n Columns are given fixed shapes defined by the arguments to this function.\n\n :param nbl: Number of baselines.\n :param nchan: Number of channels.\n :param ncorr: Number of correlation products.\n :param model_data: Boolean indicated whether MODEL_DATA and CORRECTED_DATA\n should be added to the Measurement Set.\n :return: Returns a tuple containing a table description describing\n the extra columns and hypercolumns, as well as a Data Manager\n description.\n \"\"\"\n # Columns that will be modified. We want to keep things like their\n # keywords, dims and shapes.\n modify_columns = {\"WEIGHT\", \"SIGMA\", \"FLAG\", \"FLAG_CATEGORY\",\n \"UVW\", \"ANTENNA1\", \"ANTENNA2\"}\n\n # Get the required table descriptor for an MS\n table_desc = tables.required_ms_desc(\"MAIN\")\n\n # Take columns we wish to modify\n extra_table_desc = {c: d for c, d in table_desc.items() if c in modify_columns}\n\n # Used to set the SPEC for each Data Manager Group\n dmgroup_spec = {}\n\n def dmspec(coldesc, tile_mem_limit=None):\n \"\"\"\n Create data manager spec for a given column description,\n mostly by adding a DEFAULTTILESHAPE that fits into the\n supplied memory limit.\n \"\"\"\n\n # Choose 4MB if none given\n if tile_mem_limit is None:\n tile_mem_limit = 4*1024*1024\n\n # Get the reversed column shape. DEFAULTTILESHAPE is deep in\n # casacore and its necessary to specify their ordering here\n # ntilerows is the dim that will change least quickly\n rev_shape = list(reversed(coldesc[\"shape\"]))\n\n ntilerows = 1\n np_dtype = MS_TO_NP_TYPE_MAP[coldesc[\"valueType\"].upper()]\n nbytes = np.dtype(np_dtype).itemsize\n\n # Try bump up the number of rows in our tiles while they're\n # below the memory limit for the tile\n while np.product(rev_shape + [2*ntilerows])*nbytes < tile_mem_limit:\n ntilerows *= 2\n\n return {\"DEFAULTTILESHAPE\": np.int32(rev_shape + [ntilerows])}\n\n # Update existing columns with shape and data manager information\n dm_group = 'UVW'\n shape = [3]\n extra_table_desc[\"UVW\"].update(options=0, shape=shape, ndim=len(shape),\n dataManagerGroup=dm_group,\n dataManagerType='TiledColumnStMan')\n dmgroup_spec[dm_group] = dmspec(extra_table_desc[\"UVW\"])\n\n dm_group = 'Weight'\n shape = [ncorr]\n extra_table_desc[\"WEIGHT\"].update(options=4, shape=shape, ndim=len(shape),\n dataManagerGroup=dm_group,\n dataManagerType='TiledColumnStMan')\n dmgroup_spec[dm_group] = dmspec(extra_table_desc[\"WEIGHT\"])\n\n dm_group = 'Sigma'\n shape = [ncorr]\n extra_table_desc[\"SIGMA\"].update(options=4, shape=shape, ndim=len(shape),\n dataManagerGroup=dm_group,\n dataManagerType='TiledColumnStMan')\n dmgroup_spec[dm_group] = dmspec(extra_table_desc[\"SIGMA\"])\n\n dm_group = 'Flag'\n shape = [nchan, ncorr]\n extra_table_desc[\"FLAG\"].update(options=4, shape=shape, ndim=len(shape),\n dataManagerGroup=dm_group,\n dataManagerType='TiledColumnStMan')\n dmgroup_spec[dm_group] = dmspec(extra_table_desc[\"FLAG\"])\n\n dm_group = 'FlagCategory'\n shape = [1, nchan, ncorr]\n extra_table_desc[\"FLAG_CATEGORY\"].update(options=4, keywords={},\n shape=shape, ndim=len(shape),\n dataManagerGroup=dm_group,\n dataManagerType='TiledColumnStMan')\n dmgroup_spec[dm_group] = dmspec(extra_table_desc[\"FLAG_CATEGORY\"])\n\n # Create new columns for integration into the MS\n additional_columns = []\n\n dm_group = 'Data'\n shape = [nchan, ncorr]\n desc = tables.tablecreatearraycoldesc(\n \"DATA\", 0+0j, comment=\"The Visibility DATA Column\",\n options=4, valuetype='complex', keywords={\"UNIT\": \"Jy\"},\n shape=shape, ndim=len(shape), datamanagergroup=dm_group,\n datamanagertype='TiledColumnStMan')\n dmgroup_spec[dm_group] = dmspec(desc[\"desc\"])\n additional_columns.append(desc)\n\n dm_group = 'WeightSpectrum'\n shape = [nchan, ncorr]\n desc = tables.tablecreatearraycoldesc(\n \"WEIGHT_SPECTRUM\", 1.0, comment=\"Per-channel weights\",\n options=4, valuetype='float', shape=shape, ndim=len(shape),\n datamanagergroup=dm_group, datamanagertype='TiledColumnStMan')\n dmgroup_spec[dm_group] = dmspec(desc[\"desc\"])\n additional_columns.append(desc)\n\n dm_group = 'ImagingWeight'\n shape = [nchan]\n desc = tables.tablecreatearraycoldesc(\n \"IMAGING_WEIGHT\", 0,\n comment=\"Weight set by imaging task (e.g. uniform weighting)\",\n options=4, valuetype='float', shape=shape, ndim=len(shape),\n datamanagergroup=dm_group, datamanagertype='TiledColumnStMan')\n dmgroup_spec[dm_group] = dmspec(desc[\"desc\"])\n additional_columns.append(desc)\n\n # Add MODEL_DATA and CORRECTED_DATA if requested\n if model_data:\n dm_group = 'ModelData'\n shape = [nchan, ncorr]\n desc = tables.tablecreatearraycoldesc(\n \"MODEL_DATA\", 0+0j, comment=\"The Visibility MODEL_DATA Column\",\n options=4, valuetype='complex', keywords={\"UNIT\": \"Jy\"},\n shape=shape, ndim=len(shape), datamanagergroup=dm_group,\n datamanagertype='TiledColumnStMan')\n dmgroup_spec[dm_group] = dmspec(desc[\"desc\"])\n additional_columns.append(desc)\n\n dm_group = 'CorrectedData'\n shape = [nchan, ncorr]\n desc = tables.tablecreatearraycoldesc(\n \"CORRECTED_DATA\", 0+0j,\n comment=\"The Visibility CORRECTED_DATA Column\",\n options=4, valuetype='complex', keywords={\"UNIT\": \"Jy\"},\n shape=shape, ndim=len(shape), datamanagergroup=dm_group,\n datamanagertype='TiledColumnStMan')\n dmgroup_spec[dm_group] = dmspec(desc[\"desc\"])\n additional_columns.append(desc)\n\n # Update extra table description with additional columns\n extra_table_desc.update(tables.maketabdesc(additional_columns))\n\n # Update the original table descriptor with modifications/additions\n # Need this to construct a complete Data Manager specification\n # that includes the original columns\n table_desc.update(extra_table_desc)\n\n # Construct DataManager Specification\n dminfo = tables.makedminfo(table_desc, dmgroup_spec)\n\n return extra_table_desc, dminfo\n\n\ncaltable_desc = {}\ncaltable_desc['TIME'] = std_scalar('Timestamp of solution', 'double', option=5)\ncaltable_desc['FIELD_ID'] = std_scalar('Unique id for this pointing', 'integer', option=5)\ncaltable_desc['SPECTRAL_WINDOW_ID'] = std_scalar('Spectral window', 'integer', option=5)\ncaltable_desc['ANTENNA1'] = std_scalar('ID of first antenna in interferometer', 'integer', option=5)\ncaltable_desc['ANTENNA2'] = std_scalar('ID of second antenna in interferometer', 'integer', option=5)\ncaltable_desc['INTERVAL'] = std_scalar('The effective integration time', 'double', option=5)\ncaltable_desc['SCAN_NUMBER'] = std_scalar('Scan number', 'integer', option=5)\ncaltable_desc['OBSERVATION_ID'] = std_scalar('Observation id (index in OBSERVATION table)', 'integer', option=5)\ncaltable_desc['PARAMERR'] = std_array('Parameter error', 'float', -1)\ncaltable_desc['FLAG'] = std_array('Solution values', 'boolean', -1)\ncaltable_desc['SNR'] = std_array('Signal to noise ratio', 'float', -1)\ncaltable_desc['WEIGHT'] = std_array('Weight', 'float', -1)\n# float version of caltable\ncaltable_desc_float = deepcopy(caltable_desc)\ncaltable_desc_float['FPARAM'] = std_array('Solution values', 'float', -1)\ndefine_hypercolumn(caltable_desc_float)\n# complex version of caltable\ncaltable_desc_complex = deepcopy(caltable_desc)\ncaltable_desc_complex['CPARAM'] = std_array('Solution values', 'complex', -1)\ndefine_hypercolumn(caltable_desc_complex)\n\n\n# -------- Routines that create MS data structures in dictionaries -----------\n\ndef populate_main_dict(uvw_coordinates, vis_data, flag_data, weight_data, timestamps, antenna1_index,\n antenna2_index, integrate_length, field_id=0, state_id=1,\n scan_number=0, model_data=None, corrected_data=None):\n \"\"\"Construct a dictionary containing the columns of the MAIN table.\n\n The MAIN table contains the visibility data itself. The vis data has shape\n (num_vis_samples, num_pols, num_channels). The table has one row per\n visibility sample, which is one row per baseline per snapshot (time sample).\n\n Parameters\n ----------\n uvw_coordinates : array of float, shape (num_vis_samples, 3)\n Array containing (u,v,w) coordinates in metres\n vis_data : array of complex, shape (num_vis_samples, num_channels, num_pols)\n Array containing complex visibility data in Janskys\n flag_data : array of boolean, shape same as vis_data\n weight_data : array of float, shape same as vis_data\n timestamps : array of float, shape (num_vis_samples,)\n Array of timestamps as Modified Julian Dates in seconds\n (may contain duplicate times for multiple baselines)\n antenna1_index : int or array of int, shape (num_vis_samples,)\n Array containing the index of the first antenna of each vis sample\n antenna2_index : int or array of int, shape (num_vis_samples,)\n Array containing the index of the second antenna of each vis sample\n integrate_length : float\n The integration time (one over dump rate), in seconds\n field_id : int or array of int, shape (num_vis_samples,), optional\n The field ID (pointing) associated with this data\n state_id : int or array of int, shape (num_vis_samples,), optional\n The state ID (observation intent) associated with this data\n scan_number : int or array of int, shape (num_vis_samples,), optional\n The scan index (compound scan index in the case of KAT-7)\n model_data : array of complex, shape (num_vis_samples, num_channels, num_pols)\n Array containing complex visibility data in Janskys\n corrected_data : array of complex, shape (num_vis_samples, num_channels, num_pols)\n Array containing complex visibility data in Janskys\n\n Returns\n -------\n main_dict : dict\n Dictionary containing columns of MAIN table\n\n Raises\n ------\n ValueError\n If there is a shape mismatch between some input arrays\n\n \"\"\"\n num_vis_samples, num_channels, num_pols = vis_data.shape\n timestamps = np.atleast_1d(np.asarray(timestamps, dtype=np.float64))\n\n main_dict = {}\n # ID of first antenna in interferometer (integer)\n main_dict['ANTENNA1'] = antenna1_index\n # ID of second antenna in interferometer (integer)\n main_dict['ANTENNA2'] = antenna2_index\n # ID of array or subarray (integer)\n main_dict['ARRAY_ID'] = np.zeros(num_vis_samples, dtype=np.int32)\n # The corrected data column (complex, 3-dim)\n if corrected_data is not None:\n main_dict['CORRECTED_DATA'] = corrected_data\n # The data column (complex, 3-dim)\n main_dict['DATA'] = vis_data\n # The data description table index (integer)\n main_dict['DATA_DESC_ID'] = np.zeros(num_vis_samples, dtype=np.int32)\n # The effective integration time (double)\n main_dict['EXPOSURE'] = integrate_length * np.ones(num_vis_samples)\n # The feed index for ANTENNA1 (integer)\n main_dict['FEED1'] = np.zeros(num_vis_samples, dtype=np.int32)\n # The feed index for ANTENNA1 (integer)\n main_dict['FEED2'] = np.zeros(num_vis_samples, dtype=np.int32)\n # Unique id for this pointing (integer)\n main_dict['FIELD_ID'] = field_id\n # The data flags, array of bools with same shape as data\n main_dict['FLAG'] = flag_data\n # The flag category, NUM_CAT flags for each datum [snd 1 is num channels] (boolean, 4-dim)\n main_dict['FLAG_CATEGORY'] = flag_data.reshape((num_vis_samples, 1, num_channels, num_pols))\n # Row flag - flag all data in this row if True (boolean)\n main_dict['FLAG_ROW'] = np.zeros(num_vis_samples, dtype=np.uint8)\n # The visibility weights\n main_dict['WEIGHT_SPECTRUM'] = weight_data\n # Weight set by imaging task (e.g. uniform weighting) (float, 1-dim)\n # main_dict['IMAGING_WEIGHT'] = np.ones((num_vis_samples, 1), dtype=np.float32)\n # The sampling interval (double)\n main_dict['INTERVAL'] = integrate_length * np.ones(num_vis_samples)\n # The model data column (complex, 3-dim)\n if model_data is not None:\n main_dict['MODEL_DATA'] = model_data\n # ID for this observation, index in OBSERVATION table (integer)\n main_dict['OBSERVATION_ID'] = np.zeros(num_vis_samples, dtype=np.int32)\n # Id for backend processor, index in PROCESSOR table (integer)\n main_dict['PROCESSOR_ID'] = - np.ones(num_vis_samples, dtype=np.int32)\n # Sequential scan number from on-line system (integer)\n main_dict['SCAN_NUMBER'] = scan_number\n # Estimated rms noise for channel with unity bandpass response (float, 1-dim)\n main_dict['SIGMA'] = np.ones((num_vis_samples, num_pols), dtype=np.float32)\n # ID for this observing state (integer)\n main_dict['STATE_ID'] = state_id\n # Modified Julian Dates in seconds (double)\n main_dict['TIME'] = timestamps\n # Modified Julian Dates in seconds (double)\n main_dict['TIME_CENTROID'] = timestamps\n # Vector with uvw coordinates (in metres) (double, 1-dim, shape=(3,))\n main_dict['UVW'] = np.asarray(uvw_coordinates)\n # Weight for each polarisation spectrum (float, 1-dim). This is just\n # just filled with 1's, because the real weights are in WEIGHT_SPECTRUM.\n main_dict['WEIGHT'] = np.ones((num_vis_samples, num_pols), dtype=np.float32)\n return main_dict\n\n\ndef populate_caltable_main_dict(solution_times, solution_values, antennas, scans):\n \"\"\"Construct a dictionary containing the columns of the MAIN table.\n\n The MAIN table contains the gain solution data itself. The shape of the data\n sepends on the nature of the solution: (npol,1) for gains and delays and\n (npol, nchan) for bandpasses.\n The table has one row per antenna per time.\n\n Parameters\n ----------\n solution_times : array of float, shape (num_solutions,)\n Calibration solution times\n solution_values : array of float, shape (num_solutions,)\n Calibration solution values\n antennas: array of float, shape (num_solutions,)\n Antenna corresponding to each solution value\n scans: array of float, shape (num_solutions,)\n Scan number corresponding to each solution value\n\n Returns\n -------\n calibration_main_dict : dict\n Dictionary containing columns of the caltable MAIN table\n\n \"\"\"\n num_rows = len(solution_times)\n calibration_main_dict = {}\n calibration_main_dict['TIME'] = solution_times\n calibration_main_dict['FIELD_ID'] = np.zeros(num_rows, dtype=np.int32)\n calibration_main_dict['SPECTRAL_WINDOW_ID'] = np.zeros(num_rows, dtype=np.int32)\n calibration_main_dict['ANTENNA1'] = antennas\n calibration_main_dict['ANTENNA2'] = np.zeros(num_rows, dtype=np.int32)\n calibration_main_dict['INTERVAL'] = np.zeros(num_rows, dtype=np.int32)\n calibration_main_dict['SCAN_NUMBER'] = scans\n calibration_main_dict['OBSERVATION_ID'] = np.zeros(num_rows, dtype=np.int32)\n if np.iscomplexobj(solution_values):\n calibration_main_dict['CPARAM'] = solution_values\n else:\n calibration_main_dict['FPARAM'] = solution_values\n calibration_main_dict['PARAMERR'] = np.zeros_like(solution_values, dtype=np.float32)\n calibration_main_dict['FLAG'] = np.zeros_like(solution_values, dtype=np.int32)\n calibration_main_dict['SNR'] = np.ones_like(solution_values, dtype=np.float32)\n return calibration_main_dict\n\n\ndef populate_antenna_dict(antenna_names, antenna_positions, antenna_diameters):\n \"\"\"Construct a dictionary containing the columns of the ANTENNA subtable.\n\n The ANTENNA subtable contains info about each antenna, such as its name,\n position, mount type and diameter. It has one row per antenna.\n\n Parameters\n ----------\n antenna_names : array of string, shape (num_antennas,)\n Array of antenna names, one per antenna\n antenna_positions : array of float, shape (num_antennas, 3)\n Array of antenna positions in ECEF (aka XYZ) coordinates, in metres\n antenna_diameters : array of float, shape (num_antennas,)\n Array of antenna diameters, in metres\n\n Returns\n -------\n antenna_dict : dict\n Dictionary containing columns of ANTENNA subtable\n\n \"\"\"\n num_antennas = len(antenna_names)\n antenna_dict = {}\n # Physical diameter of dish (double)\n antenna_dict['DISH_DIAMETER'] = np.asarray(antenna_diameters, np.float64)\n # Flag for this row (boolean)\n antenna_dict['FLAG_ROW'] = np.zeros(num_antennas, np.uint8)\n # Mount type e.g. alt-az, equatorial, etc. (string)\n antenna_dict['MOUNT'] = np.tile('ALT-AZ', num_antennas)\n # Antenna name, e.g. VLA22, CA03 (string)\n antenna_dict['NAME'] = np.asarray(antenna_names)\n # Axes offset of mount to FEED REFERENCE point (double, 1-dim, shape=(3,))\n antenna_dict['OFFSET'] = np.zeros((num_antennas, 3), np.float64)\n # Antenna X,Y,Z phase reference position (double, 1-dim, shape=(3,))\n antenna_dict['POSITION'] = np.asarray(antenna_positions, dtype=np.float64)\n # Station (antenna pad) name (string)\n antenna_dict['STATION'] = np.asarray(antenna_names)\n # Antenna type (e.g. SPACE-BASED) (string)\n antenna_dict['TYPE'] = np.tile('GROUND-BASED', num_antennas)\n return antenna_dict\n\n\ndef populate_feed_dict(num_feeds, num_receptors_per_feed=2):\n \"\"\"Construct a dictionary containing the columns of the FEED subtable.\n\n The FEED subtable specifies feed characteristics such as polarisation and\n beam offsets. It has one row per feed (typically one feed per antenna).\n Each feed has a number of receptors (typically one per polarisation type).\n\n Parameters\n ----------\n num_feeds : integer\n Number of feeds in telescope (typically equal to number of antennas)\n num_receptors_per_feed : integer, optional\n Number of receptors per feed (usually one per polarisation type)\n\n Returns\n -------\n feed_dict : dict\n Dictionary containing columns of FEED subtable\n\n \"\"\"\n feed_dict = {}\n # ID of antenna in this array (integer)\n feed_dict['ANTENNA_ID'] = np.arange(num_feeds, dtype=np.int32)\n # Id for BEAM model (integer)\n feed_dict['BEAM_ID'] = np.ones(num_feeds, dtype=np.int32)\n # Beam position offset (on sky but in antenna reference frame): (double, 2-dim)\n feed_dict['BEAM_OFFSET'] = np.zeros((num_feeds, 2, 2), dtype=np.float64)\n # Feed id (integer)\n feed_dict['FEED_ID'] = np.zeros(num_feeds, dtype=np.int32)\n # Interval for which this set of parameters is accurate (double)\n feed_dict['INTERVAL'] = np.zeros(num_feeds, dtype=np.float64)\n # Number of receptors on this feed (probably 1 or 2) (integer)\n feed_dict['NUM_RECEPTORS'] = np.tile(np.int32(num_receptors_per_feed), num_feeds)\n # Type of polarisation to which a given RECEPTOR responds (string, 1-dim)\n feed_dict['POLARIZATION_TYPE'] = np.tile(['X', 'Y'], (num_feeds, 1))\n # D-matrix i.e. leakage between two receptors (complex, 2-dim)\n feed_dict['POL_RESPONSE'] = np.dstack([np.eye(2, dtype=np.complex64) for n in range(num_feeds)]).transpose()\n # Position of feed relative to feed reference position (double, 1-dim, shape=(3,))\n feed_dict['POSITION'] = np.zeros((num_feeds, 3), np.float64)\n # The reference angle for polarisation (double, 1-dim). A parallactic angle of\n # 0 means that V is aligned to x (celestial North), but we are mapping H to x\n # so we have to correct with a -90 degree rotation.\n feed_dict['RECEPTOR_ANGLE'] = np.full((num_feeds, num_receptors_per_feed), -np.pi / 2, dtype=np.float64)\n # ID for this spectral window setup (integer)\n feed_dict['SPECTRAL_WINDOW_ID'] = - np.ones(num_feeds, dtype=np.int32)\n # Midpoint of time for which this set of parameters is accurate (double)\n feed_dict['TIME'] = np.zeros(num_feeds, dtype=np.float64)\n return feed_dict\n\n\ndef populate_data_description_dict():\n \"\"\"Construct a dictionary containing the columns of the DATA_DESCRIPTION subtable.\n\n The DATA_DESCRIPTION subtable groups together a set of polarisation and\n frequency parameters, which may differ for various experiments done on the\n same data set. It has one row per data setting.\n\n Returns\n -------\n data_description_dict : dict\n Dictionary containing columns of DATA_DESCRIPTION subtable\n\n \"\"\"\n data_description_dict = {}\n # Flag this row (boolean)\n data_description_dict['FLAG_ROW'] = np.zeros(1, dtype=np.uint8)\n # Pointer to polarisation table (integer)\n data_description_dict['POLARIZATION_ID'] = np.zeros(1, dtype=np.int32)\n # Pointer to spectralwindow table (integer)\n data_description_dict['SPECTRAL_WINDOW_ID'] = np.zeros(1, dtype=np.int32)\n return data_description_dict\n\n\ndef populate_polarization_dict(ms_pols=['HH', 'VV'], stokes_i=False, circular=False):\n \"\"\"Construct a dictionary containing the columns of the POLARIZATION subtable.\n\n The POLARIZATION subtable describes how the various receptors are correlated\n to create the Stokes terms. It has one row per polarisation setting.\n\n Parameters\n ----------\n ms_pols : ['HH'] | ['VV'] | ['HH','VV'] | ['HH','VV','HV','VH']\n The polarisations used in this dataset\n stokes_i : False\n Mark single pol as Stokes I\n circular : False\n Label the linear pols with circular (for fun and/or profit)\n\n Returns\n -------\n polarization_dict : dict\n Dictionary containing columns of POLARIZATION subtable\n\n \"\"\"\n pol_num = {'H': 0, 'V': 1}\n # lookups for converting to CASA speak...\n pol_types = {'I': 1, 'Q': 2, 'U': 3, 'V': 4, 'RR': 5, 'RL': 6, 'LR': 7, 'LL': 8,\n 'HH': 9, 'VV': 12, 'HV': 10, 'VH': 11}\n if len(ms_pols) > 1 and stokes_i:\n print(\"Warning: Polarisation to be marked as stokes, but more than 1 polarisation \"\n f\"product specified. Using first specified pol ({ms_pols[0]})\")\n ms_pols = [ms_pols[0]]\n # Indices describing receptors of feed going into correlation (integer, 2-dim)\n polarization_dict = {}\n # The polarisation type for each correlation product, as a Stokes enum (4 integer, 1-dim)\n # Stokes enum (starting at 1) = {I, Q, U, V, RR, RL, LR, LL, XX, XY, YX, YY, ...}\n # The native correlator data are in XX, YY, XY, YX for HV pol, XX for H pol and YY for V pol\n polarization_dict['CORR_PRODUCT'] = np.array([[pol_num[p[0]], pol_num[p[1]]]\n for p in ms_pols], dtype=np.int32)[np.newaxis, :, :]\n polarization_dict['CORR_TYPE'] = np.array([pol_types[p] - (4 if circular else 0)\n for p in (['I'] if stokes_i else ms_pols)])[np.newaxis, :]\n # Number of correlation products (integer)\n polarization_dict['FLAG_ROW'] = np.zeros(1, dtype=np.uint8)\n polarization_dict['NUM_CORR'] = np.array([len(ms_pols)], dtype=np.int32)\n return polarization_dict\n\n\ndef populate_observation_dict(start_time, end_time, telescope_name='unknown',\n observer_name='unknown', project_name='unknown'):\n \"\"\"Construct a dictionary containing the columns of the OBSERVATION subtable.\n\n The OBSERVATION subtable describes the overall project and the people doing\n the observing. It has one row per observation project/schedule?\n\n Parameters\n ----------\n start_time : float\n Start time of project, as a Modified Julian Date in seconds\n end_time : float\n End time of project, as a Modified Julian Date in seconds\n telescope_name : string, optional\n Telescope name\n observer_name : string, optional\n Name of observer\n project_name : string, optional\n Description of project\n\n Returns\n -------\n observation_dict : dict\n Dictionary containing columns of OBSERVATION subtable\n\n \"\"\"\n observation_dict = {}\n # Row flag (boolean)\n observation_dict['FLAG_ROW'] = np.zeros(1, dtype=np.uint8)\n # Observing log (string, 1-dim)\n observation_dict['LOG'] = np.array(['unavailable']).reshape((1, 1))\n # Name of observer(s) (string)\n observation_dict['OBSERVER'] = np.array([observer_name])\n # Project identification string\n observation_dict['PROJECT'] = np.array([project_name])\n # Release date when data becomes public (double)\n observation_dict['RELEASE_DATE'] = np.array([end_time])\n # Observing schedule (string, 1-dim)\n observation_dict['SCHEDULE'] = np.array(['unavailable']).reshape((1, 1))\n # Observing schedule type (string)\n observation_dict['SCHEDULE_TYPE'] = np.array(['unknown'])\n # Telescope Name (e.g. WSRT, VLBA) (string)\n observation_dict['TELESCOPE_NAME'] = np.array([telescope_name])\n # Start and end of observation (double, 1-dim, shape=(2,))\n observation_dict['TIME_RANGE'] = np.array([[start_time, end_time]])\n return observation_dict\n\n\ndef populate_spectral_window_dict(center_frequencies, channel_bandwidths, ref_freq=None):\n \"\"\"Construct a dictionary containing the columns of the SPECTRAL_WINDOW subtable.\n\n The SPECTRAL_WINDOW subtable describes groupings of frequency channels into\n spectral windows. It has one row per spectral window. At the moment, only a\n single spectral window is considered. The reference frequency is chosen to\n be the center frequency of the middle channel.\n\n Parameters\n ----------\n center_frequencies : array of float, shape (num_channels,)\n Observation center frequencies for each channel, in Hz\n channel_bandwidths : array of float, shape (num_channels,)\n Bandwidth for each channel, in Hz\n\n Returns\n -------\n spectral_window_dict : dict\n Dictionary containing columns of SPECTRAL_WINDOW subtable\n\n \"\"\"\n num_channels = len(center_frequencies)\n if len(channel_bandwidths) != num_channels:\n raise ValueError('Lengths of center_frequencies and channel_bandwidths differ (%d vs %d)' %\n (len(center_frequencies), len(channel_bandwidths)))\n spectral_window_dict = {}\n # Center frequencies for each channel in the data matrix (double, 1-dim)\n spectral_window_dict['CHAN_FREQ'] = np.array([center_frequencies], dtype=np.float64)\n # Channel width for each channel (double, 1-dim)\n spectral_window_dict['CHAN_WIDTH'] = np.array([channel_bandwidths], dtype=np.float64)\n # Effective noise bandwidth of each channel (double, 1-dim)\n spectral_window_dict['EFFECTIVE_BW'] = np.array([channel_bandwidths], dtype=np.float64)\n # Row flag (boolean)\n spectral_window_dict['FLAG_ROW'] = np.zeros(1, dtype=np.uint8)\n # Frequency group (integer)\n spectral_window_dict['FREQ_GROUP'] = np.zeros(1, dtype=np.int32)\n # Frequency group name (string)\n spectral_window_dict['FREQ_GROUP_NAME'] = np.array(['none'])\n # The IF conversion chain number (integer)\n spectral_window_dict['IF_CONV_CHAIN'] = np.zeros(1, dtype=np.int32)\n # Frequency Measure reference (integer) (5=Topocentric)\n spectral_window_dict['MEAS_FREQ_REF'] = np.array([5], dtype=np.int32)\n # Spectral window name (string)\n spectral_window_dict['NAME'] = np.array(['none'])\n # Net sideband (integer)\n spectral_window_dict['NET_SIDEBAND'] = np.ones(1, dtype=np.int32)\n # Number of spectral channels (integer)\n spectral_window_dict['NUM_CHAN'] = np.array([num_channels], dtype=np.int32)\n # The reference frequency (double) - pick the frequency of the middle channel\n if ref_freq is None:\n spectral_window_dict['REF_FREQUENCY'] = np.array([center_frequencies[num_channels // 2]], dtype=np.float64)\n else:\n spectral_window_dict['REF_FREQUENCY'] = np.array([ref_freq], dtype=np.float64)\n # The effective noise bandwidth for each channel (double, 1-dim)\n spectral_window_dict['RESOLUTION'] = np.array([channel_bandwidths], dtype=np.float64)\n # The total bandwidth for this window (double)\n spectral_window_dict['TOTAL_BANDWIDTH'] = np.array([channel_bandwidths.sum()], dtype=np.float64)\n return spectral_window_dict\n\n\ndef populate_source_dict(phase_centers, time_origins, field_names=None):\n \"\"\"Construct a dictionary containing the columns of the SOURCE subtable.\n\n The SOURCE subtable describes time-variable source information, that may\n be associated with a given FIELD_ID. It appears to be optional, but for\n completeness it is included here (with no time varying terms). Some RARG\n tasks and CASA's exportuvfits do require it, though.\n\n Parameters\n ----------\n phase_centers : array of float, shape (M, 2)\n Direction of *M* phase centers as (ra, dec) coordinates in radians\n time_origins : array of float, shape (M,)\n Time origins where the *M* phase centers are correct, as Modified Julian\n Dates in seconds\n field_names : array of string, shape (M,), optional\n Names of fields/pointings (typically some source names)\n\n Returns\n -------\n source_dict : dict\n Dictionary containing columns of SOURCE subtable\n\n \"\"\"\n phase_centers = np.atleast_2d(np.asarray(phase_centers, np.float64))\n num_fields = len(phase_centers)\n if field_names is None:\n field_names = [f'Source{field}' for field in range(num_fields)]\n source_dict = {}\n # Source identifier as specified in the FIELD sub-table (integer)\n source_dict['SOURCE_ID'] = np.arange(num_fields, dtype=np.int32)\n # Source proper motion in radians per second (double, 1-dim, shape=(2,))\n source_dict['PROPER_MOTION'] = np.zeros((num_fields, 2), dtype=np.float32)\n # Source direction (e.g. RA, DEC) in radians (double, 1-dim, shape=(2,))\n source_dict['DIRECTION'] = phase_centers\n # Calibration group number to which this source belongs (integer)\n source_dict['CALIBRATION_GROUP'] = np.full(num_fields, -1, dtype=np.int32)\n # Name of source as given during observations (string)\n source_dict['NAME'] = np.atleast_1d(field_names)\n # Number of spectral line transitions associated with this source\n # and spectral window id combination (integer)\n source_dict['NUM_LINES'] = np.zeros(num_fields, dtype=np.int32)\n # Midpoint of time for which this set of parameters is accurate (double)\n source_dict['TIME'] = np.atleast_1d(np.asarray(time_origins, dtype=np.float64))\n # Rest frequencies for the transitions in Hz (double, 1-dim, shape=(NUM_LINES,))\n # This column is optional but expected by exportuvfits and even though\n # NUM_LINES is 0, put something sensible here in case it is read.\n source_dict['REST_FREQUENCY'] = np.zeros((num_fields, 0), dtype=np.float64)\n return source_dict\n\n\ndef populate_field_dict(phase_centers, time_origins, field_names=None):\n \"\"\"Construct a dictionary containing the columns of the FIELD subtable.\n\n The FIELD subtable describes each field (or pointing) by its sky coordinates.\n It has one row per field/pointing.\n\n Parameters\n ----------\n phase_centers : array of float, shape (M, 2)\n Direction of *M* phase centers as (ra, dec) coordinates in radians\n time_origins : array of float, shape (M,)\n Time origins where the *M* phase centers are correct, as Modified Julian\n Dates in seconds\n field_names : array of string, shape (M,), optional\n Names of fields/pointings (typically some source names)\n\n Returns\n -------\n field_dict : dict\n Dictionary containing columns of FIELD subtable\n\n \"\"\"\n phase_centers = np.atleast_2d(np.asarray(phase_centers, np.float64))[:, np.newaxis, :]\n num_fields = len(phase_centers)\n if field_names is None:\n field_names = [f'Field{field}' for field in range(num_fields)]\n field_dict = {}\n # Special characteristics of field, e.g. position code (string)\n field_dict['CODE'] = np.tile('T', num_fields)\n # Direction of delay center (e.g. RA, DEC) as polynomial in time (double, 2-dim)\n field_dict['DELAY_DIR'] = phase_centers\n # Row flag (boolean)\n field_dict['FLAG_ROW'] = np.zeros(num_fields, dtype=np.uint8)\n # Name of this field (string)\n field_dict['NAME'] = np.atleast_1d(field_names)\n # Polynomial order of *_DIR columns (integer)\n field_dict['NUM_POLY'] = np.zeros(num_fields, dtype=np.int32)\n # Direction of phase center (e.g. RA, DEC) (double, 2-dim)\n field_dict['PHASE_DIR'] = phase_centers\n # Direction of REFERENCE center (e.g. RA, DEC) as polynomial in time (double, 2-dim)\n field_dict['REFERENCE_DIR'] = phase_centers\n # Source id (integer), or a value of -1 indicates there is no corresponding source defined\n field_dict['SOURCE_ID'] = np.arange(num_fields, dtype=np.int32) # the same as source id\n # Time origin for direction and rate (double)\n field_dict['TIME'] = np.atleast_1d(np.asarray(time_origins, dtype=np.float64))\n return field_dict\n\n\ndef populate_state_dict(obs_modes=['UNKNOWN']):\n \"\"\"Construct a dictionary containing the columns of the STATE subtable.\n\n The STATE subtable describes observing modes.\n It has one row per observing modes.\n\n Parameters\n ----------\n obs_modes : array of string\n Observing modes, used to define the schedule strategy.\n\n Returns\n -------\n state_dict : dict\n Dictionary containing columns of STATE subtable\n\n \"\"\"\n num_states = len(obs_modes)\n state_dict = {}\n # Signal (boolean)\n state_dict['SIG'] = np.ones(num_states, dtype=np.uint8)\n # Reference (boolean)\n state_dict['REF'] = np.zeros(num_states, dtype=np.uint8)\n # Noise calibration temperature (double)\n state_dict['CAL'] = np.zeros(num_states, dtype=np.float64)\n # Load temperature (double)\n state_dict['LOAD'] = np.zeros(num_states, dtype=np.float64)\n # Sub-scan number (int)\n state_dict['SUB_SCAN'] = np.zeros(num_states, dtype=np.int32)\n # Observing mode (string)\n state_dict['OBS_MODE'] = np.atleast_1d(obs_modes)\n # Row flag (boolean)\n state_dict['FLAG_ROW'] = np.zeros(num_states, dtype=np.uint8)\n return state_dict\n\n\ndef populate_pointing_dict(num_antennas, observation_duration, start_time, phase_center, pointing_name='default'):\n \"\"\"Construct a dictionary containing the columns of the POINTING subtable.\n\n The POINTING subtable contains data on individual antennas tracking a target.\n It has one row per pointing/antenna?\n\n Parameters\n ----------\n num_antennas : integer\n Number of antennas\n observation_duration : float\n Length of observation, in seconds\n start_time : float\n Start time of observation, as a Modified Julian Date in seconds\n phase_center : array of float, shape (2,)\n Direction of phase center, in ra-dec coordinates as 2-element array\n pointing_name : string, optional\n Name for pointing\n\n Returns\n -------\n pointing_dict : dict\n Dictionary containing columns of POINTING subtable\n\n \"\"\"\n phase_center = phase_center.reshape((2, 1, 1))\n pointing_dict = {}\n # Antenna Id (integer)\n pointing_dict['ANTENNA_ID'] = np.arange(num_antennas, dtype=np.int32)\n # Antenna pointing direction as polynomial in time (double, 2-dim)\n pointing_dict['DIRECTION'] = np.repeat(phase_center, num_antennas)\n # Time interval (double)\n pointing_dict['INTERVAL'] = np.tile(np.float64(observation_duration), num_antennas)\n # Pointing position name (string)\n pointing_dict['NAME'] = np.array([pointing_name] * num_antennas)\n # Series order (integer)\n pointing_dict['NUM_POLY'] = np.zeros(num_antennas, dtype=np.int32)\n # Target direction as polynomial in time (double, -1-dim)\n pointing_dict['TARGET'] = np.repeat(phase_center, num_antennas)\n # Time interval midpoint (double)\n pointing_dict['TIME'] = np.tile(np.float64(start_time), num_antennas)\n # Time origin for direction (double)\n pointing_dict['TIME_ORIGIN'] = np.tile(np.float64(start_time), num_antennas)\n # Tracking flag - True if on position (boolean)\n pointing_dict['TRACKING'] = np.ones(num_antennas, dtype=np.uint8)\n return pointing_dict\n\n\ndef populate_ms_dict(uvw_coordinates, vis_data, timestamps, antenna1_index, antenna2_index,\n integrate_length, center_frequencies, channel_bandwidths,\n antenna_names, antenna_positions, antenna_diameter,\n num_receptors_per_feed, start_time, end_time,\n telescope_name, observer_name, project_name, phase_center, obs_modes):\n \"\"\"Construct a dictionary containing all the tables in a MeasurementSet.\n\n Parameters\n ----------\n uvw_coordinates : array of float, shape (num_vis_samples, 3)\n Array containing (u,v,w) coordinates in multiples of the wavelength\n vis_data : array of complex, shape (num_vis_samples, num_channels, num_pols)\n Array containing complex visibility data in Janskys\n timestamps : array of float, shape (num_vis_samples,)\n Array of timestamps as Modified Julian Dates in seconds\n antenna1_index : int or array of int, shape (num_vis_samples,)\n Array containing the index of the first antenna of each uv sample\n antenna2_index : int or array of int, shape (num_vis_samples,)\n Array containing the index of the second antenna of each uv sample\n integrate_length : float\n The integration time (one over dump rate), in seconds\n center_frequencies : array of float, shape (num_channels,)\n Observation center frequencies for each channel, in Hz\n channel_bandwidths : array of float, shape (num_channels,)\n Bandwidth for each channel, in Hz\n antenna_names : array of string, shape (num_antennas,)\n Array of antenna names, one per antenna\n antenna_positions : array of float, shape (num_antennas, 3)\n Array of antenna positions in ECEF (aka XYZ) coordinates, in metres\n antenna_diameter : array of float, shape (num_antennas,)\n Array of antenna diameters, in metres\n num_receptors_per_feed : integer\n Number of receptors per feed (usually one per polarisation type)\n start_time : float\n Start time of project, as a Modified Julian Date in seconds\n end_time : float\n End time of project, as a Modified Julian Date in seconds\n telescope_name : string\n Telescope name\n observer_name : string\n Observer name\n project_name : string\n Description of project\n phase_center : array of float, shape (2,)\n Direction of phase center, in ra-dec coordinates as 2-element array\n obs_modes: array of strings\n Observing modes\n\n Returns\n -------\n ms_dict : dict\n Dictionary containing all tables and subtables of a measurement set\n\n \"\"\"\n ms_dict = {}\n ms_dict['MAIN'] = populate_main_dict(uvw_coordinates, vis_data, timestamps,\n antenna1_index, antenna2_index, integrate_length)\n ms_dict['ANTENNA'] = populate_antenna_dict(antenna_names, antenna_positions, antenna_diameter)\n ms_dict['FEED'] = populate_feed_dict(len(antenna_positions), num_receptors_per_feed)\n ms_dict['DATA_DESCRIPTION'] = populate_data_description_dict()\n ms_dict['POLARIZATION'] = populate_polarization_dict()\n ms_dict['OBSERVATION'] = populate_observation_dict(start_time, end_time,\n telescope_name, observer_name, project_name)\n ms_dict['SPECTRAL_WINDOW'] = populate_spectral_window_dict(center_frequencies, channel_bandwidths)\n ms_dict['FIELD'] = populate_field_dict(phase_center, start_time)\n ms_dict['STATE'] = populate_state_dict(obs_modes)\n ms_dict['SOURCE'] = populate_source_dict(phase_center, start_time)\n return ms_dict\n\n# ----------------- Write completed dictionary to MS file --------------------\n\n\ndef write_rows(t, row_dict, verbose=True):\n num_rows = list(row_dict.values())[0].shape[0]\n # Append rows to the table by starting after the last row in table\n startrow = t.nrows()\n # Add the space required for this group of rows\n t.addrows(num_rows)\n if verbose:\n print(f\" added {num_rows} rows\")\n for col_name, col_data in row_dict.items():\n if col_name not in t.colnames():\n if verbose:\n print(f\" column '{col_name}' not in table\")\n continue\n if col_data.dtype.kind == 'U':\n col_data = np.char.encode(col_data, encoding='utf-8')\n try:\n t.putcol(col_name, col_data, startrow)\n except RuntimeError as err:\n print(\" error writing column '%s' with shape %s (%s)\" %\n (col_name, col_data.shape, err))\n else:\n if verbose:\n print(\" wrote column '%s' with shape %s\" %\n (col_name, col_data.shape))\n\n\ndef write_dict(ms_dict, ms_name, verbose=True):\n # Iterate through subtables\n for sub_table_name, sub_dict in ms_dict.items():\n # Allow parsing of single dict and array of dicts in the same fashion\n if isinstance(sub_dict, dict):\n sub_dict = [sub_dict]\n # Iterate through row groups that are separate dicts within the sub_dict array\n for row_dict in sub_dict:\n if verbose:\n print(f\"Table {sub_table_name}:\")\n # Open main table or sub-table\n if sub_table_name == 'MAIN':\n t = open_table(ms_name, verbose=verbose)\n else:\n t = open_table('::'.join((ms_name, sub_table_name)))\n if verbose:\n print(\" opened successfully\")\n write_rows(t, row_dict, verbose)\n t.close()\n if verbose:\n print(\" closed successfully\")\n"
] | [
[
"numpy.full",
"numpy.zeros_like",
"numpy.ones_like",
"numpy.array",
"numpy.asarray",
"numpy.zeros",
"numpy.product",
"numpy.ones",
"numpy.tile",
"numpy.eye",
"numpy.float64",
"numpy.iscomplexobj",
"numpy.arange",
"numpy.atleast_1d",
"numpy.repeat",
"numpy.int32",
"numpy.char.encode",
"numpy.dtype"
]
] |
Kh4L/gluon-cv | [
"849411ed56632cd854850b07142087d599f97dcb"
] | [
"gluoncv/model_zoo/center_net/deconv_dla.py"
] | [
"\"\"\"DLA network with Deconvolution layers for CenterNet object detection.\"\"\"\n# pylint: disable=arguments-differ,unused-argument\nfrom __future__ import absolute_import\n\nimport warnings\n\nimport numpy as np\nfrom mxnet.context import cpu\nfrom mxnet.gluon import nn\nfrom mxnet.gluon import contrib\nfrom . deconv_resnet import BilinearUpSample\nfrom .. model_zoo import get_model\n\n__all__ = ['get_deconv_dla', 'dla34_deconv']\n\nclass CustomConv(nn.HybridBlock):\n \"\"\"Custom Conv Block.\n\n Parameters\n ----------\n in_channels : int\n Input channels of conv layer.\n out_channels : int\n Output channels of conv layer.\n use_dcnv2 : bool\n Whether use modulated deformable convolution(DCN version2).\n momentum : float, default is 0.9\n Momentum for Norm layer.\n norm_layer : nn.HybridBlock, default is BatchNorm.\n The norm_layer instance.\n norm_kwargs : dict\n Extra arguments for norm layer.\n\n \"\"\"\n def __init__(self, in_channels, out_channels,\n use_dcnv2=False, momentum=0.9,\n norm_layer=nn.BatchNorm, norm_kwargs=None, **kwargs):\n super(CustomConv, self).__init__(**kwargs)\n if norm_kwargs is None:\n norm_kwargs = {}\n with self.name_scope():\n self.actf = nn.HybridSequential()\n self.actf.add(*[\n norm_layer(in_channels=out_channels, momentum=momentum, **norm_kwargs),\n nn.Activation('relu')])\n if use_dcnv2:\n assert hasattr(contrib.cnn, 'ModulatedDeformableConvolution'), \\\n \"No ModulatedDeformableConvolution found in mxnet, consider upgrade...\"\n self.conv = contrib.cnn.ModulatedDeformableConvolution(out_channels,\n kernel_size=3,\n strides=1,\n padding=1,\n dilation=1,\n num_deformable_group=1,\n in_channels=in_channels)\n else:\n self.conv = nn.Conv2D(out_channels,\n kernel_size=3,\n strides=1,\n padding=1,\n dilation=1,\n in_channels=in_channels)\n\n def hybrid_forward(self, F, x):\n x = self.conv(x)\n x = self.actf(x)\n return x\n\n\nclass IDAUp(nn.HybridBlock):\n \"\"\"Iterative deep aggregation layer.\n\n Parameters\n ----------\n out_channels : iterable of int\n Output channels for multiple layers.\n in_channels : iterable of int\n Input channels for multiple layers.\n up_f : iterable of float\n Upsampling ratios.\n use_dcnv2 : bool\n Whether use modulated deformable convolution(DCN version2).\n norm_layer : nn.HybridBlock, default is BatchNorm.\n The norm_layer instance.\n norm_kwargs : dict\n Extra arguments for norm layer.\n\n \"\"\"\n def __init__(self, out_channels, in_channels, up_f,\n use_dcnv2=False, norm_layer=nn.BatchNorm, norm_kwargs=None, **kwargs):\n super(IDAUp, self).__init__(**kwargs)\n self.startp = 0\n self.endp = 1\n with self.name_scope():\n self.projs = nn.HybridSequential('ida_proj')\n self.ups = nn.HybridSequential('ida_ups')\n self.nodes = nn.HybridSequential('ida_nodes')\n for i in range(1, len(in_channels)):\n c = in_channels[i]\n f = int(up_f[i])\n proj = CustomConv(c, out_channels, use_dcnv2=use_dcnv2,\n norm_layer=norm_layer, norm_kwargs=norm_kwargs)\n node = CustomConv(out_channels, out_channels, use_dcnv2=use_dcnv2,\n norm_layer=norm_layer, norm_kwargs=norm_kwargs)\n\n up = nn.Conv2DTranspose(in_channels=out_channels, channels=out_channels,\n kernel_size=f * 2, strides=f,\n padding=f // 2, output_padding=0,\n groups=out_channels, use_bias=False,\n weight_initializer=BilinearUpSample())\n\n self.projs.add(proj)\n self.ups.add(up)\n self.nodes.add(node)\n\n\n def hybrid_forward(self, F, layers):\n for i in range(self.startp + 1, self.endp):\n upsample = self.ups[i - self.startp - 1]\n project = self.projs[i - self.startp - 1]\n layers[i] = upsample(project(layers[i]))\n node = self.nodes[i - self.startp - 1]\n layers[i] = node(layers[i] + layers[i - 1])\n return layers\n\nclass DLAUp(nn.HybridBlock):\n \"\"\"Deep layer aggregation upsampling layer.\n\n Parameters\n ----------\n startp : int\n Start index.\n channels : iterable of int\n Output channels.\n scales : iterable of int\n Upsampling scales.\n in_channels : iterable of int\n Input channels.\n use_dcnv2 : bool\n Whether use ModulatedDeformableConvolution(DCN version 2).\n norm_layer : nn.HybridBlock, default is BatchNorm\n The norm layer type.\n norm_kwargs : dict\n Extra arguments to norm layer.\n\n \"\"\"\n def __init__(self, startp, channels, scales, in_channels=None,\n use_dcnv2=False, norm_layer=nn.BatchNorm, norm_kwargs=None, **kwargs):\n super(DLAUp, self).__init__(**kwargs)\n self.startp = startp\n if in_channels is None:\n in_channels = channels\n self.channels = channels\n channels = list(channels)\n scales = np.array(scales, dtype=int)\n with self.name_scope():\n self.idas = nn.HybridSequential('ida')\n for i in range(len(channels) - 1):\n j = -i - 2\n self.idas.add(IDAUp(channels[j], in_channels[j:],\n scales[j:] // scales[j], use_dcnv2=use_dcnv2,\n norm_layer=norm_layer, norm_kwargs=norm_kwargs))\n scales[j + 1:] = scales[j]\n in_channels[j + 1:] = [channels[j] for _ in channels[j + 1:]]\n\n def hybrid_forward(self, F, layers):\n out = [layers[-1]] # start with 32\n for i in range(len(layers) - self.startp - 1):\n ida = self.idas[i]\n ida.startp = len(layers) -i - 2\n ida.endp = len(layers)\n layers = ida(layers)\n out.insert(0, layers[-1])\n return out\n\n\nclass DeconvDLA(nn.HybridBlock):\n \"\"\"Deep layer aggregation network with deconv layers(smaller strides) which produce larger\n feature map.\n\n Parameters\n ----------\n base_network : str\n Name of the base feature extraction network, must be DLA networks.\n pretrained_base : bool\n Whether load pretrained base network.\n down_ratio : int\n The downsampling ratio of the network, must be one of [2, 4, 8, 16].\n last_level : int\n Index of the last output.\n out_channel : int\n The channel number of last output. If `0`, will use the channels of the first input.\n use_dcnv2 : bool\n Whether use ModulatedDeformableConvolution(DCN version 2).\n norm_layer : nn.HybridBlock, default is BatchNorm\n The norm layer type.\n norm_kwargs : dict\n Extra arguments to norm layer.\n\n \"\"\"\n def __init__(self, base_network, pretrained_base, down_ratio,\n last_level, out_channel=0, use_dcnv2=False,\n norm_layer=nn.BatchNorm, norm_kwargs=None, **kwargs):\n super(DeconvDLA, self).__init__(**kwargs)\n assert down_ratio in [2, 4, 8, 16]\n self.first_level = int(np.log2(down_ratio))\n self.last_level = last_level\n self.base = get_model(base_network, pretrained=pretrained_base, use_feature=True)\n channels = self.base.channels\n scales = [2 ** i for i in range(len(channels[self.first_level:]))]\n self.dla_up = DLAUp(self.first_level, channels[self.first_level:], scales,\n use_dcnv2=use_dcnv2, norm_layer=norm_layer, norm_kwargs=norm_kwargs)\n\n if out_channel == 0:\n out_channel = channels[self.first_level]\n\n self.ida_up = IDAUp(out_channel, channels[self.first_level:self.last_level],\n [2 ** i for i in range(self.last_level - self.first_level)],\n use_dcnv2=use_dcnv2, norm_layer=norm_layer, norm_kwargs=norm_kwargs)\n\n def hybrid_forward(self, F, x):\n \"\"\"Forward pass\"\"\"\n x = self.base(x)\n x = self.dla_up(x)\n\n y = []\n for i in range(self.last_level - self.first_level):\n y.append(x[i])\n self.ida_up.startp = 0\n self.ida_up.endp = len(y)\n self.ida_up(y)\n\n return y[-1]\n\ndef get_deconv_dla(base_network, pretrained=False, ctx=cpu(), scale=4.0, use_dcnv2=False, **kwargs):\n \"\"\"Get resnet with deconv layers.\n\n Parameters\n ----------\n base_network : str\n Name of the base feature extraction network.\n pretrained : bool\n Whether load pretrained base network.\n ctx : mxnet.Context\n mx.cpu() or mx.gpu()\n scale : int or float, default is 4.0\n The downsampling ratio for the network, must in [2, 4, 8, 16]\n use_dcnv2 : bool\n If true, will use DCNv2 layers in upsampling blocks\n pretrained : type\n Description of parameter `pretrained`.\n Returns\n -------\n get_deconv_resnet(base_network, pretrained=False,\n Description of returned object.\n\n \"\"\"\n assert int(scale) in [2, 4, 8, 16], \"scale must be one of [2, 4, 8, 16]\"\n net = DeconvDLA(base_network=base_network, pretrained_base=pretrained,\n down_ratio=int(scale), last_level=5, use_dcnv2=use_dcnv2, **kwargs)\n with warnings.catch_warnings(record=True) as _:\n warnings.simplefilter(\"always\")\n net.initialize()\n net.collect_params().reset_ctx(ctx)\n return net\n\ndef dla34_deconv(**kwargs):\n \"\"\"DLA34 model with deconv layers.\n\n Returns\n -------\n HybridBlock\n A DLA34 model with deconv layers.\n\n \"\"\"\n kwargs['use_dcnv2'] = False\n return get_deconv_dla('dla34', **kwargs)\n\ndef dla34_deconv_dcnv2(**kwargs):\n \"\"\"DLA34 model with deconv layers and modulated deformable convolution layers.\n\n Returns\n -------\n HybridBlock\n A DLA34 model with deconv layers.\n\n \"\"\"\n kwargs['use_dcnv2'] = True\n return get_deconv_dla('dla34', **kwargs)\n"
] | [
[
"numpy.array",
"numpy.log2"
]
] |
abaisero/rl-psr | [
"ac3d1162f6629133b7f3f88a0d49e4f9fd6f2e69"
] | [
"rl_rpsr/value_function.py"
] | [
"from __future__ import annotations\n\nfrom dataclasses import dataclass\nfrom typing import Iterable, List\n\nimport numpy as np\nimport yaml\n\n\n@dataclass\nclass Alpha(yaml.YAMLObject):\n yaml_tag = u'!Alpha'\n\n action: int\n vector: np.ndarray\n\n\nclass ValueFunction(yaml.YAMLObject):\n yaml_tag = u'!ValueFunction'\n\n def __init__(self, alphas: Iterable[Alpha], horizon: int):\n self.alphas = self.standardize(alphas)\n self.horizon = horizon\n\n self.__matrix = None\n\n def __len__(self):\n return len(self.alphas)\n\n @staticmethod\n def standardize(alphas: Iterable[Alpha]) -> List[Alpha]:\n return sorted(alphas, key=lambda alpha: alpha.vector.tolist())\n\n @property\n def matrix(self):\n if self.__matrix is None:\n self.__matrix = np.column_stack(\n [alpha.vector for alpha in self.alphas]\n )\n return self.__matrix\n\n def value(self, state) -> float:\n return (self.matrix.T @ state).max()\n\n def policy(self, state) -> int:\n idx = (self.matrix.T @ state).argmax()\n return self.alphas[idx].action\n"
] | [
[
"numpy.column_stack"
]
] |
hamogu/specutils | [
"b873f2ac9b3c207c9e670246d102f46a9606d6ed"
] | [
"specutils/tests/test_slicing.py"
] | [
"import astropy.units as u\nimport astropy.wcs as fitswcs\nimport numpy as np\nfrom numpy.testing import assert_allclose\n\nfrom ..spectra.spectrum1d import Spectrum1D\n\n\ndef test_spectral_axes():\n spec1 = Spectrum1D(spectral_axis=np.arange(1, 50) * u.nm,\n flux=np.random.sample(49) * 100 * u.Jy)\n\n sliced_spec1 = spec1[0]\n\n assert isinstance(sliced_spec1, Spectrum1D)\n assert_allclose(sliced_spec1.wcs.pixel_to_world(np.arange(10)), spec1.wcs.pixel_to_world(np.arange(10)))\n\n flux2 = np.random.sample((10, 49)) * 100\n\n spec2 = Spectrum1D(spectral_axis=np.arange(1, 50) * u.nm,\n flux=flux2 * u.Jy)\n\n sliced_spec2 = spec2[0]\n\n assert isinstance(sliced_spec2, Spectrum1D)\n assert_allclose(sliced_spec2.wcs.pixel_to_world(np.arange(10)), spec2.wcs.pixel_to_world(np.arange(10)))\n assert sliced_spec2.flux.shape[0] == 49\n\n\ndef test_slicing():\n\n # Create the initial spectrum\n spec = Spectrum1D(spectral_axis=np.arange(10) * u.um, flux=2*np.arange(10)*u.Jy)\n\n # Slice it.\n sub_spec = spec[4:8]\n\n # Check basic spectral_axis property\n assert sub_spec.spectral_axis.unit == u.um\n assert np.allclose(sub_spec.spectral_axis.value, np.array([4, 5, 6, 7]))\n assert np.allclose(sub_spec.flux.value, np.array([8, 10, 12, 14]))\n\n assert sub_spec.wavelength.unit == u.AA\n assert np.allclose(sub_spec.wavelength.value, np.array([40000., 50000., 60000., 70000.]))\n\n assert sub_spec.frequency.unit == u.GHz\n assert np.allclose(sub_spec.frequency.value, np.array([74948.1145, 59958.4916, 49965.40966667, 42827.494]))\n\n # Do it a second time to confirm the original was not modified.\n sub_spec2 = spec[1:5]\n\n # Check basic spectral_axis property\n assert sub_spec2.spectral_axis.unit == u.um\n assert np.allclose(sub_spec2.spectral_axis.value, np.array([1, 2, 3, 4]))\n assert np.allclose(sub_spec2.flux.value, np.array([2, 4, 6, 8]))\n\n assert sub_spec2.wavelength.unit == u.AA\n assert np.allclose(sub_spec2.wavelength.value, np.array([10000., 20000., 30000., 40000.]))\n\n assert sub_spec2.frequency.unit == u.GHz\n assert np.allclose(sub_spec2.frequency.value, np.array([299792.458, 149896.229, 99930.81933333, 74948.1145]))\n\n # Going to repeat these to make sure the original spectrum was\n # not modified in some way\n assert spec.spectral_axis.unit == u.um\n assert np.allclose(spec.spectral_axis.value, np.array(np.arange(10)))\n assert np.allclose(spec.flux.value, np.array(2*np.arange(10)))\n\n assert spec.wavelength.unit == u.AA\n assert np.allclose(spec.wavelength.value, np.array(10000*np.arange(10)))\n\n assert sub_spec.frequency.unit == u.GHz\n assert np.allclose(sub_spec.frequency.value, np.array([74948.1145, 59958.4916, 49965.40966667, 42827.494]))\n\ndef test_slicing_with_fits():\n my_wcs = fitswcs.WCS(header={'CDELT1': 1, 'CRVAL1': 6562.8, 'CUNIT1': 'Angstrom',\n 'CTYPE1': 'WAVE', 'RESTFRQ': 1400000000, 'CRPIX1': 25})\n\n spec = Spectrum1D(flux=[5, 6, 7, 8, 9, 10] * u.Jy, wcs=my_wcs)\n spec_slice = spec[1:5]\n\n assert isinstance(spec_slice, Spectrum1D)\n assert spec_slice.flux.size == 4\n assert np.allclose(spec_slice.wcs.pixel_to_world([6, 7, 8, 9]).value, spec.wcs.pixel_to_world([6, 7, 8, 9]).value)\n"
] | [
[
"numpy.array",
"numpy.random.sample",
"numpy.arange"
]
] |
AAbdul12/Data-engineering-nanodegree | [
"794c57a52f79ceeb4201e408c8bad10fa76a9896"
] | [
"2_dend_cloud_data_warehouses/infrastructure_as_code.py"
] | [
"import pandas as pd \nimport boto3\nimport json\n\nfrom botocore.exceptions import ClientError\nimport configparser\n\n\nconfig = configparser.ConfigParser()\nconfig.read_file(open('/home/f.silvestre/Documents/Projects/Data-engineering-nanodegree/2_dend_cloud_data_warehouses/dhw.cfg'))\n\nKEY = config.get('AWS','KEY')\nSECRET = config.get('AWS','SECRET')\n\nDWH_CLUSTER_TYPE = config.get(\"DWH\",\"DWH_CLUSTER_TYPE\")\nDWH_NUM_NODES = config.get(\"DWH\",\"DWH_NUM_NODES\")\nDWH_NODE_TYPE = config.get(\"DWH\",\"DWH_NODE_TYPE\")\n\nDWH_CLUSTER_IDENTIFIER = config.get(\"DWH\",\"DWH_CLUSTER_IDENTIFIER\")\nDWH_DB = config.get(\"DWH\",\"DWH_DB\")\nDWH_DB_USER = config.get(\"DWH\",\"DWH_DB_USER\")\nDWH_DB_PASSWORD = config.get(\"DWH\",\"DWH_DB_PASSWORD\")\nDWH_PORT = config.get(\"DWH\",\"DWH_PORT\")\n\nDWH_IAM_ROLE_NAME = config.get(\"DWH\", \"DWH_IAM_ROLE_NAME\")\n\n(DWH_DB_USER, DWH_DB_PASSWORD, DWH_DB)\n\ndf = pd.DataFrame({\"Param\":\n [\"DWH_CLUSTER_TYPE\", \"DWH_NUM_NODES\", \"DWH_NODE_TYPE\", \"DWH_CLUSTER_IDENTIFIER\", \"DWH_DB\", \"DWH_DB_USER\", \"DWH_DB_PASSWORD\", \"DWH_PORT\", \"DWH_IAM_ROLE_NAME\"],\n \"Value\":\n [DWH_CLUSTER_TYPE, DWH_NUM_NODES, DWH_NODE_TYPE, DWH_CLUSTER_IDENTIFIER, DWH_DB, DWH_DB_USER, DWH_DB_PASSWORD, DWH_PORT, DWH_IAM_ROLE_NAME]\n })\n\nprint(df)\n\n# Create clients\nec2 = boto3.resource('ec2',\n region_name='us-west-2', \n aws_access_key_id=KEY,\n aws_secret_access_key=SECRET)\n\ns3 = boto3.resource('s3',\n region_name='us-west-2', \n aws_access_key_id=KEY,\n aws_secret_access_key=SECRET)\n\niam = boto3.resource('iam',\n region_name='us-west-2', \n aws_access_key_id=KEY,\n aws_secret_access_key=SECRET)\n\nredshift = boto3.resource('redshift',\n region_name='us-west-2', \n aws_access_key_id=KEY,\n aws_secret_access_key=SECRET)\n\n\n# Connect to S3\nsampleDbBucket = s3.Bucket(\"awssampledbuswest2\")\n\n\ntry:\n print(\"Creating IAM Role\")\n dwhRole=iam.create_role(\n Path='/',\n RoleName=DWH_IAM_ROLE_NAME,\n Description=\"Allows Redshift clusters to call AWS services on your behalf\",\n AssumeRolePolicyDocument=json.dumps(\n {'Statement': [{'Action':'sts:AssumeRole',\n 'Effect':'Allow',\n 'Principal':{'Service': 'redshift.amazonaws.com'}}],\n 'Version':'2012-10-17'}\n )\n )\nexcept Exception as e:\n print(e)\n\nprint(\"Attaching policy\")\n\niam.attach_role_policy(RoleName=DWH_IAM_ROLE_NAME,\n PolicyArn=\"arn:aws:iam::aws:policy/AmazonS3ReadOnlyAccess\"\n )['ResponseMetadata']['HTTPStatusCode']\n\nprint(\"Get IAM Role\")\nroleArn = iam.get_role(RoleName=DWH_IAM_ROLE_NAME)['Role']['Arn']\n\nprint(roleArn)\n\n# Create Readshift cluster\ntry:\n response = redshift.create_cluster(\n ClusterType=DWH_CLUSTER_TYPE,\n NodeType=DWH_NODE_TYPE,\n NumberOfNodes=int(DWH_NUM_NODES),\n DBName=DWH_DB,\n ClusterIdentifier=DWH_CLUSTER_IDENTIFIER,\n MasterUsername=DWH_DB_USER,\n MasterUserPassword=DWH_DB_PASSWORD,\n \n #Roles (for s3 access)\n IamRoles=[roleArn] \n )\n\nexcept Exception as e:\n print(e)\n\n\n# Describe cluster and status\ndef prettyRedshiftProps(props):\n pd.set_option('display.max_colwidth', -1)\n keysToShow = [\"ClusterIdentifier\", \"NodeType\", \"ClusterStatus\", \"MasterUsername\", \"DBName\", \"Endpoint\", \"NumberOfNodes\", 'VpcId']\n x = [(k, v) for k,v in props.items() if k in keysToShow]\n return pd.DataFrame(data=x, columns=[\"Key\", \"Value\"])\n\nmyClusterProps = redshift.describe_clusters(ClusterIdentifier=DWH_CLUSTER_IDENTIFIER)['Clusters'][0]\nprettyRedshiftProps(myClusterProps)\n"
] | [
[
"pandas.DataFrame",
"pandas.set_option"
]
] |
marlesson/recsys-fair-metrics | [
"82c0a18486455718558fbd783e0bd3bf14d8bc67"
] | [
"recsys_fair_metrics/fairness/disparate_treatment.py"
] | [
"import pandas as pd\nimport numpy as np\n\nnp.seterr(divide=\"ignore\", invalid=\"ignore\")\nfrom typing import List, Dict, Any\nfrom sklearn.metrics import confusion_matrix\nfrom scipy.stats import norm\nfrom recsys_fair_metrics.util.util import mean_confidence_interval\nimport plotly.figure_factory as ff\nimport plotly.express as px\nimport plotly.graph_objects as go\nfrom scipy.stats import ks_2samp\n\nTEMPLATE = \"plotly_white\"\n\n\nclass DisparateTreatment(object):\n def __init__(\n self,\n dataframe: pd.DataFrame,\n metric: str,\n column: str,\n prediction_score_key: str,\n prediction_key: str,\n ):\n self._dataframe = dataframe.fillna(\"-\")\n self._column = column\n self._metric = metric\n self._prediction_score_key = prediction_score_key\n self._prediction_key = prediction_key\n\n self._df_scores = None\n self._df_mean_scores = None\n self._df_mean_scores_per_column = None\n\n self.fit(\n self._dataframe,\n self._column,\n self._prediction_score_key,\n self._prediction_key,\n )\n\n def fit(\n self,\n df: pd.DataFrame,\n column: List[str],\n prediction_score_key: str,\n prediction_key: str,\n ) -> pd.DataFrame:\n\n df = df[[column, prediction_key, prediction_score_key]]\n df = df.set_index([column]).apply(pd.Series.explode).reset_index().fillna(\"-\")\n # from IPython import embed; embed()\n def confidence(x):\n return mean_confidence_interval(x)[1]\n\n df_mean = (\n df.groupby([prediction_key, column]).agg(\n count=(prediction_score_key, \"count\"),\n mean_rhat_score=(prediction_score_key, \"mean\"),\n confidence=(prediction_score_key, confidence),\n )\n ).reset_index() # .rename(columns={item_column: 'count', first_recscore_column: 'mean_rhat_score'})\n\n # Mean Score List\n df_mean = self.filter_treatment_df(\n df_mean, prediction_key, column, min_size=10\n ).sort_values(\"mean_rhat_score\")\n\n # Mean Score pivot per column\n df_mean_scores_per_column = df_mean.pivot(\n index=prediction_key, columns=self._column, values=[\"mean_rhat_score\"]\n ) # .fillna()\n\n self._sample_score = 10000\n self._df_scores = df\n self._df_mean_scores = df_mean\n self._df_mean_scores_per_column = df_mean_scores_per_column[\"mean_rhat_score\"]\n\n def filter_treatment_df(self, df, rec_column, fairness_column, min_size=10):\n # Filter significance\n df = df[df[\"count\"] >= min_size]\n\n # more them one group\n df_count = df.groupby([rec_column]).count()[\"count\"].reset_index()\n df_count = df_count[\n df_count[\"count\"] > 1\n ] # == len(np.unique(df[fairness_column]))\n df = df[df[rec_column].isin(df_count[rec_column])]\n\n return df\n\n def metrics(self):\n return self._df_metrics\n\n def show(self, kind: str = \"bar\", **kwargs):\n if kind == \"bar\":\n return self.show_bar(**kwargs)\n elif kind == \"ks\":\n return self.show_ks(**kwargs)\n\n def show_bar(self, **kwargs):\n\n title = (\n \"Disparate Treatment: \" + self._column\n if \"title\" not in kwargs\n else kwargs[\"title\"]\n )\n top_k = 10 if \"top_k\" not in kwargs else kwargs[\"top_k\"]\n\n df = self._df_mean_scores\n column = self._column\n reclist_column = self._prediction_key\n data = []\n\n # Order by variance\n df_var = (\n df.groupby(reclist_column)\n .agg(var_mean_rhat_score=(\"mean_rhat_score\", \"var\"))\n .sort_values(\"var_mean_rhat_score\", ascending=False)\n .reset_index()\n .iloc[:top_k]\n )\n\n df = df.merge(df_var).sort_values(\"var_mean_rhat_score\", ascending=False)\n\n y_sorted = list(\n df[[reclist_column, \"var_mean_rhat_score\"]]\n .drop_duplicates()\n .sort_values(\"var_mean_rhat_score\", ascending=False)[reclist_column]\n )\n y_sorted.reverse()\n\n for group, rows in df.groupby(column):\n # rows = rows.sort_values('var_mean_rhat_score', ascending=False)\n data.append(\n go.Bar(\n name=column + \".\" + str(group),\n y=[\"ID:\"+str(a) for a in rows[reclist_column]],\n x=rows[\"mean_rhat_score\"],\n orientation=\"h\",\n error_x=dict(type=\"data\", array=rows[\"confidence\"]),\n )\n ) # px.colors.sequential.Purp [i for i in range(len(rows))]\n\n fig = go.Figure(data=data)\n\n # Change the bar mode\n fig.update_layout(\n template=TEMPLATE,\n legend_orientation=\"h\",\n yaxis_title=\"supp\",\n xaxis_title=\"rhat_scores\",\n legend=dict(y=-0.2),\n title=title,\n )\n fig.update_layout(yaxis={\"categoryorder\": \"array\", \"categoryarray\": y_sorted})\n\n fig.update_layout(\n shapes=[\n dict(\n type=\"line\",\n line=dict(\n width=1,\n dash=\"dot\",\n ),\n yref=\"paper\",\n y0=0,\n y1=1,\n xref=\"x\",\n x0=df[\"mean_rhat_score\"].mean(),\n x1=df[\"mean_rhat_score\"].mean(),\n )\n ]\n )\n\n return fig\n\n def show_ks(self, **kwargs):\n \"\"\"\n In an ECDF, x-axis correspond to the range of values for variables\n and on the y-axis we plot the proportion of data points that are less\n than are equal to corresponding x-axis value.\n\n https://cmdlinetips.com/2019/05/empirical-cumulative-distribution-function-ecdf-in-python/\n \"\"\"\n\n title = (\n \"Disparate Treatment: \" + self._column\n if \"title\" not in kwargs\n else kwargs[\"title\"]\n )\n\n df = self._df_scores\n data = []\n column = self._column\n for group in np.unique(df[column].values):\n values = (\n df[df[column] == group][\"action_scores\"]\n .sample(self._sample_score, random_state=42, replace=True)\n .values\n )\n x, y = self.ecdf(values)\n data.append(\n go.Scatter(\n name=column + \".\" + str(group),\n y=y,\n x=x,\n )\n )\n # fig = px.histogram(df, x='')\n fig = go.Figure(data=data)\n\n # Change the bar mode\n fig.update_layout(\n template=TEMPLATE,\n legend_orientation=\"h\",\n xaxis_title=\"rhat_score\",\n yaxis_title=\"ECDF\",\n legend=dict(y=-0.2),\n title=title,\n )\n\n fig.add_annotation(\n x=0.8,\n y=0.1,\n xref=\"x\",\n yref=\"y\",\n text=\"Max K-S: {}\".format(self.metric()[\"max_ks\"].round(3)),\n showarrow=False,\n font=dict(family=\"Courier New, monospace\", size=12, color=\"#ffffff\"),\n align=\"center\",\n bordercolor=\"#c7c7c7\",\n borderwidth=1,\n borderpad=4,\n bgcolor=\"#ff7f0e\",\n opacity=0.8,\n )\n\n return fig\n\n def ecdf(self, data):\n \"\"\" Compute ECDF \"\"\"\n x = np.sort(data)\n n = x.size\n y = np.arange(1, n + 1) / n\n return (x, y)\n\n def metric(self):\n \"\"\"\n Max KS Distance\n \"\"\"\n df = self._df_scores\n columns = np.unique(df[self._column].values)\n ks_metrics = []\n for a in columns:\n for b in columns:\n sample_a = (\n df[df[self._column] == a][\"action_scores\"]\n .sample(self._sample_score, random_state=42, replace=True)\n .values\n )\n sample_b = (\n df[df[self._column] == b][\"action_scores\"]\n .sample(self._sample_score, random_state=42, replace=True)\n .values\n )\n ks_metrics.append(ks_2samp(sample_a, sample_b).statistic)\n\n # for a in self._df_mean_scores_per_column.columns:\n # for b in self._df_mean_scores_per_column.columns:\n # ks_metrics.append(ks_2samp(self._df_mean_scores_per_column[a], self._df_mean_scores_per_column[b]).statistic)\n\n # s = len(self._df_mean_scores_per_column.columns)\n return {\"max_ks\": np.max(ks_metrics)}\n"
] | [
[
"numpy.max",
"numpy.seterr",
"numpy.arange",
"numpy.sort",
"scipy.stats.ks_2samp",
"numpy.unique"
]
] |
Elysium-Pool/torrent-transfer-logger | [
"4d9dc2f3197db5727eada9a07d26b9f5c0834a26"
] | [
"log_transfers.py"
] | [
"#!/usr/bin/env python3\n\n# When run, this script logs the peers for each torrent in qBittorrent to a sqlite database. It is useful for performing analytics on download progress and total number of downloads of other peers for torrents you are seeding/downloading.\n# Run this script in a cronjob or similar minutely. \n\nimport qbittorrentapi\nimport logging\nimport time, datetime\nimport json\nimport pandas as pd\nimport sqlite3\n\nsqle = sqlite3.connect('torrent_transfer_log.sqlite')\n\nwith open('config.json') as f:\n config = json.load(f)\n\nqbt_client = qbittorrentapi.Client(**config['qbt_connect_args'])\n\nlogging.basicConfig(level=logging.INFO)\nlogger = logging.getLogger(__file__)\n\ntry:\n\tqbt_client.auth_log_in()\nexcept qbittorrentapi.LoginFailed as e:\n\tprint(e)\n\ndef add_torrents_log():\n\t\"\"\" Add the current peer log to the database. \"\"\"\n\tlogger.info(\"Starting add_torrents_log().\")\n\n\tfor torrent in qbt_client.torrents_info():\n\t\thash = torrent.hash\n\n\t\tpeers = qbt_client.sync_torrent_peers(hash, rid=0).peers\n\t\tval = [({'peer': key} + val) for (key, val) in dict(peers).items()]\n\n\t\tdf = pd.DataFrame(val)\n\t\tdf['log_date'] = datetime.datetime.now()\n\t\tdf['torrent_hash'] = hash\n\t\tdf['torrent_state'] = torrent.state\n\t\tdf['torrent_name'] = torrent.name\n\n\t\tif len(df.index) > 0:\t\n\t\t\tdf = df.set_index(['log_date', 'torrent_hash', 'peer'])\n\t\t\tdf.to_sql('torrent_transfer_log', con=sqle, if_exists='append')\n\n\tlogger.info('Done add_torrents_log().')\n\nif __name__ == '__main__':\n\tadd_torrents_log()\n\n"
] | [
[
"pandas.DataFrame"
]
] |
mikessut/pandas | [
"4aa0783d65dc20dc450ef3f58defda14ebab5f6f"
] | [
"pandas/io/excel/_base.py"
] | [
"import abc\nimport datetime\nfrom io import BufferedIOBase, BytesIO, RawIOBase\nimport os\nfrom textwrap import fill\nfrom typing import Any, Mapping, Union\n\nfrom pandas._config import config\n\nfrom pandas._libs.parsers import STR_NA_VALUES\nfrom pandas._typing import StorageOptions\nfrom pandas.errors import EmptyDataError\nfrom pandas.util._decorators import Appender, deprecate_nonkeyword_arguments\n\nfrom pandas.core.dtypes.common import is_bool, is_float, is_integer, is_list_like\n\nfrom pandas.core.frame import DataFrame\n\nfrom pandas.io.common import (\n IOArgs,\n get_filepath_or_buffer,\n is_url,\n stringify_path,\n urlopen,\n validate_header_arg,\n)\nfrom pandas.io.excel._util import (\n fill_mi_header,\n get_default_writer,\n get_writer,\n maybe_convert_usecols,\n pop_header_name,\n)\nfrom pandas.io.parsers import TextParser\n\n_read_excel_doc = (\n \"\"\"\nRead an Excel file into a pandas DataFrame.\n\nSupports `xls`, `xlsx`, `xlsm`, `xlsb`, `odf`, `ods` and `odt` file extensions\nread from a local filesystem or URL. Supports an option to read\na single sheet or a list of sheets.\n\nParameters\n----------\nio : str, bytes, ExcelFile, xlrd.Book, path object, or file-like object\n Any valid string path is acceptable. The string could be a URL. Valid\n URL schemes include http, ftp, s3, and file. For file URLs, a host is\n expected. A local file could be: ``file://localhost/path/to/table.xlsx``.\n\n If you want to pass in a path object, pandas accepts any ``os.PathLike``.\n\n By file-like object, we refer to objects with a ``read()`` method,\n such as a file handle (e.g. via builtin ``open`` function)\n or ``StringIO``.\nsheet_name : str, int, list, or None, default 0\n Strings are used for sheet names. Integers are used in zero-indexed\n sheet positions. Lists of strings/integers are used to request\n multiple sheets. Specify None to get all sheets.\n\n Available cases:\n\n * Defaults to ``0``: 1st sheet as a `DataFrame`\n * ``1``: 2nd sheet as a `DataFrame`\n * ``\"Sheet1\"``: Load sheet with name \"Sheet1\"\n * ``[0, 1, \"Sheet5\"]``: Load first, second and sheet named \"Sheet5\"\n as a dict of `DataFrame`\n * None: All sheets.\n\nheader : int, list of int, default 0\n Row (0-indexed) to use for the column labels of the parsed\n DataFrame. If a list of integers is passed those row positions will\n be combined into a ``MultiIndex``. Use None if there is no header.\nnames : array-like, default None\n List of column names to use. If file contains no header row,\n then you should explicitly pass header=None.\nindex_col : int, list of int, default None\n Column (0-indexed) to use as the row labels of the DataFrame.\n Pass None if there is no such column. If a list is passed,\n those columns will be combined into a ``MultiIndex``. If a\n subset of data is selected with ``usecols``, index_col\n is based on the subset.\nusecols : int, str, list-like, or callable default None\n * If None, then parse all columns.\n * If str, then indicates comma separated list of Excel column letters\n and column ranges (e.g. \"A:E\" or \"A,C,E:F\"). Ranges are inclusive of\n both sides.\n * If list of int, then indicates list of column numbers to be parsed.\n * If list of string, then indicates list of column names to be parsed.\n\n .. versionadded:: 0.24.0\n\n * If callable, then evaluate each column name against it and parse the\n column if the callable returns ``True``.\n\n Returns a subset of the columns according to behavior above.\n\n .. versionadded:: 0.24.0\n\nsqueeze : bool, default False\n If the parsed data only contains one column then return a Series.\ndtype : Type name or dict of column -> type, default None\n Data type for data or columns. E.g. {'a': np.float64, 'b': np.int32}\n Use `object` to preserve data as stored in Excel and not interpret dtype.\n If converters are specified, they will be applied INSTEAD\n of dtype conversion.\nengine : str, default None\n If io is not a buffer or path, this must be set to identify io.\n Supported engines: \"xlrd\", \"openpyxl\", \"odf\", \"pyxlsb\", default \"xlrd\".\n Engine compatibility :\n - \"xlrd\" supports most old/new Excel file formats.\n - \"openpyxl\" supports newer Excel file formats.\n - \"odf\" supports OpenDocument file formats (.odf, .ods, .odt).\n - \"pyxlsb\" supports Binary Excel files.\nconverters : dict, default None\n Dict of functions for converting values in certain columns. Keys can\n either be integers or column labels, values are functions that take one\n input argument, the Excel cell content, and return the transformed\n content.\ntrue_values : list, default None\n Values to consider as True.\nfalse_values : list, default None\n Values to consider as False.\nskiprows : list-like, int, or callable, optional\n Line numbers to skip (0-indexed) or number of lines to skip (int) at the\n start of the file. If callable, the callable function will be evaluated\n against the row indices, returning True if the row should be skipped and\n False otherwise. An example of a valid callable argument would be ``lambda\n x: x in [0, 2]``.\nnrows : int, default None\n Number of rows to parse.\nna_values : scalar, str, list-like, or dict, default None\n Additional strings to recognize as NA/NaN. If dict passed, specific\n per-column NA values. By default the following values are interpreted\n as NaN: '\"\"\"\n + fill(\"', '\".join(sorted(STR_NA_VALUES)), 70, subsequent_indent=\" \")\n + \"\"\"'.\nkeep_default_na : bool, default True\n Whether or not to include the default NaN values when parsing the data.\n Depending on whether `na_values` is passed in, the behavior is as follows:\n\n * If `keep_default_na` is True, and `na_values` are specified, `na_values`\n is appended to the default NaN values used for parsing.\n * If `keep_default_na` is True, and `na_values` are not specified, only\n the default NaN values are used for parsing.\n * If `keep_default_na` is False, and `na_values` are specified, only\n the NaN values specified `na_values` are used for parsing.\n * If `keep_default_na` is False, and `na_values` are not specified, no\n strings will be parsed as NaN.\n\n Note that if `na_filter` is passed in as False, the `keep_default_na` and\n `na_values` parameters will be ignored.\nna_filter : bool, default True\n Detect missing value markers (empty strings and the value of na_values). In\n data without any NAs, passing na_filter=False can improve the performance\n of reading a large file.\nverbose : bool, default False\n Indicate number of NA values placed in non-numeric columns.\nparse_dates : bool, list-like, or dict, default False\n The behavior is as follows:\n\n * bool. If True -> try parsing the index.\n * list of int or names. e.g. If [1, 2, 3] -> try parsing columns 1, 2, 3\n each as a separate date column.\n * list of lists. e.g. If [[1, 3]] -> combine columns 1 and 3 and parse as\n a single date column.\n * dict, e.g. {'foo' : [1, 3]} -> parse columns 1, 3 as date and call\n result 'foo'\n\n If a column or index contains an unparseable date, the entire column or\n index will be returned unaltered as an object data type. If you don`t want to\n parse some cells as date just change their type in Excel to \"Text\".\n For non-standard datetime parsing, use ``pd.to_datetime`` after ``pd.read_excel``.\n\n Note: A fast-path exists for iso8601-formatted dates.\ndate_parser : function, optional\n Function to use for converting a sequence of string columns to an array of\n datetime instances. The default uses ``dateutil.parser.parser`` to do the\n conversion. Pandas will try to call `date_parser` in three different ways,\n advancing to the next if an exception occurs: 1) Pass one or more arrays\n (as defined by `parse_dates`) as arguments; 2) concatenate (row-wise) the\n string values from the columns defined by `parse_dates` into a single array\n and pass that; and 3) call `date_parser` once for each row using one or\n more strings (corresponding to the columns defined by `parse_dates`) as\n arguments.\nthousands : str, default None\n Thousands separator for parsing string columns to numeric. Note that\n this parameter is only necessary for columns stored as TEXT in Excel,\n any numeric columns will automatically be parsed, regardless of display\n format.\ncomment : str, default None\n Comments out remainder of line. Pass a character or characters to this\n argument to indicate comments in the input file. Any data between the\n comment string and the end of the current line is ignored.\nskipfooter : int, default 0\n Rows at the end to skip (0-indexed).\nconvert_float : bool, default True\n Convert integral floats to int (i.e., 1.0 --> 1). If False, all numeric\n data will be read in as floats: Excel stores all numbers as floats\n internally.\nmangle_dupe_cols : bool, default True\n Duplicate columns will be specified as 'X', 'X.1', ...'X.N', rather than\n 'X'...'X'. Passing in False will cause data to be overwritten if there\n are duplicate names in the columns.\nstorage_options : dict, optional\n Extra options that make sense for a particular storage connection, e.g.\n host, port, username, password, etc., if using a URL that will\n be parsed by ``fsspec``, e.g., starting \"s3://\", \"gcs://\". An error\n will be raised if providing this argument with a local path or\n a file-like buffer. See the fsspec and backend storage implementation\n docs for the set of allowed keys and values.\n\n .. versionadded:: 1.2.0\n\nReturns\n-------\nDataFrame or dict of DataFrames\n DataFrame from the passed in Excel file. See notes in sheet_name\n argument for more information on when a dict of DataFrames is returned.\n\nSee Also\n--------\nDataFrame.to_excel : Write DataFrame to an Excel file.\nDataFrame.to_csv : Write DataFrame to a comma-separated values (csv) file.\nread_csv : Read a comma-separated values (csv) file into DataFrame.\nread_fwf : Read a table of fixed-width formatted lines into DataFrame.\n\nExamples\n--------\nThe file can be read using the file name as string or an open file object:\n\n>>> pd.read_excel('tmp.xlsx', index_col=0) # doctest: +SKIP\n Name Value\n0 string1 1\n1 string2 2\n2 #Comment 3\n\n>>> pd.read_excel(open('tmp.xlsx', 'rb'),\n... sheet_name='Sheet3') # doctest: +SKIP\n Unnamed: 0 Name Value\n0 0 string1 1\n1 1 string2 2\n2 2 #Comment 3\n\nIndex and header can be specified via the `index_col` and `header` arguments\n\n>>> pd.read_excel('tmp.xlsx', index_col=None, header=None) # doctest: +SKIP\n 0 1 2\n0 NaN Name Value\n1 0.0 string1 1\n2 1.0 string2 2\n3 2.0 #Comment 3\n\nColumn types are inferred but can be explicitly specified\n\n>>> pd.read_excel('tmp.xlsx', index_col=0,\n... dtype={'Name': str, 'Value': float}) # doctest: +SKIP\n Name Value\n0 string1 1.0\n1 string2 2.0\n2 #Comment 3.0\n\nTrue, False, and NA values, and thousands separators have defaults,\nbut can be explicitly specified, too. Supply the values you would like\nas strings or lists of strings!\n\n>>> pd.read_excel('tmp.xlsx', index_col=0,\n... na_values=['string1', 'string2']) # doctest: +SKIP\n Name Value\n0 NaN 1\n1 NaN 2\n2 #Comment 3\n\nComment lines in the excel input file can be skipped using the `comment` kwarg\n\n>>> pd.read_excel('tmp.xlsx', index_col=0, comment='#') # doctest: +SKIP\n Name Value\n0 string1 1.0\n1 string2 2.0\n2 None NaN\n\"\"\"\n)\n\n\n@deprecate_nonkeyword_arguments(allowed_args=2, version=\"2.0\")\n@Appender(_read_excel_doc)\ndef read_excel(\n io,\n sheet_name=0,\n header=0,\n names=None,\n index_col=None,\n usecols=None,\n squeeze=False,\n dtype=None,\n engine=None,\n converters=None,\n true_values=None,\n false_values=None,\n skiprows=None,\n nrows=None,\n na_values=None,\n keep_default_na=True,\n na_filter=True,\n verbose=False,\n parse_dates=False,\n date_parser=None,\n thousands=None,\n comment=None,\n skipfooter=0,\n convert_float=True,\n mangle_dupe_cols=True,\n storage_options: StorageOptions = None,\n):\n\n if not isinstance(io, ExcelFile):\n io = ExcelFile(io, storage_options=storage_options, engine=engine)\n elif engine and engine != io.engine:\n raise ValueError(\n \"Engine should not be specified when passing \"\n \"an ExcelFile - ExcelFile already has the engine set\"\n )\n\n return io.parse(\n sheet_name=sheet_name,\n header=header,\n names=names,\n index_col=index_col,\n usecols=usecols,\n squeeze=squeeze,\n dtype=dtype,\n converters=converters,\n true_values=true_values,\n false_values=false_values,\n skiprows=skiprows,\n nrows=nrows,\n na_values=na_values,\n keep_default_na=keep_default_na,\n na_filter=na_filter,\n verbose=verbose,\n parse_dates=parse_dates,\n date_parser=date_parser,\n thousands=thousands,\n comment=comment,\n skipfooter=skipfooter,\n convert_float=convert_float,\n mangle_dupe_cols=mangle_dupe_cols,\n )\n\n\nclass BaseExcelReader(metaclass=abc.ABCMeta):\n def __init__(self, filepath_or_buffer, storage_options: StorageOptions = None):\n self.ioargs = IOArgs(\n filepath_or_buffer=filepath_or_buffer,\n encoding=None,\n mode=None,\n compression={\"method\": None},\n )\n # If filepath_or_buffer is a url, load the data into a BytesIO\n if is_url(filepath_or_buffer):\n self.ioargs = IOArgs(\n filepath_or_buffer=BytesIO(urlopen(filepath_or_buffer).read()),\n should_close=True,\n encoding=None,\n mode=None,\n compression={\"method\": None},\n )\n elif not isinstance(filepath_or_buffer, (ExcelFile, self._workbook_class)):\n self.ioargs = get_filepath_or_buffer(\n filepath_or_buffer, storage_options=storage_options\n )\n\n if isinstance(self.ioargs.filepath_or_buffer, self._workbook_class):\n self.book = self.ioargs.filepath_or_buffer\n elif hasattr(self.ioargs.filepath_or_buffer, \"read\"):\n # N.B. xlrd.Book has a read attribute too\n assert not isinstance(self.ioargs.filepath_or_buffer, str)\n self.ioargs.filepath_or_buffer.seek(0)\n self.book = self.load_workbook(self.ioargs.filepath_or_buffer)\n elif isinstance(self.ioargs.filepath_or_buffer, str):\n self.book = self.load_workbook(self.ioargs.filepath_or_buffer)\n elif isinstance(self.ioargs.filepath_or_buffer, bytes):\n self.book = self.load_workbook(BytesIO(self.ioargs.filepath_or_buffer))\n else:\n raise ValueError(\n \"Must explicitly set engine if not passing in buffer or path for io.\"\n )\n\n @property\n @abc.abstractmethod\n def _workbook_class(self):\n pass\n\n @abc.abstractmethod\n def load_workbook(self, filepath_or_buffer):\n pass\n\n def close(self):\n self.ioargs.close()\n\n @property\n @abc.abstractmethod\n def sheet_names(self):\n pass\n\n @abc.abstractmethod\n def get_sheet_by_name(self, name):\n pass\n\n @abc.abstractmethod\n def get_sheet_by_index(self, index):\n pass\n\n @abc.abstractmethod\n def get_sheet_data(self, sheet, convert_float):\n pass\n\n def parse(\n self,\n sheet_name=0,\n header=0,\n names=None,\n index_col=None,\n usecols=None,\n squeeze=False,\n dtype=None,\n true_values=None,\n false_values=None,\n skiprows=None,\n nrows=None,\n na_values=None,\n verbose=False,\n parse_dates=False,\n date_parser=None,\n thousands=None,\n comment=None,\n skipfooter=0,\n convert_float=True,\n mangle_dupe_cols=True,\n **kwds,\n ):\n\n validate_header_arg(header)\n\n ret_dict = False\n\n # Keep sheetname to maintain backwards compatibility.\n if isinstance(sheet_name, list):\n sheets = sheet_name\n ret_dict = True\n elif sheet_name is None:\n sheets = self.sheet_names\n ret_dict = True\n else:\n sheets = [sheet_name]\n\n # handle same-type duplicates.\n sheets = list(dict.fromkeys(sheets).keys())\n\n output = {}\n\n for asheetname in sheets:\n if verbose:\n print(f\"Reading sheet {asheetname}\")\n\n if isinstance(asheetname, str):\n sheet = self.get_sheet_by_name(asheetname)\n else: # assume an integer if not a string\n sheet = self.get_sheet_by_index(asheetname)\n\n data = self.get_sheet_data(sheet, convert_float)\n usecols = maybe_convert_usecols(usecols)\n\n if not data:\n output[asheetname] = DataFrame()\n continue\n\n if is_list_like(header) and len(header) == 1:\n header = header[0]\n\n # forward fill and pull out names for MultiIndex column\n header_names = None\n if header is not None and is_list_like(header):\n header_names = []\n control_row = [True] * len(data[0])\n\n for row in header:\n if is_integer(skiprows):\n row += skiprows\n\n data[row], control_row = fill_mi_header(data[row], control_row)\n\n if index_col is not None:\n header_name, _ = pop_header_name(data[row], index_col)\n header_names.append(header_name)\n\n if is_list_like(index_col):\n # Forward fill values for MultiIndex index.\n if header is None:\n offset = 0\n elif not is_list_like(header):\n offset = 1 + header\n else:\n offset = 1 + max(header)\n\n # Check if we have an empty dataset\n # before trying to collect data.\n if offset < len(data):\n for col in index_col:\n last = data[offset][col]\n\n for row in range(offset + 1, len(data)):\n if data[row][col] == \"\" or data[row][col] is None:\n data[row][col] = last\n else:\n last = data[row][col]\n\n has_index_names = is_list_like(header) and len(header) > 1\n\n # GH 12292 : error when read one empty column from excel file\n try:\n parser = TextParser(\n data,\n names=names,\n header=header,\n index_col=index_col,\n has_index_names=has_index_names,\n squeeze=squeeze,\n dtype=dtype,\n true_values=true_values,\n false_values=false_values,\n skiprows=skiprows,\n nrows=nrows,\n na_values=na_values,\n parse_dates=parse_dates,\n date_parser=date_parser,\n thousands=thousands,\n comment=comment,\n skipfooter=skipfooter,\n usecols=usecols,\n mangle_dupe_cols=mangle_dupe_cols,\n **kwds,\n )\n\n output[asheetname] = parser.read(nrows=nrows)\n\n if not squeeze or isinstance(output[asheetname], DataFrame):\n if header_names:\n output[asheetname].columns = output[\n asheetname\n ].columns.set_names(header_names)\n\n except EmptyDataError:\n # No Data, return an empty DataFrame\n output[asheetname] = DataFrame()\n\n if ret_dict:\n return output\n else:\n return output[asheetname]\n\n\nclass ExcelWriter(metaclass=abc.ABCMeta):\n \"\"\"\n Class for writing DataFrame objects into excel sheets.\n\n Default is to use xlwt for xls, openpyxl for xlsx, odf for ods.\n See DataFrame.to_excel for typical usage.\n\n Parameters\n ----------\n path : str or typing.BinaryIO\n Path to xls or xlsx or ods file.\n engine : str (optional)\n Engine to use for writing. If None, defaults to\n ``io.excel.<extension>.writer``. NOTE: can only be passed as a keyword\n argument.\n date_format : str, default None\n Format string for dates written into Excel files (e.g. 'YYYY-MM-DD').\n datetime_format : str, default None\n Format string for datetime objects written into Excel files.\n (e.g. 'YYYY-MM-DD HH:MM:SS').\n mode : {'w', 'a'}, default 'w'\n File mode to use (write or append).\n\n .. versionadded:: 0.24.0\n\n Attributes\n ----------\n None\n\n Methods\n -------\n None\n\n Notes\n -----\n None of the methods and properties are considered public.\n\n For compatibility with CSV writers, ExcelWriter serializes lists\n and dicts to strings before writing.\n\n Examples\n --------\n Default usage:\n\n >>> with ExcelWriter('path_to_file.xlsx') as writer:\n ... df.to_excel(writer)\n\n To write to separate sheets in a single file:\n\n >>> with ExcelWriter('path_to_file.xlsx') as writer:\n ... df1.to_excel(writer, sheet_name='Sheet1')\n ... df2.to_excel(writer, sheet_name='Sheet2')\n\n You can set the date format or datetime format:\n\n >>> with ExcelWriter('path_to_file.xlsx',\n ... date_format='YYYY-MM-DD',\n ... datetime_format='YYYY-MM-DD HH:MM:SS') as writer:\n ... df.to_excel(writer)\n\n You can also append to an existing Excel file:\n\n >>> with ExcelWriter('path_to_file.xlsx', mode='a') as writer:\n ... df.to_excel(writer, sheet_name='Sheet3')\n\n You can store Excel file in RAM:\n\n >>> import io\n >>> buffer = io.BytesIO()\n >>> with pd.ExcelWriter(buffer) as writer:\n ... df.to_excel(writer)\n\n You can pack Excel file into zip archive:\n\n >>> import zipfile\n >>> with zipfile.ZipFile('path_to_file.zip', 'w') as zf:\n ... with zf.open('filename.xlsx', 'w') as buffer:\n ... with pd.ExcelWriter(buffer) as writer:\n ... df.to_excel(writer)\n \"\"\"\n\n # Defining an ExcelWriter implementation (see abstract methods for more...)\n\n # - Mandatory\n # - ``write_cells(self, cells, sheet_name=None, startrow=0, startcol=0)``\n # --> called to write additional DataFrames to disk\n # - ``supported_extensions`` (tuple of supported extensions), used to\n # check that engine supports the given extension.\n # - ``engine`` - string that gives the engine name. Necessary to\n # instantiate class directly and bypass ``ExcelWriterMeta`` engine\n # lookup.\n # - ``save(self)`` --> called to save file to disk\n # - Mostly mandatory (i.e. should at least exist)\n # - book, cur_sheet, path\n\n # - Optional:\n # - ``__init__(self, path, engine=None, **kwargs)`` --> always called\n # with path as first argument.\n\n # You also need to register the class with ``register_writer()``.\n # Technically, ExcelWriter implementations don't need to subclass\n # ExcelWriter.\n def __new__(cls, path, engine=None, **kwargs):\n # only switch class if generic(ExcelWriter)\n\n if cls is ExcelWriter:\n if engine is None or (isinstance(engine, str) and engine == \"auto\"):\n if isinstance(path, str):\n ext = os.path.splitext(path)[-1][1:]\n else:\n ext = \"xlsx\"\n\n try:\n engine = config.get_option(f\"io.excel.{ext}.writer\")\n if engine == \"auto\":\n engine = get_default_writer(ext)\n except KeyError as err:\n raise ValueError(f\"No engine for filetype: '{ext}'\") from err\n cls = get_writer(engine)\n\n return object.__new__(cls)\n\n # declare external properties you can count on\n curr_sheet = None\n path = None\n\n @property\n @abc.abstractmethod\n def supported_extensions(self):\n \"\"\"Extensions that writer engine supports.\"\"\"\n pass\n\n @property\n @abc.abstractmethod\n def engine(self):\n \"\"\"Name of engine.\"\"\"\n pass\n\n @abc.abstractmethod\n def write_cells(\n self, cells, sheet_name=None, startrow=0, startcol=0, freeze_panes=None\n ):\n \"\"\"\n Write given formatted cells into Excel an excel sheet\n\n Parameters\n ----------\n cells : generator\n cell of formatted data to save to Excel sheet\n sheet_name : str, default None\n Name of Excel sheet, if None, then use self.cur_sheet\n startrow : upper left cell row to dump data frame\n startcol : upper left cell column to dump data frame\n freeze_panes: int tuple of length 2\n contains the bottom-most row and right-most column to freeze\n \"\"\"\n pass\n\n @abc.abstractmethod\n def save(self):\n \"\"\"\n Save workbook to disk.\n \"\"\"\n pass\n\n def __init__(\n self,\n path,\n engine=None,\n date_format=None,\n datetime_format=None,\n mode=\"w\",\n **engine_kwargs,\n ):\n # validate that this engine can handle the extension\n if isinstance(path, str):\n ext = os.path.splitext(path)[-1]\n self.check_extension(ext)\n\n self.path = path\n self.sheets = {}\n self.cur_sheet = None\n\n if date_format is None:\n self.date_format = \"YYYY-MM-DD\"\n else:\n self.date_format = date_format\n if datetime_format is None:\n self.datetime_format = \"YYYY-MM-DD HH:MM:SS\"\n else:\n self.datetime_format = datetime_format\n\n self.mode = mode\n\n def __fspath__(self):\n return stringify_path(self.path)\n\n def _get_sheet_name(self, sheet_name):\n if sheet_name is None:\n sheet_name = self.cur_sheet\n if sheet_name is None: # pragma: no cover\n raise ValueError(\"Must pass explicit sheet_name or set cur_sheet property\")\n return sheet_name\n\n def _value_with_fmt(self, val):\n \"\"\"\n Convert numpy types to Python types for the Excel writers.\n\n Parameters\n ----------\n val : object\n Value to be written into cells\n\n Returns\n -------\n Tuple with the first element being the converted value and the second\n being an optional format\n \"\"\"\n fmt = None\n\n if is_integer(val):\n val = int(val)\n elif is_float(val):\n val = float(val)\n elif is_bool(val):\n val = bool(val)\n elif isinstance(val, datetime.datetime):\n fmt = self.datetime_format\n elif isinstance(val, datetime.date):\n fmt = self.date_format\n elif isinstance(val, datetime.timedelta):\n val = val.total_seconds() / float(86400)\n fmt = \"0\"\n else:\n val = str(val)\n\n return val, fmt\n\n @classmethod\n def check_extension(cls, ext: str):\n \"\"\"\n checks that path's extension against the Writer's supported\n extensions. If it isn't supported, raises UnsupportedFiletypeError.\n \"\"\"\n if ext.startswith(\".\"):\n ext = ext[1:]\n # error: \"Callable[[ExcelWriter], Any]\" has no attribute \"__iter__\"\n # (not iterable) [attr-defined]\n if not any(\n ext in extension\n for extension in cls.supported_extensions # type: ignore[attr-defined]\n ):\n raise ValueError(f\"Invalid extension for engine '{cls.engine}': '{ext}'\")\n else:\n return True\n\n # Allow use as a contextmanager\n def __enter__(self):\n return self\n\n def __exit__(self, exc_type, exc_value, traceback):\n self.close()\n\n def close(self):\n \"\"\"synonym for save, to make it more file-like\"\"\"\n return self.save()\n\n\ndef _is_ods_stream(stream: Union[BufferedIOBase, RawIOBase]) -> bool:\n \"\"\"\n Check if the stream is an OpenDocument Spreadsheet (.ods) file\n\n It uses magic values inside the stream\n\n Parameters\n ----------\n stream : Union[BufferedIOBase, RawIOBase]\n IO stream with data which might be an ODS file\n\n Returns\n -------\n is_ods : bool\n Boolean indication that this is indeed an ODS file or not\n \"\"\"\n stream.seek(0)\n is_ods = False\n if stream.read(4) == b\"PK\\003\\004\":\n stream.seek(30)\n is_ods = (\n stream.read(54) == b\"mimetype\"\n b\"application/vnd.oasis.opendocument.spreadsheet\"\n )\n stream.seek(0)\n return is_ods\n\n\nclass ExcelFile:\n \"\"\"\n Class for parsing tabular excel sheets into DataFrame objects.\n\n Uses xlrd engine by default. See read_excel for more documentation\n\n Parameters\n ----------\n path_or_buffer : str, path object (pathlib.Path or py._path.local.LocalPath),\n a file-like object, xlrd workbook or openpypl workbook.\n If a string or path object, expected to be a path to a\n .xls, .xlsx, .xlsb, .xlsm, .odf, .ods, or .odt file.\n engine : str, default None\n If io is not a buffer or path, this must be set to identify io.\n Supported engines: ``xlrd``, ``openpyxl``, ``odf``, ``pyxlsb``,\n default ``xlrd``.\n Engine compatibility :\n - ``xlrd`` supports most old/new Excel file formats.\n - ``openpyxl`` supports newer Excel file formats.\n - ``odf`` supports OpenDocument file formats (.odf, .ods, .odt).\n - ``pyxlsb`` supports Binary Excel files.\n \"\"\"\n\n from pandas.io.excel._odfreader import ODFReader\n from pandas.io.excel._openpyxl import OpenpyxlReader\n from pandas.io.excel._pyxlsb import PyxlsbReader\n from pandas.io.excel._xlrd import XlrdReader\n\n _engines: Mapping[str, Any] = {\n \"xlrd\": XlrdReader,\n \"openpyxl\": OpenpyxlReader,\n \"odf\": ODFReader,\n \"pyxlsb\": PyxlsbReader,\n }\n\n def __init__(\n self, path_or_buffer, engine=None, storage_options: StorageOptions = None\n ):\n if engine is None:\n engine = \"xlrd\"\n if isinstance(path_or_buffer, (BufferedIOBase, RawIOBase)):\n if _is_ods_stream(path_or_buffer):\n engine = \"odf\"\n else:\n ext = os.path.splitext(str(path_or_buffer))[-1]\n if ext == \".ods\":\n engine = \"odf\"\n if engine not in self._engines:\n raise ValueError(f\"Unknown engine: {engine}\")\n\n self.engine = engine\n self.storage_options = storage_options\n\n # Could be a str, ExcelFile, Book, etc.\n self.io = path_or_buffer\n # Always a string\n self._io = stringify_path(path_or_buffer)\n\n self._reader = self._engines[engine](self._io, storage_options=storage_options)\n\n def __fspath__(self):\n return self._io\n\n def parse(\n self,\n sheet_name=0,\n header=0,\n names=None,\n index_col=None,\n usecols=None,\n squeeze=False,\n converters=None,\n true_values=None,\n false_values=None,\n skiprows=None,\n nrows=None,\n na_values=None,\n parse_dates=False,\n date_parser=None,\n thousands=None,\n comment=None,\n skipfooter=0,\n convert_float=True,\n mangle_dupe_cols=True,\n **kwds,\n ):\n \"\"\"\n Parse specified sheet(s) into a DataFrame.\n\n Equivalent to read_excel(ExcelFile, ...) See the read_excel\n docstring for more info on accepted parameters.\n\n Returns\n -------\n DataFrame or dict of DataFrames\n DataFrame from the passed in Excel file.\n \"\"\"\n return self._reader.parse(\n sheet_name=sheet_name,\n header=header,\n names=names,\n index_col=index_col,\n usecols=usecols,\n squeeze=squeeze,\n converters=converters,\n true_values=true_values,\n false_values=false_values,\n skiprows=skiprows,\n nrows=nrows,\n na_values=na_values,\n parse_dates=parse_dates,\n date_parser=date_parser,\n thousands=thousands,\n comment=comment,\n skipfooter=skipfooter,\n convert_float=convert_float,\n mangle_dupe_cols=mangle_dupe_cols,\n **kwds,\n )\n\n @property\n def book(self):\n return self._reader.book\n\n @property\n def sheet_names(self):\n return self._reader.sheet_names\n\n def close(self):\n \"\"\"close io if necessary\"\"\"\n self._reader.close()\n\n def __enter__(self):\n return self\n\n def __exit__(self, exc_type, exc_value, traceback):\n self.close()\n\n def __del__(self):\n # Ensure we don't leak file descriptors, but put in try/except in case\n # attributes are already deleted\n try:\n self.close()\n except AttributeError:\n pass\n"
] | [
[
"pandas.io.excel._util.get_writer",
"pandas.io.common.IOArgs",
"pandas.io.parsers.TextParser",
"pandas.io.common.urlopen",
"pandas.io.common.validate_header_arg",
"pandas.io.excel._util.maybe_convert_usecols",
"pandas.util._decorators.deprecate_nonkeyword_arguments",
"pandas.core.dtypes.common.is_bool",
"pandas.io.common.is_url",
"pandas.io.common.stringify_path",
"pandas.util._decorators.Appender",
"pandas.io.common.get_filepath_or_buffer",
"pandas.core.dtypes.common.is_integer",
"pandas.core.frame.DataFrame",
"pandas.io.excel._util.pop_header_name",
"pandas.core.dtypes.common.is_list_like",
"pandas.io.excel._util.fill_mi_header",
"pandas._config.config.get_option",
"pandas.io.excel._util.get_default_writer",
"pandas.core.dtypes.common.is_float"
]
] |
intheon/stream_viewer | [
"386b9e27d5cd7e66eece0dc2e4977e917ef94877"
] | [
"stream_viewer/applications/minimal_markers.py"
] | [
"# Copyright (C) 2014-2021 Syntrogi Inc dba Intheon. All rights reserved.\n\n\"\"\"\nThis script is a minimal example of a basic marker presentation application.\nIt's so minimal that it doesn't even use any stream_viewer modules!\nThis example displays markers in a text window.\nThe markers can come from a provided generator (call with --generate), or from a LSL stream of type 'Markers'.\nPlease see stream_viewer.applications.minimal_signals for a simple application for time series data.\n\"\"\"\nimport sys\nimport random\nimport string\nimport time\nimport argparse\nfrom qtpy import QtWidgets, QtCore, QtGui\nimport numpy as np\nimport pylsl\n\n\nclass MarkerGenerator(QtCore.QObject):\n \"\"\"\n Like all stream_viewer data sources, this has a `data_updated` signal and a `update_requested` slot.\n This example generates a pair of sinusoids and isn't very useful.\n \"\"\"\n data_updated = QtCore.Signal(np.ndarray, np.ndarray)\n letters = string.ascii_lowercase\n\n def __init__(self, marker_rate=1.0, marker_prob=0.6):\n super().__init__() # QObject init required for signals to work\n self._marker_rate = marker_rate\n self._marker_prob = marker_prob\n self._max_marker_length = 12\n self._data_timer = QtCore.QTimer()\n self._data_timer.setInterval(int(1000/self._marker_rate)) # msec\n self._data_timer.timeout.connect(self.update_requested)\n self._last_timestamp = pylsl.local_clock()\n self._data_timer.start()\n\n @QtCore.Slot()\n def update_requested(self):\n t_elapsed = pylsl.local_clock() - self._last_timestamp\n n_samples = int(t_elapsed * self._marker_rate)\n if n_samples > 0:\n words = []\n ts_out = []\n for samp_ix in range(n_samples):\n if np.random.rand(1) <= self._marker_prob:\n n_letters = random.randint(1, self._max_marker_length)\n words.append(''.join(random.choice(self.letters) for _ in range(n_letters)))\n ts_out.append(pylsl.local_clock())\n data = np.array(words)[None, :] # Reshape to channels x samples (only 1 channel)\n self.data_updated.emit(data, np.array(ts_out))\n self._last_timestamp = ts_out[-1] if len(ts_out) > 0 else pylsl.local_clock()\n\n\nclass MarkerRenderer(QtCore.QObject):\n \"\"\"\n Like any good data renderer (or widget that wraps a renderer),\n this class has a handle_data_updated slot and native_widget attribute.\n \"\"\"\n def __init__(self):\n super().__init__()\n self._widget = QtWidgets.QTextEdit()\n\n @QtCore.Slot(np.ndarray, np.ndarray)\n def handle_data_updated(self, data, timestamps):\n if timestamps.size > 0:\n new_text = \"\\n\".join(\n [f\"{timestamps[samp_ix]:.3f} : \" + \";\".join(data[:, samp_ix]) for samp_ix in range(data.shape[1])])\n self._widget.moveCursor(QtGui.QTextCursor.End)\n self._widget.insertPlainText(new_text + \"\\n\")\n\n @property\n def native_widget(self):\n return self._widget\n\n\nclass MinMrkWindow(QtWidgets.QMainWindow):\n\n def __init__(self, use_generator=False):\n super().__init__()\n self.setWindowTitle(\"stream-viewer example\")\n self._renderer = MarkerRenderer()\n if use_generator:\n self._source = MarkerGenerator()\n else:\n from stream_viewer.data import LSLDataSource\n self._source = LSLDataSource({'type': 'Markers'}, auto_start=True, timer_interval=100)\n self.setCentralWidget(self._renderer.native_widget)\n self._source.data_updated.connect(self._renderer.handle_data_updated)\n\n\ndef main(use_generator=False):\n app = QtWidgets.QApplication(sys.argv)\n window = MinMrkWindow(use_generator=use_generator)\n window.show()\n\n sys.exit(app.exec_())\n\n\nif __name__ == '__main__':\n parser = argparse.ArgumentParser(prog=\"minimal_markers\",\n description=\"Example StreamViewer application to print markers.\")\n parser.add_argument('--generate', action='store_true')\n args = parser.parse_args()\n main(use_generator=args.generate)\n"
] | [
[
"numpy.array",
"numpy.random.rand"
]
] |
Minsoo2022/DeepHuman | [
"46ca0916d4531cf111c3a0d334d73d59773f0474"
] | [
"TrainingDataPreparation/ObjIO.py"
] | [
"from __future__ import print_function, absolute_import, division\nimport numpy as np\n\n\ndef load_obj_data(filename):\n \"\"\"load model data from .obj file\"\"\"\n v_list = [] # vertex coordinate\n vt_list = [] # vertex texture coordinate\n vc_list = [] # vertex color\n vn_list = [] # vertex normal\n f_list = [] # face vertex indices\n fn_list = [] # face normal indices\n ft_list = [] # face texture indices\n\n # read data\n fp = open(filename, 'r')\n lines = fp.readlines()\n fp.close()\n\n for line in lines:\n if len(line) < 2:\n continue\n line_data = line.strip().split(' ')\n\n # parse vertex cocordinate\n if line_data[0] == 'v':\n v_list.append((float(line_data[1]), float(line_data[2]), float(line_data[3])))\n if len(line_data) == 7:\n vc_list.append((float(line_data[4]), float(line_data[5]), float(line_data[6])))\n else:\n vc_list.append((0.5, 0.5, 0.5))\n\n # parse vertex texture coordinate\n if line_data[0] == 'vt':\n vt_list.append((float(line_data[1]), float(line_data[2])))\n\n # parse vertex normal\n if line_data[0] == 'vn':\n vn_list.append((float(line_data[1]), float(line_data[2]), float(line_data[3])))\n\n # parse face\n if line_data[0] == 'f':\n # used for parsing face element data\n def segElementData(ele_str):\n fv = None\n ft = None\n fn = None\n eles = ele_str.strip().split('/')\n if len(eles) == 1:\n fv = int(eles[0]) - 1\n elif len(eles) == 2:\n fv = int(eles[0]) - 1\n ft = int(eles[1]) - 1\n elif len(eles) == 3:\n fv = int(eles[0]) - 1\n fn = int(eles[2]) - 1\n ft = None if eles[1] == '' else int(eles[1]) - 1\n return fv, ft, fn\n\n fv0, ft0, fn0 = segElementData(line_data[1])\n fv1, ft1, fn1 = segElementData(line_data[2])\n fv2, ft2, fn2 = segElementData(line_data[3])\n f_list.append((fv0, fv1, fv2))\n if ft0 is not None and ft1 is not None and ft2 is not None:\n ft_list.append((ft0, ft1, ft2))\n if fn0 is not None and fn1 is not None and fn2 is not None:\n fn_list.append((fn0, fn1, fn2))\n\n v_list = np.asarray(v_list)\n vn_list = np.asarray(vn_list)\n vt_list = np.asarray(vt_list)\n vc_list = np.asarray(vc_list)\n f_list = np.asarray(f_list)\n ft_list = np.asarray(ft_list)\n fn_list = np.asarray(fn_list)\n\n model = {'v': v_list, 'vt': vt_list, 'vc': vc_list, 'vn': vn_list,\n 'f': f_list, 'ft': ft_list, 'fn': fn_list}\n return model\n\n\ndef load_obj_data_binary(filename):\n \"\"\"load model data from .obj file\"\"\"\n v_list = [] # vertex coordinate\n vt_list = [] # vertex texture coordinate\n vc_list = [] # vertex color\n vn_list = [] # vertex normal\n f_list = [] # face vertex indices\n fn_list = [] # face normal indices\n ft_list = [] # face texture indices\n\n # read data\n fp = open(filename, 'rb')\n lines = fp.readlines()\n fp.close()\n\n for line in lines:\n line_data = line.strip().split(' ')\n\n # parse vertex cocordinate\n if line_data[0] == 'v':\n v_list.append((float(line_data[1]), float(line_data[2]), float(line_data[3])))\n if len(line_data) == 7:\n vc_list.append((float(line_data[4]), float(line_data[5]), float(line_data[6])))\n else:\n vc_list.append((0.5, 0.5, 0.5))\n\n # parse vertex texture coordinate\n if line_data[0] == 'vt':\n vt_list.append((float(line_data[1]), float(line_data[2])))\n\n # parse vertex normal\n if line_data[0] == 'vn':\n vn_list.append((float(line_data[1]), float(line_data[2]), float(line_data[3])))\n\n # parse face\n if line_data[0] == 'f':\n # used for parsing face element data\n def segElementData(ele_str):\n fv = None\n ft = None\n fn = None\n eles = ele_str.strip().split('/')\n if len(eles) == 1:\n fv = int(eles[0]) - 1\n elif len(eles) == 2:\n fv = int(eles[0]) - 1\n ft = int(eles[1]) - 1\n elif len(eles) == 3:\n fv = int(eles[0]) - 1\n fn = int(eles[2]) - 1\n ft = None if eles[1] == '' else int(eles[1]) - 1\n return fv, ft, fn\n\n fv0, ft0, fn0 = segElementData(line_data[1])\n fv1, ft1, fn1 = segElementData(line_data[2])\n fv2, ft2, fn2 = segElementData(line_data[3])\n f_list.append((fv0, fv1, fv2))\n if ft0 is not None and ft1 is not None and ft2 is not None:\n ft_list.append((ft0, ft1, ft2))\n if fn0 is not None and fn1 is not None and fn2 is not None:\n fn_list.append((fn0, fn1, fn2))\n\n v_list = np.asarray(v_list)\n vn_list = np.asarray(vn_list)\n vt_list = np.asarray(vt_list)\n vc_list = np.asarray(vc_list)\n f_list = np.asarray(f_list)\n ft_list = np.asarray(ft_list)\n fn_list = np.asarray(fn_list)\n\n model = {'v': v_list, 'vt': vt_list, 'vc': vc_list, 'vn': vn_list,\n 'f': f_list, 'ft': ft_list, 'fn': fn_list}\n return model\n\n\ndef save_obj_data(model, filename):\n assert 'v' in model and model['v'].size != 0\n\n with open(filename, 'w') as fp:\n if 'v' in model and model['v'].size != 0:\n for v in model['v']:\n fp.write('v %f %f %f\\n' % (v[0], v[1], v[2]))\n\n if 'vn' in model and model['vn'].size != 0:\n for vn in model['vn']:\n fp.write('vn %f %f %f\\n' % (vn[0], vn[1], vn[2]))\n\n if 'vt' in model and model['vt'].size != 0:\n for vt in model['vt']:\n fp.write('vt %f %f\\n' % (vt[0], vt[1]))\n\n if 'f' in model and model['f'].size != 0:\n if 'fn' in model and model['fn'].size != 0 and 'ft' in model and model['ft'].size != 0:\n assert model['f'].size == model['fn'].size\n assert model['f'].size == model['ft'].size\n for f_, ft_, fn_ in zip(model['f'], model['ft'], model['fn']):\n f = np.copy(f_) + 1\n ft = np.copy(ft_) + 1\n fn = np.copy(fn_) + 1\n fp.write('f %d/%d/%d %d/%d/%d %d/%d/%d\\n' %\n (f[0], ft[0], fn[0], f[1], ft[1], fn[1], f[2], ft[2], fn[2]))\n elif 'fn' in model and model['fn'].size != 0:\n assert model['f'].size == model['fn'].size\n for f_, fn_ in zip(model['f'], model['fn']):\n f = np.copy(f_) + 1\n fn = np.copy(fn_) + 1\n fp.write('f %d//%d %d//%d %d//%d\\n' % (f[0], fn[0], f[1], fn[1], f[2], fn[2]))\n elif 'ft' in model and model['ft'].size != 0:\n assert model['f'].size == model['ft'].size\n for f_, ft_ in zip(model['f'], model['ft']):\n f = np.copy(f_) + 1\n ft = np.copy(ft_) + 1\n fp.write('f %d/%d %d/%d %d/%d\\n' % (f[0], ft[0], f[1], ft[1], f[2], ft[2]))\n else:\n for f_ in model['f']:\n f = np.copy(f_) + 1\n fp.write('f %d %d %d\\n' % (f[0], f[1], f[2]))\n\n\ndef save_obj_data_binary(model, filename):\n assert 'v' in model and model['v'].size != 0\n\n with open(filename, 'wb') as fp:\n if 'v' in model and model['v'].size != 0:\n for v in model['v']:\n fp.write('v %f %f %f\\n' % (v[0], v[1], v[2]))\n\n if 'vn' in model and model['vn'].size != 0:\n for vn in model['vn']:\n fp.write('vn %f %f %f\\n' % (vn[0], vn[1], vn[2]))\n\n if 'vt' in model and model['vt'].size != 0:\n for vt in model['vt']:\n fp.write('vt %f %f\\n' % (vt[0], vt[1]))\n\n if 'f' in model and model['f'].size != 0:\n if 'fn' in model and model['fn'].size != 0 and 'ft' in model and model['ft'].size != 0:\n assert model['f'].size == model['fn'].size\n assert model['f'].size == model['ft'].size\n for f_, ft_, fn_ in zip(model['f'], model['ft'], model['fn']):\n f = np.copy(f_) + 1\n ft = np.copy(ft_) + 1\n fn = np.copy(fn_) + 1\n fp.write('f %d/%d/%d %d/%d/%d %d/%d/%d\\n' %\n (f[0], ft[0], fn[0], f[1], ft[1], fn[1], f[2], ft[2], fn[2]))\n elif 'fn' in model and model['fn'].size != 0:\n assert model['f'].size == model['fn'].size\n for f_, fn_ in zip(model['f'], model['fn']):\n f = np.copy(f_) + 1\n fn = np.copy(fn_) + 1\n fp.write('f %d//%d %d//%d %d//%d\\n' % (f[0], fn[0], f[1], fn[1], f[2], fn[2]))\n elif 'ft' in model and model['ft'].size != 0:\n assert model['f'].size == model['ft'].size\n for f_, ft_ in zip(model['f'], model['ft']):\n f = np.copy(f_) + 1\n ft = np.copy(ft_) + 1\n fp.write('f %d/%d %d/%d %d/%d\\n' % (f[0], ft[0], f[1], ft[1], f[2], ft[2]))\n else:\n for f_ in model['f']:\n f = np.copy(f_) + 1\n fp.write('f %d %d %d\\n' % (f[0], f[1], f[2]))\n\n\ndef save_obj_data_binary_with_corner(model, min_corner, max_corner, corner_size, filename):\n \"\"\"\n Save Obj data with the corner of the bounding box\n This small feature will be useful when you use some 3d software to voxelize the mesh,\n because it can help you avoid complex alignments.\n \"\"\"\n assert 'v' in model and model['v'].size != 0\n with open(filename, 'wb') as fp:\n if 'v' in model and model['v'].size != 0:\n for v in model['v']:\n fp.write('v %f %f %f\\n' % (v[0], v[1], v[2]))\n\n # add corner\n fp.write('v %f %f %f\\n' % (min_corner[0] + corner_size, min_corner[1], min_corner[2]))\n fp.write('v %f %f %f\\n' % (min_corner[0], min_corner[1] + corner_size, min_corner[2]))\n fp.write('v %f %f %f\\n' % (min_corner[0], min_corner[1], min_corner[2] + corner_size))\n fp.write('v %f %f %f\\n' % (min_corner[0], min_corner[1], min_corner[2]))\n\n fp.write('v %f %f %f\\n' % (max_corner[0] - corner_size, max_corner[1], max_corner[2]))\n fp.write('v %f %f %f\\n' % (max_corner[0], max_corner[1] - corner_size, max_corner[2]))\n fp.write('v %f %f %f\\n' % (max_corner[0], max_corner[1], max_corner[2] - corner_size))\n fp.write('v %f %f %f\\n' % (max_corner[0], max_corner[1], max_corner[2]))\n\n if 'vn' in model and model['vn'].size != 0:\n for vn in model['vn']:\n fp.write('vn %f %f %f\\n' % (vn[0], vn[1], vn[2]))\n\n if 'vt' in model and model['vt'].size != 0:\n for vt in model['vt']:\n fp.write('vt %f %f\\n' % (vt[0], vt[1]))\n\n if 'f' in model and model['f'].size != 0:\n if 'fn' in model and model['fn'].size != 0 and 'ft' in model and model['ft'].size != 0:\n assert model['f'].size == model['fn'].size\n assert model['f'].size == model['ft'].size\n for f_, ft_, fn_ in zip(model['f'], model['ft'], model['fn']):\n f = np.copy(f_) + 1\n ft = np.copy(ft_) + 1\n fn = np.copy(fn_) + 1\n fp.write('f %d/%d/%d %d/%d/%d %d/%d/%d\\n' %\n (f[0], ft[0], fn[0], f[1], ft[1], fn[1], f[2], ft[2], fn[2]))\n elif 'fn' in model and model['fn'].size != 0:\n assert model['f'].size == model['fn'].size\n for f_, fn_ in zip(model['f'], model['fn']):\n f = np.copy(f_) + 1\n fn = np.copy(fn_) + 1\n fp.write('f %d//%d %d//%d %d//%d\\n' % (f[0], fn[0], f[1], fn[1], f[2], fn[2]))\n elif 'ft' in model and model['ft'].size != 0:\n assert model['f'].size == model['ft'].size\n for f_, ft_ in zip(model['f'], model['ft']):\n f = np.copy(f_) + 1\n ft = np.copy(ft_) + 1\n fp.write('f %d/%d %d/%d %d/%d\\n' % (f[0], ft[0], f[1], ft[1], f[2], ft[2]))\n else:\n for f_ in model['f']:\n f = np.copy(f_) + 1\n fp.write('f %d %d %d\\n' % (f[0], f[1], f[2]))\n\n # add corner\n vid_start = model['v'].size/ 3\n fp.write('f %d %d %d\\n' % (vid_start+1, vid_start+2, vid_start+3))\n fp.write('f %d %d %d\\n' % (vid_start+1, vid_start+4, vid_start+2))\n fp.write('f %d %d %d\\n' % (vid_start+1, vid_start+3, vid_start+4))\n fp.write('f %d %d %d\\n' % (vid_start+2, vid_start+4, vid_start+3))\n\n vid_start += 4\n fp.write('f %d %d %d\\n' % (vid_start+1, vid_start+2, vid_start+3))\n fp.write('f %d %d %d\\n' % (vid_start+1, vid_start+4, vid_start+2))\n fp.write('f %d %d %d\\n' % (vid_start+1, vid_start+3, vid_start+4))\n fp.write('f %d %d %d\\n' % (vid_start+2, vid_start+4, vid_start+3))\n"
] | [
[
"numpy.copy",
"numpy.asarray"
]
] |
MishaRubanov/SchulmanLab | [
"edb9249e5cee75211a2b8da2e0d57ae5287f9131"
] | [
"GeneletModel-Python/supp_figure36_IFFL1_2_leak.py"
] | [
"import numpy as np \r\nimport matplotlib.pyplot as plt\r\nimport GeneralGeneletModel as GGM\r\n\r\n''' \r\n###############################################################################\r\nSupplementary Figure 36\r\nThis simulates an extended IFFL where an upstream genelet produces the coactivator\r\nof the first two nodes of the IFFL with and without 5% leak\r\nThis simulates the network both with and without 150 nM dB2,dB3,dB4 which suppress the leak\r\n###############################################################################\r\n'''\r\n\r\n# G1 G2 G3 G4 G5 \r\nact_vec = [1, 2, 2, 3, 4]\r\nblk_vec = [0, 2, 2, 3, 4]\r\nprod_vec = [2, 3, 4,-4, 0]\r\nindc_vec = [0, 0, 0, 0, 0]\r\n\r\nlf = 0.05 # leak fraction\r\n\r\n''' initializing topology '''\r\neIFFL = GGM.GeneletNetwork(act_vec,prod_vec,indc_vec,blk_vec)\r\neIFFL.plot_topology(layout='circular')\r\neIFFL.plot_topology(layout='circular',show_rnas=0)\r\n\r\n# Define initial conditions\r\ndA_tot = [0]*2\r\n# dA1 dA2 dA3 dA4\r\ndA_tot[0] = np.array([250, 250, 250, 250]) # total activator added\r\ndA_tot[1] = np.array([ 0, 250, 250, 250]) # total activator added\r\n# G1 G2 G3 G4 G5\r\nG_tot = np.array([25, 5, 25, 25, 25]) # total genelet added\r\n\r\n# initial genelet states (0 = OFF, 1 = ON, -1 = BLK)\r\n# G1 G2 G3 G4 G5\r\nG_int_vec = [0, -1,-1,-1,-1]\r\n\r\nG2 = [0]*2\r\nG4 = [0]*2\r\nG5 = [0]*2\r\nls = ['-',':']\r\n'''\r\n0 nM ADDED BLOCKERS\r\n'''\r\nplt.figure()\r\nfor i in range(len(dA_tot)):\r\n \r\n ''' initializing initial conditions '''\r\n eIFFL.initial_conditions(dA_tot[i],G_tot,G_int_vec) # default of 0 for all other initial conditions\r\n \r\n t_vec1 = np.linspace(0,3,1001)*3600 # seconds\r\n \r\n ''' simulating the IFFL'''\r\n eIFFL.simulate(t_vec1,1,leak=lf)\r\n \r\n # pulling out the desired concentrations for plotting\r\n \r\n G2[i] = eIFFL.output_concentration['GdA2']\r\n G4[i] = eIFFL.output_concentration['GdA4']\r\n G5[i] = eIFFL.output_concentration['GdA5']\r\n \r\n sim_t = eIFFL.sol.t\r\n \r\n fs = 13\r\n \r\n plt.suptitle('Extended IFFL with leak',fontsize=fs+2,weight='bold')\r\n plt.subplot(3,4,2)\r\n plt.title('No addded blockers')\r\n plt.plot(sim_t/3600,G2[i]/G_tot[1],color=[0,0.4,0],linewidth=4,linestyle=ls[i])\r\n plt.ylabel('Fraction ON',fontsize=fs,weight='bold')\r\n plt.xticks(fontsize=fs,weight='bold')\r\n plt.yticks(fontsize=fs,weight='bold')\r\n ax1 = plt.gca()\r\n ax1.set_xlim(0,3)\r\n ax1.set_ylim(-0.1,1.1)\r\n ax1.xaxis.set_tick_params(which='both', size=5, width=2, direction='in', top='on')\r\n ax1.yaxis.set_tick_params(which='both', size=5, width=2, direction='in', right='on')\r\n \r\n plt.subplot(3,4,6)\r\n plt.plot(sim_t/3600,G4[i]/G_tot[3],color=[0.6,0,0],linewidth=4,linestyle=ls[i])\r\n plt.ylabel('Fraction ON',fontsize=fs,weight='bold')\r\n plt.xticks(fontsize=fs,weight='bold')\r\n plt.yticks(fontsize=fs,weight='bold')\r\n ax1 = plt.gca()\r\n ax1.set_xlim(0,3)\r\n ax1.set_ylim(-0.1,1.1)\r\n ax1.xaxis.set_tick_params(which='both', size=5, width=2, direction='in', top='on')\r\n ax1.yaxis.set_tick_params(which='both', size=5, width=2, direction='in', right='on')\r\n \r\n plt.subplot(3,4,10)\r\n plt.plot(sim_t/3600,G5[i]/G_tot[4],color=[0.4,0,0.4],linewidth=4,linestyle=ls[i])\r\n plt.ylabel('Fraction ON',fontsize=fs,weight='bold')\r\n plt.xlabel('time (hr)',fontsize=fs,weight='bold')\r\n plt.xticks(fontsize=fs,weight='bold')\r\n plt.yticks(fontsize=fs,weight='bold')\r\n ax1 = plt.gca()\r\n ax1.set_xlim(0,3)\r\n ax1.set_ylim(-0.1,1.1)\r\n ax1.xaxis.set_tick_params(which='both', size=5, width=2, direction='in', top='on')\r\n ax1.yaxis.set_tick_params(which='both', size=5, width=2, direction='in', right='on')\r\n \r\n \r\nG2 = [0]*2\r\nG4 = [0]*2\r\nG5 = [0]*2\r\n'''\r\n150 nM ADDED BLOCKERS\r\n'''\r\nfor i in range(len(dA_tot)):\r\n ''' initializing initial conditions '''\r\n eIFFL.initial_conditions(dA_tot[i],G_tot,G_int_vec,dB_added=[0,150,150,150]) # default of 0 for all other initial conditions\r\n \r\n t_vec1 = np.linspace(0,3,1001)*3600 # seconds\r\n \r\n ''' simulating the IFFL'''\r\n eIFFL.simulate(t_vec1,1,leak=lf)\r\n \r\n # pulling out the desired concentrations for plotting\r\n G2[i] = eIFFL.output_concentration['GdA2']\r\n G4[i] = eIFFL.output_concentration['GdA4']\r\n G5[i] = eIFFL.output_concentration['GdA5']\r\n \r\n sim_t = eIFFL.sol.t\r\n \r\n fs = 13\r\n plt.suptitle('Extended IFFL with leak',fontsize=fs+2,weight='bold')\r\n plt.subplot(3,4,4)\r\n plt.title('150 nM blockers')\r\n plt.plot(sim_t/3600,G2[i]/G_tot[1],color=[0,0.4,0],linewidth=4,linestyle=ls[i])\r\n plt.ylabel('Fraction ON',fontsize=fs,weight='bold')\r\n plt.xticks(fontsize=fs,weight='bold')\r\n plt.yticks(fontsize=fs,weight='bold')\r\n ax1 = plt.gca()\r\n ax1.set_xlim(0,3)\r\n ax1.set_ylim(-0.1,1.1)\r\n ax1.xaxis.set_tick_params(which='both', size=5, width=2, direction='in', top='on')\r\n ax1.yaxis.set_tick_params(which='both', size=5, width=2, direction='in', right='on')\r\n \r\n plt.subplot(3,4,8)\r\n plt.plot(sim_t/3600,G4[i]/G_tot[3],color=[0.6,0,0],linewidth=4,linestyle=ls[i])\r\n plt.ylabel('Fraction ON',fontsize=fs,weight='bold')\r\n plt.xticks(fontsize=fs,weight='bold')\r\n plt.yticks(fontsize=fs,weight='bold')\r\n ax1 = plt.gca()\r\n ax1.set_xlim(0,3)\r\n ax1.set_ylim(-0.1,1.1)\r\n ax1.xaxis.set_tick_params(which='both', size=5, width=2, direction='in', top='on')\r\n ax1.yaxis.set_tick_params(which='both', size=5, width=2, direction='in', right='on')\r\n \r\n plt.subplot(3,4,12)\r\n plt.plot(sim_t/3600,G5[i]/G_tot[4],color=[0.4,0,0.4],linewidth=4,linestyle=ls[i])\r\n plt.ylabel('Fraction ON',fontsize=fs,weight='bold')\r\n plt.xlabel('time (hr)',fontsize=fs,weight='bold')\r\n plt.xticks(fontsize=fs,weight='bold')\r\n plt.yticks(fontsize=fs,weight='bold')\r\n ax1 = plt.gca()\r\n ax1.set_xlim(0,3)\r\n ax1.set_ylim(-0.1,1.1)\r\n ax1.xaxis.set_tick_params(which='both', size=5, width=2, direction='in', top='on')\r\n ax1.yaxis.set_tick_params(which='both', size=5, width=2, direction='in', right='on')\r\n\r\n''' Exporting symbolic equations '''\r\neIFFL.export_sym_eqs(file_name='eIFFL_leak_equations')\r\n\r\n''' Compiling genelet sequences to build the network '''\r\ninput_file_loc = 'C:\\\\Users\\\\sscha\\\\OneDrive - Johns Hopkins University\\\\Desktop\\\\Programming Club\\\\Python\\Python 2020\\\\General genelet model\\\\git test\\\\PythonVersion\\\\all_genelet_sequences.xlsx'\r\nfile_name='eIFFL_leak_sequences'\r\n\r\neIFFL.compile_network_sequences(input_file_loc,desired_nodes=['G3','G5','G6','G4'],save_file_name=file_name)"
] | [
[
"numpy.array",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.suptitle",
"matplotlib.pyplot.title",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.yticks",
"matplotlib.pyplot.figure",
"numpy.linspace",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.gca",
"matplotlib.pyplot.xticks",
"matplotlib.pyplot.subplot"
]
] |
acumos/acumos-onnx-client | [
"8cc7f29b369e84268fb17c007127d12409685d8c"
] | [
"acumos-package/onnx4acumos/FilledClientSkeletonsExamples/Iris_Model_OnnxClient.py"
] | [
"#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Tue May 26 10:55:11 2020\n\n@author: Bruno Lozach OrangeFrance/TGI/OLS/SOFT_LANNION\n\"\"\"\n# Some standard imports\nimport io\nimport os\nfrom sys import argv\nimport re\nimport requests\nimport numpy as np\n\n# acumos import\nfrom acumos.modeling import Model, List, Dict, create_namedtuple, create_dataframe\n\n# onnx import\nimport onnx\n\n# Onnx model protobuf import\nimport Iris_Model_pb2 as pb\n\n# Import your own needed library below\n\"**************************************\"\nfrom sklearn.datasets import load_iris\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.ensemble import RandomForestClassifier\nimport ast\n\n\n\"**************************************\"\n\n# Define your own needed method below\n\"**************************************\"\n\n\"**************************************\"\n\n# Preprocessing method define \ndef preprocessing(preProcessingInputFileName: str):\n preProcessingInputFile = io.open(preProcessingInputFileName, \"rb\", buffering = 0)\n preProcessingData = preProcessingInputFile.read()\n preProcessingInput = io.BytesIO(preProcessingData)\n # Import the management of the Onnx data preprocessing below. \n # The \"preProcessingOutput\" variable must contain the preprocessing result with type found in run_xx_OnnxModel method signature below \n \"*************************************************************************************************\"\n global indice \n global preprocessingResult\n preProcessingInputFile = io.open(preProcessingInputFileName, \"r\")\n preProcessingData = preProcessingInputFile.read()\n preprocessingResult = np.array(ast.literal_eval(preProcessingData))[indice]\n \"**************************************************************************************************\"\n # \"PreProcessingOutput\" variable affectation with the preprocessing result\n preProcessingOutput = preprocessingResult\n preProcessingInputFile.close()\n return preProcessingOutput\n\n# Postprocessing method define\ndef postprocessing(postProcessingInput, outputFileName: str)-> bool:\n output_label = np.array(postProcessingInput.output_label).reshape((1))\n output_probability = postProcessingInput.output_probability\n # Import the management of the Onnx data postprocessing below. \n # The \"postProcessingInput\" variable must contain the data of the Onnx model result with type found in method signature below \n \"*************************************************************************************************\"\n proba = \"probability(\"\n for k in range(len(output_probability)):\n if k != (len(output_probability)-1):\n proba+= output_probability[k].key + \" : \" + str(output_probability[k].value) +\", \"\n else:\n proba+= output_probability[k].key + \" : \" + str(output_probability[k].value) +\")\"\n\n \n global preprocessingResult\n postProcessingResult = \"result(\"+ str(preprocessingResult) + \") : \" + str(output_label[0]) + \" \" + proba + \"\\n\"\n print(postProcessingResult)\n \"*************************************************************************************************\"\n # \"postProcessingResult\" variable must be affected with the postprocessing result\n # Save the processed data in new file\n if type(postProcessingResult) == str:\n outputFile = io.open(outputFileName.split(\".\")[0] +\".data\", \"a\")\n else:\n outputFile = io.open(outputFileName, \"wb\", buffering = 0)\n outputFile.write(postProcessingResult)\n outputFile.close()\n return os.path.isfile(outputFileName)\n\n\nrestURL = \"http://localhost:3330/model/methods/run_Iris_Model_OnnxModel\"\nheaders = {'Content-Type': 'application/vnd.google.protobuf','accept': 'application/vnd.google.protobuf' }\n\n#Load provided onnx model \nmodelFileName = \"Iris_Model.onnx\"\nonnx_model = onnx.load(modelFileName)\n\n\ndef run_Iris_Model_OnnxModel(float_input: List[np.float32]):\n \"\"\" This method run the provided onnx model. \"\"\"\n inputOnnx = pb.RunIrisModelOnnxmodelIn()\n oneLine = float_input.reshape(4)\n inputOnnx.float_input.extend(oneLine)\n print(\"*** Call ONNX Runtime Prediction ***\")\n result = requests.post(restURL, headers=headers, data=inputOnnx.SerializeToString())\n #print(\"result = \", result.content)\n outputOnnx = pb.MultipleReturn()\n outputOnnx.ParseFromString(result.content)\n return outputOnnx\n\n# Data Input File Name \ninputFileName =\"\"\nfound = False \nfor arg in argv:\n if found:\n inputFileName = arg\n found = False\n if re.search(\"-f\", arg):\n found = True\n# Client personalization below\nglobal indice\nindiceMax = 38\n#indiceMax = 1\n \n\n#Existence test of the provided data input file\nif not os.path.isfile(inputFileName):\n print(\"File \", inputFileName,\"is not found\")\n exit()\n\noutputFileName = \"output/\"+ modelFileName.split(\".\")[0] + '_' + inputFileName.split(\".\")[0].split(\"/\")[1] + \"_output.\" + inputFileName.split(\".\")[1]\n\n# check onnx model\ncheckModel = onnx.checker.check_model(onnx_model)\n\nif checkModel is None:\n # Client personalization below\n for indice in range(indiceMax):\n # preprocessing onnx data \n preprocessingData = preprocessing(inputFileName)\n # Onnx model call \n ort_outs = run_Iris_Model_OnnxModel(preprocessingData)\n # postprocessing onnx data, the result is stored in new file \n postprocessing(ort_outs,outputFileName)\nelse:\n raise AcumosError(\"The model {} is not a ONNX Model or is a malformed ONNX model\".format(modelFileName))\n\n\n\n\n\n\n"
] | [
[
"numpy.array"
]
] |
ekellbuch/ibllib | [
"6948f86c3f426cbebb39cc693f612d25079d7ef2"
] | [
"ibllib/io/extractors/training_audio.py"
] | [
"#!/usr/bin/env python\n# -*- coding:utf-8 -*-\nfrom pathlib import Path\nimport logging\n\nimport numpy as np\nfrom scipy import signal\nfrom scipy.io import wavfile\n\nfrom ibllib import dsp\nfrom ibllib.misc import log2session_static\nimport ibllib.io.raw_data_loaders as ioraw\nimport ibllib.io.extractors.training_trials\n\nlogger_ = logging.getLogger('ibllib')\n\nNS_WIN = 2 ** 18 # 2 ** np.ceil(np.log2(1 * fs))\nOVERLAP = NS_WIN / 2\nNS_WELCH = 512\nFTONE = 5000\nUNIT = 'dBFS' # dBFS or dbSPL\nREADY_TONE_SPL = 85\n\n\ndef _running_mean(x, N):\n cumsum = np.cumsum(np.insert(x, 0, 0))\n return (cumsum[N:] - cumsum[:-N]) / N\n\n\ndef _detect_ready_tone(w, fs):\n # get envelope of DC free signal and envelope of BP signal around freq of interest\n h = np.abs(signal.hilbert(w - np.median(w)))\n fh = np.abs(signal.hilbert(dsp.bp(w, si=1 / fs, b=FTONE * np.array([0.9, 0.95, 1.15, 1.1]))))\n dtect = _running_mean(fh / (h + 1e-3), int(fs * 0.1)) > 0.8\n return np.where(np.diff(dtect.astype(int)) == 1)[0]\n # tone = np.sin(2 * np.pi * FTONE * np.arange(0, fs * 0.1) / fs)\n # tone = tone / np.sum(tone ** 2)\n # xc = np.abs(signal.hilbert(signal.correlate(w - np.mean(w), tone)))\n\n\ndef _get_conversion_factor(unit=UNIT, ready_tone_spl=READY_TONE_SPL):\n # 3 approaches here (not exclusive):\n # a- get the mic sensitivity, the preamp gain and DAC parameters and do the math\n # b- treat the whole thing as a black box and do a calibration run (cf. people at Renard's lab)\n # c- use calibrated ready tone\n # The reference of acoustic pressure is 0dBSPL @ 1kHz which is threshold of hearing (20 μPa).\n # Usual calibration is 1 Pa (94 dBSPL) at 1 kHz\n # c) here we know that the ready tone is 55dB SPL at 5kHz, assuming a flat spectrum between\n # 1 and 5 kHz, and observing the peak value on the 5k at the microphone.\n if unit == 'dBFS':\n return 1.0\n distance_to_the_mic = .155\n peak_value_observed = 60\n rms_value_observed = np.sqrt(2) / 2 * peak_value_observed\n fac = 10 ** ((ready_tone_spl - 20 * np.log10(rms_value_observed)) / 20) * distance_to_the_mic\n return fac\n\n\ndef welchogram(fs, wav, nswin=NS_WIN, overlap=OVERLAP, nperseg=NS_WELCH):\n \"\"\"\n Computes a spectrogram on a very large audio file.\n\n :param fs: sampling frequency (Hz)\n :param wav: wav signal (vector or memmap)\n :param nswin: n samples of the sliding window\n :param overlap: n samples of the overlap between windows\n :param nperseg: n samples for the computation of the spectrogram\n :return: tscale, fscale, downsampled_spectrogram\n \"\"\"\n ns = wav.shape[0]\n window_generator = dsp.WindowGenerator(ns=ns, nswin=nswin, overlap=overlap)\n nwin = window_generator.nwin\n fscale = dsp.fscale(nperseg, 1 / fs, one_sided=True)\n W = np.zeros((nwin, len(fscale)))\n tscale = window_generator.tscale(fs=fs)\n detect = []\n for first, last in window_generator.firstlast:\n # load the current window into memory\n w = np.float64(wav[first:last]) * _get_conversion_factor()\n # detection of ready tones\n a = [d + first for d in _detect_ready_tone(w, fs)]\n if len(a):\n detect += a\n # the last window may not allow a pwelch\n if (last - first) < nperseg:\n continue\n # compute PSD estimate for the current window\n iw = window_generator.iw\n _, W[iw, :] = signal.welch(w, fs=fs, window='hanning', nperseg=nperseg, axis=-1,\n detrend='constant', return_onesided=True, scaling='density')\n if (iw % 50) == 0:\n window_generator.print_progress()\n window_generator.print_progress()\n # the onset detection may have duplicates with sliding window, average them and remove\n detect = np.sort(np.array(detect)) / fs\n ind = np.where(np.diff(detect) < 0.1)[0]\n detect[ind] = (detect[ind] + detect[ind + 1]) / 2\n detect = np.delete(detect, ind + 1)\n return tscale, fscale, W, detect\n\n\n@log2session_static('extraction')\ndef extract_sound(ses_path, save=True, force=False, delete=False):\n \"\"\"\n Simple audio features extraction for ambient sound characterization.\n From a wav file, generates several ALF files to be registered on Alyx\n\n :param ses_path: ALF full session path: (/mysubject001/YYYY-MM-DD/001)\n :param delete: if True, removes the wav file after processing\n :return: None\n \"\"\"\n ses_path = Path(ses_path)\n wav_file = ses_path / 'raw_behavior_data' / '_iblrig_micData.raw.wav'\n out_folder = ses_path / 'raw_behavior_data'\n if not wav_file.exists():\n return None\n files_out = {'power': out_folder / '_iblmic_audioSpectrogram.power.npy',\n 'frequencies': out_folder / '_iblmic_audioSpectrogram.frequencies.npy',\n 'onset_times': out_folder / '_iblmic_audioOnsetGoCue.times_mic.npy',\n 'times_microphone': out_folder / '_iblmic_audioSpectrogram.times_mic.npy',\n 'times': out_folder / '_iblmic_audioSpectrogram.times.npy'\n }\n # if they exist and the option Force is set to false, do not recompute and exit\n if all([files_out[f].exists() for f in files_out]) and not force:\n logger_.warning('Output exists. Skipping ' + str(wav_file) + ' Use force flag to override')\n return\n # crunch the wav file\n fs, wav = wavfile.read(wav_file, mmap=False)\n if len(wav) == 0:\n status = _fix_wav_file(wav_file)\n if status != 0:\n logger_.error(f\"WAV Header Indicates empty file. Couldn't fix. Abort. {wav_file}\")\n return\n else:\n fs, wav = wavfile.read(wav_file, mmap=False)\n tscale, fscale, W, detect = welchogram(fs, wav)\n # save files\n if save:\n out_folder.mkdir(exist_ok=True)\n np.save(file=files_out['power'], arr=W.astype(np.single))\n np.save(file=files_out['frequencies'], arr=fscale[None, :].astype(np.single))\n np.save(file=files_out['onset_times'], arr=detect)\n np.save(file=files_out['times_microphone'], arr=tscale[:, None].astype(np.single))\n # for the time scale, attempt to synchronize using onset sound detection and task data\n data = ioraw.load_data(ses_path)\n if data is None: # if no session data, we're done\n return\n tgocue = np.array(ibllib.io.extractors.training_trials.get_goCueOnset_times(\n None, save=False, data=data))\n ilast = min(len(tgocue), len(detect))\n dt = tgocue[:ilast] - detect[: ilast]\n # only save if dt is consistent for the whole session\n if np.std(dt) < 0.2 and save:\n tscale += np.median(dt)\n np.save(file=files_out['times'], arr=tscale[:, None].astype(np.single))\n if delete:\n wav_file.unlink()\n\n\ndef _fix_wav_file(wav_file):\n import platform\n import subprocess\n status = -1\n if platform.system() != 'Linux':\n return status\n wav_file_tmp = wav_file.with_suffix('.wav_')\n wav_file.rename(wav_file_tmp)\n command2run = f'sox --ignore-length {wav_file_tmp} {wav_file}'\n process = subprocess.Popen(command2run, shell=True, stdout=subprocess.PIPE,\n stderr=subprocess.PIPE)\n process.communicate()\n if process.returncode == 0:\n wav_file_tmp.unlink()\n else:\n wav_file_tmp.rename(wav_file)\n return process.returncode\n"
] | [
[
"numpy.delete",
"scipy.io.wavfile.read",
"numpy.array",
"numpy.median",
"numpy.save",
"numpy.diff",
"numpy.float64",
"numpy.std",
"numpy.sqrt",
"scipy.signal.welch",
"numpy.log10",
"numpy.insert"
]
] |
schuetzepaul/allpix-squared | [
"737eba52fe13f56134c4e88a7928d1a5103dd40a"
] | [
"tools/root_analysis_macros/display_mc_hits.py"
] | [
"# Create Plots to visualize MC Data from Allpix Squared\n\n# ===TO DO== #\n# Create Batch processing for multiple detectors\n\n# ROOT imports\nimport ROOT\nfrom ROOT import TFile, gDirectory, gSystem, TClass\n\nimport os, sys\nimport argparse\nimport os.path as path\n\n# numpy\nimport numpy as np\nimport numpy.ma as ma\n\n# matplotlib\nimport matplotlib\n\n# scipy\nfrom scipy import stats\nfrom scipy.stats import norm\n\n# argument parser\nparser = argparse.ArgumentParser()\nparser.add_argument(\"-l\", metavar='libAllpixObjects', required=False,\n help=\"specify path to the libAllpixObjects library (generally in allpix-squared/lib/)) \")\nparser.add_argument(\"-d\", metavar='detector', required=True,\n help=\"specify your detector name (generally detector1, dut, ...) \")\nparser.add_argument(\"-f\", metavar='rootfile', required=True, help=\"specify path to the rootfile to be processed \")\n\nparser.add_argument(\"-a\", \"--all\", required=False, help=\"Produce All Graphs\", action=\"store_true\")\n\nparser.add_argument(\"--pdf\", help=\"Create PDF rather than pop up (Useful for Docker)\", action=\"store_true\")\n\nparser.add_argument(\"-v\", \"--verbose\", help=\"Toggle verbose settings\", action=\"store_true\")\n\nparser.add_argument(\"--onedim\", \"--1d\", help=\"Print all one dimensional plots (Histograms)\", action=\"store_true\")\n\nparser.add_argument(\"--twodim\", \"--2d\", help=\"Print all two dimensional plots (Heatmaps)\", action=\"store_true\")\n\nparser.add_argument(\"--threedim\", \"--3d\", help=\"Print all Three dimensional plots\", action=\"store_true\")\n\nparser.add_argument(\"-g\", \"--gaussian\", \"--norm\", help=\"Print histograms with gaussian curve\", action=\"store_true\")\n\nparser.add_argument(\"-c\", \"--cauchy\", \"--lorentz\", help=\"Print histograms with Cauchy-Lorentz curve\", action=\"store_true\")\n\n\nargs = parser.parse_args()\n\nroot_file_name = (str(args.f))\ndetector_name = (str(args.d))\nprint_all = args.all\nprint_1d = args.onedim\nprint_2d = args.twodim\nprint_3d = args.threedim\nprint_gauss = args.gaussian\nprint_cauch = args.cauchy\nsave_pdf = args.pdf\nverbose = args.verbose\noutDir = os.path.dirname(root_file_name)\n\nif not (print_1d or print_2d or print_3d or print_gauss or print_cauch):\n print_og = True\nelse:\n print_og = False\n\nif save_pdf:\n matplotlib.use('pdf')\n\nimport matplotlib.pyplot as plt # These imports must be called after the use pdf argument\nfrom matplotlib import pyplot\nfrom matplotlib.colors import LogNorm\nfrom mpl_toolkits.mplot3d import Axes3D\nfrom matplotlib import cm\nfrom matplotlib.colors import LinearSegmentedColormap\n\nif args.l is not None: # Try to find Allpix Library\n lib_file_name = (str(args.l))\n if (not os.path.isfile(lib_file_name)):\n print(\"WARNING: \", lib_file_name, \" does not exist, exiting\")\n exit(1)\n\nelif os.path.isfile(path.abspath(path.join(__file__ ,\"..\",\"..\",\"opt\",\"allpix-squared\",\"lib\",\"libAllpixObjects.so\"))): # For native installs\n lib_file_name = path.abspath(path.join(__file__ ,\"..\",\"..\",\"opt\",\"allpix-squared\",\"lib\",\"libAllpixObjects.so\"))\n\nelif os.path.isfile(path.join(path.sep, \"opt\",\"allpix-squared\",\"lib\",\"libAllpixObjects.so\")): # For Docker installs\n lib_file_name = path.join(path.sep, \"opt\",\"allpix-squared\",\"lib\",\"libAllpixObjects.so\")\n\nelse:\n print(\"WARNING: No Allpix Objects Library found, exitting\")\n exit(1)\n\n\nif (not os.path.isfile(lib_file_name)):\n print(\"WARNING: no allpix library found, exiting (Use -l to manually set location of libraries)\")\n exit(1)\nif (not os.path.isfile(root_file_name)):\n print(\"WARNING: \" + root_file_name + \" does not exist, exiting\")\n exit(1)\n\n# load library and rootfile\ngSystem.Load(lib_file_name)\nrootfile = ROOT.TFile(root_file_name)\ngDirectory.ls()\n\nMcParticle = rootfile.Get('MCParticle')\nPixelCharge = rootfile.Get('PixelCharge')\nPropCharge = rootfile.Get('PropagatedCharge')\nPixelHit = rootfile.Get('PixelHit')\n\n# example of python dictionaries to fill\nmc_global_endpoints = {'x': [], 'y': [], 'z': []}\nmc_local_endpoints = {'x': [], 'y': [], 'z': []}\npixel_hit = {'x': [], 'y': [], 'signal': []}\n\n# loop on pixel hit branch\nempty_mc_branch = 0\nprint(\"Loading in Data...\")\nfor iev in range(0, PixelHit.GetEntries()):\n PixelHit.GetEntry(iev)\n PixelCharge.GetEntry(iev)\n McParticle.GetEntry(iev)\n PixelCharge_branch = PixelCharge.GetBranch(detector_name)\n PixelHit_branch = PixelHit.GetBranch(detector_name)\n McParticle_branch = McParticle.GetBranch(detector_name)\n\n if (not PixelCharge_branch):\n Warning(\"WARNING: cannot find PixelCharge branch in the TTree with detector name: \" + detector_name + \", exiting\")\n exit(1)\n if verbose: print(' processing event number {0}\\r'.format(iev), \"out of\", PixelHit.GetEntries(), \"events\",)\n\n # assign AP2 vectors to branches\n br_pix_charge = getattr(PixelCharge, PixelCharge_branch.GetName())\n br_pix_hit = getattr(PixelHit, PixelHit_branch.GetName())\n br_mc_part = getattr(McParticle, McParticle_branch.GetName())\n\n if br_mc_part.size() < 1:\n empty_mc_branch += 1;\n continue\n\n output_track_x = 0.\n output_track_y = 0.\n output_track_z = 0.\n\n output_track_x_global = 0.\n output_track_y_global = 0.\n output_track_z_global = 0.\n for mc_part in br_mc_part:\n output_track_x += mc_part.getLocalEndPoint().x()\n output_track_y += mc_part.getLocalEndPoint().y()\n output_track_z += mc_part.getLocalEndPoint().z()\n\n output_track_x_global += mc_part.getGlobalEndPoint().x()\n output_track_y_global += mc_part.getGlobalEndPoint().y()\n output_track_z_global += mc_part.getGlobalEndPoint().z()\n\n output_track_x /= float(br_mc_part.size())\n output_track_y /= float(br_mc_part.size())\n output_track_z /= float(br_mc_part.size())\n\n output_track_x_global /= float(br_mc_part.size())\n output_track_y_global /= float(br_mc_part.size())\n output_track_z_global /= float(br_mc_part.size())\n\n for pix_hit in br_pix_hit:\n pixel_hit['x'].append(pix_hit.getPixel().getLocalCenter().x())\n pixel_hit['y'].append(pix_hit.getPixel().getLocalCenter().y())\n pixel_hit['signal'].append(pix_hit.getSignal())\n\n mc_global_endpoints['x'].append(output_track_x_global)\n mc_global_endpoints['y'].append(output_track_y_global)\n mc_global_endpoints['z'].append(output_track_z_global)\n\n mc_local_endpoints['x'].append(output_track_x)\n mc_local_endpoints['y'].append(output_track_y)\n mc_local_endpoints['z'].append(output_track_z)\n\n# print number of events processed\nprint(\" ----- processed events (pixelhit):\" + str(PixelHit.GetEntries()) + \" empty_mc_branch:\" + str(empty_mc_branch))\n\nprint(\"Plotting...\")\n\n# plot pixel collected charge versus MC parcticle endpoint coordinates\nif print_all or print_og or print_2d:\n mc_hit_histogram = plt.figure(figsize=(11, 7))\n H2, xedges, yedges, binnmmber = stats.binned_statistic_2d(mc_local_endpoints['x'], mc_local_endpoints['y'], values=pixel_hit['signal'], statistic='mean', bins=[100, 100])\n XX, YY = np.meshgrid(xedges, yedges)\n Hm = ma.masked_where(np.isnan(H2), H2)\n plt.pcolormesh(XX, YY, Hm, cmap=\"inferno\")\n plt.ylabel(\"pixel y [mm]\")\n plt.xlabel(\"pixel x [mm]\")\n cbar = plt.colorbar(pad=.015, aspect=20)\n cbar.set_label(\"hit signal\")\n if save_pdf: mc_hit_histogram.savefig(path.join(outDir , \"GlobalHeatMap.pdf\"), bbox_inches='tight')\n\nif print_all or print_og or print_2d:\n mc_hit_histogram_z = plt.figure(figsize=(11, 7))\n H2, xedges, yedges, binnmmber = stats.binned_statistic_2d(mc_local_endpoints['x'], mc_local_endpoints['z'],\n values=pixel_hit['signal'], statistic='mean', bins=[100, 100])\n XX, YY = np.meshgrid(xedges, yedges)\n Hm = ma.masked_where(np.isnan(H2), H2)\n plt.pcolormesh(XX, YY, Hm.T, cmap=\"inferno\")\n plt.ylabel(\"pixel z [mm]\")\n plt.xlabel(\"pixel x [mm]\")\n cbar = plt.colorbar(pad=.015, aspect=20)\n cbar.set_label(\"hit signal \")\n if save_pdf: mc_hit_histogram_z.savefig(path.join(outDir , \"Z_Hist.pdf\"), bbox_inches='tight')\n\nif print_all or print_og:\n figMC_z = plt.figure()\n plt.hist(mc_local_endpoints['z'], 100)\n plt.title(\"MC global end point z coordinate\")\n plt.xlabel(\"z_global [mm]\")\n\n figMC_z_log = plt.figure()\n plt.hist(mc_global_endpoints['x'], 100)\n plt.title(\"MC global end point z coordinate\")\n plt.xlabel(\"z_global [mm]\")\n plt.yscale('log')\n if save_pdf: figMC_z_log.savefig(path.join(outDir , \"ZLog_Hist.pdf\"), bbox_inches='tight')\n\n# X Pixel Hit\nif print_all or print_1d:\n plt.clf()\n figMC_x = plt.figure()\n plt.hist(pixel_hit['x'], len(np.unique(pixel_hit['x'])))\n plt.title(\"Hit Pixel x coordinate\")\n plt.xlabel(\"hit pixel x coordinate pixels\")\n if save_pdf: figMC_x.savefig(path.join(outDir , \"XPixelHit.pdf\"), bbox_inches='tight')\n\n\n# X Pixel Hit Gaussian Density\nif print_all or print_1d or print_gauss:\n plt.clf()\n x_gauss = plt.figure()\n plt.hist(pixel_hit['x'], len(np.unique(pixel_hit['x'])), density=True)\n plt.xlabel(\"hit pixel x coordinate pixels\")\n\n mu, sigma = norm.fit(pixel_hit['x'])\n x = np.linspace(min(pixel_hit['x']), max(pixel_hit['x']), len(np.unique(pixel_hit['x'])))\n plt.plot(x, stats.norm.pdf(x, mu, sigma))\n plt.title(\"Hit Pixel Density \\n (mean = \" + str(round(mu,2)) + \" sigma = \" + str(round(sigma,2)))\n if save_pdf: x_gauss.savefig(path.join(outDir , \"XGaussianDist.pdf\"), bbox_inches='tight')\n\n# X Pixel Hit Cauchy Density\nif print_all or print_1d or print_cauch:\n plt.clf()\n x_cauch = plt.figure()\n plt.hist(pixel_hit['x'], len(np.unique(pixel_hit['x'])), density=True)\n plt.xlabel(\"hit pixel X coordinate pixels\")\n\n mean, var = stats.cauchy.fit(pixel_hit['x'])\n x = np.linspace(min(pixel_hit['y']), max(pixel_hit['x']), len(np.unique(pixel_hit['x'])))\n plt.plot(x, stats.cauchy.pdf(x, mean, var))\n plt.title(\"Hit Pixel Density (with Cauchy curve) \\n (mean = \" + str(round(mean,2)) + \" Variance = \" + str(round(var,2)) + \")\")\n if save_pdf: x_cauch.savefig(path.join(outDir , \"XCauchyDist.pdf\"), bbox_inches='tight')\n\n\n\n# Y Pixel Hit\nif print_all or print_1d:\n plt.clf()\n figMC_x = plt.figure()\n plt.hist(pixel_hit['y'], len(np.unique(pixel_hit['y'])))\n plt.title(\"Hit Pixel y coordinate\")\n plt.xlabel(\"hit pixel y coordinate pixels\")\n if save_pdf: figMC_x.savefig(path.join(outDir , \"YPixelHit.pdf\"), bbox_inches='tight')\n\n# Y Pixel Hit Gaussian Density\nif print_all or print_1d or print_gauss:\n plt.clf()\n y_gauss = plt.figure()\n plt.hist(pixel_hit['y'], len(np.unique(pixel_hit['y'])), density=True)\n plt.xlabel(\"hit pixel y coordinate pixels\")\n\n mu, sigma = norm.fit(pixel_hit['y'])\n x = np.linspace(min(pixel_hit['y']), max(pixel_hit['y']), len(np.unique(pixel_hit['y'])))\n plt.plot(x, stats.norm.pdf(x, mu, sigma))\n plt.title(\"Hit Pixel Density\\n (mean = \" + str(round(mu,2)) + \" sigma = \" + str(round(sigma,2)) + \")\")\n if save_pdf: y_gauss.savefig(path.join(outDir , \"YGaussianDist.pdf\"), bbox_inches='tight')\n\n\n# Y Pixel Hit Cauchy Density\nif print_all or print_1d or print_cauch:\n plt.clf()\n y_cauch = plt.figure()\n plt.hist(pixel_hit['y'], len(np.unique(pixel_hit['y'])), density=True)\n plt.xlabel(\"hit pixel y coordinate pixels\")\n\n mean, var = stats.cauchy.fit(pixel_hit['y'])\n x = np.linspace(min(pixel_hit['y']), max(pixel_hit['y']), len(np.unique(pixel_hit['y'])))\n plt.plot(x, stats.cauchy.pdf(x, mean, var))\n plt.title(\"Hit Pixel Density (with Cauchy curve) \\n (mean = \" + str(round(mean,2)) + \" Variance = \" + str(round(var,2)) + \")\")\n if save_pdf: y_cauch.savefig(path.join(outDir , \"YCauchyDist.pdf\"), bbox_inches='tight')\n\n\n\n# plot pixel hits in pixel Bins?\nif print_all or print_2d:\n plt.clf()\n px_bins_hm =plt.figure()\n heatmap, xedges, yedges = np.histogram2d(pixel_hit['x'], pixel_hit['y'], bins=[len(np.unique(pixel_hit['x'])),len(np.unique(pixel_hit['y']))])\n extent = [xedges[0], xedges[-1], yedges[0], yedges[-1]]\n plt.imshow(heatmap.T, origin='lower')\n plt.xlabel('pixel x position')\n plt.ylabel('pixel y position')\n plt.title('Pixel Heatmap (Number of Hits)')\n cbar = plt.colorbar(pad=.015, aspect=20)\n if save_pdf: px_bins_hm.savefig(path.join(outDir , \"PixelNumHits.pdf\"), bbox_inches='tight', dpi=900)\n\nif print_all or print_1d:\n # Pixel Charge Spectrum (Added)\n plt.clf()\n px_charge_spectrum = plt.figure()\n plt.hist(pixel_hit['signal'], bins=100)\n if save_pdf: px_charge_spectrum.savefig(path.join(outDir , \"PixelChargeSpectrum.pdf\"), bbox_inches='tight')\n\n# 3D plot x,y,z MC particle endpoint with color scale representing the amount of charge (quite heavy)\nif print_all or print_3d or print_og:\n fig3D = plt.figure()\n ax = fig3D.add_subplot(111, projection='3d')\n colors = LinearSegmentedColormap('colormap', cm.jet._segmentdata.copy(), np.max(pixel_hit['signal']))\n plot = ax.scatter(mc_local_endpoints['x'], mc_local_endpoints['y'], mc_local_endpoints['z'], c=pixel_hit['signal'],\n cmap=\"jet\", marker=\".\", s=2) # ,c= marker=m)\n ax.set_ylabel(\"y mc (mm)\")\n ax.set_xlabel(\"x mc (mm)\")\n ax.set_zlabel(\"z mc (mm)\")\n cbar = fig3D.colorbar(plot, ax=ax)\n cbar.set_label(\"hit signal\")\n if save_pdf: fig3D.savefig(path.join(outDir , \"3D.pdf\"), bbox_inches='tight')\n # show plots\n\nplt.show()\n"
] | [
[
"scipy.stats.norm.pdf",
"matplotlib.cm.jet._segmentdata.copy",
"numpy.max",
"matplotlib.pyplot.colorbar",
"scipy.stats.binned_statistic_2d",
"matplotlib.pyplot.yscale",
"scipy.stats.cauchy.pdf",
"matplotlib.use",
"matplotlib.pyplot.pcolormesh",
"matplotlib.pyplot.title",
"matplotlib.pyplot.figure",
"matplotlib.pyplot.hist",
"scipy.stats.norm.fit",
"matplotlib.pyplot.clf",
"matplotlib.pyplot.show",
"numpy.isnan",
"matplotlib.pyplot.xlabel",
"scipy.stats.cauchy.fit",
"matplotlib.pyplot.ylabel",
"numpy.meshgrid",
"numpy.unique",
"matplotlib.pyplot.imshow"
]
] |
Seizzzz/DailyCodes | [
"9a617fb64ee27b9f254be161850e9c9a61747cb1"
] | [
"Course 202009/Python/Visualize/4.py"
] | [
"import numpy as np\nfrom matplotlib import pyplot as plt\n\nx = np.linspace(-5 * np.pi, 5 * np.pi, 500)\ny1 = 3 * np.cos(x)\ny2 = np.sin(4*x)\n\nfig, ax = plt.subplots()\nplt.style.use('classic')\n\nax.spines[\"right\"].set_visible(False)\nax.spines[\"top\"].set_visible(False)\nax.spines['bottom'].set_position(('data',0))\nax.xaxis.set_ticks_position('bottom')\nax.spines['left'].set_position(('data',0))\nax.yaxis.set_ticks_position('left')\n\nplt.plot(x, y1, color='blue', linestyle='-', label='y=3cosx')\nplt.plot(x, y2, color='red', linestyle='-', label='y=sin3x')\n\nplt.legend()\nplt.show()"
] | [
[
"numpy.sin",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.legend",
"matplotlib.pyplot.subplots",
"matplotlib.pyplot.style.use",
"numpy.cos",
"matplotlib.pyplot.show",
"numpy.linspace"
]
] |
SAFedorov/bfieldtools | [
"7e64bc2033670f01d2b90df2210b60743731a948"
] | [
"bfieldtools/sphtools.py"
] | [
"\"\"\"\nFunctions for constructing real spherical harmonics (Ylms), their gradients\nand related magnetic field 'basis vectorfunctions'\n(Wlms for r**l components, Vlms for r**(-l) components).\n\nUses notations and definitions by Plattner and Simons (2014; https://arxiv.org/pdf/1306.3201.pdf)\nand the same normalization conventions.\n\nIntegration over a surface of unit sphere is\nused as the inner product <C,D> = int C dot D dOmega.\n\nAlso has many of functions for spherical <-> cartesian transformations.\n\"\"\"\n\n__all__ = [\n \"Blm\",\n \"Plm\",\n \"Rotmatrix\",\n \"SphBasis\",\n \"Vlm\",\n \"Wlm\",\n \"Xlm\",\n \"basis_fields\",\n \"basis_potentials\",\n \"cartesian2spherical\",\n \"cartvec2sph\",\n \"compute_sphcoeffs_mesh\",\n \"derlpmn_em\",\n \"derxlm\",\n \"dphiylm\",\n \"dthylm\",\n \"field\",\n \"lpmn_em\",\n \"plotBVlm_volume\",\n \"plotBWlm_volume\",\n \"plotVlm\",\n \"plotWlm\",\n \"plotXlm\",\n \"plotYlm\",\n \"plotYlms\",\n \"potential\",\n \"sinxlm\",\n \"spherical2cartesian\",\n \"sphvec2cart\",\n \"xlm\",\n \"ylm\",\n]\n\nimport numpy as np\nfrom scipy.special import factorial, lpmn\n\ntry:\n from quadpy import sphere\nexcept ImportError:\n from quadpy import u3 as sphere\n\nfrom .mesh_calculus import gradient_matrix\nfrom .utils import tri_normals_and_areas\n\n\n############################################\n# Helper functions for sph computation\n\n\ndef cartesian2spherical(p, zaxis_approx=True):\n \"\"\"\n Maps cartesian coordinates to spherical.\n\n Parameters\n ----------\n p: Nx3 array\n cartesian coordinates\n zaxis_approx: Boolean (True)\n If True, apply regularization that avoids singularity on z-axis\n\n Returns\n -------\n\n sp: Nx3 array\n spherical coordinates [r, theta, phi]\n\n \"\"\"\n\n r = np.sqrt(p[:, 0] ** 2 + p[:, 1] ** 2 + p[:, 2] ** 2)\n theta = np.arctan2(np.sqrt(p[:, 0] ** 2 + p[:, 1] ** 2), p[:, 2])\n phi = np.arctan2(p[:, 1], p[:, 0])\n\n sp = np.array((r, theta, phi)).T\n\n if zaxis_approx:\n eps = 1e-6\n theta_mask_0 = np.abs(sp[:, 1]) < eps\n theta_mask_pi = np.abs(sp[:, 1] - np.pi) < eps\n sp[theta_mask_0, 1] += eps\n sp[theta_mask_pi, 1] -= eps\n\n return sp\n\n\ndef spherical2cartesian(sp):\n \"\"\"\n Maps spherical coordinates to cartesian.\n\n Parameters\n ----------\n sp: Nx3 array\n spherical coordinates [r, theta, phi]\n\n Returns\n -------\n p: Nx3 array\n cartesian croodinates\n \"\"\"\n\n X = sp[:, 0] * np.sin(sp[:, 1]) * np.cos(sp[:, 2])\n Y = sp[:, 0] * np.sin(sp[:, 1]) * np.sin(sp[:, 2])\n Z = sp[:, 0] * np.cos(sp[:, 1])\n\n p = np.array((X, Y, Z)).T\n return p\n\n\ndef Rotmatrix(sp):\n \"\"\"\n Constructs rotation matrix from cartesian coordinates to spherical.\n\n Parameters\n ----------\n sp: Nx3 array\n spherical coordinates [r, theta, phi]\n\n Returns\n -------\n vmat: 3x3 array\n rotation matrix from cartesian to spherical.\n \"\"\"\n\n vmat = np.zeros((3, 3))\n vmat[0, 0] = np.sin(sp[1]) * np.cos(sp[2])\n vmat[0, 1] = np.sin(sp[1]) * np.sin(sp[2])\n vmat[0, 2] = np.cos(sp[1])\n vmat[1, 0] = np.cos(sp[1]) * np.cos(sp[2])\n vmat[1, 1] = np.cos(sp[1]) * np.sin(sp[2])\n vmat[1, 2] = -1 * np.sin(sp[1])\n vmat[2, 0] = -1 * np.sin(sp[2])\n vmat[2, 1] = np.cos(sp[2])\n vmat[2, 2] = 0\n\n return vmat\n\n\ndef cartvec2sph(sp, vec):\n \"\"\"\n Transforms cartesian vector to spherical coordinates.\n\n Parameters\n ----------\n sp: Nx3 array\n spherical coordinates [r, theta, phi]\n vec: Nx3 array\n vector in cartesian coordinates [e_x, e_y, e_z]\n\n Returns\n -------\n svec: Nx3 array\n vector in spherical coordinates [e_r, e_theta, e_phi]\n\n \"\"\"\n\n svec = np.zeros(vec.shape)\n for i in range(sp.shape[0]):\n vmat = Rotmatrix(sp[i])\n svec[i] = vmat @ vec[i]\n return svec\n\n\ndef sphvec2cart(sp, vec):\n \"\"\"\n Transforms cartesian vector to spherical coordinates.\n\n Parameters\n ----------\n sp: Nx3 array\n spherical coordinates [r, theta, phi]\n vec: Nx3 array\n vector in spherical coordinates [e_r, e_theta, e_phi]\n\n Returns\n -------\n svec: Nx3 array\n vector in cartesian coordinates [e_x, e_y, e_z]\n\n \"\"\"\n\n svec = np.zeros(vec.shape)\n for i in range(sp.shape[0]):\n vmat = Rotmatrix(sp[i])\n svec[i] = np.transpose(vmat) @ vec[i]\n\n return svec\n\n\n############################################\n# Functions for generating Legendre polynomials,\n# real spherical harmonics and vector spherical harmonics\n\n\ndef lpmn_em(l, m, x):\n \"\"\"\n Computes associated Legendre function (Plm) of the first kind of order m and degree l.\n\n Parameters\n ----------\n\n l: int\n degree of Plm\n m: int\n order of Plm\n x: Nx1 array\n evaluation points\n\n Returns\n -------\n lp: Nx1 array\n Plm at `x`\n\n \"\"\"\n\n lp = np.zeros(x.shape)\n for i in range(x.shape[0]):\n a, b = lpmn(m, l, x[i])\n lp[i] = a[np.abs(m), l]\n return lp\n\n\ndef derlpmn_em(l, m, x):\n \"\"\"\n Computes derivative of associated Legendre function (Plm) of the first kind of order m and degree l\n with respect to the argument x.\n\n Parameters\n ----------\n l: int\n degree of Plm\n m: int\n order of Plm\n x: Nx1 array\n evaluation points\n\n Returns\n -------\n derlp: Nx1 array\n dPlm/dx at `x`\n\n \"\"\"\n\n derlp = np.zeros(x.shape)\n for i in range(x.shape[0]):\n a, b = lpmn(m, l, x[i])\n derlp[i] = b[np.abs(m), l]\n return derlp\n\n\ndef xlm(l, m, theta):\n \"\"\"\n Xlm-function used in the definition of spherical harmonics (Ylm).\n Follows notation of Plattner and Simons (2014);\n see Eqs. 1--3 in https://arxiv.org/pdf/1306.3201.pdf.\n\n Parameters\n ----------\n l: int\n degree of Xlm\n m: int\n order of Xlm\n theta: Nx1 array\n evaluation points, theta at spherical coordinates\n\n Returns\n -------\n Xlm: Nx1 array\n Xlm at theta\n\n \"\"\"\n\n xlm = ((2 * l + 1) / (4 * np.pi)) ** 0.5 * (\n factorial(l - m) / factorial(l + m)\n ) ** 0.5\n xlm *= lpmn_em(l, m, np.cos(theta))\n return xlm\n\n\ndef ylm(l, m, theta, phi):\n \"\"\"\n Real spherical harmonics as defined by Plattner and Simons (2014);\n see Eqs. 1--3 in https://arxiv.org/pdf/1306.3201.pdf.\n\n Parameters\n ----------\n l: int\n degree of Ylm\n m: int\n order of Ylm\n theta: Nx1 array\n evaluation points, theta at spherical coordinates\n phi: Nx1 array\n evaluation points, phi at spherical coordinates\n\n Returns\n -------\n Ylm: Nx1 array\n Ylm at (theta,phi)\n\n \"\"\"\n\n if m < 0:\n ylm = np.sqrt(2) * xlm(l, m, theta) * np.cos(m * phi)\n elif m == 0:\n ylm = xlm(l, 0, theta)\n elif m > 0:\n ylm = np.sqrt(2) * xlm(l, m, theta) * np.sin(m * phi)\n\n return ylm\n\n\ndef derxlm(l, m, theta):\n \"\"\"\n Derivative of Xlm with respect to theta.\n\n Parameters\n ----------\n l: int\n degree of Xlm\n m: int\n order of Xlm\n theta: Nx1 array\n evaluation points, theta at spherical coordinates\n\n Returns\n -------\n derxlm: Nx1 array\n dXlm/dtheta at theta\n\n \"\"\"\n\n derxlm = ((2 * l + 1) / (4 * np.pi)) ** 0.5 * (\n factorial(l - m) / factorial(l + m)\n ) ** 0.5\n derxlm *= derlpmn_em(l, m, np.cos(theta))\n derxlm *= -1 * np.sin(\n theta\n ) # this comes from dXlm(cos(theta))/dtheta = dXlm(cos(theta))/dcos(theta)*(-sin(theta))\n return derxlm\n\n\ndef sinxlm(l, m, theta):\n \"\"\"\n Computes m/(sin(theta))*Xlm.\n\n Parameters\n ----------\n l: int\n degree of Xlm\n m: int\n order of Xlm\n theta: Nx1 array\n evaluation points, theta at spherical coordinates\n\n Returns\n -------\n sinxlm: Nx1 array\n m/(sin(theta))*Xlm at theta\n\n \"\"\"\n\n sinxlm = m / (np.sin(theta)) * xlm(l, m, theta)\n return sinxlm\n\n\ndef dthylm(l, m, theta, phi):\n \"\"\"\n Derivative of Ylm with respect to theta dYlm/dtheta.\n\n Parameters\n ----------\n l: int\n degree of Ylm\n m: int\n order of Ylm\n theta: Nx1 array\n evaluation points, theta at spherical coordinates\n phi: Nx1 array\n evaluation points, phi at spherical coordinates\n\n Returns\n -------\n dthylm: Nx1 array\n dYlm/dtheta at (theta, phi).\n\n \"\"\"\n\n if m < 0:\n dthylm = np.sqrt(2) * derxlm(l, m, theta) * np.cos(m * phi)\n elif m == 0:\n dthylm = derxlm(l, 0, theta)\n elif m > 0:\n dthylm = np.sqrt(2) * derxlm(l, m, theta) * np.sin(m * phi)\n return dthylm\n\n\ndef dphiylm(l, m, theta, phi):\n \"\"\"\n Derivative of Ylm with respect to phi dYlm/dphi.\n\n Parameters\n ----------\n l: int\n degree of Ylm\n m: int\n order of Ylm\n theta: Nx1 array\n evaluation points, theta at spherical coordinates\n phi: Nx1 array\n evaluation points, phi at spherical coordinates\n\n Returns\n -------\n dphiylm: Nx1 array\n dYlm/dphi at (theta, phi).\n\n \"\"\"\n\n if m < 0:\n dphiylm = -np.sqrt(2) * np.sin(m * phi) * sinxlm(l, m, theta)\n elif m == 0:\n dphiylm = 0\n elif m > 0:\n dphiylm = np.sqrt(2) * np.cos(m * phi) * sinxlm(l, m, theta)\n return dphiylm\n\n\ndef Plm(l, m, theta, phi):\n \"\"\"\n Plm vector function (see Eq. 18 Plattner and Simons (2014)).\n\n Parameters\n ----------\n l: int\n degree of Plm\n m: int\n order of Plm\n theta: Nx1 array\n evaluation points, theta at spherical coordinates\n phi: Nx1 array\n evaluation points, phi at spherical coordinates\n\n Returns\n -------\n Plm: Nx3 array\n Plm at (theta, phi).\n\n \"\"\"\n\n Plm = np.zeros((theta.shape[0], 3))\n Plm[:, 0] = ylm(l, m, theta, phi)\n return Plm\n\n\ndef Blm(l, m, theta, phi):\n \"\"\"\n Blm vector function (see Eq. 19 Plattner and Simons (2014)).\n\n Parameters\n ----------\n l: int\n degree of Plm\n m: int\n order of Plm\n theta: Nx1 array\n evaluation points, theta at spherical coordinates\n phi: Nx1 array\n evaluation points, phi at spherical coordinates\n\n Returns\n -------\n Blm: Nx3 array\n Blm at (theta, phi).\n\n \"\"\"\n\n Blm = np.zeros((theta.shape[0], 3))\n\n Blm[:, 1] = dthylm(l, m, theta, phi)\n\n Blm[:, 2] = dphiylm(l, m, theta, phi)\n\n Blm *= 1 / np.sqrt(l * (l + 1))\n return Blm\n\n\ndef Wlm(l, m, theta, phi):\n \"\"\"\n Vector basis function (Wlm) for r**l component of the magnetic field.\n Normalization <Wlm,Wkn> = delta_lk,mn.\n\n Parameters\n ----------\n l: int\n degree of Wlm\n m: int\n order of Wlm\n theta: Nx1 array\n evaluation points, theta at spherical coordinates\n phi: Nx1 array\n evaluation points, phi at spherical coordinates\n\n Returns\n -------\n Wlm: Nx3 array\n Wlm at (theta, phi).\n\n \"\"\"\n\n Wlm = l * Plm(l, m, theta, phi) + np.sqrt(l * (l + 1)) * Blm(l, m, theta, phi)\n Wlm *= 1 / np.sqrt(2 * l ** 2 + l)\n return Wlm\n\n\ndef Vlm(l, m, theta, phi):\n \"\"\"\n Vector basis function (Vlm) for r**(-l) component of the magnetic field.\n Normalization <Vlm,Vkn> = delta_lk,mn.\n\n Parameters\n ----------\n l: int\n degree of Vlm\n m: int\n order of Vlm\n theta: Nx1 array\n evaluation points, theta at spherical coordinates\n phi: Nx1 array\n evaluation points, phi at spherical coordinates\n\n Returns\n -------\n Vlm: Nx3 array\n Vlm at (theta, phi).\n\n \"\"\"\n\n Vlm = -1 * (l + 1) * Plm(l, m, theta, phi) + np.sqrt(l * (l + 1)) * Blm(\n l, m, theta, phi\n )\n Vlm *= 1 / np.sqrt((l + 1) * (2 * l + 1))\n return Vlm\n\n\ndef Xlm(l, m, theta, phi):\n \"\"\"\n Vector spherical harmonics basis function (Xlm).\n Normalization <Xlm,Xkn> = delta_lk,mn.\n\n Parameters\n ----------\n l: int\n degree of Xlm\n m: int\n order of Xlm\n theta: Nx1 array\n evaluation points, theta at spherical coordinates\n phi: Nx1 array\n evaluation points, phi at spherical coordinates\n\n Returns\n -------\n Xlm: Nx3 array\n Xlm at (theta, phi).\n\n \"\"\"\n\n temp = Blm(l, m, theta, phi)\n r = np.zeros(temp.shape)\n r[:, 0] = 1\n Xlm = -1 * np.cross(r, temp, axis=1)\n return Xlm\n\n\n############################################\n# Potential and field from the spherical harmonics\n\n\ndef basis_potentials(p, lmax, normalization=\"default\", R=1):\n \"\"\"\n Computes inner/outer basis functions for magnetic scalar potential.\n Ignores the 'DC' component l=0.\n\n Parameters\n ----------\n p: Nx3 array\n coordinates in which the potential is computed\n lmax: int\n maximum degree l which is used in computing\n normalization: string\n which normalization scheme to use\n \"default\": Integration over unit sphere <Y_lm,Y_l'm'> = delta_ll'mm' (default)\n \"energy\": each term in inner/outer basis function with respect to\n sphere with radius R is normalized to unit energy\n R: float\n Sphere radius that separates inner/outer components\n\n Returns\n -------\n pot1: Nxlmax*(lmax+2) array\n inner potential (alpha_lm) basis functions at p\n pot2: Nxlmax*(lmax+2) array\n outer potential (beta_lm) basis functions at p\n\n \"\"\"\n mu0 = 1e-7 * 4 * np.pi\n L = lmax * (lmax + 2)\n\n pot1 = np.zeros((p.shape[0], L))\n pot2 = np.zeros((p.shape[0], L))\n\n sp = cartesian2spherical(p)\n\n lind = 0\n for l in range(1, lmax + 1):\n for m in range(-1 * l, l + 1):\n _ylm = ylm(l, m, sp[:, 1], sp[:, 2])\n\n pot1[:, lind] = sp[:, 0] ** (-l - 1) * _ylm\n pot2[:, lind] = sp[:, 0] ** l * _ylm\n\n if normalization == \"energy\":\n pot1[:, lind] *= np.sqrt(R ** (2 * l + 1) / ((l + 1) * mu0))\n pot2[:, lind] *= 1 / np.sqrt(R ** (2 * l + 1) * l * mu0)\n\n lind += 1\n\n return pot1, pot2\n\n\ndef potential(p, acoeffs, bcoeffs, lmax, normalization=\"default\", R=1):\n \"\"\"\n Computes magnetic scalar potential from the sph coefficients.\n Ignores the 'DC' component l=0.\n\n Parameters\n ----------\n p: Nx3 array\n coordinates in which the potential is computed\n acoeffs: lmax*(lmax+2)x1 array\n spectral coefficients of r**l terms\n bcoeffs: lmax*(lmax+2)x1 array\n spectral coefficients of r**(-l) terms\n lmax: int\n maximum degree l which is used in computing\n normalization: string\n which normalization scheme to use\n \"default\": Integration over unit sphere <Y_lm,Y_l'm'> = delta_ll'mm' (default)\n \"energy\": each term in inner/outer basis function with respect to\n sphere with radius R is normalized to unit energy\n R: float\n Sphere radius that separates inner/outer components\n\n Returns\n -------\n pot1: Nx array\n magnetic scalar potential at p\n\n \"\"\"\n\n basis = basis_potentials(p, lmax, normalization, R)\n\n return basis[0] @ acoeffs + basis[1] @ bcoeffs\n\n\ndef field(p, acoeffs, bcoeffs, lmax, normalization=\"default\", R=1):\n \"\"\"\n Computes magnetic field at some point from the sph coefficients.\n Ignores the 'DC' component l=0.\n\n Parameters\n ----------\n p: Nx3 array\n coordinates in which the potential is computed\n acoeffs: lmax*(lmax+2)x1 array\n spectral coefficients of r**l terms\n bcoeffs: lmax*(lmax+2)x1 array\n spectral coefficients of r**(-l) terms\n lmax: int\n maximum degree l which is used in computing\n normalization: string\n \"default\": the fields correspond to normalized magnetic potential.\n \"unit\": the fields are normalized w.r.t integration over the unit sphere.\n \"energy\": each term in inner/outer basis function with respect to\n sphere with radius R is normalized to unit energy\n R: float\n Sphere radius that separates inner/outer components\n\n Returns\n -------\n B: Nx3 array\n Magnetic field produced by the sph components\n \"\"\"\n\n basis = basis_fields(p, lmax, normalization=normalization, R=R)\n\n return basis[0] @ acoeffs + basis[1] @ bcoeffs\n\n\ndef basis_fields(p, lmax, normalization=\"default\", R=1):\n \"\"\"\n Computes magnetic field of each sph coefficient.\n Ignores the 'DC' component l=0.\n\n Parameters\n ----------\n p: Nx3 array\n coordinates in which the field is computed\n lmax: int\n maximum degree l used in the computation\n normalization: string\n \"default\": the fields correspond to magnetic normalized potential.\n \"unit\": the fields are normalized w.r.t integration over the unit sphere.\n \"energy\": each term in inner/outer basis function with respect to\n sphere with radius R is normalized to unit energy\n R: float\n Sphere radius that separates inner/outer components\n\n Returns\n -------\n B1: N x 3 x N_lmax array\n magnetic field at p for each alpha_lm\n B2: N x 3 x N_lmax array\n magnetic field at p for each beta_lm\n\n \"\"\"\n mu0 = 1e-7 * 4 * np.pi\n L = lmax * (lmax + 2) # Fixed\n B1 = np.zeros((L, p.shape[0], p.shape[1]))\n B2 = np.zeros((L, p.shape[0], p.shape[1]))\n\n sp = cartesian2spherical(p)\n\n idx = 0\n for l in range(1, lmax + 1):\n for m in range(-1 * l, l + 1):\n _Wlm = Wlm(l, m, sp[:, 1], sp[:, 2])\n _Wlm[:, 0] *= sp[:, 0] ** (l - 1)\n _Wlm[:, 1] *= sp[:, 0] ** (l - 1)\n _Wlm[:, 2] *= sp[:, 0] ** (l - 1)\n\n if normalization == \"default\":\n _Wlm *= np.sqrt(2 * l ** 2 + l) * mu0\n if normalization == \"energy\":\n _Wlm *= np.sqrt(2 * l ** 2 + l) * mu0\n _Wlm *= 1 / np.sqrt(R ** (2 * l + 1) * l * mu0)\n\n _Wlm = sphvec2cart(sp, _Wlm)\n B2[idx] = -1 * _Wlm # r**l functions\n\n _Vlm = Vlm(l, m, sp[:, 1], sp[:, 2])\n if normalization == \"default\":\n _Vlm *= np.sqrt((2 * l + 1) * (l + 1)) * mu0\n if normalization == \"energy\":\n _Vlm *= np.sqrt((2 * l + 1) * (l + 1)) * mu0\n _Vlm *= np.sqrt(R ** (2 * l + 1) / ((l + 1) * mu0))\n\n _Vlm[:, 0] *= sp[:, 0] ** (-l - 2)\n _Vlm[:, 1] *= sp[:, 0] ** (-l - 2)\n _Vlm[:, 2] *= sp[:, 0] ** (-l - 2)\n _Vlm = sphvec2cart(sp, _Vlm)\n B1[idx] = -1 * _Vlm # 1/r**l functions\n\n idx += 1\n\n # FIX, should be handled earlier maybe\n B1[np.isinf(B1)] = 0\n B2[np.isinf(B2)] = 0\n\n return np.moveaxis(B1, 0, 2), np.moveaxis(B2, 0, 2)\n\n\ndef compute_sphcoeffs_mesh(mesh, lmax, normalization=\"default\", R=1):\n \"\"\"\n Computes multipole moment (spherical harmonics coefficient) transformation\n from the mesh.\n\n Parameters\n ----------\n mesh: mesh object - the surface mesh\n lmax: int\n maximum degree l of the fit\n normalization: str\n 'default' (Ylm**2 integrated over solid angle to 1)\n 'energy' (field energy of basis fields normalized to 1 in R-ball)\n R: float\n radius in the energy normalization\n Returns\n -------\n Calm: (lmax*(lmax+2)xNvertices array\n transformation from the mesh to alm coefficients (r**l-terms)\n Cblm: (lmax*(lmax+2)xNvertices array\n transformation from the mesh to blm coefficients (r**(-l)-terms)\n\n \"\"\"\n mu0 = 1e-7 * 4 * np.pi\n\n Gx, Gy, Gz = gradient_matrix(mesh, rotated=True)\n tri_normals, tri_areas = tri_normals_and_areas(mesh.vertices, mesh.faces)\n\n centers = np.mean(mesh.vertices[mesh.faces], axis=1)\n centers_sp = cartesian2spherical(centers)\n\n Calm = np.zeros((lmax * (lmax + 2), mesh.vertices.shape[0]))\n Cblm = np.zeros((lmax * (lmax + 2), mesh.vertices.shape[0]))\n\n idx = 0\n for l in range(1, lmax + 1):\n for m in range(-1 * l, l + 1):\n _Xlm = sphvec2cart(centers_sp, Xlm(l, m, *centers_sp[:, 1:].T))\n # Multiply by the normalization factor, and tri areas\n _Xlm *= np.sqrt(l * (l + 1)) * tri_areas[:, None]\n # alm ja blm have different r-dependencies\n alm_terms = _Xlm.T * (centers_sp[:, 0] ** (l))\n blm_terms = _Xlm.T * (centers_sp[:, 0] ** (-l - 1))\n\n # Combine rotated gradient (operates on stream function -> j)\n integral_alm = alm_terms[0] @ Gx + alm_terms[1] @ Gy + alm_terms[2] @ Gz\n integral_blm = blm_terms[0] @ Gx + blm_terms[1] @ Gy + blm_terms[2] @ Gz\n # Default normalization\n Cblm[idx] = -1 / ((2 * l + 1) * l) * integral_blm\n Calm[idx] = 1 / ((2 * l + 1) * (l + 1)) * integral_alm\n if normalization == \"energy\":\n Cblm[idx] *= np.sqrt(R ** (2 * l + 1) * l * mu0)\n Calm[idx] *= np.sqrt(((l + 1) * mu0) / (R ** (2 * l + 1)))\n\n idx += 1\n print(\"l = %d computed\" % (l))\n\n return Calm, Cblm\n\n\n###################################\n# sph class\n\n\nclass SphBasis:\n \"\"\"\n Constructs an object that describes unit sphere. Can be used to compute\n inner products and function sph spectra on the sphere.\n\n TODO: mu0 might be missing!!!\n\n Properties\n ----------\n sp: Nx3 array\n spherical coordinates of the points [r, theta, phi]\n p: Nx3 array\n cartesian coordinates\n qp: Mx3 array\n cartesian quadrature points\n sqp: Mx3 array\n spherical quadrature points\n \"\"\"\n\n def __init__(self, Np):\n \"\"\"\n Initialises the sphbasis object.\n\n Parameters\n ----------\n Np: int\n Mumber of points along theta and phi in spherical coordinates\n\n Returns\n -------\n self: sphbasis object\n\n \"\"\"\n\n theta = np.linspace(0.01, np.pi - 0.01, Np)\n phi = np.linspace(0, 2 * np.pi, Np)\n phi, theta = np.meshgrid(phi, theta)\n phi = phi.flatten()\n theta = theta.flatten()\n\n self.sp = np.zeros((theta.shape[0], 3))\n self.sp[:, 0] = 1\n self.sp[:, 1] = theta\n self.sp[:, 2] = phi\n\n self.p = spherical2cartesian(self.sp)\n self.Np = Np\n\n self.initqp()\n\n def initqp(self):\n \"\"\"\n Initialises quadrature points on the sphere.\n\n Default points are McLaren(10) so that we avoid singularities.\n \"\"\"\n\n self.qp = sphere.mclaren_10()\n sp = cartesian2spherical(self.qp.points)\n self.sqp = sp\n\n def innerproduct(self, fun1, fun2):\n \"\"\"\n Inner product of vector functions fun1 and fun2.\n Defined as integration over a surface of unit sphere <C,D> = int C dot D dOmega.\n Quadrature rule defined in qp is used.\n\n Parameters\n ----------\n fun1: Nx3 array\n vector function 1\n fun2: Nx3 array\n vector function 2\n\n Returns\n -------\n dotp: int\n inner product of fun1 and fun2\n\n \"\"\"\n\n dotp = np.sum(self.qp.weights * np.sum(fun1 * fun2, axis=1)) * 4 * np.pi\n return dotp\n\n def avsphspectra(self, fun, lmax):\n \"\"\"\n Calculate the l,m-spectra (over r**l-terms) of vector function defined in quadrature points\n using the inner product.\n\n Parameters\n ----------\n fun: Nx3 array\n vector function computed at quadrature points self.sqp\n lmax: int\n maximum degree l for which the spectra is computed\n\n Returns\n -------\n coeffs: lmax*(lmax+2)x1 arrays\n spectral coefficients\n\n \"\"\"\n\n coeffs = []\n\n for l in range(1, lmax + 1):\n for m in range(-1 * l, l + 1):\n _Wlm = Wlm(l, m, self.sqp[:, 1], self.sqp[:, 2])\n ctemp = self.innerproduct(fun, _Wlm)\n ctemp /= self.sqp[0, 0] ** (l - 1) * np.sqrt(\n 2 * l ** 2 + l\n ) # we use this normalization\n # ctemp /= (self.sqp[0,0]**(l-1))\n coeffs.append(ctemp)\n\n coeffs = np.array(coeffs)\n return coeffs\n\n def bvsphspectra(self, fun, lmax):\n \"\"\"\n Calculate the l,m-spectra (over r**(-l)-terms) of vector function defined in quadrature points\n using the inner product.\n\n Parameters\n ----------\n fun: Nx3 array\n vector function computed at quadrature points self.sqp\n lmax: int\n maximum degree l for which the spectra is computed\n\n Returns\n -------\n coeffs: lmax*(lmax+2)x1 arrays\n spectral coefficients\n\n \"\"\"\n\n coeffs = []\n\n for l in range(1, lmax + 1):\n for m in range(-1 * l, l + 1):\n _Vlm = Vlm(l, m, self.sqp[:, 1], self.sqp[:, 2])\n ctemp = self.innerproduct(fun, _Vlm)\n ctemp /= self.sqp[0, 0] ** (l - 1) * np.sqrt(\n (l + 1) * (2 * l + 1)\n ) # we use this normalization\n # ctemp /= (self.sqp[0,0]**(l-1))\n coeffs.append(ctemp)\n\n coeffs = np.array(coeffs)\n return coeffs\n\n\n###################################\n# Functions for plotting spherical harmonics\n\n\ndef plotYlms(sph, lmax, polar=False):\n \"\"\"\n Plots real spherical harmonics up to lmax.\n Inspired by https://docs.enthought.com/mayavi/mayavi/auto/example_spherical_harmonics.html.\n\n Parameters\n ----------\n sph: spherical harmonics analysis object\n lmax: int\n\n maximum degree l\n polar: boolean\n plot polar representation?\n \"\"\"\n from mayavi import mlab\n\n theta = np.reshape(sph.sp[:, 1], (sph.Np, sph.Np))\n phi = np.reshape(sph.sp[:, 2], (sph.Np, sph.Np))\n r = 0.4\n x = r * np.sin(theta) * np.cos(phi)\n y = r * np.sin(theta) * np.sin(phi)\n z = r * np.cos(theta)\n\n if polar:\n for l in range(1, lmax + 1):\n for m in range(l):\n _ylm = ylm(l, m, theta.flatten(), phi.flatten())\n _ylm = np.reshape(_ylm, (sph.Np, sph.Np))\n\n mlab.mesh(x - m, y - l, z, scalars=_ylm, colormap=\"bwr\")\n _ylm /= _ylm.max()\n mlab.mesh(\n _ylm * x - m,\n _ylm * y - l,\n _ylm * z + 1.3,\n scalars=np.abs(_ylm),\n colormap=\"Spectral\",\n )\n\n mlab.view(90, 70, 6.2, (-1.3, -2.9, 0.25))\n else:\n for l in range(0, lmax + 1):\n for m in range(-l, l + 1):\n _ylm = ylm(l, m, theta.flatten(), phi.flatten())\n _ylm = np.reshape(_ylm, (sph.Np, sph.Np))\n\n mlab.mesh(x - m, y - l, z, scalars=_ylm, colormap=\"bwr\")\n\n mlab.view(0, 180)\n\n\ndef plotYlm(sph, l, m):\n \"\"\"\n Plots real spherical harmonics of order m and degree l.\n Inspired by https://docs.enthought.com/mayavi/mayavi/auto/example_spherical_harmonics.html\n\n Parameters\n ----------\n sph: spherical harmonics analysis object\n l: int\n degree l\n m: int\n order m\n\n \"\"\"\n from mayavi import mlab\n\n theta = np.reshape(sph.sp[:, 1], (sph.Np, sph.Np))\n phi = np.reshape(sph.sp[:, 2], (sph.Np, sph.Np))\n r = 0.6\n x = r * np.sin(theta) * np.cos(phi)\n y = r * np.sin(theta) * np.sin(phi)\n z = r * np.cos(theta)\n\n _ylm = ylm(l, m, theta.flatten(), phi.flatten())\n _ylm = np.reshape(_ylm, (sph.Np, sph.Np))\n\n mlab.mesh(x - m, y - l, z, scalars=_ylm, colormap=\"bwr\")\n\n _ylm /= _ylm.max()\n mlab.mesh(\n _ylm * x - m,\n _ylm * y - l,\n _ylm * z + 1.3,\n scalars=np.abs(_ylm),\n colormap=\"Spectral\",\n )\n\n\ndef plotWlm(sph, l, m):\n \"\"\"\n Plots magnetic field basis function 'Wlm' (r**l) over a sphere.\n\n Parameters\n ----------\n sph: spherical harmonics analysis object\n l: int\n degree l\n m: int\n order m\n\n Returns\n -------\n obj: mayavi object\n\n \"\"\"\n from mayavi import mlab\n\n _Wlm = Wlm(l, m, sph.sp[:, 1], sph.sp[:, 2])\n _Wlm = sphvec2cart(sph.sp, _Wlm)\n obj = mlab.quiver3d(\n sph.p[:, 0], sph.p[:, 1], sph.p[:, 2], _Wlm[:, 0], _Wlm[:, 1], _Wlm[:, 2]\n )\n obj.glyph.glyph_source.glyph_source.center = np.array((0, 0, 0))\n return obj\n\n\ndef plotBWlm_volume(sph, l, m, lim, Np, offset):\n \"\"\"\n Plots magnetic field basis function 'Wlm' (r**l) over a 3D volume.\n\n Parameters\n ----------\n sph: spherical harmonics analysis object\n l: int\n degree l\n m: int\n order m\n lim: float\n limits for coordinates, e.g., xmin = -lim, xmax = lim\n Np: int\n number of points along different coordinates\n offset: 1x3 array\n offset of the volume in which Wlm is plotted\n\n Returns\n -------\n obj: mayavi object\n\n \"\"\"\n\n from mayavi import mlab\n\n x, y, z = np.meshgrid(\n np.linspace(-lim + offset[0], lim + offset[0], Np),\n np.linspace(-lim + offset[1], lim + offset[1], Np),\n np.linspace(-lim + offset[2], lim + offset[2], Np),\n )\n\n p = np.array((x.flatten(), y.flatten(), z.flatten())).T\n sp = cartesian2spherical(p)\n\n _Wlm = Wlm(l, m, sp[:, 1], sp[:, 2])\n _Wlm *= np.sqrt(2 * l ** 2 + l)\n _Wlm[:, 0] *= sp[:, 0] ** (l - 1)\n _Wlm[:, 1] *= sp[:, 0] ** (l - 1)\n _Wlm[:, 2] *= sp[:, 0] ** (l - 1)\n\n _Wlm = sphvec2cart(sp, _Wlm)\n obj = mlab.quiver3d(p[:, 0], p[:, 1], p[:, 2], _Wlm[:, 0], _Wlm[:, 1], _Wlm[:, 2])\n obj.glyph.glyph_source.glyph_source.center = np.array((0, 0, 0))\n return obj\n\n\ndef plotVlm(sph, l, m):\n \"\"\"\n Plots magnetic field basis function 'Vlm' (r**(-l)) over a sphere.\n\n Parameters\n ----------\n sph: spherical harmonics analysis object\n l: int\n degree l\n m: int\n order m\n\n Returns\n -------\n obj: mayavi object\n\n \"\"\"\n from mayavi import mlab\n\n _Vlm = Vlm(l, m, sph.sp[:, 1], sph.sp[:, 2])\n _Vlm = sphvec2cart(sph.sp, _Vlm)\n obj = mlab.quiver3d(\n sph.p[:, 0], sph.p[:, 1], sph.p[:, 2], _Vlm[:, 0], _Vlm[:, 1], _Vlm[:, 2]\n )\n obj.glyph.glyph_source.glyph_source.center = np.array((0, 0, 0))\n return obj\n\n\ndef plotBVlm_volume(sph, l, m, lim, Np, offset):\n \"\"\"\n Plots magnetic field basis function 'Vlm' (r**(-l)) over a 3D volume.\n\n Parameters\n ----------\n sph: spherical harmonics analysis object\n l: int\n degree l\n m: int\n order m\n lim: float\n limits for coordinates, e.g., xmin = -lim, xmax = lim\n Np: int\n number of points along different coordinates\n offset: 1x3 array\n offset of the volume in which Vlm is plotted\n\n Returns\n -------\n obj: mayavi object\n\n \"\"\"\n from mayavi import mlab\n\n x, y, z = np.meshgrid(\n np.linspace(-lim + offset[0], lim + offset[0], Np),\n np.linspace(-lim + offset[1], lim + offset[1], Np),\n np.linspace(-lim + offset[2], lim + offset[2], Np),\n )\n\n p = np.array((x.flatten(), y.flatten(), z.flatten())).T\n sp = cartesian2spherical(p)\n\n _Vlm = Vlm(l, m, sp[:, 1], sp[:, 2])\n _Vlm *= np.sqrt((l + 1) * (2 * l + 1))\n\n _Vlm[:, 0] *= sp[:, 0] ** (-1 * (l + 2))\n _Vlm[:, 1] *= sp[:, 0] ** (-1 * (l + 2))\n _Vlm[:, 2] *= sp[:, 0] ** (-1 * (l + 2))\n\n _Vlm = sphvec2cart(sp, _Vlm)\n obj = mlab.quiver3d(p[:, 0], p[:, 1], p[:, 2], _Vlm[:, 0], _Vlm[:, 1], _Vlm[:, 2])\n obj.glyph.glyph_source.glyph_source.center = np.array((0, 0, 0))\n return obj\n\n\ndef plotXlm(sph, l, m):\n \"\"\"\n Plots vector spherical harmonic basis function 'Xlm' over a sphere.\n\n Parameters\n ----------\n sph: spherical harmonics analysis object\n l: int\n degree l\n m: int\n order m\n\n Returns\n -------\n obj: mayavi object\n\n \"\"\"\n from mayavi import mlab\n\n _Xlm = Xlm(l, m, sph.sp[:, 1], sph.sp[:, 2])\n _Xlm = sphvec2cart(sph.sp, _Xlm)\n obj = mlab.quiver3d(\n sph.p[:, 0], sph.p[:, 1], sph.p[:, 2], _Xlm[:, 0], _Xlm[:, 1], _Xlm[:, 2]\n )\n obj.glyph.glyph_source.glyph_source.center = np.array((0, 0, 0))\n return obj\n"
] | [
[
"numpy.isinf",
"numpy.array",
"numpy.sin",
"numpy.meshgrid",
"numpy.reshape",
"numpy.zeros",
"numpy.sum",
"numpy.mean",
"numpy.transpose",
"numpy.arctan2",
"numpy.cos",
"numpy.sqrt",
"scipy.special.lpmn",
"numpy.moveaxis",
"numpy.linspace",
"numpy.abs",
"numpy.cross",
"scipy.special.factorial"
]
] |
vrautela/treadmill | [
"05e47fa8acdf8bad7af78e737efb26ea6488de82"
] | [
"lib/python/treadmill/cli/scheduler/servers.py"
] | [
"\"\"\"Show servers report.\"\"\"\n\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\nfrom __future__ import unicode_literals\n\nimport click\nimport pandas as pd\n\nfrom treadmill import cli\nfrom treadmill.cli.scheduler import fetch_report, print_report\nfrom treadmill import restclient\n\n\ndef init():\n \"\"\"Return top level command handler.\"\"\"\n\n @click.command()\n @cli.handle_exceptions(restclient.CLI_REST_EXCEPTIONS)\n @click.option('--match', help='Server name pattern match')\n @click.option('--partition', help='Partition name pattern match')\n def servers(match, partition):\n \"\"\"View servers report.\"\"\"\n report = fetch_report('servers', match, partition)\n report['valid_until'] = pd.to_datetime(report['valid_until'], unit='s')\n print_report(report)\n\n return servers\n"
] | [
[
"pandas.to_datetime"
]
] |
OMcBrien/imsu | [
"5a060f304a4308d55d7d8c4fc6d3f52e17487e48"
] | [
"imsu/population_generator.py"
] | [
"import sncosmo\nimport random\nimport math\nimport numpy as np\nimport matplotlib\nimport matplotlib.pyplot as plt\nimport matplotlib.path as mpltPath\nimport time\n\n## LAST MODIFIED : April 15, 2013\n## CREATED : April 15, 2013\n## AUTHOR : DRYX\ndef redshift2distance(z):\n \"\"\"Convert a redshift to various distance units\n\n **Key Arguments:**\n - ``z`` -- the redshift to be converted\n\n **Return:**\n - ``results`` -- result dictionary including\n - ``dcmr_mpc`` -- co-moving radius distance\n - ``da_mpc`` -- angular distance\n - ``da_scale`` -- angular distance scale\n - ``dl_mpc`` -- luminosity distance (usually use this one)\n - ``dmod`` -- distance modulus (determined from luminosity distance)\n \"\"\"\n ################ > IMPORTS ################\n ## STANDARD LIB ##\n ## THIRD PARTY ##\n ## LOCAL APPLICATION ##\n\n ################ >ACTION(S) ################\n # Cosmological Parameters (to be changed if required)\n WM = 0.3 # Omega_matter\n WV = 0.7 # Omega_vacuum\n H0 = 70.0 # Hubble constant (km s-1 Mpc-1)\n\n # Other variables\n h = H0/100.0\n WR = 4.165E-5/(h*h) # Omega_radiation\n WK = 1.0-WM-WV-WR # Omega_curvature = 1 - Omega(Total)\n c = 299792.458 # speed of light (km/s)\n\n # Arbitrarily set the values of these variables to zero just so we can define them.\n DCMR = 0.0 # comoving radial distance in units of c/H0\n DCMR_Mpc = 0.0 # comoving radial distance in units of Mpc\n DA = 0.0 # angular size distance in units of c/H0\n DA_Mpc = 0.0 # angular size distance in units of Mpc\n DA_scale = 0.0 # scale at angular size distance in units of Kpc / arcsec\n DL = 0.0 # luminosity distance in units of c/H0\n DL_Mpc = 0.0 # luminosity distance in units of Mpc\n DMOD = 0.0 # Distance modulus determined from luminosity distance\n a = 0.0 # 1/(1+z), the scale factor of the Universe\n\n az = 1.0/(1.0+z) # 1/(1+z), for the given redshift\n\n # Compute the integral over a=1/(1+z) from az to 1 in n steps\n n = 1000\n for i in range(n):\n a = az+(1.0-az)*(i+0.5)/n\n adot = math.sqrt(WK+ (WM/a) + (WR/(math.pow(a,2))) +(WV*math.pow(a,2)))\n DCMR = DCMR + 1.0/(a*adot)\n\n DCMR = (1.0-az)*DCMR/n # comoving radial distance in units of c/H0\n DCMR_Mpc = (c/H0)*DCMR # comoving radial distance in units of Mpc\n\n # Tangental comoving radial distance\n x = math.sqrt(abs(WK))*DCMR\n if x > 0.1:\n if WK > 0.0:\n ratio = 0.5*(math.exp(x)-math.exp(-x))/x\n else:\n ratio = math.sin(x)/x\n else:\n y = math.pow(x,2)\n if WK < 0.0:\n y=-y\n ratio = 1 + y/6.0 + math.pow(y,2)/120.0\n\n DA = az*ratio*DCMR #angular size distance in units of c/H0\n DA_Mpc = (c/H0)*DA #angular size distance in units of Mpc\n DA_scale = DA_Mpc/206.264806 #scale at angular size distance in units of Kpc / arcsec\n DL = DA/math.pow(az,2) #luminosity distance in units of c/H0\n DL_Mpc = (c/H0)*DL #luminosity distance in units of Mpc\n DMOD = 5*math.log10(DL_Mpc*1e6)-5 #Distance modulus determined from luminosity distance\n\n\n results = \\\n {\n \"dcmr_mpc\": DCMR_Mpc,\n \"da_mpc\": DA_Mpc,\n \"da_scale\": DA_scale,\n \"dl_mpc\": DL_Mpc,\n \"dmod\": DMOD,\n \"z\" : z\n }\n\n return results\n\n\n## LAST MODIFIED : April 15, 2013\n## CREATED : April 15, 2013\n## AUTHOR : DRYX\ndef distance2redshift(\n DL_Mpc):\n \"\"\"Convert a luminosity distance to a redshift\n\n **Key Arguments:**\n - ``DL_Mpc`` -- luminosity distance (Mpc)\n\n **Return:**\n - ``redshift`` -- the calculated redshift\n \"\"\"\n ################ > IMPORTS ################\n ## STANDARD LIB ##\n import math\n ## THIRD PARTY ##\n ## LOCAL APPLICATION ##\n\n lowerLimit = 0.\n upperLimit = 1.\n redshift = upperLimit - lowerLimit\n distGuess = float(redshift2distance(redshift)['dl_mpc'])\n\n distDiff = DL_Mpc - distGuess\n\n while math.fabs(distDiff) > 0.01:\n if distGuess < DL_Mpc:\n lowerLimit = redshift\n redshift = lowerLimit + (upperLimit - lowerLimit)/2.\n distGuess = float(redshift2distance(redshift)['dl_mpc'])\n elif distGuess > DL_Mpc:\n upperLimit = redshift\n redshift = lowerLimit + (upperLimit - lowerLimit)/2.\n distGuess = float(redshift2distance(redshift)['dl_mpc'])\n distDiff = DL_Mpc - distGuess\n\n redshift = float(\"%5.4f\" % (redshift,))\n\n return redshift\n \ndef getWeightedDeclination(lower_bound, upper_bound, nbands = 75):\n\n\tdec = np.linspace(lower_bound, upper_bound, nbands)\n\n\tdecl = dec[:-1]\n\tdecu = dec[1:]\n\n\tdecm = (decl + decu) / 2.\n\twdec = np.cos(decm * np.pi/180.)\n\n\tindices = np.arange(0, nbands - 1, 1)\n\n\tthe_index = random.choices(indices, weights = wdec, k = 1)\n\n\treturn random.uniform(decl[the_index[0]], decu[the_index[0]]) \n\n######\n\ndef setTransientIDs(nobjects):\n\n\treturn ['transient_%s' %(str(x)) for x in range(0, nobjects)]\n\ndef setPopulationDistances(nobjects, lightcurve_settings):\n\n\tt0 = time.time()\n\n\tnevents = lightcurve_settings['population']['number to inject']\n\tnshells = 75\n\t\n\tif lightcurve_settings['depth']['min redshift'] == 0.0:\n\t\tmin_redshift = 0.000001\n\telse:\n\t\tmin_redshift = lightcurve_settings['depth']['min redshift']\n\t\n\tmax_redshift = lightcurve_settings['depth']['max redshift']\n\n\tredshift = np.linspace(min_redshift, max_redshift, nshells)\n\n\tredshiftl = redshift[:-1]\n\tredshiftu = redshift[1:]\n\tredshiftm = (redshiftl + redshiftu) / 2.\n\n\tdistancem = [redshift2distance(x)['dl_mpc'] for x in redshiftm]\n\tdistancel = [redshift2distance(x)['dl_mpc'] for x in redshiftl]\n\tdistanceu = [redshift2distance(x)['dl_mpc'] for x in redshiftu]\n\n\n\tvolumem = (4. / 3.)* np.pi * (np.array(distancem))**3\n\tvolumel = (4. / 3.)* np.pi * (np.array(distancel))**3\n\tvolumeu = (4. / 3.)* np.pi * (np.array(distanceu))**3\n\tvolume_total = volumeu[-1]\n\n\twredshift = (volumeu - volumel) / volume_total\n\tindices = np.arange(0, nshells - 1, 1)\n\n\tredshifts = []\n\n\tfor i in range(0, nevents):\n\n\t\tthe_index = random.choices(indices, weights = wredshift, k = 1)\n\t\tredshifts.append(random.uniform(redshiftl[the_index[0]], redshiftu[the_index[0]]))\n\t\n\tdistances = [redshift2distance(x)['dl_mpc'] for x in redshifts]\t\n\t\n\tt1 = time.time()\n\tprint('Distances/redshifts set in %.3f s' %(t1-t0))\n\n\treturn list(distances), list(redshifts)\n\ndef setPopulationExplosionEpochs(nobjects, the_survey, lightcurve_settings):\n\n\tnobjects = lightcurve_settings['population']['number to inject']\n\n\tsurvey_begin = the_survey.begin_jd\n\tsurvey_end = the_survey.end_jd\n\n\texplosion_epochs = [random.uniform( survey_begin, survey_end) for nelements in range(nobjects)]\n\t\n# \tpopulation_settings.update({'explosion epochs': explosion_epochs})\n\n\treturn list(explosion_epochs)\n\t\ndef setPopulationSkyCoords(nobjects, the_survey, lightcurve_settings):\n\n\tmin_ra = the_survey.lower_ra_bound\n\tmax_ra = the_survey.upper_ra_bound\n\tmin_dec = the_survey.lower_dec_bound\n\tmax_dec = the_survey.upper_dec_bound\n\t\n\tras = [random.uniform( min_ra, max_ra) for nelements in range(nobjects)]\n\n\tdecs = []\n\n\tdec = np.linspace(min_dec, max_dec, 50)\n\n\tdecl = dec[:-1]\n\tdecu = dec[1:]\n\n\tdecm = (decl + decu) / 2.\n\twdec = np.cos(decm * np.pi/180.)\n\n\tindices = np.arange(0, 49, 1)\n\n\tfor i in range(0, nobjects):\n\n\t\tthe_index = random.choices(indices, weights = wdec, k = 1)\n\t\tdecs.append(random.uniform(decl[the_index[0]], decu[the_index[0]]))\n\t\n\treturn list(ras), list(decs)\n\ndef setPopulationEllipseSkyCoords(nobjects, the_survey, lightcurve_settings):\n\n\tra_cen = lightcurve_settings['ellipse geometry']['central ra']\n\tdec_cen = lightcurve_settings['ellipse geometry']['central dec']\n\n\ta = lightcurve_settings['ellipse geometry']['semi major axis']\n\tb = lightcurve_settings['ellipse geometry']['semi minor axis']\n\t\n\trot_angle = lightcurve_settings['ellipse geometry']['rotation angle'] * np.pi / 180.\n\n\n\t# regular polygon for testing\n\tlenpoly = 200\n\tpolygon = [[ a*np.cos(x)*np.cos(rot_angle) - b*np.sin(x)*np.sin(rot_angle) + ra_cen, a*np.cos(x)*np.sin(rot_angle) + b*np.sin(x)*np.cos(rot_angle) + dec_cen] for x in np.linspace(0, 2*np.pi,lenpoly)[:-1]]\n\tpolygon = np.array(polygon)\n\n\tpath = mpltPath.Path(polygon)\n\n\tras_inside = np.array([])\n\tdecs_inside = np.array([])\n\t\n\tnobjects_togo = int(nobjects)\n\t\n\n\twhile True:\n\n\t\tcoords_sample = np.array([(random.uniform( ra_cen - a, ra_cen + a ), getWeightedDeclination(dec_cen - a, dec_cen + a) ) for nelements in range(nobjects_togo)])\n\n\t\tinside = path.contains_points(coords_sample)\n\n\t\tras = coords_sample[:,0]\n\t\tdecs = coords_sample[:,1]\n\n\t\tras_inside = np.append(ras_inside, ras[inside])\n\t\tdecs_inside = np.append(decs_inside, decs[inside])\n\t\n\t\tnobjects_togo = nobjects - len(ras_inside)\n\t\n\t\tif len(ras_inside) >= nobjects:\n\t\n\t\t\tbreak\n\n\tfig = plt.figure(figsize = (10,8))\n\tax = plt.subplot(111)\n\tax.grid(True)\n\t\n\tax.plot(polygon[:,0], polygon[:,1], ls = '-', color = 'red')\n\tax.plot(ra_cen, dec_cen, ls = 'None', marker = 'x', ms = 14, mfc = 'red', mec = 'red', zorder = 1000)\n\n\tax.plot(ras_inside, decs_inside, ls = 'None', marker = '.', ms = 3, mfc = 'green', mec = 'None')\n\t# ax.plot(ras[~inside], decs[~inside], ls = 'None', marker = '.', ms = 2, mfc = 'blue', mec = 'None')\n\n\tax.set_xlabel('RA, deg.')\n\tax.set_ylabel('Dec, deg.')\n\n\tax.invert_xaxis()\n\n\tplt.show()\n\n\t\n\treturn list(ras_inside), list(decs_inside)\n\ndef generatePopulation(the_survey, lightcurve_settings):\n\n\tnobjects = lightcurve_settings['population']['number to inject']\n\t\n\ttransient_ids = setTransientIDs(nobjects)\n\tdistances, redshifts = setPopulationDistances(nobjects, lightcurve_settings)\n\texplosion_epochs = setPopulationExplosionEpochs(nobjects, the_survey, lightcurve_settings)\n\tras, decs = setPopulationSkyCoords(nobjects, the_survey, lightcurve_settings)\n\t\n\treturn {'transient_id': transient_ids, 'distances': distances, 'redshifts': redshifts, 'explosion epochs': explosion_epochs, 'ras': ras, 'decs': decs}\n\t\ndef generateGRBPopulation(the_survey, lightcurve_settings):\n\n\tnobjects = lightcurve_settings['population']['number to inject']\n\t\n\ttransient_ids = setTransientIDs(nobjects)\n\tdistances, redshifts = setPopulationDistances(nobjects, lightcurve_settings)\n\texplosion_epochs = setPopulationExplosionEpochs(nobjects, the_survey, lightcurve_settings)\n\tras, decs = setPopulationEllipseSkyCoords(nobjects, the_survey, lightcurve_settings)\n\t\n\treturn {'transient_id': transient_ids, 'distances': distances, 'redshifts': redshifts, 'explosion epochs': explosion_epochs, 'ras': ras, 'decs': decs}\n\n"
] | [
[
"matplotlib.path.Path",
"numpy.array",
"numpy.sin",
"matplotlib.pyplot.figure",
"numpy.arange",
"numpy.cos",
"numpy.append",
"matplotlib.pyplot.show",
"numpy.linspace",
"matplotlib.pyplot.subplot"
]
] |
bjodah/symvarsub | [
"aebbd3aabdc9f8c345c5892f5d3a0beebbbf906d"
] | [
"symvarsub/numtransform/numtransform.py"
] | [
"# -*- coding: utf-8 -*-\n\n\"\"\"\nLightning fast binary callbacks using F90 for array expressions\n\"\"\"\n\nimport os\nimport sysconfig\nfrom collections import defaultdict\n\nimport sympy\nfrom sympy.core.compatibility import iterable\nimport numpy as np\nfrom pycompilation import import_module_from_file, FileNotFoundError\nfrom pycompilation.compilation import FortranCompilerRunner\nfrom pycompilation.util import HasMetaData\nfrom pycodeexport.codeexport import (\n F90_Code, DummyGroup, ArrayifyGroup\n)\n\n\ndef lambdify(args, expr, **kwargs):\n \"\"\"\n Mimics from sympy.utilities.lambdify.lambdify\n but allows to use numpy arrays\n \"\"\"\n if isinstance(args, sympy.Symbol):\n args = [args]\n if not isinstance(expr, list) and not isinstance(expr, tuple):\n expr = [expr]\n return NumTransformer(expr, args, **kwargs)\n\n\nclass NumTransformer(F90_Code, HasMetaData):\n \"\"\"\n The the Transformer instance can export expressions\n (given in `exprs`) to C/Fortran and compile callbacks\n which takes input arrays/scalars (given in `inp`).\n The callback returns a two dimesional array with\n shape: (len(exprs), len(inp))\n \"\"\"\n\n templates = ['transform_template.f90']\n\n build_files = [\n 'prebuilt/transform_wrapper.o',\n 'prebuilt/'+FortranCompilerRunner.metadata_filename, # <-same compiler\n ]\n\n source_files = ['transform.f90']\n\n obj_files = [\n 'transform.o',\n 'transform_wrapper.o',\n ]\n\n so_file = 'transform_wrapper' + sysconfig.get_config_var('SO')\n\n compile_kwargs = {'options': ['pic', 'warn', 'fast']}\n\n def __init__(self, exprs, inp, **kwargs):\n self._exprs = exprs\n self._inp = inp\n\n self._cached_files = self._cached_files or []\n self.basedir = os.path.dirname(__file__)\n\n (self._robust_exprs, self._robust_inp_symbs,\n self._robust_inp_dummies) = self.robustify(self._exprs, self._inp)\n\n super(NumTransformer, self).__init__(**kwargs)\n # Make sure our self._tempdir has not been used\n # previously by another NumTransformer instance\n # (if it has import of the .so file will fail)\n # due to caching of python (if imported previously\n # in this running Python interpreter session)\n\n try:\n hash_ = self.get_from_metadata_file(self._tempdir, 'hash')\n if hash_ == hash(self):\n try:\n self._binary_mod = import_module_from_file(\n self.binary_path)\n except ImportError:\n fmt = 'Failed to import module, try removing \"{}\" in \"{}\"'\n raise ImportError(fmt.format(\n self.metadata_filename, self._tempdir))\n else:\n raise ValueError(\"Hash mismatch (current, old): {}, {}\".format(\n hash(self), hash_))\n except FileNotFoundError:\n self._binary_mod = self.compile_and_import_binary()\n self.save_to_metadata_file(self._tempdir, 'hash', hash(self))\n\n def __hash__(self):\n \"\"\"\n Due to shortcomings of pythons import mechanisms (or *nix OSes?)\n it is not (easily?) possible to reimport a .so file from the _same_\n path if it has been updated. The work-around chosen here\n is to generate a unique `so_file` name for the instance.\n\n Note that we are not guaranteeing absence of hash collisions...\n \"\"\"\n return hash(tuple(self._exprs)+tuple(self._inp))\n\n def robustify(self, exprs, inp):\n dummies = []\n\n def make_dummy(key, not_in_any):\n if isinstance(key, sympy.Function):\n candidate = sympy.Symbol(key.func.__name__, real=key.is_real)\n elif isinstance(key, sympy.Derivative):\n candidate = sympy.Symbol('d'+key.args[0].func.__name__ +\n ''.join('d'+x.name for x\n in key.args[1:]))\n elif isinstance(key, sympy.Symbol):\n candidate = key\n elif isinstance(key, str):\n candidate = sympy.Symbol(key)\n else:\n raise NotImplementedError\n # Now lets make sure the dummie symbol is unique\n if candidate not in dummies and not any(\n [not_in.has(candidate) for not_in in not_in_any]):\n dummies.append(candidate)\n return candidate\n else:\n return make_dummy(candidate.name+'p', not_in_any)\n\n # First let's determine the used keys\n used_keys = []\n used_keys_dummies = []\n derivs = defaultdict(dict)\n\n def any_expr_has(x):\n return any([expr.has(x) for expr in exprs])\n\n for key in filter(any_expr_has, inp):\n used_keys.append(key)\n if isinstance(key, sympy.Symbol):\n used_keys_dummies.append(key)\n else:\n new_dummy = make_dummy(key, not_in_any=exprs)\n used_keys_dummies.append(new_dummy)\n # Determine order of derivative\n if isinstance(key, sympy.Derivative):\n derivorder = len(key.args)-1\n derivs[derivorder][key] = new_dummy\n elif isinstance(key, sympy.Function):\n derivorder = 0\n derivs[derivorder][key] = new_dummy\n elif isinstance(key, sympy.Symbol):\n pass\n else:\n raise NotImplementedError\n\n for n in sorted(derivs.keys())[::-1]:\n # Substitutions of symbolified derivatives\n # need to be made for the highest degrees of\n # derivatives first\n for deriv, symb in derivs[n].items():\n exprs = [expr.subs({deriv: symb}) for expr in exprs]\n\n # Ok, so all Derivative(...) instances in exprs should have\n # been dummyfied - iff user provided all corresponding Derivative(...)\n # as inputs, let's check that now and stop them if they missed any:\n if any_expr_has(sympy.Derivative):\n raise ValueError('All derivatives as input?')\n\n # Now we are almost there..\n # But e.g. z(t) has included t into used_keys\n # we need to double check that t is truly used\n # now that z(t) has been turned into z\n truly_used_keys, truly_used_keys_dummies = [], []\n for k, ks in zip(used_keys, used_keys_dummies):\n if any_expr_has(ks):\n truly_used_keys.append(k)\n truly_used_keys_dummies.append(ks)\n\n return exprs, truly_used_keys, truly_used_keys_dummies\n\n def __call__(self, *args):\n \"\"\"\n Give arrays in as arguments in same order as `inp` at init.\n \"\"\"\n if self._binary_mod.__file__ != self.binary_path:\n # Avoid singleton behaviour. (Python changes binary path\n # inplace without changing id of Python object)\n self._binary_mod = import_module_from_file(self.binary_path)\n if self._binary_mod.__file__ != self.binary_path:\n raise RuntimeError\n idxs = [self._inp.index(symb) for symb in self._robust_inp_symbs]\n # make sure args[i] 1 dimensional: .reshape(len(args[i]))\n inp = np.vstack([np.array(args[i], dtype=np.float64)\n for i in idxs]).transpose()\n ret = self._binary_mod.transform(inp, len(self._exprs))\n if len(self._exprs) == 1 and len(args) == 1:\n if isinstance(args[0], float):\n return ret[0][0]\n elif all([not iterable(arg) for arg in args]):\n return ret[0]\n return ret\n\n def variables(self):\n dummy_groups = (\n DummyGroup('argdummies', self._robust_inp_dummies),\n )\n arrayify_groups = (\n ArrayifyGroup('argdummies', 'input', 1, 1),\n )\n\n cse_defs_code, exprs_in_cse_code = self.get_cse_code(\n self._robust_exprs, 'cse', dummy_groups, arrayify_groups)\n\n return {'CSES': cse_defs_code,\n 'EXPRS_IN_CSE': exprs_in_cse_code,\n 'N_EXPRS': len(self._exprs),\n 'N_ARGS': len(self._robust_inp_dummies)}\n"
] | [
[
"numpy.array"
]
] |
az85252/DataProfiler | [
"1303abe04b48fa87c67d8d9b3a13f8cb88e79afb"
] | [
"dataprofiler/tests/labelers/test_integration_struct_data_labeler.py"
] | [
"import os\nimport unittest\n\nimport numpy as np\nimport pandas as pd\n\nimport dataprofiler as dp\n\n\nclass TestStructuredDataLabeler(unittest.TestCase):\n\n @classmethod\n def setUpClass(cls) -> None:\n num_repeat_data = 50\n cls.data = np.array(\n [['123 Fake St.', '1/2/2020', 'nice.'],\n ['4/3/22', 'abc', '333-44-2341']] * num_repeat_data\n ).reshape((-1,))\n cls.labels = np.array(\n [['ADDRESS', 'DATETIME', 'UNKNOWN'],\n ['DATETIME', 'UNKNOWN', 'SSN']] * num_repeat_data\n ).reshape((-1,))\n cls.df = pd.DataFrame([cls.data, cls.labels]).T\n\n # simple test for new default TF model + predict()\n def test_fit_with_default_model(self):\n \"\"\"test fitting with data labeler\"\"\"\n # constructing default StructuredDataLabeler()\n dirpath = os.path.join(\n dp.labelers.base_data_labeler.default_labeler_dir,\n dp.labelers.StructuredDataLabeler._default_model_loc)\n default = dp.labelers.TrainableDataLabeler(dirpath=dirpath)\n\n # validate epoch id\n self.assertEqual(0, default.model._epoch_id)\n\n # with labels process\n\n # get char-level predictions on default model\n model_predictions = default.fit(x=self.df[0], y=self.df[1])\n self.assertEqual(1, len(model_predictions)) # 1 epoch only, so 1 result\n self.assertEqual(3, len(model_predictions[0])) # history, f1, f1_report\n self.assertIsInstance(model_predictions[0][0], dict) # history\n self.assertIsInstance(model_predictions[0][1], float) # float\n self.assertIsInstance(model_predictions[0][2], dict) # f1_report\n\n # validate epoch id\n self.assertEqual(1, default.model._epoch_id)\n\n # no bg, pad, but includes micro, macro, weighted\n # default labels + micro, macro, weighted - bg, pad\n self.assertEqual(len(default.labels)+1, len(model_predictions[0][2].keys()))\n\n # test default no validation\n model_predictions = default.fit(\n x=self.df[0], y=self.df[1], validation_split=0)\n self.assertEqual(1, len(model_predictions)) # 1 epoch only, so 1 result\n self.assertEqual(3, len(model_predictions[0])) # history, f1, f1_report\n self.assertIsInstance(model_predictions[0][0], dict) # history\n self.assertIsNone(model_predictions[0][1]) # no f1 since no validation\n self.assertListEqual(model_predictions[0][2], []) # empty f1_report\n\n # validate epoch id\n self.assertEqual(2, default.model._epoch_id)\n\n def test_data_labeler_change_labels(self):\n \"\"\"test changing labels of data labeler with fitting data\"\"\"\n # constructing default StructuredDataLabeler()\n dirpath = os.path.join(\n dp.labelers.base_data_labeler.default_labeler_dir,\n dp.labelers.StructuredDataLabeler._default_model_loc)\n default = dp.labelers.TrainableDataLabeler(dirpath=dirpath)\n\n # get char-level predictions on default model\n expected_label_mapping = dict(list(zip(\n ['PAD', 'UNKNOWN', 'ADDRESS', 'DATETIME', 'SSN'],\n [0, 1, 2, 3, 4]\n )))\n model_predictions = default.fit(\n x=self.df[0], y=self.df[1],\n labels=['UNKNOWN', 'ADDRESS', 'DATETIME', 'SSN'])\n self.assertEqual(1, len(model_predictions))\n self.assertEqual(3, len(model_predictions[0])) # history, f1, f1_report\n self.assertIsInstance(model_predictions[0][0], dict) # history\n self.assertIsInstance(model_predictions[0][1], float) # f1\n self.assertIsInstance(model_predictions[0][2], dict) # f1_report\n self.assertDictEqual(expected_label_mapping, default.label_mapping)\n\n # no bg, pad, but includes micro, macro, weighted\n self.assertEqual(6, len(model_predictions[0][2].keys()))\n\n # ensure as long as label in label_mapping, will work.\n # get char-level predictions on default model\n try:\n model_predictions = default.fit(\n x=self.df[0], y=self.df[1],\n labels=['UNKNOWN', 'ADDRESS', 'DATETIME', 'SSN',\n 'CREDIT_CARD'])\n except Exception as e:\n self.fail(str(e))\n\n # failure occurs if label in data frame ont in labels\n with self.assertRaises(KeyError):\n model_predictions = default.fit(\n x=self.df[0], y=self.df[1],\n labels=['UNKNOWN', 'ADDRESS', 'DATETIME'])\n\n def test_data_labeler_extend_labels(self):\n \"\"\"test extending labels of data labeler with fitting data\"\"\"\n # constructing default StructuredDataLabeler()\n dirpath = os.path.join(\n dp.labelers.base_data_labeler.default_labeler_dir,\n dp.labelers.StructuredDataLabeler._default_model_loc)\n data_labeler = dp.labelers.TrainableDataLabeler(dirpath=dirpath)\n\n original_label_mapping = data_labeler.label_mapping.copy()\n original_max_label = data_labeler.label_mapping[\n max(data_labeler.label_mapping, key=data_labeler.label_mapping.get)]\n\n new_label = 'NEW_LABEL'\n data_labeler.add_label(new_label)\n\n new_max_label = data_labeler.label_mapping[\n max(data_labeler.label_mapping, key=data_labeler.label_mapping.get)]\n\n expected_label_mapping = original_label_mapping\n expected_label_mapping[new_label] = new_max_label\n\n new_label_count = len(data_labeler.label_mapping)\n\n # validate raises error if not trained before fit\n with self.assertRaisesRegex(RuntimeError,\n \"The model label mapping definitions have \"\n \"been altered without additional training. \"\n \"Please train the model or reset the \"\n \"label mapping to predict.\"):\n model_predictions = data_labeler.predict(data=self.df[0])\n\n model_predictions = data_labeler.fit(x=self.df[0], y=self.df[1])\n\n self.assertEqual(1, len(model_predictions))\n self.assertEqual(3, len(model_predictions[0])) # history, f1, f1_report\n self.assertIsInstance(model_predictions[0][0], dict) # history\n self.assertIsInstance(model_predictions[0][1], float) # f1\n self.assertIsInstance(model_predictions[0][2], dict) # f1_report\n self.assertIn(new_label, data_labeler.label_mapping) # Ensure new label added\n self.assertEqual(original_max_label+1, new_max_label) # Ensure new label iterated\n self.assertDictEqual(expected_label_mapping, data_labeler.label_mapping)\n\n # no bg, pad, but includes micro, macro, weighted\n self.assertEqual(new_label_count+1, len(model_predictions[0][2].keys()))\n\n def test_default_tf_model(self):\n \"\"\"simple test for new default TF model + predict()\"\"\"\n\n # constructing default StructuredDataLabeler()\n default = dp.labelers.StructuredDataLabeler()\n\n # get char-level predictions on default model\n model_predictions = default.predict(self.data)\n final_results = model_predictions[\"pred\"]\n\n # for now just checking that it's not empty\n self.assertIsNotNone(final_results)\n self.assertEqual(len(self.data), len(final_results))\n\n def test_default_confidences(self):\n \"\"\"tests confidence scores output\"\"\"\n\n # constructing default StructuredDataLabeler()\n default = dp.labelers.StructuredDataLabeler()\n\n # get char-level predictions/confidence scores on default model\n results = default.predict(self.data,\n predict_options=dict(show_confidences=True))\n model_predictions_char_level, model_confidences_char_level = \\\n results[\"pred\"], results[\"conf\"]\n\n # for now just checking that it's not empty\n self.assertIsNotNone(model_confidences_char_level)\n\n def test_default_edge_cases(self):\n \"\"\"more complicated test for edge cases for the default model\"\"\"\n sample = [\"1234567890\", \"!@#$%&^*$)*#%)#*%-=+~.,/?{}[]|`\",\n \"\\n \\n \\n \\t \\t\"]\n\n # constructing default StructuredDataLabeler()\n default = dp.labelers.StructuredDataLabeler()\n\n # get char-level predictions on default model\n model_predictions = default.predict(sample)\n final_results = model_predictions[\"pred\"]\n\n # for now just checking that it's not empty\n self.assertIsNotNone(final_results)\n\n def test_default_special_cases(self):\n \"\"\"\n tests for empty string (returns none) and mixed samples cases\n (throws error) w/ default labeler\n \"\"\"\n # first test multiple empty strings in sample:\n sample1 = [\"\", \"\", \"\"]\n\n # constructing default StructuredDataLabeler()\n default = dp.labelers.StructuredDataLabeler()\n\n # get char-level predictions on default model\n results = default.predict(\n sample1, predict_options=dict(show_confidences=True))\n model_predictions_char_level = results[\"pred\"]\n model_confidences_char_level = results[\"conf\"]\n\n # test that we get empty list for predictions/confidences:\n self.assertEqual(model_predictions_char_level.tolist(),\n [None, None, None])\n self.assertTrue((model_confidences_char_level == 0.0).all())\n\n # Now we test mixed samples case:\n sample2 = [\"\", \"abc\", \"\\t\", \"\"]\n\n # this can change if model changes\n expected_output = {'pred': [None, 'UNKNOWN', 'UNKNOWN', None]}\n output = default.predict(sample2)\n output['pred'] = output['pred'].tolist()\n self.assertDictEqual(expected_output, output)\n\n # simple test for new default TF model + predict()\n def test_fit_with_reset_weights(self):\n \"\"\"test fitting with data labeler while resetting the weights\"\"\"\n # constructing default StructuredDataLabeler()\n dirpath = os.path.join(\n dp.labelers.base_data_labeler.default_labeler_dir,\n dp.labelers.StructuredDataLabeler._default_model_loc)\n default = dp.labelers.TrainableDataLabeler(dirpath=dirpath)\n\n # fit on default model with reset weights\n model_predictions = default.fit(\n x=self.df[0], y=self.df[1], reset_weights=True)\n\n # assert appropriate results\n self.assertEqual(1, len(model_predictions)) # 1 epoch only, so 1 result\n self.assertEqual(3, len(model_predictions[0])) # history, f1, f1_report\n self.assertIsInstance(model_predictions[0][0], dict) # history\n self.assertIsInstance(model_predictions[0][1], float) # float\n self.assertIsInstance(model_predictions[0][2], dict) # f1_report\n\n # validate epoch id\n self.assertEqual(1, default.model._epoch_id)\n\n # test subsequent weight reset\n model_predictions = default.fit(\n x=self.df[0], y=self.df[1], reset_weights=True)\n\n # validate epoch id\n self.assertEqual(1, default.model._epoch_id)\n\n def test_structured_data_labeler_fit_predict_take_data_obj(self):\n data = pd.DataFrame([\"123 Fake st\", \"1/1/2021\", \"blah\", \"333-44-2341\",\n \"[email protected]\", \"John Doe\", \"123-4567\"])\n labels = pd.DataFrame([\"ADDRESS\", \"DATETIME\", \"UNKNOWN\", \"SSN\",\n \"EMAIL_ADDRESS\", \"PERSON\", \"PHONE_NUMBER\"])\n for dt in [\"csv\", \"json\", \"parquet\"]:\n data_obj = dp.Data(data=data, data_type=dt)\n label_obj = dp.Data(data=labels, data_type=dt)\n labeler = dp.DataLabeler(labeler_type=\"structured\", trainable=True)\n self.assertIsNotNone(labeler.fit(x=data_obj, y=label_obj))\n self.assertIsNotNone(labeler.predict(data=data_obj))\n\n def test_warning_tf(self):\n\n test_root_path = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))\n test_dir = os.path.join(test_root_path, 'data')\n path = os.path.join(test_dir, 'csv/diamonds.csv')\n data = dp.Data(path)\n\n profile_options = dp.ProfilerOptions()\n profile_options.structured_options.set(\n {\"text.is_enabled\": False,\n \"int.is_enabled\": False,\n \"float.is_enabled\": False,\n \"order.is_enabled\": False,\n \"category.is_enabled\": False,\n \"datetime.is_enabled\": False}\n )\n\n profile = dp.StructuredProfiler(data, options=profile_options)\n results = profile.report()\n\n columns = []\n predictions = []\n for i in range(len(results['data_stats'])):\n columns.append(i)\n predictions.append(results['data_stats'][i]['data_label'])\n\n def test_warning_tf_run_dp_multiple_times(self):\n test_root_path = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))\n test_dir = os.path.join(test_root_path, 'data')\n path = os.path.join(test_dir, 'csv/diamonds.csv')\n\n for i in range(3):\n print('running dp =============================', i)\n data = dp.Data(path)\n profile_options = dp.ProfilerOptions()\n profile_options.structured_options.set(\n {\"text.is_enabled\": False,\n \"int.is_enabled\": False,\n \"float.is_enabled\": False,\n \"order.is_enabled\": False,\n \"category.is_enabled\": False,\n \"datetime.is_enabled\": False}\n )\n\n profile = dp.StructuredProfiler(data, options=profile_options)\n\n results = profile.report()\n\n columns = []\n predictions = []\n for j in range(len(results['data_stats'])):\n columns.append(j)\n predictions.append(results['data_stats'][j]['data_label'])\n\n def test_warning_tf_run_dp_merge(self):\n test_root_path = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))\n test_dir = os.path.join(test_root_path, 'data')\n path = os.path.join(test_dir, 'csv/diamonds.csv')\n\n data = dp.Data(path)\n profile_options = dp.ProfilerOptions()\n profile_options.structured_options.set(\n {\"text.is_enabled\": False,\n \"int.is_enabled\": False,\n \"float.is_enabled\": False,\n \"order.is_enabled\": False,\n \"category.is_enabled\": False,\n \"datetime.is_enabled\": False,\n \"correlation.is_enabled\": False}\n )\n print('running dp1')\n profile1 = dp.StructuredProfiler(data, options=profile_options)\n\n data = dp.Data(path)\n profile_options = dp.ProfilerOptions()\n profile_options.structured_options.set(\n {\"text.is_enabled\": False,\n \"int.is_enabled\": False,\n \"float.is_enabled\": False,\n \"order.is_enabled\": False,\n \"category.is_enabled\": False,\n \"datetime.is_enabled\": False,\n \"correlation.is_enabled\": False}\n )\n print('running dp2')\n profile2 = dp.StructuredProfiler(data, options=profile_options)\n\n profile = profile1 + profile2\n\n def test_warning_tf_multiple_dp_with_update(self):\n test_root_path = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))\n test_dir = os.path.join(test_root_path, 'data')\n path = os.path.join(test_dir, 'csv/diamonds.csv')\n\n data = dp.Data(path)\n profile_options = dp.ProfilerOptions()\n profile_options.structured_options.set(\n {\"text.is_enabled\": False,\n \"int.is_enabled\": False,\n \"float.is_enabled\": False,\n \"order.is_enabled\": False,\n \"category.is_enabled\": False,\n \"datetime.is_enabled\": False,\n \"correlation.is_enabled\": False}\n )\n print('running dp1')\n profile1 = dp.StructuredProfiler(data, options=profile_options)\n\n data = dp.Data(path)\n profile_options = dp.ProfilerOptions()\n profile_options.structured_options.set(\n {\"text.is_enabled\": False,\n \"int.is_enabled\": False,\n \"float.is_enabled\": False,\n \"order.is_enabled\": False,\n \"category.is_enabled\": False,\n \"datetime.is_enabled\": False,\n \"correlation.is_enabled\": False}\n )\n print('running dp2')\n profile2 = dp.StructuredProfiler(data, options=profile_options)\n\n profile1.update_profile(data)\n\nif __name__ == '__main__':\n unittest.main()\n"
] | [
[
"pandas.DataFrame",
"numpy.array"
]
] |
natethinks/cherry | [
"a482621a3e397f6667f21e16d5ec0eb12c7fc4fb"
] | [
"cherry/performance.py"
] | [
"# -*- coding: utf-8 -*-\n\n\"\"\"\ncherry.performance\n~~~~~~~~~~~~\nThis module implements the cherry performance.\n:copyright: (c) 2018-2019 by Windson Yang\n:license: MIT License, see LICENSE for more details.\n\"\"\"\n\nimport numpy as np\nfrom sklearn.model_selection import KFold\nfrom sklearn.pipeline import Pipeline\nfrom sklearn import metrics\nfrom .base import load_data, write_file, get_vectorizer, get_clf\nfrom .trainer import Trainer\nfrom .classifyer import Classify\nfrom .exceptions import MethodNotFoundError\n\nclass Performance:\n def __init__(self, model, **kwargs):\n x_data = kwargs['x_data']\n y_data = kwargs['y_data']\n if not (x_data and y_data):\n x_data, y_data = load_data(model)\n vectorizer = kwargs['vectorizer']\n vectorizer_method = kwargs['vectorizer_method']\n clf = kwargs['clf']\n clf_method = kwargs['clf_method']\n if not vectorizer:\n vectorizer = get_vectorizer(model, vectorizer_method)\n if not clf:\n clf = get_clf(model, clf_method)\n n_splits = kwargs['n_splits']\n output = kwargs['output']\n for train_index, test_index in KFold(n_splits=n_splits, shuffle=True).split(x_data):\n x_train, x_test = x_data[train_index], x_data[test_index]\n y_train, y_test = y_data[train_index], y_data[test_index]\n print('Calculating score')\n self.score(vectorizer, clf, x_train, y_train, x_test, y_test, output)\n\n def score(self, vectorizer, clf, x_train, y_train, x_test, y_test, output):\n vectorizer = DEFAULT_VECTORIZER if not vectorizer else vectorizer\n clf = DEFAULT_CLF if not clf else clf\n text_clf = Pipeline([\n ('vectorizer', vectorizer),\n ('clf', clf)])\n text_clf.fit(x_train, y_train)\n predicted = text_clf.predict(x_test)\n report = metrics.classification_report(y_test, predicted)\n if output == 'Stdout':\n print(report)\n else:\n self.write_file(output, report)\n"
] | [
[
"sklearn.metrics.classification_report",
"sklearn.pipeline.Pipeline",
"sklearn.model_selection.KFold"
]
] |
akhan118/Self-learing-quant | [
"81d5fc5af510e8d878b33a4c3c1e923b73092d26"
] | [
"openGYM.py"
] | [
"import gym ,sys,numpy as np\nimport numpy as np\nnp.random.seed(1335) # for reproducibility\nnp.set_printoptions(precision=5, suppress=True, linewidth=150)\n\nimport pandas as pd\nimport backtest as twp\nfrom matplotlib import pyplot as plt\nfrom sklearn import metrics, preprocessing\nfrom talib.abstract import *\nfrom sklearn.externals import joblib\n\nenv = gym.make('CartPole-v1')\nprint(env.observation_space.shape[0])\n\nfor i_episode in range(2):\n observation = env.reset()\n for t in range(1):\n # env.render()\n # print(observation.shape)\n # print(observation.size)\n print(observation)\n\n scaler = preprocessing.StandardScaler()\n xdata = scaler.fit_transform(observation.reshape(1, -1))\n img1 = observation[0]\n img2 = observation[1]\n img3 = observation[2]\n img4 =observation[3]\n\n\n xdata = np.array([[[img1, img2,img3,img4]]])\n # xdata = np.nan_to_num(xdata)\n print(xdata)\n\n\n\n print(xdata)\n print(xdata.shape)\n print(xdata.size)\n action = env.action_space.sample()\n observation, reward, done, info = env.step(action)\n\n if done:\n print(\"Episode finished after {} timesteps\".format(t+1))\n break\n"
] | [
[
"numpy.random.seed",
"numpy.set_printoptions",
"numpy.array",
"sklearn.preprocessing.StandardScaler"
]
] |
yghlc/CSF | [
"d42ac9784a7326bc3d0ecbd5931e1f8326198352"
] | [
"install-python-demo/demo_tif.py"
] | [
"#!/usr/bin/env python\n# Filename: demo_tif.py \n\"\"\"\nintroduction: run a demo: applying CSF to digital surface model in GeoTiff.\n\nauthors: Huang Lingcao\nemail:[email protected]\nadd time: 22 February, 2022\n\"\"\"\n\nimport os,sys\n# deeplabforRS = os.path.expanduser('~/codes/PycharmProjects/DeeplabforRS')\n# sys.path.insert(0, deeplabforRS)\n\n# import raster_io\n\nimport laspy\nimport CSF\nimport numpy as np\n\n\n\ndef main():\n # dsm_tif = 'SETSM_GE01_20140511_for_test_CSF.tif'\n\n dsm_las = 'SETSM_GE01_20140511_for_test_CSF.las'\n save_las = 'SETSM_GE01_20140511_for_test_CSF_ground.las'\n\n\n inFile = laspy.file.File(dsm_las, mode='r') # read a las file\n points = inFile.points\n xyz = np.vstack((inFile.x, inFile.y, inFile.z)).transpose() # extract x, y, z and put into a list\n\n csf = CSF.CSF()\n\n # prameter settings\n csf.params.bSloopSmooth = False\n csf.params.cloth_resolution = 0.5\n # more details about parameter: http://ramm.bnu.edu.cn/projects/CSF/download/\n\n csf.setPointCloud(xyz)\n ground = CSF.VecInt() # a list to indicate the index of ground points after calculation\n non_ground = CSF.VecInt() # a list to indicate the index of non-ground points after calculation\n csf.do_filtering(ground, non_ground) # do actual filtering.\n\n outFile = laspy.file.File(save_las,\n mode='w', header=inFile.header)\n outFile.points = points[ground] # extract ground points, and save it to a las file.\n outFile.close() # do not forget this\n\n\n\nif __name__ == '__main__':\n main()"
] | [
[
"numpy.vstack"
]
] |
LoicDagnas/models | [
"9cd7a576be6e80d13c2bc613ddd4004b05e95f27"
] | [
"official/vision/beta/projects/yolo/tasks/yolo.py"
] | [
"# Copyright 2021 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\"\"\"Contains classes used to train Yolo.\"\"\"\n\nimport collections\nfrom typing import Optional\n\nfrom absl import logging\nimport tensorflow as tf\n\nfrom official.core import base_task\nfrom official.core import config_definitions\nfrom official.core import input_reader\nfrom official.core import task_factory\nfrom official.modeling import performance\nfrom official.vision.beta.dataloaders import tfds_factory\nfrom official.vision.beta.dataloaders import tf_example_label_map_decoder\nfrom official.vision.beta.evaluation import coco_evaluator\nfrom official.vision.beta.ops import box_ops\nfrom official.vision.beta.projects.yolo import optimization\nfrom official.vision.beta.projects.yolo.configs import yolo as exp_cfg\nfrom official.vision.beta.projects.yolo.dataloaders import tf_example_decoder\nfrom official.vision.beta.projects.yolo.dataloaders import yolo_input\nfrom official.vision.beta.projects.yolo.modeling import factory\nfrom official.vision.beta.projects.yolo.ops import mosaic\nfrom official.vision.beta.projects.yolo.ops import preprocessing_ops\nfrom official.vision.beta.projects.yolo.tasks import task_utils\n\nOptimizationConfig = optimization.OptimizationConfig\nRuntimeConfig = config_definitions.RuntimeConfig\n\n\n@task_factory.register_task_cls(exp_cfg.YoloTask)\nclass YoloTask(base_task.Task):\n \"\"\"A single-replica view of training procedure.\n\n YOLO task provides artifacts for training/evalution procedures, including\n loading/iterating over Datasets, initializing the model, calculating the loss,\n post-processing, and customized metrics with reduction.\n \"\"\"\n\n def __init__(self, params, logging_dir: Optional[str] = None):\n super().__init__(params, logging_dir)\n self.coco_metric = None\n self._loss_fn = None\n self._model = None\n self._coco_91_to_80 = False\n self._metrics = []\n\n # globally set the random seed\n preprocessing_ops.set_random_seeds(seed=params.seed)\n return\n\n def build_model(self):\n \"\"\"Build an instance of Yolo.\"\"\"\n\n model_base_cfg = self.task_config.model\n l2_weight_decay = self.task_config.weight_decay / 2.0\n\n input_size = model_base_cfg.input_size.copy()\n input_specs = tf.keras.layers.InputSpec(shape=[None] + input_size)\n l2_regularizer = (\n tf.keras.regularizers.l2(l2_weight_decay) if l2_weight_decay else None)\n model, losses = factory.build_yolo(\n input_specs, model_base_cfg, l2_regularizer)\n\n # save for later usage within the task.\n self._loss_fn = losses\n self._model = model\n return model\n\n def _get_data_decoder(self, params):\n \"\"\"Get a decoder object to decode the dataset.\"\"\"\n if params.tfds_name:\n decoder = tfds_factory.get_detection_decoder(params.tfds_name)\n else:\n decoder_cfg = params.decoder.get()\n if params.decoder.type == 'simple_decoder':\n self._coco_91_to_80 = decoder_cfg.coco91_to_80\n decoder = tf_example_decoder.TfExampleDecoder(\n coco91_to_80=decoder_cfg.coco91_to_80,\n regenerate_source_id=decoder_cfg.regenerate_source_id)\n elif params.decoder.type == 'label_map_decoder':\n decoder = tf_example_label_map_decoder.TfExampleDecoderLabelMap(\n label_map=decoder_cfg.label_map,\n regenerate_source_id=decoder_cfg.regenerate_source_id)\n else:\n raise ValueError('Unknown decoder type: {}!'.format(\n params.decoder.type))\n return decoder\n\n def build_inputs(self, params, input_context=None):\n \"\"\"Build input dataset.\"\"\"\n model = self.task_config.model\n\n # get anchor boxes dict based on models min and max level\n backbone = model.backbone.get()\n anchor_dict, level_limits = model.anchor_boxes.get(backbone.min_level,\n backbone.max_level)\n\n params.seed = self.task_config.seed\n # set shared patamters between mosaic and yolo_input\n base_config = dict(\n letter_box=params.parser.letter_box,\n aug_rand_translate=params.parser.aug_rand_translate,\n aug_rand_angle=params.parser.aug_rand_angle,\n aug_rand_perspective=params.parser.aug_rand_perspective,\n area_thresh=params.parser.area_thresh,\n random_flip=params.parser.random_flip,\n seed=params.seed,\n )\n\n # get the decoder\n decoder = self._get_data_decoder(params)\n\n # init Mosaic\n sample_fn = mosaic.Mosaic(\n output_size=model.input_size,\n mosaic_frequency=params.parser.mosaic.mosaic_frequency,\n mixup_frequency=params.parser.mosaic.mixup_frequency,\n jitter=params.parser.mosaic.jitter,\n mosaic_center=params.parser.mosaic.mosaic_center,\n mosaic_crop_mode=params.parser.mosaic.mosaic_crop_mode,\n aug_scale_min=params.parser.mosaic.aug_scale_min,\n aug_scale_max=params.parser.mosaic.aug_scale_max,\n **base_config)\n\n # init Parser\n parser = yolo_input.Parser(\n output_size=model.input_size,\n anchors=anchor_dict,\n use_tie_breaker=params.parser.use_tie_breaker,\n jitter=params.parser.jitter,\n aug_scale_min=params.parser.aug_scale_min,\n aug_scale_max=params.parser.aug_scale_max,\n aug_rand_hue=params.parser.aug_rand_hue,\n aug_rand_saturation=params.parser.aug_rand_saturation,\n aug_rand_brightness=params.parser.aug_rand_brightness,\n max_num_instances=params.parser.max_num_instances,\n scale_xy=model.detection_generator.scale_xy.get(),\n expanded_strides=model.detection_generator.path_scales.get(),\n darknet=model.darknet_based_model,\n best_match_only=params.parser.best_match_only,\n anchor_t=params.parser.anchor_thresh,\n random_pad=params.parser.random_pad,\n level_limits=level_limits,\n dtype=params.dtype,\n **base_config)\n\n # init the dataset reader\n reader = input_reader.InputReader(\n params,\n dataset_fn=tf.data.TFRecordDataset,\n decoder_fn=decoder.decode,\n sample_fn=sample_fn.mosaic_fn(is_training=params.is_training),\n parser_fn=parser.parse_fn(params.is_training))\n dataset = reader.read(input_context=input_context)\n return dataset\n\n def build_metrics(self, training=True):\n \"\"\"Build detection metrics.\"\"\"\n metrics = []\n\n backbone = self.task_config.model.backbone.get()\n metric_names = collections.defaultdict(list)\n for key in range(backbone.min_level, backbone.max_level + 1):\n key = str(key)\n metric_names[key].append('loss')\n metric_names[key].append('avg_iou')\n metric_names[key].append('avg_obj')\n\n metric_names['net'].append('box')\n metric_names['net'].append('class')\n metric_names['net'].append('conf')\n\n for _, key in enumerate(metric_names.keys()):\n metrics.append(task_utils.ListMetrics(metric_names[key], name=key))\n\n self._metrics = metrics\n if not training:\n annotation_file = self.task_config.annotation_file\n if self._coco_91_to_80:\n annotation_file = None\n self.coco_metric = coco_evaluator.COCOEvaluator(\n annotation_file=annotation_file,\n include_mask=False,\n need_rescale_bboxes=False,\n per_category_metrics=self._task_config.per_category_metrics)\n\n return metrics\n\n def build_losses(self, outputs, labels, aux_losses=None):\n \"\"\"Build YOLO losses.\"\"\"\n return self._loss_fn(labels, outputs)\n\n def train_step(self, inputs, model, optimizer, metrics=None):\n \"\"\"Train Step.\n\n Forward step and backwards propagate the model.\n\n Args:\n inputs: a dictionary of input tensors.\n model: the model, forward pass definition.\n optimizer: the optimizer for this training step.\n metrics: a nested structure of metrics objects.\n\n Returns:\n A dictionary of logs.\n \"\"\"\n image, label = inputs\n\n with tf.GradientTape(persistent=False) as tape:\n # Compute a prediction\n y_pred = model(image, training=True)\n\n # Cast to float32 for gradietn computation\n y_pred = tf.nest.map_structure(lambda x: tf.cast(x, tf.float32), y_pred)\n\n # Get the total loss\n (scaled_loss, metric_loss,\n loss_metrics) = self.build_losses(y_pred['raw_output'], label)\n\n # Scale the loss for numerical stability\n if isinstance(optimizer, tf.keras.mixed_precision.LossScaleOptimizer):\n scaled_loss = optimizer.get_scaled_loss(scaled_loss)\n\n # Compute the gradient\n train_vars = model.trainable_variables\n gradients = tape.gradient(scaled_loss, train_vars)\n\n # Get unscaled loss if we are using the loss scale optimizer on fp16\n if isinstance(optimizer, tf.keras.mixed_precision.LossScaleOptimizer):\n gradients = optimizer.get_unscaled_gradients(gradients)\n\n # Apply gradients to the model\n optimizer.apply_gradients(zip(gradients, train_vars))\n logs = {self.loss: metric_loss}\n\n # Compute all metrics\n if metrics:\n for m in metrics:\n m.update_state(loss_metrics[m.name])\n logs.update({m.name: m.result()})\n return logs\n\n def _reorg_boxes(self, boxes, info, num_detections):\n \"\"\"Scale and Clean boxes prior to Evaluation.\"\"\"\n mask = tf.sequence_mask(num_detections, maxlen=tf.shape(boxes)[1])\n mask = tf.cast(tf.expand_dims(mask, axis=-1), boxes.dtype)\n\n # Denormalize the boxes by the shape of the image\n inshape = tf.expand_dims(info[:, 1, :], axis=1)\n ogshape = tf.expand_dims(info[:, 0, :], axis=1)\n scale = tf.expand_dims(info[:, 2, :], axis=1)\n offset = tf.expand_dims(info[:, 3, :], axis=1)\n\n boxes = box_ops.denormalize_boxes(boxes, inshape)\n boxes = box_ops.clip_boxes(boxes, inshape)\n boxes += tf.tile(offset, [1, 1, 2])\n boxes /= tf.tile(scale, [1, 1, 2])\n boxes = box_ops.clip_boxes(boxes, ogshape)\n\n # Mask the boxes for usage\n boxes *= mask\n boxes += (mask - 1)\n return boxes\n\n def validation_step(self, inputs, model, metrics=None):\n \"\"\"Validatation step.\n\n Args:\n inputs: a dictionary of input tensors.\n model: the keras.Model.\n metrics: a nested structure of metrics objects.\n\n Returns:\n A dictionary of logs.\n \"\"\"\n image, label = inputs\n\n # Step the model once\n y_pred = model(image, training=False)\n y_pred = tf.nest.map_structure(lambda x: tf.cast(x, tf.float32), y_pred)\n (_, metric_loss, loss_metrics) = self.build_losses(y_pred['raw_output'],\n label)\n logs = {self.loss: metric_loss}\n\n # Reorganize and rescale the boxes\n info = label['groundtruths']['image_info']\n boxes = self._reorg_boxes(y_pred['bbox'], info, y_pred['num_detections'])\n\n # Build the input for the coc evaluation metric\n coco_model_outputs = {\n 'detection_boxes': boxes,\n 'detection_scores': y_pred['confidence'],\n 'detection_classes': y_pred['classes'],\n 'num_detections': y_pred['num_detections'],\n 'source_id': label['groundtruths']['source_id'],\n 'image_info': label['groundtruths']['image_info']\n }\n\n # Compute all metrics\n if metrics:\n logs.update(\n {self.coco_metric.name: (label['groundtruths'], coco_model_outputs)})\n for m in metrics:\n m.update_state(loss_metrics[m.name])\n logs.update({m.name: m.result()})\n return logs\n\n def aggregate_logs(self, state=None, step_outputs=None):\n \"\"\"Get Metric Results.\"\"\"\n if not state:\n self.coco_metric.reset_states()\n state = self.coco_metric\n self.coco_metric.update_state(step_outputs[self.coco_metric.name][0],\n step_outputs[self.coco_metric.name][1])\n return state\n\n def reduce_aggregated_logs(self, aggregated_logs, global_step=None):\n \"\"\"Reduce logs and remove unneeded items. Update with COCO results.\"\"\"\n res = self.coco_metric.result()\n return res\n\n def initialize(self, model: tf.keras.Model):\n \"\"\"Loading pretrained checkpoint.\"\"\"\n\n if not self.task_config.init_checkpoint:\n logging.info('Training from Scratch.')\n return\n\n ckpt_dir_or_file = self.task_config.init_checkpoint\n if tf.io.gfile.isdir(ckpt_dir_or_file):\n ckpt_dir_or_file = tf.train.latest_checkpoint(ckpt_dir_or_file)\n\n # Restoring checkpoint.\n if self.task_config.init_checkpoint_modules == 'all':\n ckpt = tf.train.Checkpoint(**model.checkpoint_items)\n status = ckpt.read(ckpt_dir_or_file)\n status.expect_partial().assert_existing_objects_matched()\n else:\n ckpt_items = {}\n if 'backbone' in self.task_config.init_checkpoint_modules:\n ckpt_items.update(backbone=model.backbone)\n if 'decoder' in self.task_config.init_checkpoint_modules:\n ckpt_items.update(decoder=model.decoder)\n\n ckpt = tf.train.Checkpoint(**ckpt_items)\n status = ckpt.read(ckpt_dir_or_file)\n status.expect_partial().assert_existing_objects_matched()\n\n logging.info('Finished loading pretrained checkpoint from %s',\n ckpt_dir_or_file)\n\n def create_optimizer(self,\n optimizer_config: OptimizationConfig,\n runtime_config: Optional[RuntimeConfig] = None):\n \"\"\"Creates an TF optimizer from configurations.\n\n Args:\n optimizer_config: the parameters of the Optimization settings.\n runtime_config: the parameters of the runtime.\n\n Returns:\n A tf.optimizers.Optimizer object.\n \"\"\"\n opt_factory = optimization.YoloOptimizerFactory(optimizer_config)\n # pylint: disable=protected-access\n ema = opt_factory._use_ema\n opt_factory._use_ema = False\n\n opt_type = opt_factory._optimizer_type\n if opt_type == 'sgd_torch':\n optimizer = opt_factory.build_optimizer(opt_factory.build_learning_rate())\n optimizer.set_bias_lr(\n opt_factory.get_bias_lr_schedule(self._task_config.smart_bias_lr))\n optimizer.search_and_set_variable_groups(self._model.trainable_variables)\n else:\n optimizer = opt_factory.build_optimizer(opt_factory.build_learning_rate())\n opt_factory._use_ema = ema\n\n if ema:\n logging.info('EMA is enabled.')\n optimizer = opt_factory.add_ema(optimizer)\n\n # pylint: enable=protected-access\n\n if runtime_config and runtime_config.loss_scale:\n use_float16 = runtime_config.mixed_precision_dtype == 'float16'\n optimizer = performance.configure_optimizer(\n optimizer,\n use_graph_rewrite=False,\n use_float16=use_float16,\n loss_scale=runtime_config.loss_scale)\n\n return optimizer\n"
] | [
[
"tensorflow.shape",
"tensorflow.train.latest_checkpoint",
"tensorflow.GradientTape",
"tensorflow.expand_dims",
"tensorflow.io.gfile.isdir",
"tensorflow.cast",
"tensorflow.keras.layers.InputSpec",
"tensorflow.keras.regularizers.l2",
"tensorflow.tile",
"tensorflow.train.Checkpoint"
]
] |
rikichou/mmpose | [
"d1d23325f6d17d2888b45a34e1d8c1e18c878d1f"
] | [
"mmpose/models/backbones/resnet_tiny.py"
] | [
"import torch.nn as nn\nfrom mmcv.cnn import build_conv_layer, build_norm_layer\n\nfrom ..builder import BACKBONES\nfrom .resnet import ResNet,ResNetSimple\n\[email protected]_module()\nclass ResNet_Tiny(ResNetSimple):\n \"\"\"ResNet backbone for CIFAR.\n\n Compared to standard ResNet, it uses `kernel_size=3` and `stride=1` in\n conv1, and does not apply MaxPoolinng after stem. It has been proven to\n be more efficient than standard ResNet in other public codebase, e.g.,\n `https://github.com/kuangliu/pytorch-cifar/blob/master/models/resnet.py`.\n\n Args:\n depth (int): Network depth, from {18, 34, 50, 101, 152}.\n in_channels (int): Number of input image channels. Default: 3.\n stem_channels (int): Output channels of the stem layer. Default: 64.\n base_channels (int): Middle channels of the first stage. Default: 64.\n num_stages (int): Stages of the network. Default: 4.\n strides (Sequence[int]): Strides of the first block of each stage.\n Default: ``(1, 2, 2, 2)``.\n dilations (Sequence[int]): Dilation of each stage.\n Default: ``(1, 1, 1, 1)``.\n out_indices (Sequence[int]): Output from which stages. If only one\n stage is specified, a single tensor (feature map) is returned,\n otherwise multiple stages are specified, a tuple of tensors will\n be returned. Default: ``(3, )``.\n style (str): `pytorch` or `caffe`. If set to \"pytorch\", the stride-two\n layer is the 3x3 conv layer, otherwise the stride-two layer is\n the first 1x1 conv layer.\n deep_stem (bool): This network has specific designed stem, thus it is\n asserted to be False.\n avg_down (bool): Use AvgPool instead of stride conv when\n downsampling in the bottleneck. Default: False.\n frozen_stages (int): Stages to be frozen (stop grad and set eval mode).\n -1 means not freezing any parameters. Default: -1.\n conv_cfg (dict | None): The config dict for conv layers. Default: None.\n norm_cfg (dict): The config dict for norm layers.\n norm_eval (bool): Whether to set norm layers to eval mode, namely,\n freeze running stats (mean and var). Note: Effect on Batch Norm\n and its variants only. Default: False.\n with_cp (bool): Use checkpoint or not. Using checkpoint will save some\n memory while slowing down the training speed. Default: False.\n zero_init_residual (bool): Whether to use zero init for last norm layer\n in resblocks to let them behave as identity. Default: True.\n \"\"\"\n\n def __init__(self, depth, deep_stem=False, **kwargs):\n super(ResNet_Tiny, self).__init__(\n depth, deep_stem=deep_stem, **kwargs)\n assert not self.deep_stem, 'ResNet_CIFAR do not support deep_stem'\n\n def _make_stem_layer(self, in_channels, base_channels):\n self.conv1 = build_conv_layer(\n self.conv_cfg,\n in_channels,\n base_channels,\n kernel_size=3,\n stride=1,\n padding=1,\n bias=False)\n self.norm1_name, norm1 = build_norm_layer(\n self.norm_cfg, base_channels, postfix=1)\n self.add_module(self.norm1_name, norm1)\n self.relu = nn.ReLU(inplace=True)\n\n def forward(self, x):\n x = self.conv1(x)\n x = self.norm1(x)\n x = self.relu(x)\n outs = []\n for i, layer_name in enumerate(self.res_layers):\n res_layer = getattr(self, layer_name)\n x = res_layer(x)\n if i in self.out_indices:\n outs.append(x)\n if len(outs) == 1:\n return outs[0]\n else:\n return tuple(outs)"
] | [
[
"torch.nn.ReLU"
]
] |
comp-neural-circuits/tctx | [
"4fcd1a195a64015e777e55f582e8df35c4913993"
] | [
"tctx/networks/base.py"
] | [
"\"\"\"\n Code to support the creation of network instances.\n\"\"\"\nimport logging\n\nfrom tctx.util import sim_nest\nimport nest\nimport numpy as np\nimport pandas as pd\n\nfrom tctx.util.profiling import log_time\nimport tctx.util.networks\n\n\nclass NetworkInstance(tctx.util.networks.NetworkInstance):\n \"\"\"\n Class to hold results of instantiating a network.\n cells and connections attributes are pd.DataFrames.\n Optionally, an instance can be implemented using NEST for simulation.\n \"\"\"\n\n def __init__(self, params, cells, connections, extra=None):\n super().__init__(params, cells, connections, extra)\n report(cells, connections, level=logging.DEBUG)\n\n def implement(self):\n with log_time('implement nest'):\n self.cells['nest_id'] = self._implement_nest()\n\n with log_time('initialise nest'):\n self._initialise_nest()\n\n def _implement_nest(self):\n \"\"\"translate the self into exectuable nest nodes and connections\"\"\"\n\n nest_ids = self._instantiate_nest_cells()\n\n self._instantiate_nest_connections(nest_ids)\n\n return nest_ids\n\n def _instantiate_nest_cells(self):\n\n # these are params required by NEST that we may want to differentiate between E and I populations\n group_specific_neuron_keys = {\n 't_ref', 'V_reset', 'E_L', 'I_e',\n 'a', 'b', 'tau_w', 'V_th', 'V_peak', 'Delta_T',\n 'C_m', 'g_L'}\n\n # these are params required by NEST that are common to all of our neurons\n common_neuron_keys = {\n 'E_ex', 'E_in', 'tau_syn_ex', 'tau_syn_in'\n }\n common_neuron_params = {k: self.params[k] for k in common_neuron_keys}\n\n model = self.params['model']\n\n groups = {}\n for group_id in ['e', 'i']:\n group_neuron_params = common_neuron_params.copy()\n\n group_neuron_params.update({\n k: self.params[f'{group_id}_{k}']\n for k in group_specific_neuron_keys\n })\n\n group_size = np.count_nonzero(self.cells.ei_type == group_id)\n nest_ids = nest.Create(model, group_size, group_neuron_params)\n groups[group_id] = list(nest_ids) # we want lists because it's what pandas likes to index by\n\n nest_ids = pd.Series(\n data=np.concatenate([groups['e'], groups['i']]),\n index=np.concatenate([self.cells[self.cells.ei_type == 'e'].index.values,\n self.cells[self.cells.ei_type == 'i'].index.values]))\n\n return nest_ids\n\n def _instantiate_nest_connections(self, nest_ids):\n\n sender_gids = nest_ids.reindex(self.connections['source']).values\n receiver_gids = nest_ids.reindex(self.connections['target']).values\n weights = self.connections.weight.values\n delays = self.connections.delay.values\n\n with log_time(f'create NEST connections ({len(sender_gids):,})', pre=True, level=logging.INFO):\n nest.Connect(\n sender_gids,\n receiver_gids,\n {\n 'rule': 'one_to_one'\n },\n {\n 'model': 'static_synapse',\n 'weight': weights,\n 'delay': delays\n }\n )\n\n def _initialise_nest(self):\n nodes = list(self.cells.nest_id.values)\n sim_nest.random_init_normal(nodes, 'V_m', self.params['V_0_mean'], spread=self.params['V_0_std'])\n sim_nest.random_init_normal(nodes, 'w', mean=self.params['w_0_mean'], spread=self.params['w_0_std'])\n\n\nclass ByDist:\n \"\"\"Use a different distribution based on a value\"\"\"\n\n def __init__(self, **dists):\n \"\"\"\n :param dists: a map from `by` to callable objects\n \"\"\"\n self.dists = dists\n\n def sample(self, series):\n \"\"\"\n Generate a weight for each entry in series.\n Depends only on the property given in series.\n \"\"\"\n all_values = []\n\n for group_id, group in series.groupby(series):\n values = self.dists[group_id].sample(len(group))\n all_values.append(pd.Series(data=values, index=group.index))\n logging.debug('created %d %s weights between [%f, %f]',\n len(values), group_id, np.min(values), np.max(values))\n\n all_values = pd.concat(all_values)\n\n return all_values\n\n\nclass ClippedDist:\n \"\"\"ensure we do not make weights that are ridiculously high.\n This will keep re-sampling untilt `count` elements are generated and all are less or equal to `vmax`.\n \"\"\"\n\n def __init__(self, dist, vmin, vmax):\n \"\"\"\n :param dist: callable that samples a given number\n :param vmax: maximum allowed value\n \"\"\"\n self.dist = dist\n self.vmax = vmax\n self.vmin = vmin\n\n # @numba.jit\n def sample(self, count):\n values = np.zeros(count, dtype=np.float)\n\n # it might be nice to use a product with a sigmoidal in order to avoid the \"hard\" max\n # TODO apply this also to non-space turtle\n\n invalid = np.ones(count, dtype=np.bool_)\n left = np.count_nonzero(invalid)\n\n while left != 0:\n values[invalid] = self.dist(left)\n\n abs_values = np.abs(values)\n\n invalid = (abs_values > np.abs(self.vmax)) | (abs_values < np.abs(self.vmin))\n\n left = np.count_nonzero(invalid)\n\n return values\n\n def scale(self, g):\n \"\"\"given a distribution of excitatory weights, create one that is g-times stronger\"\"\"\n\n def scaled_sample(size):\n sample = self.dist(size)\n return g * sample\n\n return ClippedDist(dist=scaled_sample, vmax=g * self.vmax, vmin=self.vmin)\n\n\nclass FixedDist:\n \"\"\"returns always the same value\"\"\"\n\n def __init__(self, constant):\n self.constant = constant\n\n def sample(self, count):\n return np.ones(count, dtype=np.float) * self.constant\n\n def scale(self, g):\n \"\"\"given a distribution of excitatory weights, create one that is g-times stronger\"\"\"\n return FixedDist(constant=g * self.constant)\n\n\ndef sample_delays(connections, delay_dist, decimals=1):\n \"\"\"create delays from the given distribution. Independent from connection properties\"\"\"\n if connections.empty:\n return pd.Series(index=connections.index)\n\n delays = delay_dist(len(connections))\n delays = np.round(delays, decimals=decimals)\n\n return delays\n\n\ndef report(cells, connections, level):\n with log_time('report', level=level):\n cell_type_counts = cells.groupby('ei_type')['ei_type'].count()\n logging.log(level, 'Cells:\\n%s', cell_type_counts)\n\n connections_type_counts = connections.groupby('con_type')['con_type'].count()\n\n possible_connections_counts = pd.Series({\n con_type: cell_type_counts[con_type[0]] * cell_type_counts[con_type[-1]] for con_type in connections_type_counts.index\n })\n\n # it may be a CategoricalIndex in which we can't insert 'all'\n connections_type_counts.index = connections_type_counts.index.astype(str)\n\n connections_type_counts.loc['all'] = connections_type_counts.sum()\n possible_connections_counts.loc['all'] = np.square(cell_type_counts.sum())\n\n connections_type_probs = connections_type_counts / possible_connections_counts\n\n con_stats = pd.DataFrame(\n data={\n 'count': connections_type_counts,\n 'possible': possible_connections_counts,\n 'probs': connections_type_probs,\n 'weight mean': connections.groupby('con_type')['weight'].mean(),\n 'weight min': connections.groupby('con_type')['weight'].min(),\n 'weight max': connections.groupby('con_type')['weight'].max(),\n 'delay mean': connections.groupby('con_type')['delay'].mean(),\n 'delay min': connections.groupby('con_type')['delay'].min(),\n 'delay max': connections.groupby('con_type')['delay'].max(),\n },\n # columns=['count' 'prob.', 'weight_mean', 'weight_std', 'delay_mean', 'delay_std'],\n )\n\n con_stats.loc['all', 'weight mean'] = connections['weight'].mean()\n con_stats.loc['all', 'weight min'] = connections['weight'].min()\n con_stats.loc['all', 'weight max'] = connections['weight'].max()\n con_stats.loc['all', 'delay mean'] = connections['delay'].mean()\n con_stats.loc['all', 'delay min'] = connections['delay'].min()\n con_stats.loc['all', 'delay max'] = connections['delay'].max()\n\n logging.log(level, 'Connections:\\n%s', con_stats.to_string())\n"
] | [
[
"numpy.concatenate",
"numpy.max",
"numpy.count_nonzero",
"numpy.zeros",
"numpy.round",
"numpy.ones",
"numpy.min",
"numpy.abs",
"pandas.concat",
"pandas.Series"
]
] |
Mirotivo/biovid | [
"4cc4b1d2afd3f37224c74fe982d67aee99b81dc0"
] | [
"DataPreparation/2.B ECG Filter.py"
] | [
"##################Signal Characteristics###########################\nimport pandas as pd\nSignals = pd.read_csv('Signals/071309_w_21-BL1-081_bio.csv',sep = \t'\t').iloc[:,:].values\nSignals_Filtered = pd.read_csv('Signals/071309_w_21-BL1-081_bio.csv',sep = \t'\t').iloc[:,:].values\n\n\nN = len(Signals[:,0]) # Number of samplepoints\nFs = len(Signals[:,0])//(Signals[:,0][-1]/1000000) # Sample Frequency\nTs = 1.0 / Fs # Sample Period\nNyq = 0.5 * Fs # Nyquist Frequency\nimport numpy as np\nsignal = Signals[:,2]\n######################Signal Spectrum############################## \nimport scipy.fftpack\nsignal_freq = scipy.fftpack.fft(signal)\n######################Filter Bandwidth#############################\nfrom scipy.signal import butter, lfilter, freqz\nLowCutoff = 0.1 # desired low cutoff frequency of the filter, Hz\nHighCutoff = 250 # desired high cutoff frequency of the filter, Hz\nb, a = butter(N = 4, Wn = [LowCutoff/Nyq, HighCutoff/Nyq], btype='band', analog=False)\n########################Apply Filter###############################\nsignal_filtered = lfilter(b, a, signal)\n##################Filtered Signal Spectrum#########################\nimport scipy.fftpack\nsignal_filtered_freq = scipy.fftpack.fft(signal_filtered)\n\n\n\n###################################################################\n###################################################################\nimport matplotlib.pyplot as plt\nimport matplotlib.ticker as mticker \nplt.subplot(2, 2, 1)\nplt.title(\"Bandpass Filter Frequency Response\")\nplt.xlabel('Frequency [Hz]')\nplt.ylabel('Gain')\nplt.legend(loc='best')\nplt.grid()\nfor order in [4]:\n b, a = butter(N = order, Wn = [LowCutoff/Nyq, HighCutoff/Nyq], btype='band', analog=False)\n w, h = freqz(b, a, worN=8000)\n plt.plot(Nyq*w/np.pi, np.abs(h), label=\"order = %d\" % order)\nplt.plot(LowCutoff, 0.5*np.sqrt(2), 'ko') # Intersection Point\nplt.plot(HighCutoff, 0.5*np.sqrt(2), 'ko') # Intersection Point\nplt.axvline(LowCutoff, color='k') # Ideal low cutoff frequency\nplt.axvline(HighCutoff, color='k') # Ideal high cutoff frequency\n\n\nplt.subplot(2, 2, 2)\nplt.subplots_adjust(hspace=0.35)\nplt.title('Signals Visualisation')\nplt.xlabel('Time [sec]')\nplt.ylabel('Magnitude')\nplt.grid()\nplt.legend()\nplt.plot(Signals[:,0][:], signal[:], 'b-', label='data')\nplt.plot(Signals[:,0][:], signal_filtered[:], 'g-', linewidth=2, label='filtered data')\n\n\nplt.subplot(2, 2, 3)\nplt.title('Signal Spectrum')\nplt.xlabel('Frequency')\nplt.ylabel('Magnitude')\nplt.gca().xaxis.set_major_formatter(mticker.FormatStrFormatter('%d Hz'))\nplt.gca().yaxis.set_major_formatter(mticker.FormatStrFormatter('%d'))\nFreq = np.linspace(0.0, 1.0/(2.0*Ts), N/2)\nAmp = 2/N * np.abs(signal_freq[:N//2])\nplt.plot(Freq,Amp)\nplt.show()\n\nplt.subplot(2, 2, 4)\nplt.title('Filtered Signal Spectrum')\nplt.xlabel('Frequency')\nplt.ylabel('Magnitude')\nplt.gca().xaxis.set_major_formatter(mticker.FormatStrFormatter('%d Hz'))\nplt.gca().yaxis.set_major_formatter(mticker.FormatStrFormatter('%d'))\nFreq = np.linspace(0.0, 1.0/(2.0*Ts), N/2)\nAmp = 2/N * np.abs(signal_filtered_freq[:N//2])\nplt.plot(Freq,Amp)\nplt.show()\n###################################################################\n###################################################################"
] | [
[
"scipy.signal.lfilter",
"pandas.read_csv",
"numpy.sqrt",
"matplotlib.pyplot.gca",
"matplotlib.pyplot.subplots_adjust",
"matplotlib.pyplot.subplot",
"matplotlib.pyplot.title",
"matplotlib.ticker.FormatStrFormatter",
"scipy.signal.freqz",
"matplotlib.pyplot.show",
"matplotlib.pyplot.axvline",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.grid",
"matplotlib.pyplot.plot",
"scipy.signal.butter",
"matplotlib.pyplot.legend",
"matplotlib.pyplot.ylabel",
"numpy.abs",
"numpy.linspace"
]
] |
kahnchana/Vesses | [
"beb7c64ce0d4ac943193fcef0c79b97eef7b362d"
] | [
"recognition/label_image.py"
] | [
"#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n\"\"\" \nCreated on Thu Feb 1 22:06:48 2018\n\n@author: kanchana\n\"\"\"\n\nimport os, sys\nimport tensorflow as tf\n\nos.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'\n\n# change this as you see fit\nimage_path = sys.argv[1]\n\n# Read in the image_data\nimage_data = tf.gfile.FastGFile(image_path, 'rb').read()\n\n# Loads label file, strips off carriage return\nlabel_lines = [line.rstrip() for line \n in tf.gfile.GFile(\"retrained_labels.txt\")]\n\n# Unpersists graph from file\nwith tf.gfile.FastGFile(\"retrained_graph.pb\", 'rb') as f:\n graph_def = tf.GraphDef()\n graph_def.ParseFromString(f.read())\n tf.import_graph_def(graph_def, name='')\n\nwith tf.Session() as sess:\n # Feed the image_data as input to the graph and get first prediction\n softmax_tensor = sess.graph.get_tensor_by_name('final_result:0')\n \n predictions = sess.run(softmax_tensor, \\\n {'DecodeJpeg/contents:0': image_data})\n \n # Sort to show labels of first prediction in order of confidence\n top_k = predictions[0].argsort()[-len(predictions[0]):][::-1]\n \n for node_id in top_k:\n human_string = label_lines[node_id]\n score = predictions[0][node_id]\n print('%s (score = %.5f)' % (human_string, score))\n"
] | [
[
"tensorflow.GraphDef",
"tensorflow.Session",
"tensorflow.import_graph_def",
"tensorflow.gfile.GFile",
"tensorflow.gfile.FastGFile"
]
] |
ChristosChristofidis/h2o-3 | [
"2a926c0950a98eff5a4c06aeaf0373e17176ecd8"
] | [
"h2o-py/tests/testdir_algos/glm/pyunit_wide_dataset_largeGLM.py"
] | [
"import sys\nsys.path.insert(1, \"../../../\")\nimport h2o\nimport numpy as np\n\ndef wide_dataset_large(ip,port):\n # Connect to h2o\n h2o.init(ip,port)\n\n print(\"Reading in Arcene training data for binomial modeling.\")\n trainDataResponse = np.genfromtxt(h2o.locate(\"smalldata/arcene/arcene_train_labels.labels\"), delimiter=' ')\n trainDataResponse = np.where(trainDataResponse == -1, 0, 1)\n trainDataFeatures = np.genfromtxt(h2o.locate(\"smalldata/arcene/arcene_train.data\"), delimiter=' ')\n trainData = h2o.H2OFrame(np.column_stack((trainDataResponse, trainDataFeatures)).tolist())\n\n print(\"Run model on 3250 columns of Arcene with strong rules off.\")\n model = h2o.glm(x=trainData[1:3250], y=trainData[0].asfactor(), family=\"binomial\", lambda_search=False, alpha=[1])\n\n print(\"Test model on validation set.\")\n validDataResponse = np.genfromtxt(h2o.locate(\"smalldata/arcene/arcene_valid_labels.labels\"), delimiter=' ')\n validDataResponse = np.where(validDataResponse == -1, 0, 1)\n validDataFeatures = np.genfromtxt(h2o.locate(\"smalldata/arcene/arcene_valid.data\"), delimiter=' ')\n validData = h2o.H2OFrame(np.column_stack((validDataResponse, validDataFeatures)).tolist())\n prediction = model.predict(validData)\n\n print(\"Check performance of predictions.\")\n performance = model.model_performance(validData)\n\n print(\"Check that prediction AUC better than guessing (0.5).\")\n assert performance.auc() > 0.5, \"predictions should be better then pure chance\"\n\nif __name__ == \"__main__\":\n h2o.run_test(sys.argv, wide_dataset_large)\n"
] | [
[
"numpy.where",
"numpy.column_stack"
]
] |
machinelearning147/decision-forests | [
"e2e2c3f8f1c270a23ac97a6833f84a28ec99c51e"
] | [
"tensorflow_decision_forests/keras/keras_test.py"
] | [
"# Copyright 2021 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\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport collections\nimport enum\nimport functools\nimport os\nimport shutil\nimport subprocess\nfrom typing import List, Tuple, Any, Optional, Type\n\nfrom absl import flags\nfrom absl import logging\nfrom absl.testing import parameterized\nimport numpy as np\nimport pandas as pd\nimport tensorflow as tf\n\nfrom google.protobuf import text_format\n\nfrom tensorflow_decision_forests import keras\nfrom tensorflow_decision_forests.component.model_plotter import model_plotter\nfrom tensorflow_decision_forests.keras import core\nfrom tensorflow_decision_forests.tensorflow import core as tf_core\nfrom yggdrasil_decision_forests.dataset import synthetic_dataset_pb2\nfrom yggdrasil_decision_forests.learner.decision_tree import decision_tree_pb2\nfrom yggdrasil_decision_forests.learner.random_forest import random_forest_pb2\n\nlayers = tf.keras.layers\nmodels = tf.keras.models\noptimizers = tf.keras.optimizers\ncallbacks = tf.keras.callbacks\nNormalization = layers.experimental.preprocessing.Normalization\nCategoryEncoding = layers.experimental.preprocessing.CategoryEncoding\nStringLookup = layers.experimental.preprocessing.StringLookup\n\nDataset = collections.namedtuple(\n \"Dataset\", [\"train\", \"test\", \"semantics\", \"label\", \"num_classes\"])\n\n# Tf's tf.feature_column_FeatureColumn is not accessible.\nFeatureColumn = Any\n\n\ndef data_root_path() -> str:\n return \"\"\n\n\ndef test_data_path() -> str:\n return os.path.join(data_root_path(),\n \"external/ydf/yggdrasil_decision_forests/test_data\")\n\n\ndef tmp_path() -> str:\n return flags.FLAGS.test_tmpdir\n\n\ndef prepare_dataset(train, test, label, num_classes) -> Dataset:\n \"\"\"Prepares a dataset object.\"\"\"\n\n semantics = tf_core.infer_semantic_from_dataframe(train)\n del semantics[label]\n\n def clean(dataset):\n for key, semantic in semantics.items():\n if semantic == tf_core.Semantic.CATEGORICAL:\n dataset[key] = dataset[key].fillna(\"\")\n return dataset\n\n train = clean(train)\n test = clean(test)\n\n return Dataset(\n train=train,\n test=test,\n semantics=semantics,\n label=label,\n num_classes=num_classes)\n\n\ndef train_test_split(dataset: pd.DataFrame,\n ratio_second: float) -> Tuple[pd.DataFrame, pd.DataFrame]:\n \"\"\"Splits randomly a dataframe in two.\"\"\"\n assert ratio_second >= 0.0\n assert ratio_second <= 1.0\n index_second = np.random.rand(len(dataset)) < ratio_second\n return dataset[~index_second], dataset[index_second]\n\n\ndef adult_dataset() -> Dataset:\n \"\"\"Adult/census binary classification dataset.\"\"\"\n\n # Path to dataset.\n dataset_directory = os.path.join(test_data_path(), \"dataset\")\n train_path = os.path.join(dataset_directory, \"adult_train.csv\")\n test_path = os.path.join(dataset_directory, \"adult_test.csv\")\n\n train = pd.read_csv(train_path)\n test = pd.read_csv(test_path)\n label = \"income\"\n\n def clean(ds):\n ds[label] = np.where(ds[label] == \">50K\", 1, 0)\n return ds\n\n train = clean(train)\n test = clean(test)\n return prepare_dataset(train, test, label, num_classes=2)\n\n\ndef iris_dataset() -> Dataset:\n \"\"\"Iris multi-class classification dataset.\"\"\"\n\n # Path to dataset.\n dataset_directory = os.path.join(test_data_path(), \"dataset\")\n dataset_path = os.path.join(dataset_directory, \"iris.csv\")\n dataset = pd.read_csv(dataset_path)\n train, test = train_test_split(dataset, ratio_second=0.30)\n label = \"class\"\n classes = [\"setosa\", \"versicolor\", \"virginica\"]\n\n def clean(ds):\n ds[label] = ds[label].map(classes.index)\n return ds\n\n train = clean(train)\n test = clean(test)\n return prepare_dataset(train, test, label, num_classes=len(classes))\n\n\ndef abalone_dataset() -> Dataset:\n \"\"\"Abalone regression dataset.\"\"\"\n\n # Path to dataset.\n dataset_directory = os.path.join(test_data_path(), \"dataset\")\n dataset_path = os.path.join(dataset_directory, \"abalone.csv\")\n dataset = pd.read_csv(dataset_path)\n train, test = train_test_split(dataset, ratio_second=0.30)\n\n return prepare_dataset(train, test, label=\"Rings\", num_classes=1)\n\n\ndef shopping_dataset() -> Dataset:\n \"\"\"Shopping ranking dataset.\"\"\"\n\n # Path to dataset.\n dataset_directory = os.path.join(internal_test_data_path(), \"dataset\")\n dataset_path = os.path.join(dataset_directory,\n \"shopping_relevance_small1.csv\")\n dataset = pd.read_csv(dataset_path)\n train, test = train_test_split(dataset, ratio_second=0.30)\n\n return prepare_dataset(train, test, label=\"relevance\", num_classes=1)\n\n\ndef z_normalize(value, mean, std):\n return (value - mean) / std\n\n\ndef build_feature_usages(dataset: Dataset,\n include_semantic: bool) -> List[keras.FeatureUsage]:\n if include_semantic:\n return [\n keras.FeatureUsage(key, semantic=semantic)\n for key, semantic in dataset.semantics.items()\n ]\n else:\n return [\n keras.FeatureUsage(key) for key, semantic in dataset.semantics.items()\n ]\n\n\ndef build_feature_columns(dataset: Dataset, dense: bool) -> List[FeatureColumn]:\n # Build tensorflow feature columns.\n feature_columns = []\n\n for key, semantic in dataset.semantics.items():\n if semantic == keras.FeatureSemantic.NUMERICAL:\n mean = dataset.train[key].mean()\n std = dataset.train[key].std()\n if std == 0:\n std = 1\n\n feature_columns.append(\n tf.feature_column.numeric_column(\n key,\n normalizer_fn=functools.partial(z_normalize, mean=mean, std=std)))\n\n elif semantic == keras.FeatureSemantic.CATEGORICAL:\n vocabulary = dataset.train[key].unique()\n sparse_column = tf.feature_column.categorical_column_with_vocabulary_list(\n key, vocabulary)\n\n if dense:\n indicator_column = tf.feature_column.indicator_column(sparse_column)\n feature_columns.append(indicator_column)\n else:\n feature_columns.append(sparse_column)\n\n else:\n assert False\n\n return feature_columns\n\n\ndef build_preprocessing(dataset: Dataset) -> Tuple[List[Any], List[Any]]:\n\n raw_inputs = []\n processed_inputs = []\n\n for key, semantic in dataset.semantics.items():\n raw_input_values = dataset.train[key].values\n\n if semantic == keras.FeatureSemantic.NUMERICAL:\n\n normalizer = Normalization()\n normalizer.adapt(raw_input_values)\n\n raw_input = layers.Input(shape=(1,), name=key)\n processed_input = normalizer(raw_input)\n\n raw_inputs.append(raw_input)\n processed_inputs.append(processed_input)\n\n elif semantic == keras.FeatureSemantic.CATEGORICAL:\n\n if raw_input_values.dtype in [np.int64]:\n # Integer\n raw_input = layers.Input(shape=(1,), name=key, dtype=\"int64\")\n raw_input = layers.minimum([raw_input, 5])\n onehot = CategoryEncoding(\n num_tokens=np.minimum(raw_input_values, 5), output_mode=\"binary\")\n processed_input = onehot(raw_input)\n\n else:\n # String\n raw_input = layers.Input(shape=(1,), name=key, dtype=\"string\")\n\n lookup = StringLookup(max_tokens=5, output_mode=\"binary\")\n lookup.adapt(raw_input_values)\n processed_input = lookup(raw_input)\n\n raw_inputs.append(raw_input)\n processed_inputs.append(processed_input)\n\n else:\n assert False\n\n return raw_inputs, processed_inputs\n\n\ndef dataset_to_tf_dataset(\n dataset: Dataset) -> Tuple[tf.data.Dataset, tf.data.Dataset]:\n \"\"\"Converts a Dataset into a training and testing tf.Datasets.\"\"\"\n\n def df_to_ds(df):\n return tf.data.Dataset.from_tensor_slices(\n (dict(df.drop(dataset.label, 1)), df[dataset.label].values))\n\n train_ds = df_to_ds(dataset.train).shuffle(1024).batch(1024)\n test_ds = df_to_ds(dataset.test).batch(1024)\n return train_ds, test_ds\n\n\n# The different ways to train a model.\nclass Signature(enum.Enum):\n # Automatic input discovery.\n AUTOMATIC_FEATURE_DISCOVERY = 1\n\n # A set of input features is specified with the \"features\" argument.\n # Feature semantics are not provided.\n FEATURES_WITHOUT_SEMANTIC = 2\n\n # A set of input features is specified with the \"features\" argument.\n # Feature semantics are provided.\n FEATURES_WITH_SEMANTIC = 3\n\n # A preprocessing is given. The output of the preprocessing is a dense tensor.\n DENSE_PREPROCESSING = 4\n\n # A preprocessing is given. The output of the preprocessing is a dictionary of\n # tensors.\n STRUCTURED_DICTIONARY_PREPROCESSING = 5\n\n # A preprocessing is given. The output of the preprocessing is a list of\n # tensors.\n STRUCTURED_LIST_PREPROCESSING = 6\n\n # Similar to \"STRUCTURED_PREPROCESSING\". But with additional semantic\n # provided.\n STRUCTURED_PREPROCESSING_WITH_SEMANTIC = 7\n\n # TensorFlow Feature columns with dense output.\n # Deprecated in Keras (Oct. 2020).\n DENSE_FEATURE_COLUMN = 8\n\n # TensorFlow Feature columns with both dense and sparse, float and int and\n # string outputs.\n ANY_FEATURE_COLUMN = 9\n\n\ndef build_model(signature: Signature, dataset: Dataset, **args) -> models.Model:\n \"\"\"Builds a model with the different supported signatures.\n\n Setting nn_baseline=True creates a NN keras model instead. This is useful to\n ensure the unit tests are valid\n\n Args:\n signature: How to build the model object.\n dataset: Dataset for the training and evaluation.\n **args: Extra arguments for the model.\n\n Returns:\n A keras model.\n \"\"\"\n\n if signature == Signature.AUTOMATIC_FEATURE_DISCOVERY:\n model = keras.RandomForestModel(**args)\n\n elif signature == Signature.FEATURES_WITHOUT_SEMANTIC:\n features = build_feature_usages(dataset, include_semantic=False)\n model = keras.RandomForestModel(features=features, **args)\n\n elif signature == Signature.FEATURES_WITH_SEMANTIC:\n features = build_feature_usages(dataset, include_semantic=True)\n model = keras.RandomForestModel(features=features, **args)\n\n elif signature == Signature.DENSE_PREPROCESSING:\n raw_inputs, processed_inputs = build_preprocessing(dataset)\n processed_inputs = layers.Concatenate()(processed_inputs)\n preprocessing = models.Model(inputs=raw_inputs, outputs=processed_inputs)\n model = keras.RandomForestModel(preprocessing=preprocessing, **args)\n\n elif signature == Signature.STRUCTURED_DICTIONARY_PREPROCESSING:\n raw_inputs, processed_inputs = build_preprocessing(dataset)\n processed_inputs = {value.name: value for value in processed_inputs}\n preprocessing = models.Model(inputs=raw_inputs, outputs=processed_inputs)\n model = keras.RandomForestModel(preprocessing=preprocessing, **args)\n\n elif signature == Signature.STRUCTURED_LIST_PREPROCESSING:\n raw_inputs, processed_inputs = build_preprocessing(dataset)\n preprocessing = models.Model(inputs=raw_inputs, outputs=processed_inputs)\n model = keras.RandomForestModel(preprocessing=preprocessing, **args)\n\n elif signature == Signature.STRUCTURED_PREPROCESSING_WITH_SEMANTIC:\n raw_inputs, processed_inputs = build_preprocessing(dataset)\n processed_inputs = {value.name: value for value in processed_inputs}\n preprocessing = models.Model(inputs=raw_inputs, outputs=processed_inputs)\n features = []\n for key in processed_inputs.keys():\n features.append(keras.FeatureUsage(key))\n model = keras.RandomForestModel(\n preprocessing=preprocessing, features=features, **args)\n\n elif signature == Signature.DENSE_FEATURE_COLUMN:\n feature_columns = build_feature_columns(dataset, dense=True)\n preprocessing = layers.DenseFeatures(feature_columns)\n model = keras.RandomForestModel(preprocessing=preprocessing, **args)\n\n elif signature == Signature.ANY_FEATURE_COLUMN:\n feature_columns = build_feature_columns(dataset, dense=False)\n preprocessing = layers.DenseFeatures(feature_columns)\n model = keras.RandomForestModel(preprocessing=preprocessing, **args)\n\n else:\n assert False\n\n return model\n\n\nclass TFDFTest(parameterized.TestCase, tf.test.TestCase):\n\n def _check_adult_model(self,\n model,\n dataset,\n minimum_accuracy,\n check_serialization=True):\n \"\"\"Runs a battery of test on a model compatible with the adult dataset.\n\n The following tests are run:\n - Run and evaluate the model (before training).\n - Train the model.\n - Run and evaluate the model.\n - Serialize the model to a SavedModel.\n - Run the model is a separate binary (without dependencies to the training\n custom OPs).\n - Move the serialized model to another random location.\n - Load the serialized model.\n - Evaluate and run the loaded model.\n\n Args:\n model: A non-trained model on the adult dataset.\n dataset: A dataset compatible with the model.\n minimum_accuracy: minimum accuracy.\n check_serialization: If true, check the serialization of the model.\n \"\"\"\n tf_train, tf_test = dataset_to_tf_dataset(dataset)\n\n model.compile(metrics=[\"accuracy\"])\n\n # Evaluate the model before training.\n evaluation = model.evaluate(tf_test)\n logging.info(\"Pre-training evaluation: %s\", evaluation)\n\n predictions = model.predict(tf_test)\n logging.info(\"Pre-training predictions: %s\", predictions)\n\n # Train the model.\n model.fit(x=tf_train)\n logging.info(\"Trained model:\")\n model.summary()\n\n # Plot the model\n plot = model_plotter.plot_model(model)\n plot_path = os.path.join(self.get_temp_dir(), \"plot.html\")\n logging.info(\"Plot to %s\", plot_path)\n with open(plot_path, \"w\") as f:\n f.write(plot)\n\n # Evaluate the trained model.\n evaluation = model.evaluate(tf_test)\n logging.info(\"Evaluation: %s\", evaluation)\n self.assertGreaterEqual(evaluation[1], minimum_accuracy)\n\n predictions = model.predict(tf_test)\n logging.info(\"Predictions: %s\", predictions)\n\n if check_serialization:\n tf.keras.backend.clear_session()\n\n # Export the trained model.\n saved_model_path = os.path.join(self.get_temp_dir(), \"saved_model\")\n new_saved_model_path = os.path.join(self.get_temp_dir(),\n \"saved_model_copy\")\n logging.info(\"Saving model to %s\", saved_model_path)\n model.save(saved_model_path)\n\n tf.keras.backend.clear_session()\n\n logging.info(\"Run model in separate binary\")\n process = subprocess.Popen([\n os.path.join(\n data_root_path(),\n \"tensorflow_decision_forests/keras/test_runner\"),\n \"--model_path\", saved_model_path, \"--dataset_path\",\n os.path.join(test_data_path(), \"dataset\", \"adult_test.csv\")\n ],\n stdout=subprocess.PIPE,\n stderr=subprocess.PIPE)\n stdout, stderr = process.communicate()\n logging.info(\"stdout:\\n%s\", stdout.decode(\"utf-8\"))\n logging.info(\"stderr:\\n%s\", stderr.decode(\"utf-8\"))\n\n logging.info(\"Copying model from %s to %s\", saved_model_path,\n new_saved_model_path)\n\n shutil.copytree(saved_model_path, new_saved_model_path)\n shutil.rmtree(saved_model_path)\n\n # Load and evaluate the exported trained model.\n logging.info(\"Loading model from %s\", new_saved_model_path)\n loaded_model = models.load_model(new_saved_model_path)\n loaded_model.summary()\n\n evaluation = loaded_model.evaluate(tf_test)\n logging.info(\"Loaded model evaluation: %s\", evaluation)\n self.assertGreaterEqual(evaluation[1], minimum_accuracy)\n\n predictions = loaded_model.predict(tf_test)\n logging.info(\"Loaded model predictions: %s\", predictions)\n\n def _check_adult_model_with_cart(self,\n model,\n dataset,\n check_serialization=True):\n \"\"\"Instance of _check_model for the adult dataset.\"\"\"\n\n self._check_adult_model(\n model=model,\n dataset=dataset,\n minimum_accuracy=0.865,\n check_serialization=check_serialization)\n\n def _check_adult_model_with_one_hot(self,\n model,\n dataset,\n check_serialization=True):\n \"\"\"Instance of _check_model for the adult dataset with bad preprocessing.\"\"\"\n\n self._check_adult_model(\n model=model,\n dataset=dataset,\n minimum_accuracy=0.859,\n check_serialization=check_serialization)\n\n def test_model_adult_automatic_discovery(self):\n \"\"\"Test on the Adult dataset.\n\n Binary classification.\n \"\"\"\n\n dataset = adult_dataset()\n model = build_model(\n signature=Signature.AUTOMATIC_FEATURE_DISCOVERY, dataset=dataset)\n self._check_adult_model_with_cart(model, dataset)\n\n inspector = model.make_inspector()\n self.assertEqual(inspector.num_trees(), 300)\n self.assertEqual(inspector.task, keras.Task.CLASSIFICATION)\n logging.info(\"Variable importances:\\n%s\", inspector.variable_importances())\n\n def test_model_adult_with_hyperparameter_template_v1(self):\n \"\"\"Test on the Adult dataset.\n\n Binary classification.\n \"\"\"\n\n dataset = adult_dataset()\n model = keras.RandomForestModel(\n hyperparameter_template=\"benchmark_rank1@v1\")\n\n self._check_adult_model(\n model=model,\n dataset=dataset,\n minimum_accuracy=0.864,\n check_serialization=True)\n\n def test_model_adult_with_hyperparameter_template_v2(self):\n \"\"\"Test on the Adult dataset.\n\n Binary classification.\n \"\"\"\n\n dataset = adult_dataset()\n model = keras.RandomForestModel(hyperparameter_template=\"benchmark_rank1\")\n\n self._check_adult_model(\n model=model,\n dataset=dataset,\n minimum_accuracy=0.864,\n check_serialization=True)\n\n def test_model_adult_automatic_discovery_oob_variable_importance(self):\n\n dataset = adult_dataset()\n model = keras.RandomForestModel(compute_oob_variable_importances=True)\n model.fit(keras.pd_dataframe_to_tf_dataset(dataset.train, dataset.label))\n\n inspector = model.make_inspector()\n logging.info(\"Variable importances:\\n%s\", inspector.variable_importances())\n logging.info(\"OOB Evaluation:\\n%s\", inspector.evaluation())\n self.assertIn(\"MEAN_DECREASE_IN_ACCURACY\", inspector.variable_importances())\n self.assertGreater(inspector.evaluation().accuracy, 0.86)\n\n def test_model_adult_automatic_discovery_cart(self):\n \"\"\"Test on the Adult dataset.\n\n Binary classification with the Cart learner.\n \"\"\"\n\n dataset = adult_dataset()\n model = keras.CartModel()\n self._check_adult_model(\n model=model,\n dataset=dataset,\n minimum_accuracy=0.853,\n check_serialization=True)\n\n def test_model_adult_automatic_discovery_cart_pandas_dataframe(self):\n \"\"\"Test the support of pandas dataframes.\"\"\"\n\n dataset = adult_dataset()\n model = keras.CartModel()\n model.compile(metrics=[\"accuracy\"])\n\n # Train the model.\n model.fit(\n keras.pd_dataframe_to_tf_dataset(\n dataset.train, dataset.label, task=keras.Task.CLASSIFICATION))\n\n # Evaluate the model.\n evaluation = model.evaluate(\n keras.pd_dataframe_to_tf_dataset(\n dataset.test, dataset.label, task=keras.Task.CLASSIFICATION))\n self.assertGreaterEqual(evaluation[1], 0.853)\n\n # Generate predictions with a dataset containing labels (i.e. the label\n # are ignored).\n prediction_1 = model.predict(\n keras.pd_dataframe_to_tf_dataset(\n dataset.test, dataset.label, task=keras.Task.CLASSIFICATION))\n logging.info(\"prediction_1 %s\", prediction_1)\n\n # Generate predictions with a dataset without labels.\n prediction_2 = model.predict(keras.pd_dataframe_to_tf_dataset(dataset.test))\n logging.info(\"prediction_2 %s\", prediction_2)\n\n def test_save_model_without_evaluation(self):\n \"\"\"Train and save the model without evaluating it.\n\n The evaluation or prediction functions are automatically building the graph\n used when saving the model. This test ensures the train function also build\n a graph.\n \"\"\"\n\n dataset = adult_dataset()\n model = keras.CartModel()\n tf_train, tf_test = dataset_to_tf_dataset(dataset)\n\n model.fit(tf_train)\n\n # Export the model.\n saved_model_path = os.path.join(self.get_temp_dir(), \"saved_model\")\n model.save(saved_model_path)\n\n # Load and evaluate the exported trained model.\n logging.info(\"Loading model from %s\", saved_model_path)\n loaded_model = models.load_model(saved_model_path)\n loaded_model.summary()\n\n loaded_model.compile(metrics=[\"accuracy\"])\n evaluation = loaded_model.evaluate(tf_test)\n logging.info(\"Loaded model evaluation: %s\", evaluation)\n self.assertGreaterEqual(evaluation[1], 0.853)\n\n def test_model_adult_features_without_semantic(self):\n dataset = adult_dataset()\n model = build_model(\n signature=Signature.FEATURES_WITHOUT_SEMANTIC, dataset=dataset)\n self._check_adult_model_with_cart(model, dataset)\n\n def test_model_adult_features_with_semantic(self):\n dataset = adult_dataset()\n model = build_model(\n signature=Signature.FEATURES_WITH_SEMANTIC, dataset=dataset)\n self._check_adult_model_with_cart(model, dataset)\n\n def test_model_adult_structured_preprocessing(self):\n dataset = adult_dataset()\n model = build_model(\n signature=Signature.STRUCTURED_LIST_PREPROCESSING, dataset=dataset)\n self._check_adult_model_with_one_hot(model, dataset)\n\n def test_model_adult_structured_dictionary_preprocessing(self):\n dataset = adult_dataset()\n model = build_model(\n signature=Signature.STRUCTURED_DICTIONARY_PREPROCESSING,\n dataset=dataset,\n num_trees=100)\n self._check_adult_model_with_one_hot(model, dataset)\n\n def test_model_adult_structured_preprocessing_with_semantic(self):\n dataset = adult_dataset()\n model = build_model(\n signature=Signature.STRUCTURED_PREPROCESSING_WITH_SEMANTIC,\n dataset=dataset,\n num_trees=100)\n self._check_adult_model_with_one_hot(model, dataset)\n\n def test_model_adult_dense_feature_columns(self):\n dataset = adult_dataset()\n model = build_model(\n signature=Signature.DENSE_FEATURE_COLUMN, dataset=dataset)\n # The z-normalization of numerical feature columns cannot be serialized\n # (25 Nov.2020).\n self._check_adult_model_with_one_hot(\n model, dataset, check_serialization=False)\n\n def test_model_adult_dense_nparray(self):\n dataset = adult_dataset()\n feature_columns = build_feature_columns(dataset, dense=True)\n dense_features = layers.DenseFeatures(feature_columns)\n\n train_x = dense_features(dict(dataset.train)).numpy()\n train_y = dataset.train[dataset.label].values\n test_x = dense_features(dict(dataset.test)).numpy()\n test_y = dataset.test[dataset.label].values\n\n model = build_model(\n signature=Signature.AUTOMATIC_FEATURE_DISCOVERY, dataset=dataset)\n\n model.compile(metrics=[\"accuracy\"])\n\n evaluation = model.evaluate(test_x, test_y)\n logging.info(\"Pre-training evaluation: %s\", evaluation)\n\n predictions = model.predict(test_x)\n logging.info(\"Pre-training predictions: %s\", predictions)\n\n model.fit(x=train_x, y=train_y, validation_data=(test_x, test_y))\n model.summary()\n\n evaluation = model.evaluate(test_x, test_y)\n logging.info(\"Evaluation: %s\", evaluation)\n self.assertGreaterEqual(evaluation[1], 0.82) # Accuracy\n\n predictions = model.predict(test_x)\n logging.info(\"Predictions: %s\", predictions)\n\n def test_model_adult_dense_tfdataset(self):\n\n dataset = adult_dataset()\n feature_columns = build_feature_columns(dataset, dense=True)\n dense_features = layers.DenseFeatures(feature_columns)\n\n train_x = dense_features(dict(dataset.train))\n train_y = dataset.train[dataset.label].values\n test_x = dense_features(dict(dataset.test))\n test_y = dataset.test[dataset.label].values\n\n train_ds = tf.data.Dataset.from_tensor_slices((train_x, train_y))\n test_ds = tf.data.Dataset.from_tensor_slices((test_x, test_y))\n\n train_ds = train_ds.shuffle(1024).batch(64)\n test_ds = test_ds.batch(64)\n\n model = build_model(\n signature=Signature.AUTOMATIC_FEATURE_DISCOVERY, dataset=dataset)\n\n model.compile(metrics=[\"accuracy\"])\n\n model.fit(x=train_ds, validation_data=test_ds)\n model.summary()\n evaluation = model.evaluate(test_ds)\n logging.info(\"Evaluation: %s\", evaluation)\n self.assertGreaterEqual(evaluation[1], 0.82) # Accuracy\n\n def test_model_iris(self):\n \"\"\"Test on the Iris dataset.\n\n Multi-class classification.\n \"\"\"\n\n dataset = iris_dataset()\n\n logging.info(\"Dataset:\\n%s\", dataset.train.head())\n\n tf_train, tf_test = dataset_to_tf_dataset(dataset)\n\n model = build_model(\n signature=Signature.AUTOMATIC_FEATURE_DISCOVERY, dataset=dataset)\n\n model.compile(metrics=[\"accuracy\"])\n\n model.fit(x=tf_train, validation_data=tf_test)\n model.summary()\n evaluation = model.evaluate(tf_test)\n logging.info(\"Evaluation: %s\", evaluation)\n self.assertGreaterEqual(evaluation[1], 0.90) # Accuracy\n\n predictions = model.predict(tf_test)\n logging.info(\"Predictions: %s\", predictions)\n\n def test_model_abalone(self):\n \"\"\"Test on the Abalone dataset.\n\n Regression.\n \"\"\"\n\n dataset = abalone_dataset()\n tf_train, tf_test = dataset_to_tf_dataset(dataset)\n\n model = build_model(\n signature=Signature.AUTOMATIC_FEATURE_DISCOVERY,\n dataset=dataset,\n task=keras.Task.REGRESSION)\n\n model.compile(metrics=[\"mse\"]) # REMOVE run_eagerly\n\n model.fit(x=tf_train, validation_data=tf_test)\n model.summary()\n evaluation = model.evaluate(tf_test)\n logging.info(\"Evaluation: %s\", evaluation)\n self.assertLessEqual(evaluation[1], 6.0) # mse\n\n predictions = model.predict(tf_test)\n logging.info(\"Predictions: %s\", predictions)\n\n def test_model_abalone_advanced_config(self):\n \"\"\"Test on the Abalone dataset.\"\"\"\n\n dataset = abalone_dataset()\n tf_train, tf_test = dataset_to_tf_dataset(dataset)\n\n # Disable the pre-sorting of the numerical features.\n yggdrasil_training_config = keras.core.YggdrasilTrainingConfig()\n rf_training_config = yggdrasil_training_config.Extensions[\n random_forest_pb2.random_forest_config]\n rf_training_config.decision_tree.internal.sorting_strategy = decision_tree_pb2.DecisionTreeTrainingConfig.Internal.SortingStrategy.IN_NODE\n\n # Train on 10 threads.\n yggdrasil_deployment_config = keras.core.YggdrasilDeploymentConfig(\n num_threads=10)\n\n model = keras.RandomForestModel(\n task=keras.Task.REGRESSION,\n advanced_arguments=keras.AdvancedArguments(\n yggdrasil_training_config=yggdrasil_training_config,\n yggdrasil_deployment_config=yggdrasil_deployment_config))\n\n model.compile(metrics=[\"mse\"]) # REMOVE run_eagerly\n model.fit(x=tf_train, validation_data=tf_test)\n model.summary()\n evaluation = model.evaluate(tf_test)\n logging.info(\"Evaluation: %s\", evaluation)\n self.assertLessEqual(evaluation[1], 6.0) # mse\n\n predictions = model.predict(tf_test)\n logging.info(\"Predictions: %s\", predictions)\n\n def _synthetic_train_and_test(\n self,\n task: keras.Task,\n limit_eval_train: float,\n limit_eval_test: float,\n test_numerical: Optional[bool] = False,\n test_multidimensional_numerical: Optional[bool] = False,\n test_categorical: Optional[bool] = False,\n test_categorical_set: Optional[bool] = False,\n label_shape: Optional[int] = None,\n fit_raises: Optional[Type[Exception]] = None):\n \"\"\"Trains a model on a synthetic dataset.\"\"\"\n\n train_path = os.path.join(self.get_temp_dir(), \"train.rio.gz\")\n test_path = os.path.join(self.get_temp_dir(), \"test.rio.gz\")\n options = synthetic_dataset_pb2.SyntheticDatasetOptions(\n num_numerical=1 if test_numerical else 0,\n num_categorical=2 if test_categorical else 0,\n num_categorical_set=2 if test_categorical_set else 0,\n num_boolean=1 if test_numerical else 0,\n num_multidimensional_numerical=1\n if test_multidimensional_numerical else 0,\n num_accumulators=3)\n if task == keras.Task.CLASSIFICATION:\n options.classification.num_classes = 2\n options.classification.store_label_as_str = False\n elif task == keras.Task.REGRESSION:\n options.regression.SetInParent()\n elif task == keras.Task.RANKING:\n options.ranking.SetInParent()\n else:\n assert False\n\n options_path = os.path.join(self.get_temp_dir(), \"options.pbtxt\")\n with open(options_path, \"w\") as f:\n f.write(text_format.MessageToString(options))\n\n logging.info(\"Create synthetic dataset in %s and %s\", train_path, test_path)\n args = [\n \"tensorflow_decision_forests/keras/synthetic_dataset\",\n \"--alsologtostderr\", \"--train\", \"tfrecord+tfe:\" + train_path, \"--test\",\n \"tfrecord+tfe:\" + test_path, \"--ratio_test\", \"0.1\", \"--options\",\n options_path\n ]\n popen = subprocess.Popen(args, stdout=subprocess.PIPE)\n popen.wait()\n\n feature_spec = {}\n label_shape = [label_shape] if label_shape else []\n if task == keras.Task.CLASSIFICATION:\n feature_spec[\"LABEL\"] = tf.io.FixedLenFeature(label_shape, tf.int64)\n elif task == keras.Task.REGRESSION:\n feature_spec[\"LABEL\"] = tf.io.FixedLenFeature(label_shape, tf.float32)\n elif task == keras.Task.RANKING:\n feature_spec[\"LABEL\"] = tf.io.FixedLenFeature(label_shape, tf.float32)\n feature_spec[\"GROUP\"] = tf.io.FixedLenFeature([], tf.string)\n else:\n assert False\n\n if test_numerical:\n feature_spec[\"num_0\"] = tf.io.FixedLenFeature([], tf.float32, np.nan)\n feature_spec[\"bool_0\"] = tf.io.FixedLenFeature([], tf.float32, np.nan)\n\n if test_multidimensional_numerical:\n feature_spec[\"multidimensional_num_0\"] = tf.io.FixedLenFeature(\n [5], tf.float32, [np.nan] * 5)\n\n if test_categorical:\n feature_spec[\"cat_int_0\"] = tf.io.FixedLenFeature([], tf.int64, -2)\n feature_spec[\"cat_str_0\"] = tf.io.FixedLenFeature([], tf.string, \"\")\n feature_spec[\"cat_int_1\"] = tf.io.VarLenFeature(tf.int64)\n feature_spec[\"cat_str_1\"] = tf.io.VarLenFeature(tf.string)\n\n if test_categorical_set:\n feature_spec[\"cat_set_int_0\"] = tf.io.VarLenFeature(tf.int64)\n feature_spec[\"cat_set_str_0\"] = tf.io.VarLenFeature(tf.string)\n feature_spec[\"cat_set_int_1\"] = tf.io.VarLenFeature(tf.int64)\n feature_spec[\"cat_set_str_1\"] = tf.io.VarLenFeature(tf.string)\n\n def parse(serialized_example):\n feature_values = tf.io.parse_single_example(\n serialized_example, features=feature_spec)\n label = feature_values.pop(\"LABEL\")\n return feature_values, label\n\n def preprocess(feature_values, label):\n if test_categorical_set:\n for name in [\"cat_set_int_1\", \"cat_set_str_1\"]:\n feature_values[name] = tf.RaggedTensor.from_sparse(\n feature_values[name])\n\n if task == keras.Task.CLASSIFICATION:\n label = label - 1 # Encode the label in {0,1}.\n return feature_values, label\n\n train_dataset = tf.data.TFRecordDataset(\n train_path,\n compression_type=\"GZIP\").map(parse).batch(50).map(preprocess)\n test_dataset = tf.data.TFRecordDataset(\n test_path, compression_type=\"GZIP\").map(parse).batch(50).map(preprocess)\n\n features = []\n\n if test_categorical_set:\n # The semantic of sparse tensors cannot be inferred safely.\n features.extend([\n keras.FeatureUsage(\"cat_set_int_0\",\n keras.FeatureSemantic.CATEGORICAL_SET),\n keras.FeatureUsage(\"cat_set_str_0\",\n keras.FeatureSemantic.CATEGORICAL_SET)\n ])\n\n if test_categorical:\n # integers are detected as numerical by default.\n features.extend([\n keras.FeatureUsage(\"cat_int_0\", keras.FeatureSemantic.CATEGORICAL),\n keras.FeatureUsage(\"cat_int_1\", keras.FeatureSemantic.CATEGORICAL)\n ])\n\n val_keys = [\"val_loss\"]\n if task == keras.Task.CLASSIFICATION:\n model = keras.RandomForestModel(task=task, features=features)\n model.compile(metrics=[\"accuracy\"])\n compare = self.assertGreaterEqual\n val_keys += [\"val_accuracy\"]\n elif task == keras.Task.REGRESSION:\n model = keras.RandomForestModel(task=task, features=features)\n model.compile(metrics=[\"mse\"])\n compare = self.assertLessEqual\n val_keys += [\"val_mse\"]\n elif task == keras.Task.RANKING:\n model = keras.GradientBoostedTreesModel(\n task=task, features=features, ranking_group=\"GROUP\", num_trees=50)\n compare = None\n else:\n assert False\n\n # Test that `on_epoch_end` callbacks can call `Model.evaluate` and will have\n # the results proper for a trained model.\n class _TestEvalCallback(tf.keras.callbacks.Callback):\n\n def on_epoch_end(self, epoch, logs=None):\n self.evaluation = model.evaluate(test_dataset)\n\n callback = _TestEvalCallback()\n history = None\n if fit_raises is not None:\n with self.assertRaises(fit_raises):\n model.fit(\n train_dataset, validation_data=test_dataset, callbacks=[callback])\n else:\n history = model.fit(\n train_dataset, validation_data=test_dataset, callbacks=[callback])\n if history is None:\n return\n model.summary()\n\n train_evaluation = model.evaluate(train_dataset)\n logging.info(\"Train evaluation: %s\", train_evaluation)\n test_evaluation = model.evaluate(test_dataset)\n logging.info(\"Test evaluation: %s\", test_evaluation)\n val_evaluation = [history.history[key][0] for key in val_keys]\n logging.info(\n \"Validation evaluation in training \"\n \"(validation_data=test_dataset): %s\", val_evaluation)\n logging.info(\"Callback evaluation (test_dataset): %s\", callback.evaluation)\n\n # The training evaluation is capped by the ratio of missing value (5%).\n if compare is not None:\n compare(train_evaluation[1], limit_eval_train)\n compare(test_evaluation[1], limit_eval_test)\n self.assertEqual(val_evaluation[1], test_evaluation[1])\n self.assertEqual(callback.evaluation[1], test_evaluation[1])\n\n _ = model.predict(test_dataset)\n\n def test_synthetic_classification_numerical(self):\n self._synthetic_train_and_test(\n keras.Task.CLASSIFICATION, 0.8, 0.72, test_numerical=True)\n\n def test_synthetic_classification_squeeze_label(self):\n self._synthetic_train_and_test(\n keras.Task.CLASSIFICATION,\n 0.8,\n 0.72,\n test_numerical=True,\n label_shape=1)\n\n def test_synthetic_classification_squeeze_label_invalid_shape(self):\n self._synthetic_train_and_test(\n keras.Task.CLASSIFICATION,\n 0.8,\n 0.72,\n test_numerical=True,\n label_shape=2,\n fit_raises=ValueError)\n\n def test_synthetic_classification_categorical(self):\n self._synthetic_train_and_test(\n keras.Task.CLASSIFICATION, 0.95, 0.70, test_categorical=True)\n\n def test_synthetic_classification_multidimensional_numerical(self):\n self._synthetic_train_and_test(\n keras.Task.CLASSIFICATION,\n 0.96,\n 0.70,\n test_multidimensional_numerical=True)\n\n def test_synthetic_classification_categorical_set(self):\n self._synthetic_train_and_test(\n keras.Task.CLASSIFICATION, 0.915, 0.645, test_categorical_set=True)\n\n def test_synthetic_regression_numerical(self):\n self._synthetic_train_and_test(\n keras.Task.REGRESSION, 0.41, 0.43, test_numerical=True)\n\n def test_synthetic_regression_categorical(self):\n self._synthetic_train_and_test(\n keras.Task.REGRESSION, 0.34, 0.34, test_categorical=True)\n\n def test_synthetic_regression_multidimensional_numerical(self):\n self._synthetic_train_and_test(\n keras.Task.REGRESSION, 0.47, 0.46, test_multidimensional_numerical=True)\n\n def test_synthetic_regression_categorical_set(self):\n self._synthetic_train_and_test(\n keras.Task.REGRESSION, 0.345, 0.345, test_categorical_set=True)\n\n def test_synthetic_ranking_numerical(self):\n self._synthetic_train_and_test(\n keras.Task.RANKING, -1.0, -1.0, test_numerical=True)\n\n def test_model_adult_df_on_top_of_nn(self):\n \"\"\"Composition of a DF on top of a NN.\"\"\"\n\n dataset = adult_dataset()\n tf_train, tf_test = dataset_to_tf_dataset(dataset)\n\n # Train a NN.\n # Note: The following code does not work with the \"models.Sequential\" API\n # (Nov.17, 2020).\n raw_inputs, preprocessed_inputs = build_preprocessing(dataset)\n z1 = layers.Concatenate()(preprocessed_inputs)\n z2 = layers.Dense(16, activation=tf.nn.relu6)(z1)\n z3 = layers.Dense(16, activation=tf.nn.relu, name=\"last\")(z2)\n y = layers.Dense(1)(z3)\n nn_model = models.Model(raw_inputs, y)\n\n nn_model.compile(\n optimizer=optimizers.Adam(),\n loss=tf.keras.losses.BinaryCrossentropy(),\n metrics=[\"accuracy\"])\n\n nn_model.fit(x=tf_train, validation_data=tf_test, epochs=10)\n logging.info(\"Trained NN\")\n nn_model.summary()\n\n # Build a DF on top of the NN\n nn_without_head = models.Model(\n inputs=nn_model.inputs, outputs=nn_model.get_layer(\"last\").output)\n df_model = keras.RandomForestModel(preprocessing=nn_without_head)\n\n df_model.compile(metrics=[\"accuracy\"])\n\n df_model.fit(x=tf_train, validation_data=tf_test)\n logging.info(\"Combined model\")\n df_model.summary()\n\n def test_parse_hp_template(self):\n\n self.assertEqual(core._parse_hp_template(\"abc@v5\"), (\"abc\", 5))\n self.assertEqual(core._parse_hp_template(\"abc\"), (\"abc\", None))\n with self.assertRaises(ValueError):\n core._parse_hp_template(\"abc@5\")\n\n def test_get_matching_template(self):\n a = core.HyperParameterTemplate(\n name=\"t1\", version=1, parameters={\"p\": 1.0}, description=\"\")\n b = core.HyperParameterTemplate(\n name=\"t1\", version=2, parameters={\"p\": 2.0}, description=\"\")\n c = core.HyperParameterTemplate(\n name=\"t2\", version=1, parameters={\"p\": 3.0}, description=\"\")\n templates = [a, b, c]\n\n self.assertEqual(core._get_matching_template(\"t1@v1\", templates), a)\n self.assertEqual(core._get_matching_template(\"t1@v2\", templates), b)\n self.assertEqual(core._get_matching_template(\"t1\", templates), b)\n self.assertEqual(core._get_matching_template(\"t2\", templates), c)\n\n with self.assertRaises(ValueError):\n core._get_matching_template(\"t1@v4\", templates)\n\n with self.assertRaises(ValueError):\n core._get_matching_template(\"t3\", templates)\n\n def test_apply_hp_template(self):\n templates = [\n core.HyperParameterTemplate(\n name=\"t1\", version=1, parameters={\"p1\": 2.0}, description=\"\")\n ]\n\n self.assertEqual(\n core._apply_hp_template({\"p1\": 1.0},\n \"t1\",\n templates,\n explicit_parameters=set()), {\"p1\": 2.0})\n\n self.assertEqual(\n core._apply_hp_template({\"p1\": 1.0},\n \"t1\",\n templates,\n explicit_parameters=set([\"p1\"])), {\"p1\": 1.0})\n\n with self.assertRaises(ValueError):\n core._apply_hp_template({\"p1\": 1.0},\n \"t2\",\n templates,\n explicit_parameters=set())\n\n def test_list_explicit_arguments(self):\n\n @core._list_explicit_arguments\n def f(a=1, b=2, c=3, explicit_args=None):\n f.last_explicit_args = explicit_args\n\n del a\n del b\n del c\n\n f()\n self.assertEqual(f.last_explicit_args, set([]))\n\n f(a=5)\n self.assertEqual(f.last_explicit_args, set([\"a\"]))\n\n f(b=6, c=7)\n self.assertEqual(f.last_explicit_args, set([\"b\", \"c\"]))\n\n def test_rank1_preprocessing(self):\n \"\"\"Test the limitation on rank1 preprocessing.\"\"\"\n\n def experiment(infer_prediction_signature, save_model):\n x_train = [1.0, 2.0, 3.0, 4.0] # Dataset with a single feature.\n y_train = [0, 1, 0, 1]\n\n @tf.function(\n input_signature=(tf.TensorSpec(shape=[None], dtype=tf.float32),))\n def processor(x):\n return x + 1\n\n model = keras.RandomForestModel(\n preprocessing=processor,\n advanced_arguments=keras.AdvancedArguments(\n infer_prediction_signature=infer_prediction_signature))\n model.fit(x=x_train, y=y_train)\n\n if save_model:\n # Fails if the model is not build before.\n model.save(os.path.join(self.get_temp_dir(), \"saved_model\"))\n\n experiment(infer_prediction_signature=False, save_model=False)\n\n with self.assertRaises(ValueError):\n experiment(infer_prediction_signature=False, save_model=True)\n\n with self.assertRaises(ValueError):\n experiment(infer_prediction_signature=True, save_model=False)\n\n def test_get_all_models(self):\n print(keras.get_all_models())\n\n def test_feature_with_comma(self):\n model = keras.GradientBoostedTreesModel()\n dataset = pd.DataFrame({\"a,b\": [0, 1, 2], \"label\": [0, 1, 2]})\n model.fit(keras.pd_dataframe_to_tf_dataset(dataset, label=\"label\"))\n\n def test_error_too_much_classes(self):\n dataframe = pd.DataFrame({\"x\": list(range(10)), \"label\": list(range(10))})\n with self.assertRaises(ValueError):\n keras.pd_dataframe_to_tf_dataset(\n dataframe, label=\"label\", max_num_classes=5)\n\n def test_error_non_matching_task(self):\n dataframe = pd.DataFrame({\"x\": list(range(10)), \"label\": list(range(10))})\n dataset = keras.pd_dataframe_to_tf_dataset(\n dataframe, label=\"label\", task=keras.Task.CLASSIFICATION)\n model = keras.GradientBoostedTreesModel(task=keras.Task.REGRESSION)\n with self.assertRaises(ValueError):\n model.fit(dataset)\n\n\nif __name__ == \"__main__\":\n tf.test.main()\n"
] | [
[
"tensorflow.TensorSpec",
"tensorflow.data.TFRecordDataset",
"tensorflow.data.Dataset.from_tensor_slices",
"numpy.minimum",
"pandas.DataFrame",
"tensorflow.feature_column.categorical_column_with_vocabulary_list",
"tensorflow.io.FixedLenFeature",
"tensorflow.feature_column.indicator_column",
"numpy.where",
"tensorflow.io.parse_single_example",
"tensorflow.keras.backend.clear_session",
"tensorflow.test.main",
"pandas.read_csv",
"tensorflow.io.VarLenFeature",
"tensorflow.keras.losses.BinaryCrossentropy",
"tensorflow.RaggedTensor.from_sparse"
]
] |
dattasiddhartha/GIFShop-Wizard | [
"a3e9ba198b3bdc6645e53e0d652430534c362442"
] | [
"vision/foreground_removal/image_inpainting.py"
] | [
"import tensorflow as tf\nphysical_devices = tf.config.experimental.list_physical_devices('GPU')\ntf.config.experimental.set_memory_growth(physical_devices[0], True)\nfrom absl import flags, app\nfrom absl.flags import FLAGS\nfrom vision.foreground_removal.pix2pix.utils.model import Pix2Pix\nfrom vision.foreground_removal.pix2pix.utils.dataset import train_pipeline, test_pipeline\n\nflags.DEFINE_integer('buffer_size', 400, 'size of buffer')\nflags.DEFINE_integer('batch_size', 4, 'size of batch')\nflags.DEFINE_integer('width', 256, 'width of resulting images')\nflags.DEFINE_integer('height', 256, 'height of resulting images')\nflags.DEFINE_float('lambda_p', 100, 'lambda parameter')\nflags.DEFINE_integer('epochs', 25, 'Number of epochs to train from', short_name='e')\nflags.DEFINE_string('checkpoint', 'pix2pix/checkpoint/', 'Checkpoint directory')\nflags.DEFINE_string('training_dir', 'input/train/', 'Path for training samples', short_name='train')\nflags.DEFINE_string('testing_dir', 'input/test/', 'Path for testing samples', short_name='test')\nflags.DEFINE_bool('restore_check', True, 'Restore last checkpoint in folder --checkpoint', short_name='restore')\nflags.DEFINE_integer('num_images', -1, 'Number of images to take from dataset', short_name='n')\nflags.DEFINE_integer('test_samples', 2, 'Number of generated samples for testing')\nflags.DEFINE_string('mode', 'test', 'Mode: train or test')\n\ndef main(_argv):\n print('Parameters:\\n')\n print(f'Image = [{FLAGS.height}x{FLAGS.width}]\\n')\n print(f'Lambda = {FLAGS.lambda_p}\\n')\n print(f'Number of images = {FLAGS.num_images}\\n')\n\n mode = FLAGS.mode\n if mode == 'train':\n train_dataset = train_pipeline(FLAGS.training_dir, FLAGS.buffer_size, FLAGS.width, FLAGS.height, FLAGS.num_images,\n FLAGS.batch_size)\n test_dataset = test_pipeline(FLAGS.testing_dir, FLAGS.width, FLAGS.height, FLAGS.num_images)\n\n p2p = Pix2Pix(mode, train_dataset, test_dataset, FLAGS.lambda_p, FLAGS.epochs, FLAGS.checkpoint, FLAGS.restore_check,\n FLAGS.test_samples)\n p2p.fit()\n elif mode == 'test':\n train_dataset = []\n test_dataset = test_pipeline(FLAGS.testing_dir, FLAGS.width, FLAGS.height, FLAGS.num_images)\n\n p2p = Pix2Pix(mode, train_dataset, test_dataset, FLAGS.lambda_p, FLAGS.epochs, FLAGS.checkpoint, FLAGS.restore_check,\n FLAGS.test_samples)\n\n p2p.test_model()\n\n\nif __name__ == '__main__':\n try:\n app.run(main)\n except Exception as e:\n print(f'Error: {e}')\n"
] | [
[
"tensorflow.config.experimental.list_physical_devices",
"tensorflow.config.experimental.set_memory_growth"
]
] |
jedludlow/tolerance_interval_py | [
"cf3ecd1e2f9b870de3e71bc92e07e6394510c001"
] | [
"tests/test_oneside_nonparmetric.py"
] | [
"# -- coding: utf-8 --\nimport numpy as np\nfrom toleranceinterval.oneside import non_parametric\nimport unittest\n\n\nclass TestEverything(unittest.TestCase):\n\n # Tabuluar values from Table J11 from:\n # Meeker, W.Q., Hahn, G.J. and Escobar, L.A., 2017. Statistical intervals:\n # A guide for practitioners and researchers (Vol. 541). John Wiley & Sons.\n\n sample_sizes = np.array([10, 15, 20, 25, 30, 35, 40, 50, 60, 80, 100, 200,\n 300, 400, 500, 600, 800, 1000])\n P = np.array([0.75, 0.75, 0.75, 0.90, 0.90, 0.90, 0.95, 0.95, 0.95, 0.99,\n 0.99, 0.99])\n G = np.array([0.90, 0.95, 0.99, 0.90, 0.95, 0.99, 0.90, 0.95, 0.99, 0.90,\n 0.95, 0.99])\n K = np.array([1, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan,\n np.nan, np.nan, np.nan, np.nan, 2, 1, np.nan, np.nan, np.nan,\n np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, 3, 2,\n 1, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan,\n np.nan, np.nan, 4, 3, 2, 1, np.nan, np.nan, np.nan, np.nan,\n np.nan, np.nan, np.nan, np.nan, 5, 4, 2, 1, 1, np.nan,\n np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, 6, 5, 3, 1,\n 1, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, 7,\n 6, 4, 2, 1, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan,\n np.nan, 9, 8, 6, 2, 2, 1, 1, np.nan, np.nan, np.nan, np.nan,\n np.nan, 11, 10, 8, 3, 2, 1, 1, 1, np.nan, np.nan, np.nan,\n np.nan, 15, 14, 11, 5, 4, 2, 2, 1, np.nan, np.nan, np.nan,\n np.nan, 20, 18, 15, 6, 5, 4, 2, 2, 1, np.nan, np.nan, np.nan,\n 42, 40, 36, 15, 13, 11, 6, 5, 4, np.nan, np.nan, np.nan, 65,\n 63, 58, 23, 22, 19, 10, 9, 7, 1, 1, np.nan, 89, 86, 80, 32,\n 30, 27, 15, 13, 11, 2, 1, np.nan, 113, 109, 103, 41, 39, 35,\n 19, 17, 14, 2, 2, 1, 136, 133, 126, 51, 48, 44, 23, 21, 18,\n 3, 2, 1, 184, 180, 172, 69, 66, 61, 32, 30, 26, 5, 4, 2, 233,\n 228, 219, 88, 85, 79, 41, 39, 35, 6, 5, 3]) - 1.\n K = K.reshape(sample_sizes.size, P.size)\n\n def test_upper_table_bounds(self):\n for i, row in enumerate(self.K):\n n = self.sample_sizes[i]\n x = np.arange(n)\n for j, k in enumerate(row):\n k = n - k - 1\n p = self.P[j]\n g = self.G[j]\n bound = non_parametric(x, p, g)[0]\n if np.isnan(k) and np.isnan(bound):\n self.assertTrue(True)\n else:\n self.assertEqual(k, bound)\n\n def test_lower_table_bounds(self):\n for i, row in enumerate(self.K):\n n = self.sample_sizes[i]\n x = np.arange(n)\n for j, k in enumerate(row):\n p = 1.0 - self.P[j]\n g = self.G[j]\n bound = non_parametric(x, p, g)[0]\n if np.isnan(k) and np.isnan(bound):\n self.assertTrue(True)\n else:\n self.assertEqual(k, bound)\n\n def test_random_shapes(self):\n M = [3, 10, 20]\n N = [5, 10, 20]\n for m in M:\n for n in N:\n x = np.random.random((m, n))\n bounds = non_parametric(x, 0.1, 0.95)\n _m = bounds.size\n self.assertTrue(_m == m)\n\n def test_value_error(self):\n with self.assertRaises(ValueError):\n x = np.random.random((1, 2, 4, 3))\n non_parametric(x, 0.1, 0.9)\n\n\nif __name__ == '__main__':\n np.random.seed(121)\n unittest.main()\n"
] | [
[
"numpy.array",
"numpy.isnan",
"numpy.random.seed",
"numpy.arange",
"numpy.random.random"
]
] |
dprada/OpenPharmacophore | [
"bfcf4bdafd586b27a48fd5d1f13614707b5e55a8"
] | [
"openpharmacophore/utils/direction_vector.py"
] | [
"import numpy as np\n\ndef donor_acceptor_direction_vector(molecule, feat_type, atom_indx, coords, conformer_idx):\n \"\"\"\n Compute the direction vector for an H bond donor or H bond acceptor feature \n\n Parameters\n ----------\n molecule : rdkit.Chem.rdchem.Mol\n Molecule that contains the feature which direction vector will be computed.\n\n feat_type : str\n Type of feature. Wheter is donor or acceptor.\n\n atom_indx : int\n Index of the H bond acceptor or donor atom.\n\n coords : numpy.ndarray; shape(3,)\n Coordiantes of the H bond acceptor or donor atom.\n\n conformer_idx : int \n Index of the conformer for which the direction vector will be computed.\n\n Returns\n -------\n direction : numpy.ndarray; shape(3,)\n Coordinates of the direction vector.\n\n \"\"\"\n direction = np.zeros((3,)) \n atom = molecule.GetAtomWithIdx(atom_indx)\n for a in atom.GetNeighbors():\n if a.GetSymbol() == \"H\":\n continue\n position = molecule.GetConformer(conformer_idx).GetAtomPosition(a.GetIdx())\n direction[0] += position.x - coords[0]\n direction[1] += position.y - coords[1]\n direction[2] += position.z - coords[2]\n if feat_type == \"Donor\":\n direction = -direction\n return direction\n \n\ndef aromatic_direction_vector(molecule, atom_indxs, conformer_idx):\n \"\"\" Compute the direction vector for an aromatic feature. \n\n Parameters\n ----------\n molecule : rdkit.Chem.rdchem.Mol\n Molecule that contains the feature which direction vector will be computed.\n\n atom_indxs : tuple of int\n Indices of the aromatic atoms.\n\n conformer_idx : int \n Index of the conformer for which the direction vector will be computed.\n\n Returns\n -------\n direction : numpy.ndarray; shape(3,)\n Coordinates of the direction vector.\n\n \"\"\"\n coords = np.zeros((3, 3)) # Take just the first three atoms\n for j, idx in enumerate(atom_indxs[0:3]):\n position = molecule.GetConformer(conformer_idx).GetAtomPosition(idx)\n coords[j, 0] = position.x\n coords[j, 1] = position.y\n coords[j, 2] = position.z\n \n # Find the vector normal to the plane defined by the three atoms\n u = coords[1, :] - coords[0, :]\n v = coords[2, :] - coords[0, :]\n direction = np.cross(u, v)\n\n return direction"
] | [
[
"numpy.cross",
"numpy.zeros"
]
] |
HinanawiTS/ECE-143-Project | [
"b23c85d4815943b284a4275f10f0a73f77d1c038"
] | [
"src/logistic_plus.py"
] | [
"import matplotlib\nimport pandas as pd\nimport numpy as np\nimport seaborn as sns\nimport matplotlib.pyplot as plt\nfrom sklearn.linear_model import LogisticRegression\nfrom sklearn.preprocessing import PolynomialFeatures\nfrom sklearn.pipeline import Pipeline\nfrom PlotPitch import draw_pitch\n#from sklearn.pipeline import make_pipeline\n\n\ndef logistic_dist(x_train_dis_2, y_train_dis_2):\n \"\"\"\n Logistic Regression Model between goal and Distance\n \"\"\"\n assert isinstance(x_train_dis_2, pd.DataFrame)\n assert isinstance(y_train_dis_2, pd.Series)\n poly = PolynomialFeatures(degree = 2, interaction_only=False, include_bias=False)\n lgm_dis_2 = LogisticRegression()\n lgm_dis_2.fit(x_train_dis_2,y_train_dis_2)\n pipe = Pipeline([('polynomial_features',poly), ('logistic_regression',lgm_dis_2)])\n pipe.fit(x_train_dis_2, y_train_dis_2)\n\n return lgm_dis_2.coef_, lgm_dis_2.intercept_\n\ndef plot_prob_goal_dist(df, coef, intercept):\n \"\"\"\n Plot Logistic Regression Model between goal and distance\n \"\"\"\n assert isinstance(df, pd.DataFrame)\n assert isinstance(coef, np.ndarray)\n assert isinstance(intercept, np.ndarray)\n fig, axes = plt.subplots(figsize=(11, 5))\n #first we want to create bins to calc our probability\n #pandas has a function qcut that evenly distibutes the data \n #into n bins based on a desired column value\n df['Goal']=df['Goal'].astype(int)\n df['Distance_Bins'] = pd.qcut(df['Distance'],q=100)\n #now we want to find the mean of the Goal column(our prob density) for each bin\n #and the mean of the distance for each bin\n dist_prob = df.groupby('Distance_Bins',as_index=False)['Goal'].mean()['Goal']\n dist_mean = df.groupby('Distance_Bins',as_index=False)['Distance'].mean()['Distance']\n dist_trend = sns.scatterplot(x=dist_mean,y=dist_prob)\n dist_trend.set_xlabel(\"Distance (m)\", fontsize=12)\n dist_trend.set_ylabel(\"Probabilty of Goal\", fontsize=12)\n dist_trend.set_title(\"Probability of Scoring Based on Distance\", fontsize=17, weight = \"bold\")\n dis = np.linspace(0,50,100)\n sns.lineplot(x = dis,y = 1/(1+np.exp((coef[0][0]*dis-coef[0][1]*dis**2-intercept[0]))),color='green',\n label='Log Fit with Quadratic Term')\n \n plt.show()\n\ndef logistic_angle(X_train, Y_train):\n \"\"\"\n Logistic Regression Model between goal and angle\n \"\"\"\n assert isinstance(X_train, pd.DataFrame)\n assert isinstance(Y_train, pd.Series)\n poly = PolynomialFeatures(degree = 2, interaction_only=False, include_bias=False)\n lr_ang_poly = LogisticRegression()\n pipe = Pipeline([('polynomial_features',poly), ('logistic_regression',lr_ang_poly)])\n pipe.fit(X_train, Y_train)\n\n log_odds = lr_ang_poly.coef_[0]\n\n return lr_ang_poly.coef_, lr_ang_poly.intercept_\n\ndef plot_prob_goal_angle(df, coef, intercept):\n \"\"\"\n Plot Logistic Regression Model between goal and angle\n \"\"\"\n assert isinstance(df, pd.DataFrame)\n assert isinstance(coef, np.ndarray)\n assert isinstance(intercept, np.ndarray)\n fig, axes = plt.subplots(figsize=(11, 5))\n df['Angle_Bins'] = pd.qcut(df['Angle Degrees'],q=100)\n angle_prob = df.groupby('Angle_Bins',as_index=False)['Goal'].mean()['Goal']\n angle_mean = df.groupby('Angle_Bins',as_index=False)['Angle Degrees'].mean()['Angle Degrees']\n angle_trend = sns.scatterplot(x=angle_mean,y=angle_prob)\n angle_trend.set_xlabel(\"Avg. Angle of Bin\", fontsize=12)\n angle_trend.set_ylabel(\"Probabilty of Goal\", fontsize=12)\n angle_trend.set_title(\"Probability of Scoring Based on Angle\", fontsize=17, weight = \"bold\")\n ang = np.linspace(0,100,100)\n sns.lineplot(x = ang,y = 1/(1+np.exp(-(coef[0][0]*ang + coef[0][1]*ang**2\n + intercept[0]))),color='green', label='Log Fit')\n\n plt.show()\n\ndef logistic_dist_angle(X_train, Y_train):\n \"\"\"\n Logistic Regression Model 2Dimension\n \"\"\"\n assert isinstance(X_train, pd.DataFrame)\n assert isinstance(Y_train, pd.Series)\n\n lgm_2 = LogisticRegression(random_state=0)\n lgm_2.fit(X_train,Y_train)\n \n return lgm_2.coef_, lgm_2.intercept_\n\ndef Logistic(Y):\n g_y = 1 + np.exp(-Y)\n return np.reciprocal(g_y)\n\ndef plot_logistic_model(coef, intercept):\n \"\"\"\n Plot Logsitc Regression Model\n \"\"\"\n assert isinstance(coef, np.ndarray)\n assert isinstance(intercept, np.ndarray)\n x0 = np.linspace(-34, 34, 100)\n x1 = np.linspace(.1, 53 , 100)\n x_0 = np.linspace(0, 68, 100)\n x0_grid, x1_grid = np.meshgrid(x0, x1)\n c=7.32\n a=np.sqrt((x0_grid-7.32/2)**2 + x1_grid**2)\n b=np.sqrt((x0_grid+7.32/2)**2 + x1_grid**2)\n h_grid = Logistic(coef[0][1]*np.arccos((c**2-a**2-b**2)/(-2*a*b))\n +coef[0][0]*np.sqrt((x1_grid)**2+(x0_grid)**2)+intercept[0])\n\n\n fig, ax = plt.subplots(figsize=(11, 7))\n draw_pitch(orientation=\"vertical\",\n aspect=\"half\",\n pitch_color='white',\n line_color=\"black\",\n ax=ax)\n\n\n CS =plt.contourf(x_0,x1, h_grid,alpha=.85,cmap='OrRd',levels=50)\n\n\n plt.title('xG Model', fontsize=17, weight = \"bold\")\n\n #plt.axis('off')\n ax.set_xlim(0,68)\n ax.set_ylim(52.5,0)\n plt.colorbar()\n\n plt.show()\n\n# Define a class that forces representation of float to look a certain way\n# This remove trailing zero so '1.0' becomes '1'\nclass nf(float):\n def __repr__(self):\n str = '%.1f' % (self.__float__(),)\n if str[-1] == '0':\n return '%.0f' % self.__float__()\n else:\n return '%.1f' % self.__float__()\n\ndef plot_logistic_contour(coef, intercept):\n \"\"\"\n Logistic Regression Model 2Dimension Contour\n \"\"\"\n assert isinstance(coef, np.ndarray)\n assert isinstance(intercept, np.ndarray)\n matplotlib.rcParams['xtick.direction'] = 'out'\n matplotlib.rcParams['ytick.direction'] = 'out'\n \n x0 = np.linspace(-34, 34, 100)\n x1 = np.linspace(.1, 53 , 100)\n x_0 = np.linspace(0, 68, 100)\n x0_grid, x1_grid = np.meshgrid(x0, x1)\n c=7.32\n a=np.sqrt((x0_grid-7.32/2)**2 + x1_grid**2)\n b=np.sqrt((x0_grid+7.32/2)**2 + x1_grid**2)\n h_grid = Logistic(1.57148079*np.arccos((c**2-a**2-b**2)/(-2*a*b))\n -0.11023242*np.sqrt((x1_grid)**2+(x0_grid)**2)-1.02645936)\n\n\n fig, ax = plt.subplots(figsize=(11, 7))\n draw_pitch(orientation=\"vertical\",\n aspect=\"half\",\n pitch_color='white',\n line_color=\"black\",\n ax=ax)\n\n\n CS =plt.contour(x_0,x1, h_grid,alpha=1,cmap='OrRd',levels=7)\n\n # Recast levels to new class\n CS.levels = [nf(val*100) for val in CS.levels]\n\n # Label levels with specially formatted floats\n if plt.rcParams[\"text.usetex\"]:\n fmt = r'%r \\%%'\n else:\n fmt = '%r %%'\n plt.clabel(CS, CS.levels[1::2],inline=True, fmt=fmt, fontsize=12)\n\n plt.title('xG Model', fontsize=17, weight = \"bold\")\n\n #plt.axis('off')\n ax.set_xlim(10,58)\n ax.set_ylim(22,0)\n\n plt.show()"
] | [
[
"matplotlib.pyplot.colorbar",
"numpy.arccos",
"matplotlib.pyplot.contourf",
"matplotlib.pyplot.contour",
"pandas.qcut",
"sklearn.preprocessing.PolynomialFeatures",
"matplotlib.pyplot.title",
"matplotlib.pyplot.subplots",
"numpy.exp",
"sklearn.linear_model.LogisticRegression",
"numpy.reciprocal",
"numpy.sqrt",
"matplotlib.pyplot.clabel",
"matplotlib.pyplot.show",
"numpy.linspace",
"sklearn.pipeline.Pipeline",
"numpy.meshgrid"
]
] |
samrobbins85/SM-AI_Search-Coursework | [
"4f7954b0c5c009ffb034037e0ea11429514d92ae"
] | [
"AlgBbasic.py"
] | [
"import os\nimport sys\nimport time\nimport random\nimport numpy as np\nimport collections\n\n\ndef read_file_into_string(input_file, from_ord, to_ord):\n # take a file \"input_file\", read it character by character, strip away all unwanted\n # characters with ord < \"from_ord\" and ord > \"to_ord\" and return the concatenation\n # of the file as the string \"output_string\"\n the_file = open(input_file,'r')\n current_char = the_file.read(1)\n output_string = \"\"\n while current_char != \"\":\n if ord(current_char) >= from_ord and ord(current_char) <= to_ord:\n output_string = output_string + current_char\n current_char = the_file.read(1)\n the_file.close()\n return output_string\n\ndef stripped_string_to_int(a_string):\n # take a string \"a_string\" and strip away all non-numeric characters to obtain the string\n # \"stripped_string\" which is then converted to an integer with this integer returned\n a_string_length = len(a_string)\n stripped_string = \"0\"\n if a_string_length != 0:\n for i in range(0,a_string_length):\n if ord(a_string[i]) >= 48 and ord(a_string[i]) <= 57:\n stripped_string = stripped_string + a_string[i]\n resulting_int = int(stripped_string)\n return resulting_int\n\ndef get_string_between(from_string, to_string, a_string, from_index):\n # look for the first occurrence of \"from_string\" in \"a_string\" starting at the index\n # \"from_index\", and from the end of this occurrence of \"from_string\", look for the first\n # occurrence of the string \"to_string\"; set \"middle_string\" to be the sub-string of \"a_string\"\n # lying between these two occurrences and \"to_index\" to be the index immediately after the last\n # character of the occurrence of \"to_string\" and return both \"middle_string\" and \"to_index\"\n middle_string = \"\" # \"middle_string\" and \"to_index\" play no role in the case of error\n to_index = -1 # but need to initialized to something as they are returned\n start = a_string.find(from_string,from_index)\n if start == -1:\n flag = \"*** error: \" + from_string + \" doesn't appear\"\n #trace_file.write(flag + \"\\n\")\n else:\n start = start + len(from_string)\n end = a_string.find(to_string,start)\n if end == -1:\n flag = \"*** error: \" + to_string + \" doesn't appear\"\n #trace_file.write(flag + \"\\n\")\n else:\n middle_string = a_string[start:end]\n to_index = end + len(to_string)\n flag = \"good\"\n return middle_string,to_index,flag\n\ndef string_to_array(a_string, from_index, num_cities):\n # convert the numbers separated by commas in the file-as-a-string \"a_string\", starting from index \"from_index\",\n # which should point to the first comma before the first digit, into a two-dimensional array \"distances[][]\"\n # and return it; note that we have added a comma to \"a_string\" so as to find the final distance\n # distance_matrix = []\n if from_index >= len(a_string):\n flag = \"*** error: the input file doesn't have any city distances\"\n #trace_file.write(flag + \"\\n\")\n else:\n row = 0\n column = 1\n row_of_distances = [0]\n flag = \"good\"\n while flag == \"good\":\n middle_string, from_index, flag = get_string_between(\",\", \",\", a_string, from_index)\n from_index = from_index - 1 # need to look again for the comma just found\n if flag != \"good\":\n flag = \"*** error: there aren't enough cities\"\n # trace_file.write(flag + \"\\n\")\n else:\n distance = stripped_string_to_int(middle_string)\n row_of_distances.append(distance)\n column = column + 1\n if column == num_cities:\n distance_matrix.append(row_of_distances)\n row = row + 1\n if row == num_cities - 1:\n flag = \"finished\"\n row_of_distances = [0]\n for i in range(0, num_cities - 1):\n row_of_distances.append(0)\n distance_matrix.append(row_of_distances)\n else:\n row_of_distances = [0]\n for i in range(0,row):\n row_of_distances.append(0)\n column = row + 1\n if flag == \"finished\":\n flag = \"good\"\n return flag\n\ndef make_distance_matrix_symmetric(num_cities):\n # make the upper triangular matrix \"distance_matrix\" symmetric;\n # note that there is nothing returned\n for i in range(1,num_cities):\n for j in range(0,i):\n distance_matrix[i][j] = distance_matrix[j][i]\n\n# read input file into string\n\n#######################################################################################################\n############ now we read an input file to obtain the number of cities, \"num_cities\", and a ############\n############ symmetric two-dimensional list, \"distance_matrix\", of city-to-city distances. ############\n############ the default input file is given here if none is supplied via a command line ############\n############ execution; it should reside in a folder called \"city-files\" whether it is ############\n############ supplied internally as the default file or via a command line execution. ############\n############ if your input file does not exist then the program will crash. ############\n\ninput_file = \"AISearchfile175.txt\"\n\n#######################################################################################################\n\n# you need to worry about the code below until I tell you; that is, do not touch it!\n\nif len(sys.argv) == 1:\n file_string = read_file_into_string(\"../city-files/\" + input_file,44,122)\nelse:\n input_file = sys.argv[1]\n file_string = read_file_into_string(\"../city-files/\" + input_file,44,122)\nfile_string = file_string + \",\" # we need to add a final comma to find the city distances\n # as we look for numbers between commas\nprint(\"I'm working with the file \" + input_file + \".\")\n \n# get the name of the file\n\nname_of_file,to_index,flag = get_string_between(\"NAME=\", \",\", file_string, 0)\n\nif flag == \"good\":\n print(\"I have successfully read \" + input_file + \".\")\n # get the number of cities\n num_cities_string,to_index,flag = get_string_between(\"SIZE=\", \",\", file_string, to_index)\n num_cities = stripped_string_to_int(num_cities_string)\nelse:\n print(\"***** ERROR: something went wrong when reading \" + input_file + \".\")\nif flag == \"good\":\n print(\"There are \" + str(num_cities) + \" cities.\")\n # convert the list of distances into a 2-D array\n distance_matrix = []\n to_index = to_index - 1 # ensure \"to_index\" points to the comma before the first digit\n flag = string_to_array(file_string, to_index, num_cities)\nif flag == \"good\":\n # if the conversion went well then make the distance matrix symmetric\n make_distance_matrix_symmetric(num_cities)\n print(\"I have successfully built a symmetric two-dimensional array of city distances.\")\nelse:\n print(\"***** ERROR: something went wrong when building the two-dimensional array of city distances.\")\n\n#######################################################################################################\n############ end of code to build the distance matrix from the input file: so now you have ############\n############ the two-dimensional \"num_cities\" x \"num_cities\" symmetric distance matrix ############\n############ \"distance_matrix[][]\" where \"num_cities\" is the number of cities ############\n#######################################################################################################\n\n# now you need to supply some parameters ...\n\n#######################################################################################################\n############ YOU NEED TO INCLUDE THE FOLLOWING PARAMETERS: ############\n############ \"my_user_name\" = your user-name, e.g., mine is dcs0ias ############\n\nmy_user_name = \"mbkb74\"\n\n############ \"my_first_name\" = your first name, e.g., mine is Iain ############\n\nmy_first_name = \"Iain\"\n\n############ \"my_last_name\" = your last name, e.g., mine is Stewart ############\n\nmy_last_name = \"Stewart\"\n\n############ \"alg_code\" = the two-digit code that tells me which algorithm you have ############\n############ implemented (see the assignment pdf), where the codes are: ############\n############ BF = brute-force search ############\n############ BG = basic greedy search ############\n############ BS = best_first search without heuristic data ############\n############ ID = iterative deepening search ############\n############ BH = best_first search with heuristic data ############\n############ AS = A* search ############\n############ HC = hilling climbing search ############\n############ SA = simulated annealing search ############\n############ GA = genetic algorithm ############\n\nalg_code = \"CA\"\n\n############ you can also add a note that will be added to the end of the output file if ############\n############ you like, e.g., \"in my basic greedy search, I broke ties by always visiting ############\n############ the first nearest city found\" or leave it empty if you wish ############\n\nadded_note = \"\"\n\n############ the line below sets up a dictionary of codes and search names (you need do ############\n############ nothing unless you implement an alternative algorithm and I give you a code ############\n############ for it when you can add the code and the algorithm to the dictionary) ############\n\ncodes_and_names = {'BF' : 'brute-force search',\n 'BG' : 'basic greedy search',\n 'BS' : 'best_first search without heuristic data',\n 'ID' : 'iterative deepening search',\n 'BH' : 'best_first search with heuristic data',\n 'AS' : 'A* search',\n 'HC' : 'hilling climbing search',\n 'SA' : 'simulated annealing search',\n 'GA' : 'genetic algorithm',\n 'CA' : 'Christofides'}\n\n#######################################################################################################\n############ now the code for your algorithm should begin ############\n#######################################################################################################\n\n# Set up the matrices\ninfinity=float(\"inf\")\nmatrix_numpy=np.array(distance_matrix).astype(float)\n# matrix_numpy[matrix_numpy == 0] =infinity\nnp.fill_diagonal(matrix_numpy, np.inf)\nmatrix_numpy[:,0]=np.inf\nT=np.full(matrix_numpy.shape, np.inf)\nvisited = [0]\n\n\n# Prims algorithm\nfor list in matrix_numpy:\n short_matrix=matrix_numpy[tuple(visited),:]\n ind = np.unravel_index(np.argmin(short_matrix, axis=None), short_matrix.shape)\n ind=np.asarray(ind)\n ind[0]=visited[ind[0]]\n ind=tuple(ind)\n visited.append(ind[1])\n min_shortmatrix=np.amin(short_matrix)\n T[ind]=min_shortmatrix\n T[ind[::-1]]=min_shortmatrix\n matrix_numpy[:,[ind[1]]]=np.inf\n\n\n# Find the vertices with odd degree\nsubgraph=matrix_numpy=np.array(distance_matrix).astype(float)\nnp.fill_diagonal(subgraph, np.inf)\neven_vertices=[]\nodd_vertices=[]\nfor counter,row in enumerate(T):\n col=collections.Counter(row)\n other=len(row)-col[np.inf]\n if other%2==0:\n even_vertices.append(counter)\n subgraph[counter,:]=np.inf\n subgraph[:,counter]=np.inf\n else:\n odd_vertices.append(counter)\n# matching=np.full(matrix_numpy.shape, np.inf)\n\n# Find a matching (naive because I don't have time for blossoms)\n# print(matching)\nwhile odd_vertices:\n ind = np.unravel_index(np.argmin(subgraph, axis=None), subgraph.shape)\n min = subgraph[ind]\n subgraph[ind,:]=np.inf\n subgraph[:,ind]=np.inf\n odd_vertices.remove(ind[0])\n odd_vertices.remove(ind[1])\n T[ind[::-1]]=min\n T[ind]=min\n\n# Here T is the union of the matching and T\n# Now to find a eulerian tour\n# Might be easier to convert T into an adjacency matrix first\nadjacent=T.copy()\nadjacent[adjacent != np.inf] = 1\nadjacent[adjacent == np.inf] = 0\ntour2 = []\n\n# We can use this function to also calculate the route length\ndef visit(current):\n for x in range(len(adjacent)):\n if adjacent[current][x] > 0:\n adjacent[current][x] -= 1\n adjacent[x][current] -= 1\n visit(x)\n tour2.append(current)\nvisit(0)\n\n# Now in here I need to remove duplicates and calculate the distance\ntour=[]\ntour_length=0\nfor x in tour2:\n if x not in tour:\n if len(tour)>=1:\n tour_length+=distance_matrix[x][tour[-1]]\n tour.append(x)\ntour_length+=distance_matrix[tour[0]][tour[-1]]\ntour.append(tour[0])\n\n\n\n\n\n\n\n\n\n\n#######################################################################################################\n############ the code for your algorithm should now be complete and you should have ############\n############ computed a tour held in the list \"tour\" of length \"tour_length\" ############\n#######################################################################################################\n\n# you do not need to worry about the code below; that is, do not touch it\n\n#######################################################################################################\n############ start of code to verify that the constructed tour and its length are valid ############\n#######################################################################################################\n\ncheck_tour_length = 0\nfor i in range(0,num_cities-1):\n check_tour_length = check_tour_length + distance_matrix[tour[i]][tour[i+1]]\ncheck_tour_length = check_tour_length + distance_matrix[tour[num_cities-1]][tour[0]]\nflag = \"good\"\nif tour_length != check_tour_length:\n flag = \"bad\"\nif flag == \"good\":\n print(\"Great! Your tour-length of \" + str(tour_length) + \" from your \" + codes_and_names[alg_code] + \" is valid!\")\nelse:\n print(\"***** ERROR: Your claimed tour-length of \" + str(tour_length) + \"is different from the true tour length of \" + str(check_tour_length) + \".\")\n\n#######################################################################################################\n############ start of code to write a valid tour to a text (.txt) file of the correct ############\n############ format; if your tour is not valid then you get an error message on the ############\n############ standard output and the tour is not written to a file ############\n############ ############\n############ the name of file is \"my_user_name\" + mon-dat-hr-min-sec (11 characters); ############\n############ for example, dcs0iasSep22105857.txt; if dcs0iasSep22105857.txt already exists ############\n############ then it is overwritten ############\n#######################################################################################################\n\nif flag == \"good\":\n local_time = time.asctime(time.localtime(time.time())) # return 24-character string in form \"Tue Jan 13 10:17:09 2009\"\n output_file_time = local_time[4:7] + local_time[8:10] + local_time[11:13] + local_time[14:16] + local_time[17:19]\n # output_file_time = mon + day + hour + min + sec (11 characters)\n output_file_name = my_user_name + output_file_time + \".txt\"\n f = open(output_file_name,'w')\n f.write(\"USER = \" + my_user_name + \" (\" + my_first_name + \" \" + my_last_name + \")\\n\")\n f.write(\"ALGORITHM = \" + alg_code + \", FILENAME = \" + name_of_file + \"\\n\")\n f.write(\"NUMBER OF CITIES = \" + str(num_cities) + \", TOUR LENGTH = \" + str(tour_length) + \"\\n\")\n f.write(str(tour[0]))\n for i in range(1,num_cities):\n f.write(\",\" + str(tour[i]))\n if added_note != \"\":\n f.write(\"\\nNOTE = \" + added_note)\n f.close()\n print(\"I have successfully written the tour to the output file \" + output_file_name + \".\")\n \n \n\n\n\n\n\n\n\n\n\n\n\n \n\n\n"
] | [
[
"numpy.full",
"numpy.array",
"numpy.asarray",
"numpy.fill_diagonal",
"numpy.argmin",
"numpy.amin"
]
] |
cjhillbrand/PyTradingBot | [
"aceb971c9630b2e3c8a68d912215ecc9e169b32d"
] | [
"LinReg.py"
] | [
"import pandas as pd\nimport numpy as np\n\nCEIL_PRICE = 40\nFLOOR_PRICE = 5\nSAMPLES = 500\nRANDOM_STATE = 42\nEPOCHS = 10\n\ndf = pd.read_csv('./data/russell_2000.csv')\nof_interest = df[(df['Price'] <= CEIL_PRICE) & (df['Price'] > FLOOR_PRICE)]\nof_interest = of_interest.sample(n=SAMPLES, random_state=RANDOM_STATE)\n\ndf = pd.read_csv('Best_MA.csv')\nresult = pd.merge(df, of_interest[['Ticker', 'Beta']],\n left_on='Sym', right_on='Ticker',\n how='left')\nresult.drop(columns=['Ticker'], inplace=True)\n\nweights = pd.DataFrame(np.random.random((2, 2)))\np = pd.DataFrame([np.ones((len(result))), result['Beta']])\n# FIXME need a better fill strat\np.fillna(0, inplace=True)\na = pd.DataFrame([result['Sa'], result['La']], index=[0, 1])\nm = len(p)\nalpha = 0.1\nfor i in range(0, EPOCHS):\n t = weights.dot(p)\n err = (t - a).transpose()\n err.fillna(0, inplace=True)\n adjustment = alpha / m * p.dot(err)\n weights -= adjustment\n\n cost = ((t - a) ** 2)\n cost = cost.sum(1) / (m * 2)\n print(cost)\n\n\n"
] | [
[
"pandas.DataFrame",
"pandas.read_csv",
"pandas.merge",
"numpy.random.random"
]
] |
ocordeiro/pmdarima | [
"d0dadb42b631156367a8af71786d58d22c08ca4c"
] | [
"setup.py"
] | [
"# -*- coding: utf-8 -*-\n#\n# Author: Taylor Smith <[email protected]>\n#\n# Setup the pmdarima module. This is heavily adapted from the scikit-learn\n# setup.py, since they have a similar package structure and build similar\n# Cython + C modules.\n\nimport sys\nimport os\nimport platform\nimport shutil\n\nfrom distutils.command.clean import clean as Clean\nfrom pkg_resources import parse_version\nimport traceback\nimport importlib\ntry:\n import builtins\nexcept ImportError:\n # python 2 compat: just to be able to declare that Python >=3.5 is needed\n import __builtin__ as builtins\n\n# Hacky (!!), adopted from sklearn. This sets a global variable\n# so pmdarima __init__ can detect if it's being loaded in the setup\n# routine, so it won't load submodules that haven't yet been built.\n# This is because of the numpy distutils extensions that are used by pmdarima\n# to build the compiled extensions in sub-packages\nbuiltins.__PMDARIMA_SETUP__ = True\n\n# metadata\nDISTNAME = 'pmdarima'\nPYPIDIST = 'pmdarima'\nGIT_REPO_NAME = 'pmdarima'\nDESCRIPTION = \"Python's forecast::auto.arima equivalent\"\n\n# Get the long desc\nwith open(\"README.md\", \"r\") as fh:\n LONG_DESCRIPTION = fh.read()\n\nMAINTAINER = 'Taylor G. Smith'\nMAINTAINER_GIT = 'tgsmith61591'\nMAINTAINER_EMAIL = '[email protected]'\nLICENSE = 'MIT'\nURL = 'http://alkaline-ml.com/pmdarima'\nDOWNLOAD_URL = 'https://pypi.org/project/pmdarima/#files'\nPROJECT_URLS = {\n 'Bug Tracker': 'https://github.com/alkaline-ml/pmdarima/issues',\n 'Documentation': URL,\n 'Source Code': 'https://github.com/alkaline-ml/pmdarima'\n}\n\n# import restricted version of pmdarima that does not need the compiled code\nimport pmdarima\nVERSION = pmdarima.__version__ # will be 0.0.0 unless tagging\n\n# get the installation requirements:\nwith open('requirements.txt') as req:\n REQUIREMENTS = [l for l in req.read().split(os.linesep) if l]\n print(\"Requirements: %r\" % REQUIREMENTS)\n\n# Optional setuptools features\nSETUPTOOLS_COMMANDS = { # this is a set literal, not a dict\n 'develop', 'release', 'bdist_egg', 'bdist_rpm',\n 'bdist_wininst', 'install_egg_info', 'build_sphinx',\n 'egg_info', 'easy_install', 'upload', 'bdist_wheel',\n '--single-version-externally-managed',\n\n # scikit does NOT do this:\n 'sdist,'\n}\n\nif SETUPTOOLS_COMMANDS.intersection(sys.argv):\n # we don't use setuptools, but if we don't import it, the \"develop\"\n # option for setup.py is invalid.\n import setuptools # noqa\n\n print('Adding extra setuptools args')\n extra_setuptools_args = dict(\n zip_safe=False, # the package can run out of an .egg file\n include_package_data=True,\n data_files=[\n ('pmdarima', ['pmdarima/VERSION']),\n ],\n # scikit does this:\n # extras_require={\n # 'alldeps': REQUIREMENTS\n # }\n )\nelse:\n extra_setuptools_args = dict()\n\n\n# Custom clean command to remove build artifacts -- adopted from sklearn\nclass CleanCommand(Clean):\n description = \"Remove build artifacts from the source tree\"\n\n # this is mostly in case we ever add a Cython module to SMRT\n def run(self):\n Clean.run(self)\n # Remove c files if we are not within a sdist package\n cwd = os.path.abspath(os.path.dirname(__file__))\n remove_c_files = not os.path.exists(os.path.join(cwd, 'PKG-INFO'))\n if remove_c_files:\n print('Will remove generated .c files')\n if os.path.exists('build'):\n shutil.rmtree('build')\n for dirpath, dirnames, filenames in os.walk(DISTNAME):\n for filename in filenames:\n if any(filename.endswith(suffix) for suffix in\n (\".so\", \".pyd\", \".dll\", \".pyc\")):\n print('Removing file: %s' % filename)\n os.unlink(os.path.join(dirpath, filename))\n continue\n extension = os.path.splitext(filename)[1]\n if remove_c_files and extension in ['.c', '.cpp']:\n pyx_file = str.replace(filename, extension, '.pyx')\n if os.path.exists(os.path.join(dirpath, pyx_file)):\n os.unlink(os.path.join(dirpath, filename))\n for dirname in dirnames:\n if dirname == '__pycache__':\n absdir = os.path.join(dirpath, dirname)\n print('Removing directory: %s' % absdir)\n shutil.rmtree(absdir)\n\n\ncmdclass = {'clean': CleanCommand}\n\n\n# build_ext has to be imported after setuptools\ntry:\n from numpy.distutils.command.build_ext import build_ext # noqa\n\n class build_ext_subclass(build_ext):\n def build_extensions(self):\n build_ext.build_extensions(self)\n\n cmdclass['build_ext'] = build_ext_subclass\n\nexcept ImportError:\n # Numpy should not be a dependency just to be able to introspect\n # that python 3.5 is required.\n pass\n\n# Here is where scikit configures the wheelhouse uploader, but we don't deal\n# with that currently. Maybe in the future...\n\n\ndef configuration(parent_package='', top_path=None):\n if os.path.exists('MANIFEST'):\n os.remove('MANIFEST')\n\n # we know numpy is a valid import now\n from numpy.distutils.misc_util import Configuration\n from pmdarima._build_utils import _check_cython_version\n\n config = Configuration(None, parent_package, top_path)\n\n # Avoid non-useful msg\n # \"Ignoring attempt to set 'name' (from ... \"\n config.set_options(ignore_setup_xxx_py=True,\n assume_default_configuration=True,\n delegate_options_to_subpackages=True,\n quiet=True)\n\n # Cython is required by config.add_subpackage, so check that we have the\n # correct version of Cython\n _check_cython_version()\n\n config.add_subpackage(DISTNAME)\n return config\n\n\ndef check_package_status(package, min_version):\n \"\"\"\n Returns a dictionary containing a boolean specifying whether given package\n is up-to-date, along with the version string (empty string if\n not installed).\n \"\"\"\n package_status = {}\n try:\n module = importlib.import_module(package)\n package_version = module.__version__\n package_status['up_to_date'] = parse_version(\n package_version) >= parse_version(min_version)\n package_status['version'] = package_version\n except ImportError:\n traceback.print_exc()\n package_status['up_to_date'] = False\n package_status['version'] = \"\"\n\n req_str = \"pmdarima requires {} >= {}.\\n\".format(\n package, min_version)\n\n if package_status['up_to_date'] is False:\n if package_status['version']:\n raise ImportError(\"Your installation of {} \"\n \"{} is out-of-date.\\n{}\"\n .format(package, package_status['version'],\n req_str))\n else:\n raise ImportError(\"{} is not \"\n \"installed.\\n{}\"\n .format(package, req_str))\n\n\ndef do_setup():\n # setup the config\n metadata = dict(name=PYPIDIST,\n # packages=[DISTNAME],\n maintainer=MAINTAINER,\n maintainer_email=MAINTAINER_EMAIL,\n description=DESCRIPTION,\n license=LICENSE,\n url=URL,\n download_url=DOWNLOAD_URL,\n project_urls=PROJECT_URLS,\n version=VERSION,\n long_description=LONG_DESCRIPTION,\n long_description_content_type=\"text/markdown\",\n classifiers=[\n 'Intended Audience :: Science/Research',\n 'Intended Audience :: Developers',\n 'Intended Audience :: Financial and Insurance Industry',\n 'Programming Language :: C',\n 'Programming Language :: Python',\n 'Topic :: Software Development',\n 'Topic :: Scientific/Engineering',\n 'Operating System :: Microsoft :: Windows',\n 'Operating System :: POSIX',\n 'Operating System :: Unix',\n 'Operating System :: MacOS',\n 'Programming Language :: Python :: 3',\n 'Programming Language :: Python :: 3.5',\n 'Programming Language :: Python :: 3.6',\n 'Programming Language :: Python :: 3.7',\n 'Programming Language :: Python :: 3.8',\n ('Programming Language :: Python :: '\n 'Implementation :: CPython'),\n ('Programming Language :: Python :: '\n 'Implementation :: PyPy')\n ],\n cmdclass=cmdclass,\n python_requires='>=3.5',\n install_requires=REQUIREMENTS,\n # We have a MANIFEST.in, so I'm not convinced this is fully\n # necessary, but better to be safe since we've had sdist\n # problems in the past...\n package_data=dict(\n DISTNAME=[\n '*',\n 'pmdarima/*',\n 'pmdarima/VERSION',\n 'pmdarima/__check_build/*',\n 'pmdarima/_build_utils/*',\n 'pmdarima/arima/*',\n 'pmdarima/arima/tests/data/*',\n 'pmdarima/compat/*',\n 'pmdarima/datasets/*',\n 'pmdarima/datasets/data/*',\n 'pmdarima/model_selection/*',\n 'pmdarima/preprocessing/*',\n 'pmdarima/preprocessing/endog/*',\n 'pmdarima/preprocessing/exog/*',\n 'pmdarima/tests/*',\n 'pmdarima/utils/*',\n ]\n ),\n keywords='arima timeseries forecasting pyramid pmdarima '\n 'pyramid-arima scikit-learn statsmodels',\n **extra_setuptools_args)\n\n if len(sys.argv) == 1 or (\n len(sys.argv) >= 2 and ('--help' in sys.argv[1:] or\n sys.argv[1] in ('--help-commands',\n 'egg_info',\n 'dist_info',\n '--version',\n 'clean'))):\n # For these actions, NumPy is not required, so we can import the\n # setuptools module. However this is not preferable... the moment\n # setuptools is imported, it monkey-patches distutils' setup and\n # changes its behavior...\n # (https://github.com/scikit-learn/scikit-learn/issues/1016)\n #\n # This is called when installing from pip and numpy might not\n # be on the system yet\n try:\n from setuptools import setup\n print(\"Setting up with setuptools\")\n except ImportError:\n print(\"Setting up with distutils\")\n from distutils.core import setup\n\n metadata['version'] = VERSION\n\n else:\n if sys.version_info < (3, 5):\n raise RuntimeError(\n \"pmdarima requires Python 3.5 or later. The current \"\n \"Python version is %s installed in %s.\"\n % (platform.python_version(), sys.executable))\n\n # for sdist, use setuptools so we get the long_description_content_type\n if 'sdist' in sys.argv:\n from setuptools import setup\n print(\"Setting up with setuptools\")\n else:\n # we should only need numpy for building. Everything else can be\n # collected via install_requires above\n check_package_status('numpy', '1.16')\n\n from numpy.distutils.core import setup\n print(\"Setting up with numpy.distutils.core\")\n\n # add the config to the metadata\n metadata['configuration'] = configuration\n\n # call setup on the dict\n setup(**metadata)\n\n\nif __name__ == '__main__':\n do_setup()\n"
] | [
[
"numpy.distutils.command.build_ext.build_ext.build_extensions",
"numpy.distutils.misc_util.Configuration"
]
] |
NREL/AEflow | [
"38d9e333f35bf0094993b96cd74391dad416245c"
] | [
"AEflow.py"
] | [
"import tensorflow as tf\nimport numpy as np\n\nclass AEflow:\n def __init__(self, x, status='full', reuse=False):\n '''\n Inputs:\n x: Input to the network. Depends on the given status\n Status: Which mode to run the model in\n Options:\n 'full': Input the full data field and output the compressed then reconstructed data\n 'compress': Input the full data field and output the compressed data\n 'reconstruct': Input the compressed data field and output the reconstructed data\n\n Variables:\n y: Output of the model. Depends on the given status\n var_list: List of variables to determine how much of the model to load\n loss: Loss function for training\n '''\n if x is None: return\n\n status = status.lower()\n assert status in ['full', 'compress', 'reconstruct'], 'Error in autoencoder status.'\n\n if status in ['full', 'compress']:\n self.y = self.__encoder__(x, reuse)\n self.var_list = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='encoder')\n else:\n self.y = x\n self.var_list = []\n\n if status in ['full', 'reconstruct']:\n self.y = self.__decoder__(self.y, reuse)\n self.var_list = (self.var_list + tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='decoder'))\n\n if status == 'full':\n self.loss = tf.reduce_mean((self.y - x)**2)\n else:\n self.loss = None\n\n\n def __conv_layer_3d__(self, x, filter_shape, stride):\n filter_ = tf.get_variable(name='weight', shape=filter_shape, dtype=tf.float64,\n initializer=tf.contrib.layers.xavier_initializer(), trainable=True)\n\n return tf.nn.conv3d(input=x, filter=filter_, strides=[1, stride, stride, stride, 1],\n padding='SAME')\n\n\n def __deconv_layer_3d__(self, x, filter_shape, output_shape, stride):\n filter_ = tf.get_variable(name='weight', shape=filter_shape, dtype=tf.float64,\n initializer=tf.contrib.layers.xavier_initializer(), trainable=True)\n\n return tf.nn.conv3d_transpose(value=x, filter=filter_, output_shape=output_shape,\n strides=[1, stride, stride, stride, 1])\n\n\n def __encoder__(self, x, reuse):\n with tf.variable_scope('encoder', reuse=reuse):\n\n C = 4\n with tf.variable_scope('conv_1'):\n x = self.__conv_layer_3d__(x, [5, 5, 5, x.get_shape()[-1], C], 1)\n x = tf.nn.leaky_relu(x)\n\n skip_connection = x\n \n for i in range(12):\n B_skip_connection = x\n\n with tf.variable_scope('residual_block_{}a'.format(i)):\n x = self.__conv_layer_3d__(x, [5, 5, 5, x.get_shape()[-1], C], 1)\n x = tf.nn.relu(x)\n\n with tf.variable_scope('residual_block_{}b'.format(i)):\n x = self.__conv_layer_3d__(x, [5, 5, 5, C, C], 1)\n\n x = tf.add(x, B_skip_connection)\n\n with tf.variable_scope('conv_2'):\n x = self.__conv_layer_3d__(x, [5, 5, 5, C, C], 1)\n x = tf.add(x, skip_connection)\n \n C_mult = [2, 2, 1]\n for i in range(3):\n C = int(x.get_shape()[-1])\n\n with tf.variable_scope('compress_block_{}a'.format(i)):\n x = self.__conv_layer_3d__(x, [5, 5, 5, C, C], 2)\n x = tf.nn.leaky_relu(x, alpha=0.2)\n\n with tf.variable_scope('compress_block_{}b'.format(i)):\n x = self.__conv_layer_3d__(x, [5, 5, 5, C, C_mult[i]*C], 1)\n x = tf.nn.leaky_relu(x, alpha=0.2)\n \n with tf.variable_scope('conv_out'):\n C = int(x.get_shape()[-1])\n x = self.__conv_layer_3d__(x, [5, 5, 5, C, int(C/2)], 1)\n\n return x\n \n\n def __decoder__(self, x, reuse):\n with tf.variable_scope('decoder', reuse=reuse):\n with tf.variable_scope('conv_1'):\n C = int(x.get_shape()[-1])\n x = self.__conv_layer_3d__(x, [5, 5, 5, C, 2*C], 1)\n\n C_div = [1, 2, 2]\n for i in range(3):\n N, h, w, d, C = tf.shape(x)[0], tf.shape(x)[1], tf.shape(x)[2], tf.shape(x)[3], x.get_shape()[4]\n C_over_div = int(int(C)/C_div[i])\n\n with tf.variable_scope('decompress_block_{}a'.format(i)):\n x = self.__conv_layer_3d__(x, [5, 5, 5, C, C_over_div], 1)\n x = tf.nn.leaky_relu(x, alpha=0.2)\n\n with tf.variable_scope('decompress_block_{}b'.format(i)):\n x = self.__deconv_layer_3d__(x, [5, 5, 5, C_over_div, C_over_div], [N, 2*h, 2*w, 2*d, C_over_div], 2)\n x = tf.nn.leaky_relu(x, alpha=0.2)\n\n skip_connection = x\n\n C = 4\n for i in range(12):\n B_skip_connection = x\n\n with tf.variable_scope('residual_block_{}a'.format(i)):\n x = self.__conv_layer_3d__(x, [5, 5, 5, x.get_shape()[-1], C], 1)\n x = tf.nn.relu(x)\n\n with tf.variable_scope('residual_block_{}b'.format(i)):\n x = self.__conv_layer_3d__(x, [5, 5, 5, C, C], 1)\n\n x = tf.add(x, B_skip_connection)\n\n with tf.variable_scope('conv_2'):\n x = self.__conv_layer_3d__(x, [5, 5, 5, C, C], 1)\n x = tf.add(x, skip_connection)\n\n with tf.variable_scope('conv_out'):\n x = self.__conv_layer_3d__(x, [5, 5, 5, C, 1], 1)\n\n return x\n\n\n\n\n"
] | [
[
"tensorflow.nn.conv3d",
"tensorflow.shape",
"tensorflow.nn.leaky_relu",
"tensorflow.nn.relu",
"tensorflow.contrib.layers.xavier_initializer",
"tensorflow.nn.conv3d_transpose",
"tensorflow.variable_scope",
"tensorflow.add",
"tensorflow.reduce_mean",
"tensorflow.get_collection"
]
] |
Rachit201/narknet | [
"87d7f7387f10a92c1df1daa5d5a8a366064a86c1"
] | [
"classify/video.py"
] | [
"#imports\n\nimport cv2\nimport numpy as np\nimport time\nimport sys\n\n#Load Yolo\nprint(\"Loading Model.....\")\nnet = cv2.dnn.readNet('../weights/yolov3.weights','../cfg/yolov3.cfg')\nclasses = []\n\nwith open('../dataset/coco.names','r') as f:\n\tclasses = [line.strip() for line in f.readlines()]\n\nlayer_names = net.getLayerNames()\noutput_layers = [layer_names[i[0]-1] for i in net.getUnconnectedOutLayers()]\n\nprint(\"Model Loaded\")\n\n#image loading\nfile = sys.argv[1]\ncap = cv2.VideoCapture(\"../tests/\" + file)\nf = open('../results/dump.csv', 'a+') \ntime_now = time.time()\nframe_id = 0\nfont = cv2.FONT_HERSHEY_PLAIN\n\nwhile True:\n\t_,frame = cap.read()\n\ttry:\n\t\tframe = cv2.resize(frame,(800,800))\n\texcept Exception:\n\t\tprint(\"ERROR\")\n\t\texit(1)\n\tframe_id = frame_id + 1\n\theight, width, channels = frame.shape\n\t#detecting object\n\n\tblob = cv2.dnn.blobFromImage(frame,0.00392,(320,320),(0,0,0), True, crop = False)\n\n\t# for b in blob:\n\t# \tfor n,img_blob in enumerate(b):\n\t# \t\tcv2.imshow(str(n),img_blob)\n\n\tnet.setInput(blob)\n\touts = net.forward(output_layers)\n\n\t#outs to image\n\tboxes = []\n\tconfidences = []\n\tclass_ids = []\n\n\tfor out in outs:\n\t\tfor detection in out:\n\t\t\tscores = detection[5:]\n\t\t\tclass_id = np.argmax(scores)\n\t\t\tconfidence = scores[class_id]\n\t\t\tif confidence > 0.3:\n\t\t\t\tcenter_x = int(detection[0] * width)\n\t\t\t\tcenter_y = int(detection[1] * height)\n\t\t\t\tw = int(detection[2] * width)\n\t\t\t\th = int(detection[3] * height)\n\t\t\t\tx = int(center_x - w/2)\n\t\t\t\ty = int(center_y - h/2)\n\t\t\t\tboxes.append([x,y,w,h])\n\t\t\t\tconfidences.append(float(confidence))\n\t\t\t\tclass_ids.append(class_id)\n\n\t#supressing similar boxes\n\tindexes = cv2.dnn.NMSBoxes(boxes,confidences,0.5,0.4)\n\n\tobjects_detected = len(boxes)\n\tfor i in range(objects_detected):\n\t\tif i in indexes:\n\t\t\tx,y,w,h = boxes[i]\n\t\t\tlabel = classes[class_ids[i]] + \" \" + str(int(confidences[i]*100)) + \"%\"\n\t\t\ts = str(x) + ',' + str(y) + ',' + str(w) + ',' + str(h) + ',' + classes[class_id] + ',' + str(int(confidences[i]*100)) + '\\n'\n\t\t\tf.write(s)\n\t\t\tprint(x,y,w,h,label)\n\t\t\tcv2.rectangle(frame,(x,y),(x+w,y+h),(0,255,0),2)\n\t\t\tcv2.putText(frame,label,(x,y+30),font,1,(0,0,255),2)\n\n\ttime_passed = time.time() - time_now\n\tfps = frame_id/time_passed\n\tcv2.putText(frame,\"fps: \"+ str(fps),(10,30),font, 2,(255,255,255),1)\n\tcv2.imshow('Video',frame)\n\tkey = cv2.waitKey(1)\n\tif key == 27:\n\t\tbreak\ncap.release()\ncv2.destroyAllWindows()\nf.close()"
] | [
[
"numpy.argmax"
]
] |
ShigekiKarita/tfd | [
"1ecd2b7306ee6e41f1805787b398da3bab816dd5"
] | [
"example/graph_import/graph_import.py"
] | [
"import tensorflow.compat.v1 as tf\n\nwith tf.Session() as sess:\n with open(\"add-d.bin\", \"rb\") as f:\n graph_def = tf.GraphDef()\n graph_def.ParseFromString(f.read())\n\n tf.import_graph_def(graph_def)\n graph = tf.get_default_graph()\n for op in graph.get_operations():\n print(op.name)\n\n a = graph.get_tensor_by_name(\"import/a:0\")\n add = graph.get_tensor_by_name(\"import/add:0\")\n result = sess.run(add, {a: 1})\n print(result)\n assert(result == 4)\n"
] | [
[
"tensorflow.compat.v1.Session",
"tensorflow.compat.v1.get_default_graph",
"tensorflow.compat.v1.import_graph_def",
"tensorflow.compat.v1.GraphDef"
]
] |
AvinoamCo/AvinoamSlime | [
"d53bc125b727c02df6c16eaa725987ee210eaa22"
] | [
"lib/BasicSlime.py"
] | [
"import numpy as np\n\n\nclass BasicSlime(object):\n \"\"\"\n This is the basic slime class.\n It includes the most basic features of slime\n \"\"\"\n\n def __init__(self, can_cyber=True):\n self.can_cyber = can_cyber\n self.is_cyber_unlocked = False\n\n def do(self, activity):\n \"\"\"Used for doing activities with the slime\n\n Args:\n activity (string): The activity (method name)\n \"\"\"\n\n if activity == \"play\":\n self.play()\n elif activity == \"calculate\":\n try:\n operation = input(\n \"Please enter the operation you'd like to use (+, -, *, /): \")\n num1 = int(input(\"Please enter the first number: \"))\n num2 = int(input(\"Please enter the second number: \"))\n\n self.calculate(operation, num1, num2)\n except:\n print(\"Something is invalid.\")\n elif activity == \"trigo\" or activity == \"trigonometry\":\n try:\n operation = input(\n \"Please enter the operation you'd like to use (cos, sin, tan): \")\n angle = int(\n input(\"Please enter the angle you'd like to calculate: \"))\n is_deg = input(\"Are you using degrees? \")\n\n if is_deg.lower() == \"yes\" or is_deg.lower() == \"y\":\n is_deg = True\n else:\n is_deg = False\n\n self.trigo(operation, angle, is_deg)\n except:\n print(\"Something is invalid.\")\n elif activity == \"unlock secret power\":\n self.unlock_secret_power()\n elif activity == \"cyber\":\n self.cyber()\n else:\n print(\"Your slime doesn't recognize this kind of activity!\")\n\n def play(self):\n \"\"\"Playing with the slime\n \"\"\"\n\n print(\"You are playing with the slime!\")\n print(\"You are \\\"enjoying\\\"!\")\n\n def calculate(self, operation, num1, num2):\n \"\"\"Calculates using the inputted operation something with inputted nums\n\n Args:\n operation (string): The operation used (+, -, *, /)\n num1 (int): The first number\n num2 (int): The second number\n \"\"\"\n\n if operation == \"+\":\n print(f\"{num1} + {num2} = {num1 + num2}\")\n elif operation == \"-\":\n print(f\"{num1} - {num2} = {num1 - num2}\")\n elif operation == \"*\":\n print(f\"{num1} * {num2} = {num1 * num2}\")\n elif operation == \"/\":\n print(f\"{num1} / {num2} = {num1 / num2}\")\n else:\n print(\"Unknown operation\")\n\n def trigo(self, operation, angle, is_deg=True):\n \"\"\"Prints the result for the inputted trigonometry function on the inputted angle\n\n Args:\n operation (string): The function used (cos, sin, tan)\n angle (int): The angle\n is_deg (bool, optional): Defaults to True. Whether you use degrees or radians\n \"\"\"\n\n degree_sign = '°' if is_deg else \"rad\"\n if operation == \"cos\":\n result = np.cos(angle)\n if is_deg:\n result = np.cos(np.deg2rad(angle))\n print(f\"{operation}({angle}{degree_sign}) = {result}\")\n elif operation == \"sin\":\n result = np.sin([angle])\n if is_deg:\n result = np.sin(np.deg2rad(angle))\n print(f\"{operation}({angle}{degree_sign}) = {result}\")\n elif operation == \"tan\":\n result = np.tan(angle)\n if is_deg:\n result = np.tan(np.deg2rad(angle))\n print(f\"{operation}({angle}{degree_sign}) = {result}\")\n else:\n print(\"Unknown operation\")\n\n def unlock_secret_power(self):\n \"\"\"Unlocks the secret power\n \"\"\"\n\n if self.can_cyber:\n print(\"You've just unlocked the secret power of AvinoamCo's slime!\")\n self.is_cyber_unlocked = True\n else:\n print(\"Your slime isn't capable of unlocking the secret power!\")\n\n def cyber(self):\n \"\"\"Cybers\n \"\"\"\n\n if self.is_cyber_unlocked:\n print(\"You've just used the \\\"Cyber\\\" activity!\")\n print(\"Your slime is now cybering the Pentagon!\")\n else:\n print(\"Your slime isn't capable of \\\"Cyber\\\" yet!\")\n"
] | [
[
"numpy.deg2rad",
"numpy.sin",
"numpy.tan",
"numpy.cos"
]
] |
jwrr/python-stuff | [
"7be2a408b751fe6636537d478296350256e2f133"
] | [
"raw-img/raw-patgen.py"
] | [
"#!/usr/bin/env python3\n\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport sys\n\n\ndef get_args(required_num):\n scriptname = sys.argv[0]\n num_args = len(sys.argv) - 1\n if num_args < required_num:\n print(\"Example: {} width height bitwidth\".format(scriptname))\n sys.exit(1)\n return sys.argv[1:]\n\n\ndef gradient_h(shape, dtype, filename):\n img = np.empty(shape, dtype=dtype)\n (h,w) = shape\n row = np.linspace(0, 2**16-1, w)\n for r in range(h):\n img[r] = row\n img.tofile(filename)\n print(filename)\n return img\n \n \ndef gradient_v(shape, dtype, filename):\n img = np.empty(shape, dtype=dtype)\n (h,w) = shape\n vec = np.linspace(0, 2**16-1, h)\n for c in range(w):\n img[:, c] = vec\n img.tofile(filename)\n print(filename)\n return img\n\n \ndef bars_h(shape, dtype, filename):\n img = np.zeros(shape, dtype=dtype)\n (h,w) = shape\n vec1 = np.empty(w)\n vec1.fill(2**15-1) # half-scale\n for r in range(h):\n if (r // 40) % 2:\n img[r,:] = vec1\n if filename != \"\":\n img.tofile(filename)\n print(filename)\n return img\n\n \ndef bars_v(shape, dtype, filename=\"\"):\n img = np.zeros(shape, dtype=dtype)\n (h,w) = shape\n vec1 = np.empty(h)\n vec1.fill(2**16-1)\n for c in range(w):\n if (c // 40) % 2:\n img[:, c] = vec1\n if filename != \"\":\n img.tofile(filename)\n print(filename)\n return img\n\ndef bars_vh(shape, dtype, filename=\"\"):\n img = bars_h(shape, dtype, \"\")\n (h,w) = shape\n vec1 = np.empty(h)\n vec1.fill(2**16-1)\n for c in range(w):\n if (c // 40) % 2:\n img[:, c] = vec1\n if filename != \"\":\n img.tofile(filename)\n print(filename)\n return img\n\n\ndef x(shape, dtype, filename=\"\"):\n img = np.zeros(shape, dtype=dtype)\n (h,w) = shape\n val = 2**15-1\n for r in range(h):\n img[r,r] = val\n img[r,h-r] = val\n if filename != \"\":\n img.tofile(filename)\n print(filename)\n return img\n\n\n\n\n# =================================================================\n# =================================================================\n\nw,h,bw = get_args(3)\nprint(\"width={}, height={}, bw={}\".format(w,h,bw))\n\nshape = (int(h), int(w))\ndtype = np.uint16\n\nsuffix = \"_w{}xh{}x{}bit.raw\".format(w, h, bw)\n\ngradient_h(shape, dtype, \"gradient_h\" + suffix)\ngradient_v(shape, dtype, \"gradient_v\" + suffix)\nbars_h(shape, dtype, \"bars_h\" + suffix)\nbars_v(shape, dtype, \"bars_v\" + suffix)\nbars_vh(shape, dtype, \"bars_vh\" + suffix)\nx(shape, dtype, \"x\" + suffix)\n\nprint(\"done\")\nsys.exit(0)\n\n\n# =================================================================\n# Write and read a 2d array of uint16 \nw=10\nh=8\n\n# raw = np.zeros((h,w), dtype=np.uint16)\nrow_1d = np.arange(w, dtype=np.uint16)\nimga_2d = np.empty((0,w), dtype=np.uint16)\n\nfor i in range(h):\n imga_2d = np.vstack([imga_2d, row_1d])\n\nprint(imga_2d)\n\nimga_2d.tofile(\"img.raw\")\n\n# View binary files with hexdump or xxd from linux command line\n\nimgb_2d = np.fromfile(\"img.raw\", dtype=np.uint16).reshape((-1,w))\nprint(imgb_2d)\n\n# =================================================================\n# Create and display VGA grayscale gradient image of uint16\n\nw=640\nh=480\nvga_row = np.arange(0, w*100, 100, dtype=np.uint16)\nvga_frame = np.empty((0,w), dtype=np.uint16)\nfor i in range(h):\n vga_frame = np.vstack([vga_frame, vga_row])\n\nprint(vga_frame.shape)\n\nfig, ax = plt.subplots()\nax.imshow(vga_frame, cmap=\"gray\", interpolation=\"none\")\n\n## Change default mouse-over value from float to int\ndef format_coord(x,y):\n val = vga_frame[int(y), int(x)]\n return \"x = {}, y = {} [{}]\".format(int(x), int(y), val)\nax.format_coord = format_coord\n\nplt.show()\n\n\n"
] | [
[
"numpy.empty",
"numpy.zeros",
"matplotlib.pyplot.subplots",
"numpy.arange",
"numpy.fromfile",
"matplotlib.pyplot.show",
"numpy.linspace",
"numpy.vstack"
]
] |
RafayAK/light-weight-refinenet | [
"18670c4177b91d53462b9dc30b78078b45d901ca"
] | [
"custom_aug.py"
] | [
"from abc import ABC\n\nimport matplotlib.pyplot as plt\nfrom PIL import Image\nimport numpy as np\nimport os\nimport random\nimport cv2\nimport albumentations as A\nfrom typing import Sequence, Dict, List, Callable, Any, Tuple\n\n\ndef change_background(img, msk, bg_path):\n # convert all values > 0 to 1 in the segmentation mask\n msk = np.asarray(msk.copy(), dtype=np.uint8)\n msk[msk > 0] = 1\n # cv2.imwrite(\"cv2image.png\", img)\n # Image.fromarray(img.astype('uint8')).save(\"pil_image.png\")\n\n # extract the image of hands and objects using the segmentation mask\n extracted_regions = cv2.bitwise_and(img, img, mask=msk)\n extracted_regions = Image.fromarray(extracted_regions.astype(\"uint8\"))\n\n # pick a random background image and superimpose the image\n background = Image.open(bg_path).convert('RGB') # makes sure image is RGB not RGBA to avoid normalization problems.\n background.paste(extracted_regions, (0, 0), Image.fromarray(msk * 255))\n\n # return np.array(background).astype('float32')\n return np.array(background).astype('uint8')\n\n\nclass ChangeBackground(A.DualTransform):\n\n \"\"\"\n Changes the background of the image by extracting the objects using segmentation\n masks and then overlaying them on to new background\n\n background_path: path to background images. Should match the size of images in the dataset\n\n \"\"\"\n\n def __init__(self, background_path: str = \"backgrounds\", always_apply: bool = False , p: float = 1.0):\n super().__init__(always_apply, p)\n\n self.background_path = background_path\n self.backgrounds_list = os.listdir(background_path)\n if len(self.backgrounds_list) == 0:\n raise IOError(f\"path for backgrounds: {background_path} does not exist\")\n\n def apply(self, img: np.ndarray, **params):\n # call change background with random background from the list\n mask = params[\"mask\"] # FIXME: change back to \"segm\"\n return change_background(img, mask, self.background_path + \"/\" + random.choice(self.backgrounds_list))\n\n def apply_to_mask(self, img: np.ndarray, **params):\n return img\n\n @property\n def target_dependence(self) -> Dict:\n return {\"image\": [\"mask\"]} # FIXME: change back to \"segm\"\n\n\n# aug = ChangeBackground(background_path=\"./backgrounds\", p=1)\n#\n#\n# def aug_tfm(img, msk):\n# np_img = np.array(img)\n# np_msk = np.array(msk)\n# aug_img = aug(image=np_img, mask=np_msk)\n#\n# return aug_img[\"image\"], aug_img[\"mask\"]\n#\n#\n# transform = A.Compose([\n# ChangeBackground(background_path=\"./backgrounds\", p=1),\n# A.HorizontalFlip(p=0.5),\n# A.RandomBrightnessContrast(p=0.2),\n# ])\n#\n#\n# image = Image.open('/home/rafay_veeve/Desktop/Veeve/galactus/HO3D_v3/train/MC1/rgb/0190.jpg')\n# mask = Image.open('/home/rafay_veeve/Desktop/Veeve/galactus/HO3D_v3/train/MC1/segmentations/0190.png')\n#\n# # aug_tfm(image, mask)\n# # i, m = aug_tfm(image, mask)\n#\n# transformed = transform(image=np.array(image), mask=np.array(mask))\n# i = transformed['image']\n# m = transformed['mask']\n#\n# # print(np.unique(m))\n# plt.subplot(1, 2, 1)\n# plt.imshow(i)\n# plt.subplot(1, 2, 2)\n# plt.imshow(m)\n# plt.show()"
] | [
[
"numpy.array"
]
] |
hebinalee/DreamAI_2020 | [
"ec2d49bb3ec66626d6c6b1cc50a015aef5c1ac7f"
] | [
"audiodataset.py"
] | [
"###################################\n## LOAD AND PREPROCESS AUDIO DATA\n###################################\n\nimport os\nimport random\nimport torch\nimport torch.nn as nn\nfrom torch.utils.data import Dataset\nimport glob\nimport numpy as np\nfrom util import read_filepaths\nfrom PIL import Image\nimport torchaudio\nimport torchaudio.transforms as AT\nfrom torchvision import transforms\nfrom sklearn.model_selection import train_test_split\nimport librosa\nimport json\n\nmel_spectrogram = nn.Sequential(\n AT.MelSpectrogram(sample_rate=16000, \n n_fft=512, \n win_length=400,\n hop_length=160,\n n_mels=80),\n AT.AmplitudeToDB()\n)\n\nclass CoswaraDataset(Dataset):\n \"\"\"\n Code for reading the CoswaraDataset\n \"\"\"\n\n def __init__(self, mode, n_classes=2, dataset_path='../final/Dataset/Coswara-Data/*/*/', segment_length=16000):\n \n\n self.CLASSES = n_classes\n self.AudioDICT = {'healthy': 0, 'positive': 1}\n self.segment_length = segment_length\n pid_list = glob.glob(dataset_path)\n \n paths = []\n labels = []\n for pid in pid_list:\n json_file = pid + 'metadata.json'\n with open(json_file) as json_file:\n json_data = json.load(json_file)\n status = json_data[\"covid_status\"]\n if status == 'positive_mild' or status == 'positive_moderate':\n status = 'positive'\n if status != 'healthy' and status != 'positive':\n continue\n file_list = glob.glob(pid + '*.wav')\n for f in file_list:\n if 'cough' not in f:\n continue\n paths.append(f)\n labels.append(status)\n paths = np.array(paths)\n labels = np.array(labels)\n \n n_sample = np.sum(labels == 'positive')\n h_paths = paths[labels == 'healthy']\n h_labels = labels[labels == 'healthy']\n idx_sample = np.random.choice(len(h_paths), n_sample) #class balance\n print(idx_sample)\n new_paths = np.concatenate([h_paths[idx_sample], paths[labels == 'positive']])\n new_labels = np.concatenate([h_labels[idx_sample], labels[labels == 'positive']])\n x, x_test, y, y_test = train_test_split(new_paths, new_labels, test_size=0.2, shuffle=True, stratify=new_labels, random_state=10)\n \n if (mode == 'train' or mode == 'valid'):\n x_train, x_valid, y_train, y_valid = train_test_split(x, y, test_size=0.1, shuffle=True, stratify=y, random_state=10)\n if mode == 'train':\n self.paths, self.labels = x, y\n elif mode == 'valid':\n self.paths, self.labels = x_valid, y_valid\n elif (mode == 'test'):\n self.paths, self.labels = x_test, y_test\n _, cnts = np.unique(self.labels, return_counts=True)\n print(\"{} examples = {}\".format(mode, len(self.paths)), cnts)\n \n \n\n def __len__(self):\n return len(self.paths)\n\n def __getitem__(self, index):\n\n audio = self.load_audio(self.paths[index])\n# audio = np.expand_dims(audio, 0)\n audio = torch.from_numpy(audio)\n \n # Take segment\n if audio.size(0) >= self.segment_length:\n max_audio_start = audio.size(0) - self.segment_length\n audio_start = random.randint(0, max_audio_start)\n audio = audio[audio_start:audio_start+self.segment_length]\n else:\n audio = torch.nn.functional.pad(audio, (0, self.segment_length - audio.size(0)), 'constant').data\n# mel = mel_spectrogram(audio)\n# mel = librosa.feature.melspectrogram(audio, sr=16000, n_fft=512, n_mels=80, hop_length=160)\n# mel = np.expand_dims(mel, 0)\n audio = audio.unsqueeze(0)\n label_tensor = torch.tensor(self.AudioDICT[self.labels[index]], dtype=torch.long)\n\n return audio, label_tensor\n\n def load_audio(self, path):\n if not os.path.exists(path):\n print(\"AUDIO DOES NOT EXIST {}\".format(path))\n audio, sr = librosa.load(path, sr=16000)\n# image_tensor = self.transform(image)\n\n return audio\n"
] | [
[
"numpy.concatenate",
"numpy.array",
"numpy.sum",
"torch.from_numpy",
"torch.tensor",
"sklearn.model_selection.train_test_split",
"numpy.unique"
]
] |
victorvg17/interpretable-reinforcement-learning-using-attention | [
"0f3ac27e10794ba5ea29eda27d83e4fb825eebf6"
] | [
"torchbeast/utils/conv_lstm.py"
] | [
"import torch\nimport torch.nn.functional as F\nfrom torch import nn\n\n\nclass ConvLSTMCell(nn.Module):\n def __init__(self, input_channels, hidden_channels, kernel_size):\n \"\"\"Initialize stateful ConvLSTM cell.\n\n Parameters\n ----------\n input_channels : ``int``\n Number of channels of input tensor.\n hidden_channels : ``int``\n Number of channels of hidden state.\n kernel_size : ``int``\n Size of the convolutional kernel.\n\n Paper\n -----\n https://papers.nips.cc/paper/5955-convolutional-lstm-network-a-machine-learning-approach-for-precipitation-nowcasting.pdf\n\n Referenced code\n ---------------\n https://github.com/automan000/Convolution_LSTM_PyTorch/blob/master/convolution_lstm.py\n \"\"\"\n super(ConvLSTMCell, self).__init__()\n\n assert hidden_channels % 2 == 0\n\n self.input_channels = input_channels\n self.hidden_channels = hidden_channels\n self.kernel_size = kernel_size\n self.num_features = 4\n\n self.padding = int((kernel_size - 1) / 2)\n\n self.Wxi = nn.Conv2d(\n self.input_channels,\n self.hidden_channels,\n self.kernel_size,\n 1,\n self.padding,\n bias=True,\n )\n self.Whi = nn.Conv2d(\n self.hidden_channels,\n self.hidden_channels,\n self.kernel_size,\n 1,\n self.padding,\n bias=False,\n )\n self.Wxf = nn.Conv2d(\n self.input_channels,\n self.hidden_channels,\n self.kernel_size,\n 1,\n self.padding,\n bias=True,\n )\n self.Whf = nn.Conv2d(\n self.hidden_channels,\n self.hidden_channels,\n self.kernel_size,\n 1,\n self.padding,\n bias=False,\n )\n self.Wxc = nn.Conv2d(\n self.input_channels,\n self.hidden_channels,\n self.kernel_size,\n 1,\n self.padding,\n bias=True,\n )\n self.Whc = nn.Conv2d(\n self.hidden_channels,\n self.hidden_channels,\n self.kernel_size,\n 1,\n self.padding,\n bias=False,\n )\n self.Wxo = nn.Conv2d(\n self.input_channels,\n self.hidden_channels,\n self.kernel_size,\n 1,\n self.padding,\n bias=True,\n )\n self.Who = nn.Conv2d(\n self.hidden_channels,\n self.hidden_channels,\n self.kernel_size,\n 1,\n self.padding,\n bias=False,\n )\n\n self.Wci = None\n self.Wcf = None\n self.Wco = None\n\n def forward(self, x, state):\n if self.Wci is None:\n batch_size, _, height, width = x.size()\n self.initial_state(\n batch_size, self.hidden_channels, height, width, x.device\n )\n h, c = state\n ci = torch.sigmoid(self.Wxi(x) + self.Whi(h) + c * self.Wci)\n cf = torch.sigmoid(self.Wxf(x) + self.Whf(h) + c * self.Wcf)\n cc = cf * c + ci * torch.tanh(self.Wxc(x) + self.Whc(h))\n co = torch.sigmoid(self.Wxo(x) + self.Who(h) + cc * self.Wco)\n ch = co * torch.tanh(cc)\n\n state = ch, cc\n return ch, state\n\n def initial_state(self, batch_size, hidden, height, width, device):\n if self.Wci is None:\n self.Wci = torch.zeros(1, hidden, height, width, requires_grad=True).to(\n device\n )\n self.Wcf = torch.zeros(1, hidden, height, width, requires_grad=True).to(\n device\n )\n self.Wco = torch.zeros(1, hidden, height, width, requires_grad=True).to(\n device\n )"
] | [
[
"torch.zeros",
"torch.tanh",
"torch.nn.Conv2d"
]
] |
SimonCarozza/autoclf | [
"025bdc324c0c9ae064e88f229c3282125d92d185"
] | [
"examples/ottog_knc_exp.py"
] | [
"from sklearn.model_selection import StratifiedKFold\nfrom sklearn.pipeline import Pipeline\nfrom sklearn.dummy import DummyClassifier\n\nfrom pandas import read_csv, DataFrame\nimport numpy as np\n\nimport os\nimport sys\nfrom autoclf import auto_utils as au\nfrom autoclf.classification import eval_utils as eu\nfrom autoclf.classification import param_grids_distros as pgd\nfrom autoclf.classification import train_calibrate as tc\nimport autoclf.getargs as ga\nfrom pkg_resources import resource_string\nfrom io import StringIO\n\n\n# starting program\nif __name__ == '__main__':\n\n print()\n print(\"### Probability Calibration Experiment -- CalibratedClassifierCV \"\n \"with cv=cv (no prefit) ###\")\n print()\n\n d_name = ga.get_name()\n\n if d_name is None:\n d_name = \"OttoG\"\n\n seed = 7\n np.random.seed(seed)\n\n try:\n df = read_csv(\"datasets/otto_group_train.csv\", delimiter=\",\")\n except FileNotFoundError as fe:\n ottog_bytes = resource_string(\n \"autoclf\", os.path.join(\"datasets\", 'otto_group_train.csv'))\n ottog_file = StringIO(str(ottog_bytes,'utf-8'))\n\n df = read_csv(ottog_file, delimiter=\",\")\n except Exception as e:\n raise e\n\n print(df.shape)\n\n print(\"Dataframe description - no encoding:\\n\", df.describe())\n print()\n\n print()\n print(\"=== [task] Train-test split + early pre-processing.\")\n print()\n\n # Missing Attribute Values: None\n\n ###\n df = df.drop(['id'], axis=1)\n print(df.shape)\n\n description = df.describe()\n print(\"Description - no encoding:\\n\", description)\n\n print()\n\n target = 'target'\n\n # feature engineering\n\n sltt = eu.scoring_and_tt_split(df, target, 0.2, seed)\n\n X_train, X_test, y_train, y_test = sltt['arrays']\n scoring = sltt['scoring']\n Y_type = sltt['target_type']\n labels = sltt['labels']\n\n print()\n print(\"X_train shape: \", X_train.shape)\n print(\"X_train -- first row:\", X_train.values[0])\n print(\"y_train shape: \", y_train.shape)\n print()\n\n print(\"X_test shape: \", X_test.shape)\n print(\"X_test -- first row:\", X_test.values[0])\n print(\"y_test shape: \", y_test.shape)\n print()\n\n print(y_train[:3])\n # input(\"Enter key to continue... \\n\")\n\n print()\n print(\"scoring:\", scoring)\n print()\n\n auto_feat_eng_data = eu.auto_X_encoding(sltt, seed)\n\n encoding = auto_feat_eng_data['encoding']\n scaler_tuple = auto_feat_eng_data['scaler']\n featselector = auto_feat_eng_data['feat_selector']\n steps = auto_feat_eng_data['steps']\n X_train_transformed, y_train, X_test_transformed, y_test =\\\n auto_feat_eng_data['data_arrays']\n X, y = auto_feat_eng_data['Xy']\n train_index, test_index = auto_feat_eng_data['tt_index']\n\n n_splits = au.select_nr_of_splits_for_kfold_cv()\n n_iter = au.select_nr_of_iterations()\n\n inner_cv = StratifiedKFold(n_splits=n_splits, shuffle=True, random_state=seed)\n outer_cv = StratifiedKFold(n_splits=n_splits, shuffle=True, random_state=seed)\n\n ### reproducing the whole autoclf workflow\n\n names = []\n results = []\n\n print(\"Metric:\", scoring)\n print(\"Calibration of untrained models -- CCCV 2nd\")\n print()\n\n best_atts = eu.best_model_initial_attributes(scoring, n_splits)\n\n best_score, best_score_dev, best_cv_results, best_model_name = best_atts\n\n best_exec_time = 31536000 # one year in seconds\n best_model = (best_model_name, None, None)\n\n Dummy_scores = []\n\n models_data = []\n names = []\n results = []\n\n scores_of_worst_model = (best_score, best_score_dev, best_cv_results,\n best_exec_time, best_model)\n\n scores_of_best_model = scores_of_worst_model\n\n average_scores_and_best_scores = dict()\n average_scores_and_best_scores[best_model_name] \\\n = (best_score, best_score_dev, best_exec_time, best_model, {})\n\n # Start evaluation process\n\n print()\n print(\"=== [task] Evaluation of DummyClassifier\")\n print()\n\n wtr = eu.calculate_sample_weight(y_train)\n\n strategy = 'stratified' # 'most_frequent'\n\n evaluation_result = eu.single_classic_cv_evaluation(\n X_train_transformed, y_train, 'DummyClf_2nd',\n DummyClassifier(strategy=strategy), wtr, scoring, outer_cv,\n dict(), scores_of_best_model, results, names, seed)\n\n average_scores_and_best_scores = evaluation_result[0]\n scores_of_best_model = evaluation_result[1]\n\n Dummy_scores.append(scores_of_best_model[0]) # Dummy score -- ROC_AUC\n Dummy_scores.append(scores_of_best_model[1]) # Dummy score std\n Dummy_scores.append(scores_of_best_model[2]) # Dummy cv results\n Dummy_scores.append(scores_of_best_model[3]) # Dummy execution time\n # Dummy model's name and estimator\n Dummy_scores.append(scores_of_best_model[4])\n\n names = []\n results = []\n\n print()\n\n all_models_and_parameters = dict()\n\n # replace with name from pgd.full_search_models_and_parameters\n test_model_name = 'model_from_param_grids_distros' # 'KNeighborsClf_2nd'\n\n print(\"=== [task] Comparing DummyClassifier to KNeighborsClassifier\")\n print()\n\n evaluation_result = eu.single_nested_rscv_evaluation(\n X_train_transformed, y_train, test_model_name,\n pgd.full_search_models_and_parameters[test_model_name][0], \n pgd.full_search_models_and_parameters[test_model_name][1],\n wtr, scoring, n_iter, inner_cv, outer_cv, \n average_scores_and_best_scores, scores_of_best_model, \n results, names, seed)\n\n print()\n au.box_plots_of_models_performance(results, names)\n\n print()\n print(\"=== After Non-nested CV evaluation of %s...\" % test_model_name)\n print()\n\n scores_of_best_model = evaluation_result[1]\n\n best_model_name = scores_of_best_model[4][0]\n best_model_estim = scores_of_best_model[4][1]\n\n best_score = scores_of_best_model[0]\n best_score_dev = scores_of_best_model[1]\n best_cv_results = scores_of_best_model[2]\n best_exec_time = scores_of_best_model[3]\n\n Dummy_score = Dummy_scores[0]\n Dummy_score_dev = Dummy_scores[1]\n Dummy_cv_results = Dummy_scores[2]\n Dummy_exec_time = Dummy_scores[3]\n\n print()\n print(\"Currently, best model is '%s' with score '%s': %1.3f (%1.3f)... :\" %\n (best_model_name, scoring.strip('neg_'), best_score, best_score_dev))\n print(\"... execution time: %.2fs\" % best_exec_time)\n # print(\"and prediction confidence: %1.3f\" % best_brier_score)\n print()\n\n if best_model_name != 'DummyClf_2nd':\n # It's assumed best model's performance is\n # satistically better than that of DummyClf on this dataset\n print(\"DummyClassifier's scores -- '%s': %1.3f (%1.3f)\" % (\n scoring.strip('neg_'), Dummy_score, Dummy_score_dev))\n print(\"'%s' does better than DummyClassifier.\" % best_model_name)\n if best_exec_time < Dummy_exec_time:\n print(\"'%s' is quicker than DummyClf.\" % best_model_name)\n print()\n print()\n input(\"Press key to continue...\")\n\n preprocessing = (encoding, scaler_tuple, featselector)\n\n all_models_and_parameters[best_model_name] = (\n best_model, pgd.full_search_models_and_parameters[best_model_name][1])\n\n if labels is not None:\n print(\"You have labels:\", labels)\n all_models_and_parameters['labels'] = labels\n\n print(\"Defined dictionary with models, parameters and related data.\")\n print()\n\n tc.tune_calibrate_best_model(\n X, y, X_train_transformed, X_test_transformed,\n y_train, y_test, auto_feat_eng_data['tt_index'], \n preprocessing, scores_of_best_model,\n all_models_and_parameters, n_splits, n_iter, 0,\n scoring, models_data, d_name, seed)\n else:\n sys.exit(\"Your best classifier is not a good classifier.\")\n\n input(\"=== [End Of Program] Enter key to continue... \\n\")"
] | [
[
"numpy.random.seed",
"pandas.read_csv",
"sklearn.dummy.DummyClassifier",
"sklearn.model_selection.StratifiedKFold"
]
] |
yadupokhrel/Chaudhari_Amazon_Hydropower | [
"6ec80dca5cce607f7f4167d435b8af451c78a663"
] | [
"NatSus_Fig1.py"
] | [
"#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n\nimport numpy as np\nfrom pylab import *\nimport math\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport matplotlib.gridspec as gridspec\nfrom mpl_toolkits.basemap import Basemap\nfrom matplotlib.patches import Polygon\n\nr\"\"\"\n#%%------------------------------------------------------------------\n Description: NatSus Paper Figure 1\n\n First Version: 03/18/2020\n last Updated : 03/31/2021\n\n Developer:\t Suyog Chaudhari\n\n\t Outstanding Issues:\n\t\t\t\t\t1-\n---------------------------------------------------------------------\n#%%\n\"\"\"\ndef yy(a):\n return math.trunc(float(float(a + 20.5) / 0.01666666667))\n\ndef xx(a):\n return math.trunc(float(float(a + 81.5) / 0.01666666667))\n\ndef draw_screen_poly( lats, lons, m):\n x, y = m( lons, lats )\n xy = zip(x,y)\n poly = Polygon( list(xy), edgecolor='k', facecolor='None',lw=1.2 )\n plt.gca().add_patch(poly)\n\n#%%\n#Set Data\nIGHP = 'data/Shp_files/IGHP30'\nTHP = 'data/Shp_files/TIP_40D'\namz_shp='data/Shp_files/Amazon_basin'\ncontinents = 'data/Shp_files/Continents'\next_dam = 'data/Shp_files/Existing_dams'\npro_dam = 'data/Shp_files/Planned_dams'\nund_dam = 'data/Shp_files/Underconstruction_dams'\n\ndf=pd.read_excel('Chaudhari_NatSus2021_Fig1_data.xlsx',sheetname='IGHP30')\ndf1=pd.read_excel('Chaudhari_NatSus2021_Fig1_data.xlsx',sheetname='DamVsInst')\nIGHP_subbasin = list(df.IGHP30)\n\nrivers=['japura', 'madeira', 'negro', 'purus', 'solimoes', 'tapajos', 'tocantins', 'xingu']\nriv_basin = ['Japura','Madeira','Negro','Purus','Solimoes','Tapajos','Tocantins','Xingu']\n\n#%%\n#================================= CREATING CUSTOM COLORBAR ==============================================\nimport matplotlib as mpl\ncmap=plt.cm.get_cmap('gist_earth_r',14)\nnorm = mpl.colors.BoundaryNorm(list(range(14)), cmap.N)\n\nplot_colors = [mpl.colors.rgb2hex(cmap(j)[:3]) for j in range(cmap.N)]\nplot_colors = plot_colors[1:]\nbounds = [0,1,10,20,30,100,500,1000,2000,6000,15000]\n\nfrom matplotlib.colors import LinearSegmentedColormap\ncmap = LinearSegmentedColormap.from_list('cm', plot_colors[:12], N=10)\nnorm = mpl.colors.BoundaryNorm(bounds, cmap.N)\n\n#%%\n#================================= CREATING BASEMAP ==========================================\nfig = plt.figure(figsize=(7,8.2),facecolor='white',edgecolor=None,linewidth=1.0,frameon=True)\n##----------------- for basemap\nnxa=-81.50\nnxb=nxa + 37\nnya=-22\nnyb=nya + 29\nres=0.01666666667\n##----------------- for basemap\ngs = gridspec.GridSpec(12,2, width_ratios = [4,1])\ngs.update(wspace=0.15,hspace=0.5)\nfig.subplots_adjust(left=0.04, right=0.96, bottom=0.1, top=0.97 )\n\n#================================= Plot Gross Potential polylines =============================\nax1 = plt.subplot(gs[0:6, 0])\nmap=Basemap( projection ='cyl', llcrnrlon = nxa, urcrnrlon = nxb, llcrnrlat = nya, urcrnrlat = nyb, resolution = \"i\")\nmap.drawcountries (linewidth=0.1, color='gray');\nmap.drawparallels(np.arange(-21,10,3.),labels=[1,0,1,0],linewidth=0.1,fontsize=8,dashes=(5,20))\nmap.drawmeridians(np.arange(-80,46,5.),labels=[1,0,1,0],linewidth=0.1,fontsize=8,dashes=(5,20))\nplt.annotate('a', xy=(-47,5), xycoords='data',fontsize=11, fontweight='bold')\n\nmap.readshapefile(continents, 'Continents', drawbounds=True, linewidth=0.5, color='#808B96')\nmap.readshapefile(amz_shp, 'Amazon_basin', drawbounds=True, linewidth=1., color='#95A5A6')\nmap.readshapefile(IGHP, 'IGHP', drawbounds=False)\nfor info, shape in zip(map.IGHP_info, map.IGHP):\n x=[]; y=[]\n if info['GRID_CODE'] <= 1: lwidth = 0.2; cc = plot_colors[0]\n elif info['GRID_CODE'] <= 10 and info['GRID_CODE'] > 1: lwidth = 0.2; cc = plot_colors[1]\n elif info['GRID_CODE'] <= 20 and info['GRID_CODE'] > 10: lwidth = 0.3; cc = plot_colors[2]\n elif info['GRID_CODE'] <= 30 and info['GRID_CODE'] > 20: lwidth = 0.4; cc = plot_colors[3]\n elif info['GRID_CODE'] <= 100 and info['GRID_CODE'] > 30: lwidth = 0.5; cc = plot_colors[4]\n elif info['GRID_CODE'] <= 500 and info['GRID_CODE'] > 100: lwidth = 0.8; cc = plot_colors[5]\n elif info['GRID_CODE'] <= 1000 and info['GRID_CODE'] > 500: lwidth = 1.5; cc = plot_colors[6]\n elif info['GRID_CODE'] <= 2000 and info['GRID_CODE'] > 1000: lwidth = 2.0; cc = plot_colors[7]\n elif info['GRID_CODE'] <= 6000 and info['GRID_CODE'] > 2000: lwidth = 2.5; cc = plot_colors[8]\n elif info['GRID_CODE'] > 6000: lwidth = 3.0; cc = plot_colors[9]\n\n x.append(info['START_X'])\n x.append(info['END_X'])\n y.append(info['START_Y'])\n y.append(info['END_Y'])\n map.plot(x, y, marker=None,color=cc,linewidth=lwidth,solid_capstyle='round')\n\n#Locate Existing and Underconstruction Dams\nmap.readshapefile(ext_dam, 'Existing_dams', drawbounds=False)\nmap.readshapefile(und_dam, 'Underconstruction_dams', drawbounds=False)\n\nfor info, dam in zip(map.Existing_dams_info, map.Existing_dams):\n map.plot(dam[0], dam[1], marker='o', markeredgecolor='dodgerblue', fillstyle='none', markersize=9, markeredgewidth=1.2) if float(info['capacity']) > 1000. \\\n else map.plot(dam[0], dam[1], marker='o', markeredgecolor='dodgerblue', fillstyle='none', markersize=7, markeredgewidth=1.2) if float(info['capacity']) > 300. and float(info['capacity']) <= 1000. \\\n else map.plot(dam[0], dam[1], marker='o', markeredgecolor='dodgerblue', fillstyle='none', markersize=5, markeredgewidth=1.2) if float(info['capacity']) > 30. and float(info['capacity']) <= 300. \\\n else map.plot(dam[0], dam[1], marker='o', markeredgecolor='dodgerblue', fillstyle='none', markersize=2, markeredgewidth=0.5)\n\nfor info, dam in zip(map.Underconstruction_dams_info, map.Underconstruction_dams):\n map.plot(dam[0], dam[1], marker='o', markeredgecolor='#eda41c', fillstyle='none', markersize=9, markeredgewidth=1.2) if float(info['capacity']) > 1000. \\\n else map.plot(dam[0], dam[1], marker='o', markeredgecolor='#eda41c', fillstyle='none', markersize=7, markeredgewidth=1.2) if float(info['capacity']) > 300. and float(info['capacity']) <= 1000.\\\n else map.plot(dam[0], dam[1], marker='o', markeredgecolor='#eda41c', fillstyle='none', markersize=5, markeredgewidth=1.2) if float(info['capacity']) > 30. and float(info['capacity']) <= 300. \\\n else map.plot(dam[0], dam[1], marker='o', markeredgecolor='#eda41c', fillstyle='none', markersize=3, markeredgewidth=0.5)\n#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n\n#================================= GHP side plots ===============================================\nax2 = plt.subplot(gs[:3, 1])\ny_pos = np.arange(len(riv_basin))\nax2.bar(y_pos,IGHP_subbasin, align='center',color=('#66c2a5','#fc8d62','#8da0cb','#e78ac3','#a6d854','#ffd92f','#e5c494','#b3b3b3'))\nax2.set_yticks(np.arange(0,1100,200))\nax2.set_yticklabels(np.arange(0,1100,200),fontsize=10)\nax2.set_ylim(0,1100)\nax2.set_xticks(y_pos)\nax2.set_xticklabels([])\nplt.gca().yaxis.grid(True,'both',linestyle='--',lw=0.8)\nax2.spines['top'].set_visible(False)\nax2.spines['right'].set_visible(False)\nax2.text(8.5, 525, r'IGHP$_{30}$', rotation=90, verticalalignment='center', fontsize=11, fontweight='bold')\nax2.text(-0.5, 1010, 'TWh $yr^{-1}$', horizontalalignment='left', fontsize=10)\nax2.text(6.5, 1010, 'b', horizontalalignment='left', fontsize=11, fontweight='bold')\n#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n\n#================================= Planned_vs_Instream side plot ==================================\nax6 = plt.subplot(gs[3:, 1])\nmap.readshapefile(pro_dam, 'Planned_dams', drawbounds=False)\nset_colors=['#66c2a5','#fc8d62','#8da0cb','#e78ac3','#a6d854','#ffd92f','#e5c494','#b3b3b3']\ncap = list(df1.Capacity)\nX = list(df1.Basin_num)\nInst_cap=list(df1.Instream_cap)\n\nfor ii in range(len(cap)):\n ax6.scatter(X[ii],cap[ii], s=30,marker='o',facecolors='none', edgecolors=set_colors[X[ii]],linewidths=2)\n ax6.scatter(X[ii],Inst_cap[ii], s=80,marker='s',facecolors='none', edgecolors=set_colors[X[ii]],linewidths=2, zorder=0)\nax6.set_xticks(range(len(riv_basin)))\nax6.set_xticklabels([])\nplt.gca().yaxis.grid(True,'major',linestyle='--',lw=0.8)\nax6.set_ylim(1,10000)\nax6.set_yscale('log')\nax6.set_xticks(y_pos)\nax6.set_xticklabels(riv_basin, fontsize=10,rotation=90)\nax6.spines['top'].set_visible(False)\nax6.spines['right'].set_visible(False)\nax6.text(8.5,100, 'Planned Dam Capacity vs In-stream Capacity', rotation=90, verticalalignment='center', fontsize=11, fontweight='bold')\nax6.text(-0.5,8100, 'MW', horizontalalignment='left', fontsize=10)\nax6.text(6.5, 8100, 'd', horizontalalignment='left', fontsize=11, fontweight='bold')\n#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n\n#================================= Plot Technical Potential polylines ============================\nax4 = plt.subplot(gs[6:, 0])\nmap=Basemap( projection ='cyl', llcrnrlon = nxa, urcrnrlon = nxb, llcrnrlat = nya, urcrnrlat = nyb, resolution = \"i\")\nmap.drawcountries (linewidth=0.1, color='gray');\nmap.drawparallels(np.arange(-21,10,3.),labels=[1,0,0,0],linewidth=0.1,fontsize=8,dashes=(5,20))\nmap.drawmeridians(np.arange(-80,46,5.),labels=[1,0,0,0],linewidth=0.1,fontsize=8,dashes=(5,20))\nplt.annotate('c', xy=(-47,5), xycoords='data',fontsize=11, fontweight='bold')\n\nmap.readshapefile(continents, 'Continents', drawbounds=True, linewidth=0.5, color='#808B96')\nmap.readshapefile(amz_shp, 'Amazon_basin', drawbounds=True, linewidth=1., color='#95A5A6')\nmap.readshapefile(THP, 'THP', drawbounds=False)\nfor info, shape in zip(map.THP_info, map.THP):\n x=[]; y=[]\n if info['GRID_CODE']/1000 <= 1: lwidth = 0.2; cc = plot_colors[0]\n elif info['GRID_CODE']/1000 <= 10 and info['GRID_CODE']/1000 > 1: lwidth = 0.2; cc = plot_colors[1]\n elif info['GRID_CODE']/1000 <= 20 and info['GRID_CODE']/1000 > 10: lwidth = 0.3; cc = plot_colors[2]\n elif info['GRID_CODE']/1000 <= 30 and info['GRID_CODE']/1000 > 20: lwidth = 0.4; cc = plot_colors[3]\n elif info['GRID_CODE']/1000 <= 100 and info['GRID_CODE']/1000 > 30: lwidth = 0.5; cc = plot_colors[4]\n elif info['GRID_CODE']/1000 <= 500 and info['GRID_CODE']/1000 > 100: lwidth = 0.8; cc = plot_colors[5]\n elif info['GRID_CODE']/1000 <= 1000 and info['GRID_CODE']/1000 > 500: lwidth = 1.5; cc = plot_colors[6]\n elif info['GRID_CODE']/1000 <= 2000 and info['GRID_CODE']/1000 > 1000: lwidth = 2.0; cc = plot_colors[7]\n elif info['GRID_CODE']/1000 <= 6000 and info['GRID_CODE']/1000 > 2000: lwidth = 2.5; cc = plot_colors[8]\n elif info['GRID_CODE']/1000 > 6000: lwidth = 3.0; cc = plot_colors[9]\n else: lwidth = 3.0; cc = plot_colors[9]\n\n x.append(info['START_X'])\n x.append(info['END_X'])\n y.append(info['START_Y'])\n y.append(info['END_Y'])\n map.plot(x, y, marker=None,color=cc,linewidth=lwidth,solid_capstyle='round')\n\n#Locate Planned Dams\nmap.readshapefile(pro_dam, 'Planned_dams', drawbounds=False)\nfor info, dam in zip(map.Planned_dams_info, map.Planned_dams):\n map.plot(dam[0], dam[1], marker='o', markeredgecolor='purple', fillstyle='none', markersize=9, markeredgewidth=1.2) if float(info['Capacity_1']) > 1000 \\\n else map.plot(dam[0], dam[1], marker='o', markeredgecolor='purple', fillstyle='none', markersize=7, markeredgewidth=1.2) if float(info['Capacity_1']) > 300. and float(info['Capacity_1']) <= 1000 \\\n else map.plot(dam[0], dam[1], marker='o', markeredgecolor='purple', fillstyle='none', markersize=5, markeredgewidth=1.2) if float(info['Capacity_1']) > 30. and float(info['Capacity_1']) <= 300 \\\n else map.plot(dam[0], dam[1], marker='o', markeredgecolor='purple', fillstyle='none', markersize=3, markeredgewidth=0.5)\n\nrec_lats = [[ 0, 4, 4, 0],[ -11, -6.5, -6.5, -11 ],[ -5, -1, -1, -5 ], [ -14.5, 2, 2, -14.5 ]]\nrec_lons = [[ -63.5, -63.5, -60, -60 ], [ -63, -63, -59, -59 ], [ -68, -68, -63, -63 ],[ -80, -80, -72.5, -72.5 ]]\nfor i in range(len(rec_lats)):\n draw_screen_poly( rec_lats[i], rec_lons[i], map )\n ax4.text(rec_lons[i][1]+0.2,rec_lats[i][1]+0.2, str(i+1),fontsize=10, fontweight='bold')\n\n\n##============================ Adding Scatter Legend ==================================================================\nfrom matplotlib.lines import Line2D\nlegend_elements = [Line2D([0], [0], color='w',marker='o', label='Existing', markeredgecolor='dodgerblue', fillstyle='none', markersize=9, markeredgewidth=1.2),\n Line2D([0], [0], color='w',marker='o', label='Under construction', markeredgecolor='#eda41c', fillstyle='none', markersize=9, markeredgewidth=1.2),\n Line2D([0], [0], color='w',marker='o', label='Planned', markeredgecolor='purple', fillstyle='none', markersize=9, markeredgewidth=1.2)]\nlegend1=plt.legend(handles=legend_elements, bbox_to_anchor=(0.3, 0.0), loc=1,ncol=1, borderpad=0.1, labelspacing=0.5,fontsize=10,handletextpad=0.1)\n\n#Dam Capacity legend\nlegend_elements1 = [Line2D([0], [0], color='w',marker='o', label='>1000 MW', markeredgecolor='k', fillstyle='none', markersize=9, markeredgewidth=1.2),\n Line2D([0], [0], color='w',marker='o', label='300-1000 MW', markeredgecolor='k', fillstyle='none', markersize=7, markeredgewidth=1.2),\n Line2D([0], [0], color='w',marker='o', label='30-300 MW', markeredgecolor='k', fillstyle='none', markersize=5, markeredgewidth=1.2),\n Line2D([0], [0], color='w',marker='o', label='<30 MW', markeredgecolor='k', fillstyle='none', markersize=3, markeredgewidth=0.5)]\nplt.legend(handles=legend_elements1, bbox_to_anchor=(0.305, 0.25), loc=1,ncol=1, borderpad=0.3,fontsize=9.5,handletextpad=0.1)\nplt.gca().add_artist(legend1)\n\n##======================== Create Second Axes For Colorbar ============================================================\ncbw=.015; cbl=.47\ncax = fig.add_axes([0.26, 0.06, cbl, cbw])\ncb = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm, spacing='uniform', orientation='horizontal', ticks=bounds, boundaries=bounds,extend='both')#, format='%0.2f')\ncb.ax.invert_yaxis()\n[t.set_fontsize(9.5) and t.set_rotation(0) for t in cb.ax.get_xticklabels()]\nfig.text(0.45, 0.015,'GWh/year',fontsize=10, verticalalignment='center',fontweight='bold') #Axis label\n\nfig.savefig('Figure_1.png', dpi=300)"
] | [
[
"matplotlib.pyplot.subplot",
"matplotlib.pyplot.annotate",
"matplotlib.lines.Line2D",
"matplotlib.pyplot.gca",
"pandas.read_excel",
"matplotlib.pyplot.legend",
"matplotlib.pyplot.figure",
"matplotlib.colors.BoundaryNorm",
"numpy.arange",
"matplotlib.colorbar.ColorbarBase",
"matplotlib.pyplot.cm.get_cmap",
"matplotlib.gridspec.GridSpec",
"matplotlib.colors.LinearSegmentedColormap.from_list"
]
] |
zhouai9070/QuanTangshi-AA- | [
"f598e459294ef6093781ebddb2df15a551566913"
] | [
"models/AttBiLSTM.py"
] | [
"# @Author : bamtercelboo\n# @Datetime : 2018/8/17 16:06\n# @File : BiLSTM.py\n# @Last Modify Time : 2018/8/17 16:06\n# @Contact : bamtercelboo@{gmail.com, 163.com}\n\n\"\"\"\n FILE : BiLSTM.py\n FUNCTION : None\n\"\"\"\n\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom torch.nn.utils.rnn import pack_padded_sequence, pad_packed_sequence\nimport random\nfrom DataUtils.Common import *\nfrom models.initialize import *\nfrom models.modelHelp import prepare_pack_padded_sequence\nfrom .HierachicalAtten import HierachicalAtten\ntorch.manual_seed(seed_num)\nrandom.seed(seed_num)\n\n\nclass ABiLSTM(nn.Module):\n \"\"\"\n BiLSTM\n \"\"\"\n\n def __init__(self, **kwargs):\n super(ABiLSTM, self).__init__()\n\n for k in kwargs:\n self.__setattr__(k, kwargs[k])\n\n V = self.embed_num\n D = self.embed_dim\n C = self.label_num\n paddingId = self.paddingId\n self.embed = nn.Embedding(V, D, padding_idx=paddingId)\n\n if self.pretrained_embed:\n self.embed.weight.data.copy_(self.pretrained_weight)\n else:\n init_embedding(self.embed.weight)\n\n self.dropout_embed = nn.Dropout(self.dropout_emb)\n self.dropout = nn.Dropout(self.dropout)\n\n self.bilstm = nn.LSTM(input_size=D, hidden_size=self.lstm_hiddens, num_layers=self.lstm_layers,\n bidirectional=True, batch_first=True, bias=True)\n self.hierachicalAtt = HierachicalAtten(in_size=self.lstm_hiddens * 2, attention_size=200)\n self.linear = nn.Linear(in_features=self.lstm_hiddens * 2, out_features=C, bias=True)\n init_linear_weight_bias(self.linear)\n\n def forward(self, word, sentence_length):\n \"\"\"\n :param word:\n :param sentence_length:\n :param desorted_indices:\n :return:\n \"\"\"\n word, sentence_length, desorted_indices = prepare_pack_padded_sequence(word, sentence_length, use_cuda=self.use_cuda)\n x = self.embed(word) # (N,W,D)\n x = self.dropout_embed(x)\n packed_embed = pack_padded_sequence(x, sentence_length, batch_first=True)\n x, _ = self.bilstm(packed_embed)\n x, _ = pad_packed_sequence(x, batch_first=True)\n x = x[desorted_indices]\n\n x = self.hierachicalAtt(x)\n # x = x.permute(0, 2, 1)\n # x = self.dropout(x)\n # x = F.max_pool1d(x, x.size(2)).squeeze(2)\n # x = F.tanh(x)\n logit = self.linear(x)\n return logit\n"
] | [
[
"torch.nn.Linear",
"torch.nn.Dropout",
"torch.nn.LSTM",
"torch.manual_seed",
"torch.nn.utils.rnn.pad_packed_sequence",
"torch.nn.utils.rnn.pack_padded_sequence",
"torch.nn.Embedding"
]
] |
cameronraysmith/glow | [
"98acbed1d48ee487c24fcfec53d91f41143a6d7d"
] | [
"docs/source/conftest.py"
] | [
"# Copyright 2019 The Glow Authors\n# \n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n# \n# http://www.apache.org/licenses/LICENSE-2.0\n# \n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n\nimport glow\nfrom sybil import Sybil\nfrom sybil.parsers.codeblock import PythonCodeBlockParser\nfrom pandas.testing import assert_series_equal\nimport pytest\nimport pandas as pd\n\[email protected](scope=\"module\")\ndef register_glow(spark):\n glow.register(spark, new_session=False)\n\[email protected](scope=\"session\")\ndef assert_rows_equal():\n def _assert_rows_equal(r1, r2):\n d1 = r1.asDict(recursive=True)\n s1 = pd.Series(d1, index = sorted(d1.keys()))\n d2 = r2.asDict(recursive=True)\n s2 = pd.Series(d2, index = sorted(d2.keys()))\n # Permissive to floating-point error\n assert_series_equal(s1, s2)\n return _assert_rows_equal\n\npytest_collect_file = Sybil(\n parsers=[\n PythonCodeBlockParser(future_imports=['print_function']),\n ],\n pattern='*.rst',\n fixtures=['assert_rows_equal', 'spark', 'register_glow'],\n).pytest()\n"
] | [
[
"pandas.testing.assert_series_equal"
]
] |
openoakland/lovely-rita | [
"35ec5a5fc27fcf4ee27078e05fb38f15723ddf9a"
] | [
"lovelyrita/data.py"
] | [
"from __future__ import print_function\nimport numpy as np\nimport pandas as pd\nfrom shapely.geometry import Point\nimport geopandas\nfrom lovelyrita.clean import clean as clean_data\nfrom lovelyrita.config import VALID_COLUMN_NAMES as valid_column_names\n\n\ndef read_data(paths, usecols=None, delimiter=',', clean=False):\n \"\"\"Load data from a list of file paths.\n\n Parameters\n ----------\n paths : list\n A list of file paths to the data to be loaded\n usecols : list of str\n If provided, only load these columns\n dtype : dict\n A dict containing key (column name) and value (data type)\n delimiter : str\n\n Returns\n -------\n A DataFrame containing the loaded data\n \"\"\"\n if not isinstance(paths, (tuple, list)):\n paths = [paths, ]\n\n dataframe = []\n for path in paths:\n\n if usecols is None:\n usecols = get_column_names(path)\n\n df = pd.read_csv(path, usecols=usecols, delimiter=delimiter)\n\n df['street'] = df['street'].str.strip(' ')\n\n if clean:\n df = clean_data(df)\n\n dataframe.append(df)\n\n dataframe = pd.concat(dataframe).reset_index(drop=True)\n\n return dataframe\n\n\ndef get_column_names(path, valid_column_names=valid_column_names):\n \"\"\"Return the intersection of columns present in the dataset and valid column names\n\n Parameters:\n -----------\n path : str\n valid_column_names : list of st\n\n Return:\n -------\n \"\"\"\n column_names = pd.read_csv(path, nrows=1)\n if valid_column_names is not None:\n column_names = [n for n in column_names if n in valid_column_names]\n else:\n column_names = [n for n in column_names]\n\n return column_names\n\n\ndef to_geodataframe(dataframe, copy=False, drop_null_geometry=True,\n projection='epsg:4326'):\n \"\"\"Convert a pandas DataFrame to geopandas DataFrame.\n\n Parameters\n ----------\n dataframe : pandas.DataFrame\n Must contain latitude and longitude fields\n copy : bool\n drop_null_geometry : bool\n projection : str\n\n Returns\n -------\n A GeoDataFrame of the given DataFrame\n \"\"\"\n if copy:\n df = dataframe.copy()\n else:\n df = dataframe\n\n df.latitude = df.latitude.astype('float32')\n df.longitude = df.longitude.astype('float32')\n\n points = []\n for x, y in zip(df.latitude, df.longitude):\n if not x == 0:\n points.append(Point(y, x))\n else:\n points.append(None)\n df['geometry'] = points\n\n df.drop(['latitude', 'longitude'], axis=1, inplace=True)\n\n if drop_null_geometry:\n df = df.loc[~df.geometry.isnull()]\n\n # geopandas cannot handle datetime formats, so convert to string\n for column in df.select_dtypes(include=['datetime']):\n df[column] = df[column].dt.strftime('%m/%d/%y %H:%M:%S')\n\n return geopandas.GeoDataFrame(df, geometry='geometry', crs={'init': projection})\n\n\ndef write_shapefile(geodataframe, path):\n \"\"\"Write a geodataframe to a shapefile.\n\n Parameters\n ----------\n geodataframe : geopandas.GeoDataFrame\n path : str\n \"\"\"\n geodataframe.to_file(path, driver='ESRI Shapefile')\n\n\ndef get_sample_value(series):\n \"\"\"Return a sample value from a series\n\n Parameters\n ----------\n series : pandas.Series\n\n Returns\n -------\n A sample value from the series or None if all values in the series are null\n \"\"\"\n unique = series.unique()\n for value in unique:\n if value is not np.nan:\n return value\n\n\ndef summarize(dataframe):\n \"\"\"Generate a summary of the data in a dataframe.\n\n Parameters\n ----------\n dataframe : pandas.DataFrame\n\n Returns\n -------\n A DataFrame containing the data type, number of unique values, a sample value, number and\n percent of null values\n \"\"\"\n column_report = []\n for column in dataframe.columns:\n unique = dataframe[column].unique()\n sample = get_sample_value(dataframe[column])\n n_null = dataframe[column].isnull().sum()\n pct_null = 100. * n_null / dataframe.shape[0]\n r = [column, dataframe[column].dtype, len(unique), sample, n_null, pct_null]\n column_report.append(r)\n\n columns = [\"Column Name\", \"Data Type\", \"Unique Count\", \"Sample Value\", \"null\", \"% null\"]\n column_report = pd.DataFrame(column_report, columns=columns).round(2)\n column_report.sort_values(by=\"null\", inplace=True)\n\n return column_report\n"
] | [
[
"pandas.DataFrame",
"pandas.read_csv",
"pandas.concat"
]
] |
WaelAshraf/Image.TextScanner | [
"dbe8480209864d99a51b9f6d9d3d428da7ef4cd8"
] | [
"bank-check-ocr-2/bank_check_ocr.py"
] | [
"# USAGE\n# python bank_check_ocr.py --image example_check.png --reference micr_e13b_reference.png\n\n# import the necessary packages\nfrom skimage.segmentation import clear_border\nfrom imutils import contours\nimport imutils\nimport numpy as np\nimport argparse\nimport cv2\n\ndef extract_digits_and_symbols(image, charCnts, minW=5, minH=15):\n\t# grab the internal Python iterator for the list of character\n\t# contours, then initialize the character ROI and location\n\t# lists, respectively\n\tcharIter = charCnts.__iter__()\n\trois = []\n\tlocs = []\n\n\t# keep looping over the character contours until we reach the end\n\t# of the list\n\twhile True:\n\t\ttry:\n\t\t\t# grab the next character contour from the list, compute\n\t\t\t# its bounding box, and initialize the ROI\n\t\t\tc = next(charIter)\n\t\t\t(cX, cY, cW, cH) = cv2.boundingRect(c)\n\t\t\troi = None\n\n\t\t\t# check to see if the width and height are sufficiently\n\t\t\t# large, indicating that we have found a digit\n\t\t\tif cW >= minW and cH >= minH:\n\t\t\t\t# extract the ROI\n\t\t\t\troi = image[cY:cY + cH, cX:cX + cW]\n\t\t\t\trois.append(roi)\n\t\t\t\tlocs.append((cX, cY, cX + cW, cY + cH))\n\n\t\t\t# otherwise, we are examining one of the special symbols\n\t\t\telse:\n\t\t\t\t# MICR symbols include three separate parts, so we\n\t\t\t\t# need to grab the next two parts from our iterator,\n\t\t\t\t# followed by initializing the bounding box\n\t\t\t\t# coordinates for the symbol\n\t\t\t\tparts = [c, next(charIter), next(charIter)]\n\t\t\t\t(sXA, sYA, sXB, sYB) = (np.inf, np.inf, -np.inf,\n\t\t\t\t\t-np.inf)\n\n\t\t\t\t# loop over the parts\n\t\t\t\tfor p in parts:\n\t\t\t\t\t# compute the bounding box for the part, then\n\t\t\t\t\t# update our bookkeeping variables\n\t\t\t\t\t(pX, pY, pW, pH) = cv2.boundingRect(p)\n\t\t\t\t\tsXA = min(sXA, pX)\n\t\t\t\t\tsYA = min(sYA, pY)\n\t\t\t\t\tsXB = max(sXB, pX + pW)\n\t\t\t\t\tsYB = max(sYB, pY + pH)\n\n\t\t\t\t# extract the ROI\n\t\t\t\troi = image[sYA:sYB, sXA:sXB]\n\t\t\t\trois.append(roi)\n\t\t\t\tlocs.append((sXA, sYA, sXB, sYB))\n\n\t\t# we have reached the end of the iterator; gracefully break\n\t\t# from the loop\n\t\texcept StopIteration:\n\t\t\tbreak\n\n\t# return a tuple of the ROIs and locations\n\treturn (rois, locs)\n\n# construct the argument parse and parse the arguments\nap = argparse.ArgumentParser()\nap.add_argument(\"-i\", \"--image\", required=True,\n\thelp=\"path to input image\")\nap.add_argument(\"-r\", \"--reference\", required=True,\n\thelp=\"path to reference MICR E-13B font\")\nargs = vars(ap.parse_args())\n\n# initialize the list of reference character names, in the same\n# order as they appear in the reference image where the digits\n# their names and:\n# T = Transit (delimit bank branch routing transit #)\n# U = On-us (delimit customer account number)\n# A = Amount (delimit transaction amount)\n# D = Dash (delimit parts of numbers, such as routing or account)\ncharNames = [\"1\", \"2\", \"3\", \"4\", \"5\", \"6\", \"7\", \"8\", \"9\", \"0\",\n\t\"T\", \"U\", \"A\", \"D\"]\n\n# load the reference MICR image from disk, convert it to grayscale,\n# and threshold it, such that the digits appear as *white* on a\n# *black* background\nref = cv2.imread(args[\"reference\"])\nref = cv2.cvtColor(ref, cv2.COLOR_BGR2GRAY)\nref = imutils.resize(ref, width=400)\nref = cv2.threshold(ref, 0, 255, cv2.THRESH_BINARY_INV |\n\tcv2.THRESH_OTSU)[1]\n\n# find contours in the MICR image (i.e,. the outlines of the\n# characters) and sort them from left to right\nrefCnts = cv2.findContours(ref.copy(), cv2.RETR_EXTERNAL,\n\tcv2.CHAIN_APPROX_SIMPLE)\nrefCnts = imutils.grab_contours(refCnts)\nrefCnts = contours.sort_contours(refCnts, method=\"left-to-right\")[0]\n\n# extract the digits and symbols from the list of contours, then\n# initialize a dictionary to map the character name to the ROI\nrefROIs = extract_digits_and_symbols(ref, refCnts,\n\tminW=10, minH=20)[0]\nchars = {}\n\n# loop over the reference ROIs\nfor (name, roi) in zip(charNames, refROIs):\n\t# resize the ROI to a fixed size, then update the characters\n\t# dictionary, mapping the character name to the ROI\n\troi = cv2.resize(roi, (36, 36)) \n\tchars[name] = roi\n\n# initialize a rectangular kernel (wider than it is tall) along with\n# an empty list to store the output of the check OCR\nrectKernel = cv2.getStructuringElement(cv2.MORPH_RECT, (17, 7))\noutput = []\n\n# load the input image, grab its dimensions, and apply array slicing\n# to keep only the bottom 20% of the image (that's where the account\n# information is)\nimage = cv2.imread(args[\"image\"])\n(h, w,) = image.shape[:2]\ndelta = int(h - (h * 0.2))\nbottom = image[delta:h, 0:w]\n\n# convert the bottom image to grayscale, then apply a blackhat\n# morphological operator to find dark regions against a light\n# background (i.e., the routing and account numbers)\ngray = cv2.cvtColor(bottom, cv2.COLOR_BGR2GRAY)\nblackhat = cv2.morphologyEx(gray, cv2.MORPH_BLACKHAT, rectKernel)\n\n# compute the Scharr gradient of the blackhat image, then scale\n# the rest back into the range [0, 255]\ngradX = cv2.Sobel(blackhat, ddepth=cv2.CV_32F, dx=1, dy=0,\n\tksize=-1)\ngradX = np.absolute(gradX)\n(minVal, maxVal) = (np.min(gradX), np.max(gradX))\ngradX = (255 * ((gradX - minVal) / (maxVal - minVal)))\ngradX = gradX.astype(\"uint8\")\n\n# apply a closing operation using the rectangular kernel to help\n# cloes gaps in between rounting and account digits, then apply\n# Otsu's thresholding method to binarize the image\ngradX = cv2.morphologyEx(gradX, cv2.MORPH_CLOSE, rectKernel)\nthresh = cv2.threshold(gradX, 0, 255,\n\tcv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]\n\n# remove any pixels that are touching the borders of the image (this\n# simply helps us in the next step when we prune contours)\nthresh = clear_border(thresh)\n\n# find contours in the thresholded image, then initialize the\n# list of group locations6we`2\ngroupCnts = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL,\n\tcv2.CHAIN_APPROX_SIMPLE)\ngroupCnts = groupCnts[0]\ngroupLocs = []\n\n# loop over the group contours\nfor (i, c) in enumerate(groupCnts):\n\t# compute the bounding box of the contour\n\t(x, y, w, h) = cv2.boundingRect(c)\n\n\t# only accept the contour region as a grouping of characters if\n\t# the ROI is sufficiently large\n\tif w > 50 and h > 15:\n\t\tgroupLocs.append((x, y, w, h))\n\n# sort the digit locations from left-to-right\ngroupLocs = sorted(groupLocs, key=lambda x:x[0])\n\n# loop over the group locations\nfor (gX, gY, gW, gH) in groupLocs:\n\t# initialize the group output of characters\n\tgroupOutput = []\n\n\t# extract the group ROI of characters from the grayscale\n\t# image, then apply thresholding to segment the digits from\n\t# the background of the credit card\n\tgroup = gray[gY - 5:gY + gH + 5, gX - 5:gX + gW + 5]\n\tgroup = cv2.threshold(group, 0, 255,\n\t\tcv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)[1]\n\n\tcv2.imshow(\"Group\", group)\n\tcv2.waitKey(0)\n\n\t# find character contours in the group, then sort them from\n\t# left to right\n\tcharCnts = cv2.findContours(group.copy(), cv2.RETR_EXTERNAL,\n\t\tcv2.CHAIN_APPROX_SIMPLE)\n\tcharCnts = imutils.grab_contours(charCnts)\n\tcharCnts = contours.sort_contours(charCnts,\n\t\tmethod=\"left-to-right\")[0]\n\n\t# find the characters and symbols in the group\n\t(rois, locs) = extract_digits_and_symbols(group, charCnts)\n\n\t# loop over the ROIs from the group\n\tfor roi in rois:\n\t\t# initialize the list of template matching scores and\n\t\t# resize the ROI to a fixed size\n\t\tscores = []\n\t\troi = cv2.resize(roi, (36, 36))\n\n\t\t# loop over the reference character name and corresponding\n\t\t# ROI\n\t\tfor charName in charNames:\n\t\t\t# apply correlation-based template matching, take the\n\t\t\t# score, and update the scores list\n\t\t\tresult = cv2.matchTemplate(roi, chars[charName],\n\t\t\t\tcv2.TM_CCOEFF)\n\t\t\t(_, score, _, _) = cv2.minMaxLoc(result)\n\t\t\tscores.append(score)\n\n\t\t# the classification for the character ROI will be the\n\t\t# reference character name with the *largest* template\n\t\t# matching score\n\t\tgroupOutput.append(charNames[np.argmax(scores)])\n\n\t# draw (padded) bounding box surrounding the group along with\n\t# the OCR output of the group\n\tcv2.rectangle(image, (gX - 10, gY + delta - 10),\n\t\t(gX + gW + 10, gY + gY + delta), (0, 0, 255), 2)\n\tcv2.putText(image, \"\".join(groupOutput),\n\t\t(gX - 10, gY + delta - 25), cv2.FONT_HERSHEY_SIMPLEX,\n\t\t0.95, (0, 0, 255), 3)\n\n\t# add the group output to the overall check OCR output\n\toutput.append(\"\".join(groupOutput))\n\n# display the output check OCR information to the screen\nprint(\"Check OCR: {}\".format(\" \".join(output)))\ncv2.imshow(\"Check OCR\", image)\ncv2.waitKey(0)"
] | [
[
"numpy.max",
"numpy.argmax",
"numpy.min",
"numpy.absolute"
]
] |
GAIA-DARPA-AIDA/face-building | [
"d1c574ceb6f48eb989ea077bec4b23267398f383"
] | [
"src/facenet.py"
] | [
"\"\"\"Functions for building the face recognition network.\n\"\"\"\n# MIT License\n# \n# Copyright (c) 2016 David Sandberg\n# \n# Permission is hereby granted, free of charge, to any person obtaining a copy\n# of this software and associated documentation files (the \"Software\"), to deal\n# in the Software without restriction, including without limitation the rights\n# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n# copies of the Software, and to permit persons to whom the Software is\n# furnished to do so, subject to the following conditions:\n# \n# The above copyright notice and this permission notice shall be included in all\n# copies or substantial portions of the Software.\n# \n# THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n# SOFTWARE.\n\n# pylint: disable=missing-docstring\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport os\nfrom subprocess import Popen, PIPE\nimport tensorflow as tf\nimport numpy as np\nfrom scipy import misc\nfrom sklearn.model_selection import KFold\nfrom scipy import interpolate\nfrom tensorflow.python.training import training\nimport random\nimport re\nfrom tensorflow.python.platform import gfile\nimport math\nfrom six import iteritems\n\ndef triplet_loss(anchor, positive, negative, alpha):\n \"\"\"Calculate the triplet loss according to the FaceNet paper\n \n Args:\n anchor: the embeddings for the anchor images.\n positive: the embeddings for the positive images.\n negative: the embeddings for the negative images.\n \n Returns:\n the triplet loss according to the FaceNet paper as a float tensor.\n \"\"\"\n with tf.compat.v1.variable_scope('triplet_loss'):\n pos_dist = tf.reduce_sum(input_tensor=tf.square(tf.subtract(anchor, positive)), axis=1)\n neg_dist = tf.reduce_sum(input_tensor=tf.square(tf.subtract(anchor, negative)), axis=1)\n \n basic_loss = tf.add(tf.subtract(pos_dist,neg_dist), alpha)\n loss = tf.reduce_mean(input_tensor=tf.maximum(basic_loss, 0.0), axis=0)\n \n return loss\n \ndef center_loss(features, label, alfa, nrof_classes):\n \"\"\"Center loss based on the paper \"A Discriminative Feature Learning Approach for Deep Face Recognition\"\n (http://ydwen.github.io/papers/WenECCV16.pdf)\n \"\"\"\n nrof_features = features.get_shape()[1]\n centers = tf.compat.v1.get_variable('centers', [nrof_classes, nrof_features], dtype=tf.float32,\n initializer=tf.compat.v1.constant_initializer(0), trainable=False)\n label = tf.reshape(label, [-1])\n centers_batch = tf.gather(centers, label)\n diff = (1 - alfa) * (centers_batch - features)\n centers = tf.compat.v1.scatter_sub(centers, label, diff)\n with tf.control_dependencies([centers]):\n loss = tf.reduce_mean(input_tensor=tf.square(features - centers_batch))\n return loss, centers\n\ndef get_image_paths_and_labels(dataset):\n image_paths_flat = []\n labels_flat = []\n for i in range(len(dataset)):\n image_paths_flat += dataset[i].image_paths\n labels_flat += [i] * len(dataset[i].image_paths)\n return image_paths_flat, labels_flat\n\ndef shuffle_examples(image_paths, labels):\n shuffle_list = list(zip(image_paths, labels))\n random.shuffle(shuffle_list)\n image_paths_shuff, labels_shuff = zip(*shuffle_list)\n return image_paths_shuff, labels_shuff\n\ndef random_rotate_image(image):\n angle = np.random.uniform(low=-10.0, high=10.0)\n return misc.imrotate(image, angle, 'bicubic')\n \n# 1: Random rotate 2: Random crop 4: Random flip 8: Fixed image standardization 16: Flip\nRANDOM_ROTATE = 1\nRANDOM_CROP = 2\nRANDOM_FLIP = 4\nFIXED_STANDARDIZATION = 8\nFLIP = 16\ndef create_input_pipeline(input_queue, image_size, nrof_preprocess_threads, batch_size_placeholder):\n images_and_labels_list = []\n for _ in range(nrof_preprocess_threads):\n filenames, label, control = input_queue.dequeue()\n images = []\n for filename in tf.unstack(filenames):\n file_contents = tf.io.read_file(filename)\n image = tf.image.decode_image(file_contents, 3)\n image = tf.cond(pred=get_control_flag(control[0], RANDOM_ROTATE),\n true_fn=lambda:tf.compat.v1.py_func(random_rotate_image, [image], tf.uint8), \n false_fn=lambda:tf.identity(image))\n image = tf.cond(pred=get_control_flag(control[0], RANDOM_CROP), \n true_fn=lambda:tf.image.random_crop(image, image_size + (3,)), \n false_fn=lambda:tf.image.resize_with_crop_or_pad(image, image_size[0], image_size[1]))\n image = tf.cond(pred=get_control_flag(control[0], RANDOM_FLIP),\n true_fn=lambda:tf.image.random_flip_left_right(image),\n false_fn=lambda:tf.identity(image))\n image = tf.cond(pred=get_control_flag(control[0], FIXED_STANDARDIZATION),\n true_fn=lambda:(tf.cast(image, tf.float32) - 127.5)/128.0,\n false_fn=lambda:tf.image.per_image_standardization(image))\n image = tf.cond(pred=get_control_flag(control[0], FLIP),\n true_fn=lambda:tf.image.flip_left_right(image),\n false_fn=lambda:tf.identity(image))\n #pylint: disable=no-member\n image.set_shape(image_size + (3,))\n images.append(image)\n images_and_labels_list.append([images, label])\n\n image_batch, label_batch = tf.compat.v1.train.batch_join(\n images_and_labels_list, batch_size=batch_size_placeholder, \n shapes=[image_size + (3,), ()], enqueue_many=True,\n capacity=4 * nrof_preprocess_threads * 100,\n allow_smaller_final_batch=True)\n \n return image_batch, label_batch\n\ndef get_control_flag(control, field):\n return tf.equal(tf.math.floormod(tf.math.floordiv(control, field), 2), 1)\n \ndef _add_loss_summaries(total_loss):\n \"\"\"Add summaries for losses.\n \n Generates moving average for all losses and associated summaries for\n visualizing the performance of the network.\n \n Args:\n total_loss: Total loss from loss().\n Returns:\n loss_averages_op: op for generating moving averages of losses.\n \"\"\"\n # Compute the moving average of all individual losses and the total loss.\n loss_averages = tf.train.ExponentialMovingAverage(0.9, name='avg')\n losses = tf.compat.v1.get_collection('losses')\n loss_averages_op = loss_averages.apply(losses + [total_loss])\n \n # Attach a scalar summmary to all individual losses and the total loss; do the\n # same for the averaged version of the losses.\n for l in losses + [total_loss]:\n # Name each loss as '(raw)' and name the moving average version of the loss\n # as the original loss name.\n tf.compat.v1.summary.scalar(l.op.name +' (raw)', l)\n tf.compat.v1.summary.scalar(l.op.name, loss_averages.average(l))\n \n return loss_averages_op\n\ndef train(total_loss, global_step, optimizer, learning_rate, moving_average_decay, update_gradient_vars, log_histograms=True):\n # Generate moving averages of all losses and associated summaries.\n loss_averages_op = _add_loss_summaries(total_loss)\n\n # Compute gradients.\n with tf.control_dependencies([loss_averages_op]):\n if optimizer=='ADAGRAD':\n opt = tf.compat.v1.train.AdagradOptimizer(learning_rate)\n elif optimizer=='ADADELTA':\n opt = tf.compat.v1.train.AdadeltaOptimizer(learning_rate, rho=0.9, epsilon=1e-6)\n elif optimizer=='ADAM':\n opt = tf.compat.v1.train.AdamOptimizer(learning_rate, beta1=0.9, beta2=0.999, epsilon=0.1)\n elif optimizer=='RMSPROP':\n opt = tf.compat.v1.train.RMSPropOptimizer(learning_rate, decay=0.9, momentum=0.9, epsilon=1.0)\n elif optimizer=='MOM':\n opt = tf.compat.v1.train.MomentumOptimizer(learning_rate, 0.9, use_nesterov=True)\n else:\n raise ValueError('Invalid optimization algorithm')\n \n grads = opt.compute_gradients(total_loss, update_gradient_vars)\n \n # Apply gradients.\n apply_gradient_op = opt.apply_gradients(grads, global_step=global_step)\n \n # Add histograms for trainable variables.\n if log_histograms:\n for var in tf.compat.v1.trainable_variables():\n tf.compat.v1.summary.histogram(var.op.name, var)\n \n # Add histograms for gradients.\n if log_histograms:\n for grad, var in grads:\n if grad is not None:\n tf.compat.v1.summary.histogram(var.op.name + '/gradients', grad)\n \n # Track the moving averages of all trainable variables.\n variable_averages = tf.train.ExponentialMovingAverage(\n moving_average_decay, global_step)\n variables_averages_op = variable_averages.apply(tf.compat.v1.trainable_variables())\n \n with tf.control_dependencies([apply_gradient_op, variables_averages_op]):\n train_op = tf.no_op(name='train')\n \n return train_op\n\ndef prewhiten(x):\n mean = np.mean(x)\n std = np.std(x)\n std_adj = np.maximum(std, 1.0/np.sqrt(x.size))\n y = np.multiply(np.subtract(x, mean), 1/std_adj)\n return y \n\ndef crop(image, random_crop, image_size):\n if image.shape[1]>image_size:\n sz1 = int(image.shape[1]//2)\n sz2 = int(image_size//2)\n if random_crop:\n diff = sz1-sz2\n (h, v) = (np.random.randint(-diff, diff+1), np.random.randint(-diff, diff+1))\n else:\n (h, v) = (0,0)\n image = image[(sz1-sz2+v):(sz1+sz2+v),(sz1-sz2+h):(sz1+sz2+h),:]\n return image\n \ndef flip(image, random_flip):\n if random_flip and np.random.choice([True, False]):\n image = np.fliplr(image)\n return image\n\ndef to_rgb(img):\n w, h = img.shape\n ret = np.empty((w, h, 3), dtype=np.uint8)\n ret[:, :, 0] = ret[:, :, 1] = ret[:, :, 2] = img\n return ret\n \ndef load_data(image_paths, do_random_crop, do_random_flip, image_size, do_prewhiten=True):\n nrof_samples = len(image_paths)\n images = np.zeros((nrof_samples, image_size, image_size, 3))\n for i in range(nrof_samples):\n print (image_paths[i])\n img = misc.imread(image_paths[i].replace('._',''))\n if img.ndim == 2:\n img = to_rgb(img)\n if do_prewhiten:\n img = prewhiten(img)\n img = crop(img, do_random_crop, image_size)\n img = flip(img, do_random_flip)\n images[i,:,:,:] = img\n return images\n\ndef get_label_batch(label_data, batch_size, batch_index):\n nrof_examples = np.size(label_data, 0)\n j = batch_index*batch_size % nrof_examples\n if j+batch_size<=nrof_examples:\n batch = label_data[j:j+batch_size]\n else:\n x1 = label_data[j:nrof_examples]\n x2 = label_data[0:nrof_examples-j]\n batch = np.vstack([x1,x2])\n batch_int = batch.astype(np.int64)\n return batch_int\n\ndef get_batch(image_data, batch_size, batch_index):\n nrof_examples = np.size(image_data, 0)\n j = batch_index*batch_size % nrof_examples\n if j+batch_size<=nrof_examples:\n batch = image_data[j:j+batch_size,:,:,:]\n else:\n x1 = image_data[j:nrof_examples,:,:,:]\n x2 = image_data[0:nrof_examples-j,:,:,:]\n batch = np.vstack([x1,x2])\n batch_float = batch.astype(np.float32)\n return batch_float\n\ndef get_triplet_batch(triplets, batch_index, batch_size):\n ax, px, nx = triplets\n a = get_batch(ax, int(batch_size/3), batch_index)\n p = get_batch(px, int(batch_size/3), batch_index)\n n = get_batch(nx, int(batch_size/3), batch_index)\n batch = np.vstack([a, p, n])\n return batch\n\ndef get_learning_rate_from_file(filename, epoch):\n with open(filename, 'r') as f:\n for line in f.readlines():\n line = line.split('#', 1)[0]\n if line:\n par = line.strip().split(':')\n e = int(par[0])\n if par[1]=='-':\n lr = -1\n else:\n lr = float(par[1])\n if e <= epoch:\n learning_rate = lr\n else:\n return learning_rate\n\nclass ImageClass():\n \"Stores the paths to images for a given class\"\n def __init__(self, name, image_paths):\n self.name = name\n self.image_paths = image_paths\n \n def __str__(self):\n return self.name + ', ' + str(len(self.image_paths)) + ' images'\n \n def __len__(self):\n return len(self.image_paths)\n \ndef get_dataset(path, has_class_directories=True):\n dataset = []\n path_exp = os.path.expanduser(path)\n classes = [path for path in os.listdir(path_exp) \\\n if os.path.isdir(os.path.join(path_exp, path))]\n classes.sort()\n nrof_classes = len(classes)\n for i in range(nrof_classes):\n class_name = classes[i]\n facedir = os.path.join(path_exp, class_name)\n image_paths = get_image_paths(facedir)\n dataset.append(ImageClass(class_name, image_paths))\n \n return dataset\n\ndef get_image_paths(facedir):\n \"\"\"\n image_paths = []\n if os.path.isdir(facedir):\n images = os.listdir(facedir)\n image_paths = [os.path.join(facedir,img) for img in images]\n return image_paths\n \"\"\"\n image_paths = []\n for root, dirs, files in os.walk(facedir):\n for file in files:\n if file.endswith(\".jpg\"):\n #print(os.path.join(root, file))\n image_paths.append(os.path.join(root, file))\n return image_paths\n\t\n \ndef split_dataset(dataset, split_ratio, min_nrof_images_per_class, mode):\n if mode=='SPLIT_CLASSES':\n nrof_classes = len(dataset)\n class_indices = np.arange(nrof_classes)\n np.random.shuffle(class_indices)\n split = int(round(nrof_classes*(1-split_ratio)))\n train_set = [dataset[i] for i in class_indices[0:split]]\n test_set = [dataset[i] for i in class_indices[split:-1]]\n elif mode=='SPLIT_IMAGES':\n train_set = []\n test_set = []\n for cls in dataset:\n paths = cls.image_paths\n np.random.shuffle(paths)\n nrof_images_in_class = len(paths)\n split = int(math.floor(nrof_images_in_class*(1-split_ratio)))\n if split==nrof_images_in_class:\n split = nrof_images_in_class-1\n if split>=min_nrof_images_per_class and nrof_images_in_class-split>=1:\n train_set.append(ImageClass(cls.name, paths[:split]))\n test_set.append(ImageClass(cls.name, paths[split:]))\n else:\n raise ValueError('Invalid train/test split mode \"%s\"' % mode)\n return train_set, test_set\n\ndef load_model(model, input_map=None):\n # Check if the model is a model directory (containing a metagraph and a checkpoint file)\n # or if it is a protobuf file with a frozen graph\n model_exp = os.path.expanduser(model)\n if (os.path.isfile(model_exp)):\n print('Model filename: %s' % model_exp)\n with gfile.FastGFile(model_exp,'rb') as f:\n graph_def = tf.compat.v1.GraphDef()\n graph_def.ParseFromString(f.read())\n tf.import_graph_def(graph_def, input_map=input_map, name='')\n else:\n print('Model directory: %s' % model_exp)\n meta_file, ckpt_file = get_model_filenames(model_exp)\n \n print('Metagraph file: %s' % meta_file)\n print('Checkpoint file: %s' % ckpt_file)\n \n saver = tf.compat.v1.train.import_meta_graph(os.path.join(model_exp, meta_file), input_map=input_map)\n saver.restore(tf.compat.v1.get_default_session(), os.path.join(model_exp, ckpt_file))\n \ndef get_model_filenames(model_dir):\n files = os.listdir(model_dir)\n meta_files = [s for s in files if s.endswith('.meta')]\n if len(meta_files)==0:\n raise ValueError('No meta file found in the model directory (%s)' % model_dir)\n elif len(meta_files)>1:\n raise ValueError('There should not be more than one meta file in the model directory (%s)' % model_dir)\n meta_file = meta_files[0]\n ckpt = tf.train.get_checkpoint_state(model_dir)\n if ckpt and ckpt.model_checkpoint_path:\n ckpt_file = os.path.basename(ckpt.model_checkpoint_path)\n return meta_file, ckpt_file\n\n meta_files = [s for s in files if '.ckpt' in s]\n max_step = -1\n for f in files:\n step_str = re.match(r'(^model-[\\w\\- ]+.ckpt-(\\d+))', f)\n if step_str is not None and len(step_str.groups())>=2:\n step = int(step_str.groups()[1])\n if step > max_step:\n max_step = step\n ckpt_file = step_str.groups()[0]\n return meta_file, ckpt_file\n \ndef distance(embeddings1, embeddings2, distance_metric=0):\n if distance_metric==0:\n # Euclidian distance\n diff = np.subtract(embeddings1, embeddings2)\n dist = np.sum(np.square(diff),1)\n elif distance_metric==1:\n # Distance based on cosine similarity\n dot = np.sum(np.multiply(embeddings1, embeddings2), axis=1)\n norm = np.linalg.norm(embeddings1, axis=1) * np.linalg.norm(embeddings2, axis=1)\n similarity = dot / norm\n dist = np.arccos(similarity) / math.pi\n else:\n raise 'Undefined distance metric %d' % distance_metric \n \n return dist\n\ndef calculate_roc(thresholds, embeddings1, embeddings2, actual_issame, nrof_folds=10, distance_metric=0, subtract_mean=False):\n assert(embeddings1.shape[0] == embeddings2.shape[0])\n assert(embeddings1.shape[1] == embeddings2.shape[1])\n nrof_pairs = min(len(actual_issame), embeddings1.shape[0])\n nrof_thresholds = len(thresholds)\n k_fold = KFold(n_splits=nrof_folds, shuffle=False)\n \n tprs = np.zeros((nrof_folds,nrof_thresholds))\n fprs = np.zeros((nrof_folds,nrof_thresholds))\n accuracy = np.zeros((nrof_folds))\n \n indices = np.arange(nrof_pairs)\n \n for fold_idx, (train_set, test_set) in enumerate(k_fold.split(indices)):\n if subtract_mean:\n mean = np.mean(np.concatenate([embeddings1[train_set], embeddings2[train_set]]), axis=0)\n else:\n mean = 0.0\n dist = distance(embeddings1-mean, embeddings2-mean, distance_metric)\n \n # Find the best threshold for the fold\n acc_train = np.zeros((nrof_thresholds))\n for threshold_idx, threshold in enumerate(thresholds):\n _, _, acc_train[threshold_idx] = calculate_accuracy(threshold, dist[train_set], actual_issame[train_set])\n best_threshold_index = np.argmax(acc_train)\n for threshold_idx, threshold in enumerate(thresholds):\n tprs[fold_idx,threshold_idx], fprs[fold_idx,threshold_idx], _ = calculate_accuracy(threshold, dist[test_set], actual_issame[test_set])\n _, _, accuracy[fold_idx] = calculate_accuracy(thresholds[best_threshold_index], dist[test_set], actual_issame[test_set])\n \n tpr = np.mean(tprs,0)\n fpr = np.mean(fprs,0)\n return tpr, fpr, accuracy\n\ndef calculate_accuracy(threshold, dist, actual_issame):\n predict_issame = np.less(dist, threshold)\n tp = np.sum(np.logical_and(predict_issame, actual_issame))\n fp = np.sum(np.logical_and(predict_issame, np.logical_not(actual_issame)))\n tn = np.sum(np.logical_and(np.logical_not(predict_issame), np.logical_not(actual_issame)))\n fn = np.sum(np.logical_and(np.logical_not(predict_issame), actual_issame))\n \n tpr = 0 if (tp+fn==0) else float(tp) / float(tp+fn)\n fpr = 0 if (fp+tn==0) else float(fp) / float(fp+tn)\n acc = float(tp+tn)/dist.size\n return tpr, fpr, acc\n\n\n \ndef calculate_val(thresholds, embeddings1, embeddings2, actual_issame, far_target, nrof_folds=10, distance_metric=0, subtract_mean=False):\n assert(embeddings1.shape[0] == embeddings2.shape[0])\n assert(embeddings1.shape[1] == embeddings2.shape[1])\n nrof_pairs = min(len(actual_issame), embeddings1.shape[0])\n nrof_thresholds = len(thresholds)\n k_fold = KFold(n_splits=nrof_folds, shuffle=False)\n \n val = np.zeros(nrof_folds)\n far = np.zeros(nrof_folds)\n \n indices = np.arange(nrof_pairs)\n \n for fold_idx, (train_set, test_set) in enumerate(k_fold.split(indices)):\n if subtract_mean:\n mean = np.mean(np.concatenate([embeddings1[train_set], embeddings2[train_set]]), axis=0)\n else:\n mean = 0.0\n dist = distance(embeddings1-mean, embeddings2-mean, distance_metric)\n \n # Find the threshold that gives FAR = far_target\n far_train = np.zeros(nrof_thresholds)\n for threshold_idx, threshold in enumerate(thresholds):\n _, far_train[threshold_idx] = calculate_val_far(threshold, dist[train_set], actual_issame[train_set])\n if np.max(far_train)>=far_target:\n f = interpolate.interp1d(far_train, thresholds, kind='slinear')\n threshold = f(far_target)\n else:\n threshold = 0.0\n \n val[fold_idx], far[fold_idx] = calculate_val_far(threshold, dist[test_set], actual_issame[test_set])\n \n val_mean = np.mean(val)\n far_mean = np.mean(far)\n val_std = np.std(val)\n return val_mean, val_std, far_mean\n\n\ndef calculate_val_far(threshold, dist, actual_issame):\n predict_issame = np.less(dist, threshold)\n true_accept = np.sum(np.logical_and(predict_issame, actual_issame))\n false_accept = np.sum(np.logical_and(predict_issame, np.logical_not(actual_issame)))\n n_same = np.sum(actual_issame)\n n_diff = np.sum(np.logical_not(actual_issame))\n val = float(true_accept) / float(n_same)\n far = float(false_accept) / float(n_diff)\n return val, far\n\ndef store_revision_info(src_path, output_dir, arg_string):\n try:\n # Get git hash\n cmd = ['git', 'rev-parse', 'HEAD']\n gitproc = Popen(cmd, stdout = PIPE, cwd=src_path)\n (stdout, _) = gitproc.communicate()\n git_hash = stdout.strip()\n except OSError as e:\n git_hash = ' '.join(cmd) + ': ' + e.strerror\n \n try:\n # Get local changes\n cmd = ['git', 'diff', 'HEAD']\n gitproc = Popen(cmd, stdout = PIPE, cwd=src_path)\n (stdout, _) = gitproc.communicate()\n git_diff = stdout.strip()\n except OSError as e:\n git_diff = ' '.join(cmd) + ': ' + e.strerror\n \n # Store a text file in the log directory\n rev_info_filename = os.path.join(output_dir, 'revision_info.txt')\n with open(rev_info_filename, \"w\") as text_file:\n text_file.write('arguments: %s\\n--------------------\\n' % arg_string)\n text_file.write('tensorflow version: %s\\n--------------------\\n' % tf.__version__) # @UndefinedVariable\n text_file.write('git hash: %s\\n--------------------\\n' % git_hash)\n text_file.write('%s' % git_diff)\n\ndef list_variables(filename):\n reader = training.NewCheckpointReader(filename)\n variable_map = reader.get_variable_to_shape_map()\n names = sorted(variable_map.keys())\n return names\n\ndef put_images_on_grid(images, shape=(16,8)):\n nrof_images = images.shape[0]\n img_size = images.shape[1]\n bw = 3\n img = np.zeros((shape[1]*(img_size+bw)+bw, shape[0]*(img_size+bw)+bw, 3), np.float32)\n for i in range(shape[1]):\n x_start = i*(img_size+bw)+bw\n for j in range(shape[0]):\n img_index = i*shape[0]+j\n if img_index>=nrof_images:\n break\n y_start = j*(img_size+bw)+bw\n img[x_start:x_start+img_size, y_start:y_start+img_size, :] = images[img_index, :, :, :]\n if img_index>=nrof_images:\n break\n return img\n\ndef write_arguments_to_file(args, filename):\n with open(filename, 'w') as f:\n for key, value in iteritems(vars(args)):\n f.write('%s: %s\\n' % (key, str(value)))\n"
] | [
[
"tensorflow.image.resize_with_crop_or_pad",
"numpy.arccos",
"numpy.random.choice",
"tensorflow.compat.v1.summary.histogram",
"tensorflow.image.random_flip_left_right",
"tensorflow.io.read_file",
"tensorflow.import_graph_def",
"tensorflow.train.get_checkpoint_state",
"tensorflow.reshape",
"numpy.mean",
"tensorflow.compat.v1.train.AdagradOptimizer",
"tensorflow.compat.v1.trainable_variables",
"numpy.multiply",
"numpy.size",
"tensorflow.control_dependencies",
"tensorflow.compat.v1.constant_initializer",
"tensorflow.identity",
"tensorflow.cast",
"tensorflow.no_op",
"numpy.max",
"numpy.concatenate",
"numpy.less",
"numpy.empty",
"numpy.linalg.norm",
"tensorflow.compat.v1.train.AdamOptimizer",
"tensorflow.compat.v1.train.RMSPropOptimizer",
"tensorflow.subtract",
"tensorflow.python.platform.gfile.FastGFile",
"numpy.logical_and",
"numpy.arange",
"numpy.argmax",
"numpy.sqrt",
"numpy.random.randint",
"tensorflow.compat.v1.get_default_session",
"scipy.misc.imrotate",
"numpy.vstack",
"tensorflow.compat.v1.scatter_sub",
"numpy.square",
"scipy.interpolate.interp1d",
"numpy.zeros",
"tensorflow.compat.v1.variable_scope",
"tensorflow.compat.v1.py_func",
"numpy.random.shuffle",
"tensorflow.math.floordiv",
"tensorflow.compat.v1.GraphDef",
"tensorflow.compat.v1.train.batch_join",
"numpy.std",
"numpy.subtract",
"tensorflow.compat.v1.train.MomentumOptimizer",
"tensorflow.compat.v1.summary.scalar",
"tensorflow.compat.v1.train.AdadeltaOptimizer",
"sklearn.model_selection.KFold",
"tensorflow.unstack",
"tensorflow.image.flip_left_right",
"tensorflow.compat.v1.get_collection",
"numpy.fliplr",
"numpy.logical_not",
"tensorflow.image.decode_image",
"numpy.sum",
"tensorflow.image.random_crop",
"numpy.random.uniform",
"tensorflow.train.ExponentialMovingAverage",
"tensorflow.gather",
"tensorflow.image.per_image_standardization",
"tensorflow.maximum",
"tensorflow.square",
"tensorflow.python.training.training.NewCheckpointReader"
]
] |
shanemmattner/Dash_Multipage | [
"8b451ccfa0b28553b8162f0fbd127b68788519c0"
] | [
"db_database.py"
] | [
"# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Wed Apr 21 13:41:45 2021\n\n@author: shane\n\"\"\"\n\nimport sqlite3\nimport os\nimport pandas as pd\nfrom datetime import datetime\n\n\nDEFAULT_PATH = os.path.join(os.path.dirname(__file__), 'database.sqlite3')\n\n#connect to sqlite database\ndef connect(db_path = DEFAULT_PATH):\n try:\n conn = sqlite3.connect(db_path)\n create_desc_table(conn)#we make sure there's a description table every time we connect\n except:\n print(\"Error\")\n return conn\n\n\ndef list_tables(conn):\n tables = pd.read_sql_query(\"SELECT name FROM sqlite_master WHERE type='table'\", conn)\n return tables\n\ndef create_table(conn, df):\n tables = list_tables(connect()) #get the list of tables\n new_table_name = 'test' + str(len(tables))\n df.to_sql(new_table_name, con = conn)\n\ndef retrieve_table(conn):\n tables = list_tables(connect()) #get the list of tables\n last_table_name = 'test' + str(len(tables)-1)\n df = pd.read_sql_query('SELECT * FROM ' + last_table_name, conn)\n return df\n\ndef create_desc_table(conn):\n try:\n sql_create_desc_table = \"\"\"\n CREATE TABLE IF NOT EXISTS desc(\n id integer PRIMARY KEY,\n date text NOT NULL,\n desc text NOT NULL,\n sRate float NOT NULL,\n push float,\n start float,\n end float\n );\"\"\"\n cur = conn.cursor()\n cur.execute(sql_create_desc_table) #no commit needed, this is table structure stuff\n except:\n print(\"Error\")\n\n# Function that creates table to hold shapes data\n# All shapes have x0, x1, y1, y2 coordinates\n# Circles and rectangles have 'fill color' and 'fill rule' as well but we won't store that data\ndef create_shapes_table(conn):\n try:\n sql_create_desc_table = \"\"\"\n CREATE TABLE IF NOT EXISTS rect(\n id integer PRIMARY KEY,\n test_num integer NOT NULL,\n shape_type text NOT NULL,\n x0 float NOT NULL,\n x1 float NOT NULL,\n y0 float NOT NULL,\n y1 float NOT NULL,\n );\"\"\"\n cur = conn.cursor()\n cur.execute(sql_create_desc_table) #no commit needed, this is table structure stuff\n except:\n print(\"Error\")\n\ndef add_desc_entry(conn,description, sample_rate,end_time):\n try:\n #get the date\n now = datetime.today()\n frmt_now = now.strftime(\"%Y-%m-%d %H:%M:%S\") #TODO: convert from UTC to CST\n sql_insert_query = \"\"\"\n INSERT INTO desc\n (date, desc, sRate, push, start, end)\n VALUES\n (\"{}\",\"{}\",{},{},{},{})\n \"\"\".format(frmt_now, description, sample_rate, 0, 0, end_time)\n cur = conn.cursor()\n cur.execute(sql_insert_query)\n conn.commit()\n desc_table = pd.read_sql_query(\"SELECT * FROM desc\", conn)\n print(desc_table)\n except Exception as e:\n print(\"couldn't add description: \", e)\n\n "
] | [
[
"pandas.read_sql_query"
]
] |
M3nin0/data_cube_utilities | [
"badd774c35babc5becc17e1a2b38a0d1782d3540"
] | [
"data_cube_utilities/xarray_bokeh_plotting.py"
] | [
"from bokeh.models.widgets import Panel, Tabs\nimport numpy as np\nimport importlib\nimport pandas as pd\nfrom bokeh.models import FuncTickFormatter\nfrom bokeh.io import push_notebook, show, output_notebook\nfrom bokeh.layouts import row\nfrom bokeh.plotting import figure\nfrom bokeh.models.sources import ColumnDataSource\nfrom bokeh.models import HoverTool\n\n\ndef __stem_figure(list1,\n name1,\n list2,\n name2,\n **kwargs):\n \n dataframe_A = pd.DataFrame(list1, index = list1).rename(columns = {0:name1})\n dataFrame_B = pd.DataFrame(list2, index = list2).rename(columns = {0:name2})\n \n\n\n result = pd.concat([dataframe_A,dataFrame_B], join = 'outer', axis = 1)\n result = (~pd.isnull(result)).astype(int)\n \n aframe = result[name1][ result[name1] > 0]\n bframe = result[name2][ result[name2] > 0]\n bframe = bframe.map(np.negative) \n \n positive_match = aframe[result[name1] == result[name2]]\n positive_miss = aframe[result[name1] != result[name2]]\n \n negative_match = bframe[result[name1] == result[name2]]\n negative_miss = bframe[result[name1] != result[name2]]\n \n \n ## Handle DateTime formats on X-Axis\n x_axis_format = 'auto' if type(list1[0]) != np.datetime64 else \"datetime\" \n\n ## Create Canvas/Figure \n p = figure(plot_width = 900,\n plot_height = 200,\n tools = \"xpan, reset, save, xzoom_in, xzoom_out\",\n x_axis_type = x_axis_format,\n title= \"Coordinate Comparison: {}\".format(kwargs['dimension']))\n \n ## Create a long horizontal line\n start = min(aframe.index.min(), bframe.index.min())\n end = max(aframe.index.max(), bframe.index.max())\n \n \n categories = [\"oof\", \"doof\"]\n\n \n ## Remove Horizontal Gridlines \n p.ygrid.grid_line_color = None\n \n ## Remove YAxis Labels (Since they ploy categorical)\n p.yaxis.major_tick_line_color = None # turn off y-axis major ticks\n p.yaxis.minor_tick_line_color = None # turn off y-axis minor ticks\n# p.yaxis.major_label_text_font_size = '0pt' # turn off y-axis tick labels\n \n p.segment(x0 = start,\n x1 = end,\n y0 = 0,\n y1 = 0,\n line_width = 1)\n\n def __plot_stem_and_bulb(figure, series, color, name): \n \n figure.circle(x = \"index\",\n y = name,\n source = ColumnDataSource(series.to_frame()),\n alpha=0.5,\n size = 10,\n color = color)\n \n figure.segment(x0 = 'index',\n x1 = 'index',\n y0 = 0,\n y1 = name,\n source = ColumnDataSource(series.to_frame()),\n line_width = 1,\n color = color)\n return figure\n \n p = __plot_stem_and_bulb(p, positive_match, \"green\", name1)\n p = __plot_stem_and_bulb(p, positive_miss, \"red\", name1)\n p = __plot_stem_and_bulb(p, negative_match, \"green\", name2)\n p = __plot_stem_and_bulb(p, negative_miss, \"red\", name2) \n \n p.yaxis.axis_label = \"{} {}\".format(name2, name1)\n \n return p\n print(result)\n\ndef init_notebook():\n from bokeh.plotting import figure, show\n from bokeh.io import output_notebook\n output_notebook()\n \ndef dim_alignement(dataset_1 = None,\n name_1 = \"dataset_1\",\n dataset_2 = None,\n name_2 = \"dataset_2\",\n ):\n xr1 = dataset_1\n xr2 = dataset_2 \n \n common_dims = set(xr1.dims).intersection(set(xr2.dims))\n \n empty_set = set()\n if common_dims == empty_set:\n raise Exception(\"datasets do not have any dims in common\")\n \n display_tabs = []\n for dim in common_dims:\n fig = __stem_figure(xr1[dim].values,\n name_1,\n xr2[dim].values,\n name_2,\n dimension = dim\n )\n \n display_tabs.append(Panel(child = fig, title = dim))\n \n tabs = Tabs(tabs = display_tabs) ## Make a figure with many tabs. \n show(tabs)\n "
] | [
[
"pandas.isnull",
"pandas.DataFrame",
"pandas.concat"
]
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.