repo_name
stringlengths 6
130
| hexsha
list | file_path
list | code
list | apis
list |
|---|---|---|---|---|
rijobro/CCPi-Framework | [
"ff08216d4e6fef84659b43155c5c52484b1dc543",
"ff08216d4e6fef84659b43155c5c52484b1dc543"
]
| [
"Wrappers/Python/test/test_TranslateFunction.py",
"Wrappers/Python/ccpi/optimisation/functions/Rosenbrock.py"
]
| [
"# -*- coding: utf-8 -*-\n# CCP in Tomographic Imaging (CCPi) Core Imaging Library (CIL).\n\n# Copyright 2017 UKRI-STFC\n# Copyright 2017 University of Manchester\n\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n\n# http://www.apache.org/licenses/LICENSE-2.0\n\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nfrom ccpi.optimisation.functions import Function, L1Norm, ScaledFunction, \\\n LeastSquares, L2NormSquared, \\\n KullbackLeibler, ZeroFunction, ConstantFunction, TranslateFunction\nfrom ccpi.optimisation.operators import Identity \nfrom ccpi.framework import ImageGeometry, BlockGeometry\n\nimport unittest\nimport numpy\nfrom numbers import Number\n\n\n''' Here we test SumFunction class for different function\n\nL2Norm, L1Norm, KullbackLeibler, ZeroFunction, ConstantFunction, Scalar\n\nfor call method\nfor gradient method\n\n\n\n'''\n\n\n\nclass TestFunction(unittest.TestCase):\n \n def assertBlockDataContainerEqual(self, container1, container2):\n print (\"assert Block Data Container Equal\")\n self.assertTrue(issubclass(container1.__class__, container2.__class__))\n for col in range(container1.shape[0]):\n if issubclass(container1.get_item(col).__class__, DataContainer):\n print (\"Checking col \", col)\n self.assertNumpyArrayEqual(\n container1.get_item(col).as_array(), \n container2.get_item(col).as_array()\n )\n else:\n self.assertBlockDataContainerEqual(container1.get_item(col),container2.get_item(col))\n \n def assertNumpyArrayEqual(self, first, second):\n res = True\n try:\n numpy.testing.assert_array_equal(first, second)\n except AssertionError as err:\n res = False\n print(err)\n self.assertTrue(res)\n\n def assertNumpyArrayAlmostEqual(self, first, second, decimal=6):\n res = True\n try:\n numpy.testing.assert_array_almost_equal(first, second, decimal)\n except AssertionError as err:\n res = False\n print(err)\n print(\"expected \" , second)\n print(\"actual \" , first)\n\n self.assertTrue(res)\n \n def test_TranslateFunction(self): \n \n # Test TranslationFunction\n \n ig = ImageGeometry(4,4)\n tmp = ig.allocate('random_int')\n b = ig.allocate('random_int')\n scalar = 0.4\n tau = 0.05\n \n list1 = [ L2NormSquared(), scalar * L2NormSquared(), scalar * L2NormSquared(b=b), \n L1Norm(), scalar * L1Norm(), scalar * L1Norm(b=b)]\n \n list1_shift = [ L2NormSquared().centered_at(ig.allocate()), scalar * L2NormSquared().centered_at(ig.allocate()), scalar * L2NormSquared().centered_at(b),\n L1Norm().centered_at(ig.allocate()), scalar * L1Norm().centered_at(ig.allocate()), scalar * L1Norm().centered_at(b)] \n \n out_gradient1 = ig.allocate()\n out_gradient2 = ig.allocate()\n \n out_proximal1 = ig.allocate()\n out_proximal2 = ig.allocate() \n \n out_proximal_conj1 = ig.allocate()\n out_proximal_conj2 = ig.allocate() \n \n for func, func_shift in zip(list1, list1_shift):\n\n # check call\n res1 = func(tmp)\n res2 = func_shift(tmp)\n self.assertNumpyArrayAlmostEqual(res1, res2)\n \n try:\n # check gradient\n res1_gradient = func.gradient(tmp)\n res2_gradient = func_shift.gradient(tmp)\n self.assertNumpyArrayAlmostEqual(res1_gradient.as_array(), res2_gradient.as_array()) \n \n # check gradient out\n func.gradient(tmp, out = out_gradient1)\n func_shift.gradient(tmp, out = out_gradient2)\n self.assertNumpyArrayAlmostEqual(out_gradient1.as_array(), out_gradient2.as_array())\n \n except NotImplementedError:\n print('Function is not differentiable')\n \n # check proximal \n func.proximal(tmp, tau, out = out_proximal1)\n func_shift.proximal(tmp, tau, out = out_proximal2)\n self.assertNumpyArrayAlmostEqual(out_proximal1.as_array(), out_proximal2.as_array()) \n\n # check proximal conjugate\n func.proximal_conjugate(tmp, tau, out = out_proximal_conj1)\n func_shift.proximal_conjugate(tmp, tau, out = out_proximal_conj2)\n self.assertNumpyArrayAlmostEqual(out_proximal_conj1.as_array(), out_proximal_conj1.as_array()) \n \n \nif __name__ == '__main__':\n# \n t = TestFunction()\n t.test_TranslateFunction() \n\n\n# ig = ImageGeometry(4,4)\n# tmp = ig.allocate('random_int')\n# b = ig.allocate('random_int')\n# scalar = 0.4\n# \n## f = scalar * L2NormSquared().centered_at(b)\n## print(f.function.function)\n# list1 = [ L2NormSquared(), scalar * L2NormSquared(), scalar * L2NormSquared(b=b)] \n# \n## for func in list_functions:\n## \n### if isinstance(func, ScaledFunction):\n### func_tmp = func.function\n### else:\n### func_tmp = func \n### \n### if func_tmp.b is None:\n### tmp_data = ig.allocate()\n### else:\n### tmp_data = b \n## \n## func_tmp = func\n## tmp_data = ig.allocate()\n## \n## res1 = func_tmp(tmp) \n## res2 = func_tmp.centered_at(tmp_data)(tmp)\n## \n## self.assertNumpyArrayAlmostEqual(res1, res2)\n \n \n\n \n \n# \n# for i in list_functions:\n# \n# print('Test Translation for Function {} '.format(type(i).__name__))\n# \n# if isinstance(i, L2NormSquared):\n# \n# f = L2NormSquared(b = b) \n# g = TranslateFunction(L2NormSquared(), b)\n# \n# elif isinstance(i, L1Norm):\n# \n# f = L1Norm(b = b) \n# g = TranslateFunction(L1Norm(), b)\n# \n# elif isinstance(i, ScaledFunction):\n# \n# if isinstance(i.function, L2NormSquared):\n# f = scalar * L2NormSquared(b = b) \n# g = scalar * TranslateFunction(L2NormSquared(), b)\n# \n# if isinstance(i.function, L1Norm):\n# f = scalar * L1Norm(b = b) \n# g = scalar * TranslateFunction(L1Norm(), b) \n# \n# # check call\n# res1 = f(tmp)\n# res2 = g(tmp) \n# numpy.testing.assert_equal(res1, res2)\n# \n# # check gradient\n# \n# if not isinstance(i, L1Norm):\n# \n# res1 = f.gradient(tmp)\n# res2 = g.gradient(tmp) \n# numpy.testing.assert_equal(res1.as_array(), res2.as_array()) \n# \n# # check gradient out\n# res3 = ig.allocate()\n# res4 = ig.allocate()\n# f.gradient(tmp, out = res3)\n# g.gradient(tmp, out = res4)\n# numpy.testing.assert_equal(res3.as_array(), res4.as_array())\n# \n# # check convex conjugate\n# res1 = f.convex_conjugate(tmp)\n# res2 = g.convex_conjugate(tmp)\n# numpy.testing.assert_equal(res1, res2) \n# \n# # check proximal \n# tau = 0.5\n# res1 = f.proximal(tmp, tau)\n# res2 = g.proximal(tmp, tau)\n# numpy.testing.assert_equal(res1.as_array(), res2.as_array()) \n# \n# # check proximal out \n# res3 = ig.allocate()\n# res4 = ig.allocate()\n# f.proximal(tmp, tau, out = res3)\n# g.proximal(tmp, tau, out = res4)\n# numpy.testing.assert_array_almost_equal(res3.as_array(), res4.as_array(),decimal = decimal) \n# \n# # check proximal conjugate \n# tau = 0.4\n# res1 = f.proximal_conjugate(tmp, tau)\n# res2 = g.proximal_conjugate(tmp, tau)\n# numpy.testing.assert_array_almost_equal(res1.as_array(), res2.as_array(),decimal = decimal) \n# \n# # check proximal out \n# res3 = ig.allocate()\n# res4 = ig.allocate()\n# f.proximal_conjugate(tmp, tau, out = res3)\n# g.proximal_conjugate(tmp, tau, out = res4)\n# numpy.testing.assert_array_almost_equal(res3.as_array(), res4.as_array(),decimal = decimal) \n# \n# \n# f = L2NormSquared() + 1\n# print(f(tmp))\n# \n# \n \n# \n# \n# # tau = 0.5 \n# # f = L2NormSquared(b=b) \n# # g = TranslateFunction(f, b)\n# # res1 = f.proximal_conjugate(tmp, tau) \n# # res2 = tmp - tau * f.proximal(tmp/tau, 1/tau)\n# # res3 = g.proximal_conjugate(tmp, tau)\n# \n# # print(res1.as_array())\n# # print(res3.as_array())\n# # numpy.testing.assert_equal(res1.as_array(), res2.as_array()) \n# # numpy.testing.assert_equal(res1.as_array(), res3.as_array()) \n# \n# \n# \n",
"# -*- coding: utf-8 -*-\n#========================================================================\n# Copyright 2019 Science Technology Facilities Council\n# Copyright 2019 University of Manchester\n#\n# This work is part of the Core Imaging Library developed by Science Technology\n# Facilities Council and University of Manchester\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.txt\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n#\n#=========================================================================\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\nfrom __future__ import unicode_literals\nimport numpy\nfrom ccpi.optimisation.functions import Function\nfrom ccpi.framework import VectorData, VectorGeometry\n\nclass Rosenbrock(Function):\n r'''Rosenbrock function\n\n .. math:: \n\n F(x,y) = (\\alpha - x)^2 + \\beta(y-x^2)^2\n\n The function has a global minimum at .. math:: (x,y)=(\\alpha, \\alpha^2)\n\n '''\n def __init__(self, alpha, beta):\n super(Rosenbrock, self).__init__()\n\n self.alpha = alpha\n self.beta = beta\n\n def __call__(self, x):\n if not isinstance(x, VectorData):\n raise TypeError('Rosenbrock function works on VectorData only')\n vec = x.as_array()\n a = (self.alpha - vec[0])\n b = (vec[1] - (vec[0]*vec[0]))\n return a * a + self.beta * b * b\n\n def gradient(self, x, out=None):\n r'''Gradient of the Rosenbrock function\n \n .. math::\n\n \\nabla f(x,y) = \\left[ 2*((x-\\alpha) - 2\\beta x(y-x^2)) ; 2\\beta (y - x^2) \\right]\n\n '''\n if not isinstance(x, VectorData):\n raise TypeError('Rosenbrock function works on VectorData only')\n\n vec = x.as_array()\n a = (vec[0] - self.alpha)\n b = (vec[1] - (vec[0]*vec[0]))\n\n res = numpy.empty_like(vec)\n res[0] = 2 * ( a - 2 * self.beta * vec[0] * b)\n res[1] = 2 * self.beta * b\n\n if out is not None:\n out.fill (res)\n else:\n return VectorData(res) \n\n"
]
| [
[
"numpy.testing.assert_array_almost_equal",
"numpy.testing.assert_array_equal"
],
[
"numpy.empty_like"
]
]
|
pingrunhuang/mars | [
"cde691285d921add5460944764c7278e7ddec8ff"
]
| [
"mars/scheduler/tests/test_graph.py"
]
| [
"# Copyright 1999-2018 Alibaba Group Holding Ltd.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport contextlib\nimport uuid\nimport unittest\n\nimport mars.tensor as mt\nfrom mars.cluster_info import ClusterInfoActor\nfrom mars.scheduler import GraphActor, GraphMetaActor, ResourceActor, ChunkMetaActor, \\\n AssignerActor, GraphState\nfrom mars.utils import serialize_graph, get_next_port\nfrom mars.actors import create_actor_pool\nfrom mars.tests.core import patch_method\n\n\nclass Test(unittest.TestCase):\n @contextlib.contextmanager\n def prepare_graph_in_pool(self, expr, clean_io_meta=True, compose=False):\n session_id = str(uuid.uuid4())\n graph_key = str(uuid.uuid4())\n\n graph = expr.build_graph(compose=compose)\n serialized_graph = serialize_graph(graph)\n chunked_graph = expr.build_graph(compose=compose, tiled=True)\n\n addr = '127.0.0.1:%d' % get_next_port()\n with create_actor_pool(n_process=1, backend='gevent', address=addr) as pool:\n pool.create_actor(ClusterInfoActor, [pool.cluster_info.address],\n uid=ClusterInfoActor.default_name())\n resource_ref = pool.create_actor(ResourceActor, uid=ResourceActor.default_name())\n pool.create_actor(ChunkMetaActor, uid=ChunkMetaActor.default_name())\n pool.create_actor(AssignerActor, uid=AssignerActor.default_name())\n graph_ref = pool.create_actor(GraphActor, session_id, graph_key, serialized_graph,\n uid=GraphActor.gen_name(session_id, graph_key))\n\n graph_ref.prepare_graph(compose=compose)\n fetched_graph = graph_ref.get_chunk_graph()\n self.assertIsNotNone(fetched_graph)\n self.assertEqual(len(chunked_graph), len(fetched_graph))\n\n graph_ref.scan_node()\n op_infos = graph_ref.get_operand_info()\n for n in fetched_graph:\n depth = op_infos[n.op.key]['optimize']['depth']\n self.assertIsNotNone(depth)\n successor_size = op_infos[n.op.key]['optimize']['successor_size']\n self.assertIsNotNone(successor_size)\n descendant_size = op_infos[n.op.key]['optimize']['descendant_size']\n self.assertIsNotNone(descendant_size)\n\n resource_ref.set_worker_meta('localhost:12345', dict(hardware=dict(cpu_total=4)))\n resource_ref.set_worker_meta('localhost:23456', dict(hardware=dict(cpu_total=4)))\n\n graph_ref.place_initial_chunks()\n op_infos = graph_ref.get_operand_info()\n\n for n in fetched_graph:\n if fetched_graph.count_predecessors(n) != 0:\n continue\n target_worker = op_infos[n.op.key]['target_worker']\n self.assertIsNotNone(target_worker)\n\n graph_ref.create_operand_actors(_clean_io_meta=clean_io_meta)\n op_infos = graph_ref.get_operand_info()\n\n if not clean_io_meta:\n orig_metas = dict()\n for n in fetched_graph:\n try:\n meta = orig_metas[n.op.key]\n except KeyError:\n meta = orig_metas[n.op.key] = dict(\n predecessors=set(), successors=set(), input_chunks=set(), chunks=set()\n )\n meta['predecessors'].update([pn.op.key for pn in fetched_graph.iter_predecessors(n)])\n meta['successors'].update([sn.op.key for sn in fetched_graph.iter_successors(n)])\n meta['input_chunks'].update([pn.key for pn in fetched_graph.iter_predecessors(n)])\n meta['chunks'].update([c.key for c in n.op.outputs])\n\n for n in fetched_graph:\n self.assertEqual(op_infos[n.op.key]['op_name'], type(n.op).__name__)\n\n io_meta = op_infos[n.op.key]['io_meta']\n orig_io_meta = orig_metas[n.op.key]\n\n self.assertSetEqual(set(io_meta['predecessors']), set(orig_io_meta['predecessors']))\n self.assertSetEqual(set(io_meta['successors']), set(orig_io_meta['successors']))\n self.assertSetEqual(set(io_meta['input_chunks']), set(orig_io_meta['input_chunks']))\n self.assertSetEqual(set(io_meta['chunks']), set(orig_io_meta['chunks']))\n\n self.assertEqual(op_infos[n.op.key]['output_size'], sum(ch.nbytes for ch in n.op.outputs))\n\n yield pool, graph_ref\n\n def testSimpleGraphPreparation(self, *_):\n arr = mt.random.randint(10, size=(10, 8), chunk_size=4)\n arr_add = mt.random.randint(10, size=(10, 8), chunk_size=4)\n arr2 = arr + arr_add\n with self.prepare_graph_in_pool(arr2, clean_io_meta=False):\n pass\n\n def testSplitPreparation(self, *_):\n arr = mt.ones(12, chunk_size=4)\n arr_split = mt.split(arr, 2)\n arr_sum = arr_split[0] + arr_split[1]\n with self.prepare_graph_in_pool(arr_sum, clean_io_meta=False):\n pass\n\n def testSameKeyPreparation(self, *_):\n arr = mt.ones((5, 5), chunk_size=3)\n arr2 = mt.concatenate((arr, arr))\n with self.prepare_graph_in_pool(arr2, clean_io_meta=False):\n pass\n\n def testFusePreparation(self, *_):\n from mars.tensor.expressions.fuse.core import TensorFuseChunk\n arr = mt.ones((5, 5), chunk_size=3)\n arr2 = (arr + 5) * 2\n with self.prepare_graph_in_pool(arr2, compose=True) as (pool, graph_ref):\n out_graph = graph_ref.get_chunk_graph()\n self.assertTrue(all(isinstance(v.op, TensorFuseChunk) for v in out_graph))\n\n def testMultipleAddPreparation(self, *_):\n import numpy as np\n import operator\n from mars.compat import reduce\n\n base_arr = np.random.random((100, 100))\n a = mt.array(base_arr)\n sumv = reduce(operator.add, [a[:10, :10] for _ in range(10)])\n with self.prepare_graph_in_pool(sumv):\n pass\n\n def testGraphTermination(self, *_):\n from mars.tensor.expressions.arithmetic.add import TensorAddConstant\n arr = mt.random.random((8, 2), chunk_size=2)\n arr2 = arr + 1\n with self.prepare_graph_in_pool(arr2) as (pool, graph_ref):\n out_graph = graph_ref.get_chunk_graph()\n for c in out_graph:\n if not isinstance(c.op, TensorAddConstant):\n continue\n self.assertNotEqual(graph_ref.get_state(), GraphState.SUCCEEDED)\n graph_ref.mark_terminal_finished(c.op.key)\n\n self.assertEqual(graph_ref.get_state(), GraphState.SUCCEEDED)\n\n arr = mt.random.random((8, 2), chunk_size=2)\n arr2 = arr + 1\n with self.prepare_graph_in_pool(arr2) as (pool, graph_ref):\n out_graph = graph_ref.get_chunk_graph()\n for c in out_graph:\n if not isinstance(c.op, TensorAddConstant):\n continue\n self.assertNotEqual(graph_ref.get_state(), GraphState.FAILED)\n graph_ref.mark_terminal_finished(c.op.key, GraphState.FAILED)\n\n self.assertEqual(graph_ref.get_state(), GraphState.FAILED)\n\n def testErrorOnPrepare(self, *_):\n session_id = str(uuid.uuid4())\n\n addr = '127.0.0.1:%d' % get_next_port()\n with create_actor_pool(n_process=1, backend='gevent', address=addr) as pool:\n pool.create_actor(ClusterInfoActor, [pool.cluster_info.address],\n uid=ClusterInfoActor.default_name())\n resource_ref = pool.create_actor(ResourceActor, uid=ResourceActor.default_name())\n pool.create_actor(ChunkMetaActor, uid=ChunkMetaActor.default_name())\n pool.create_actor(AssignerActor, uid=AssignerActor.default_name())\n\n resource_ref.set_worker_meta('localhost:12345', dict(hardware=dict(cpu_total=4)))\n resource_ref.set_worker_meta('localhost:23456', dict(hardware=dict(cpu_total=4)))\n\n # error occurred in create_operand_actors\n graph_key = str(uuid.uuid4())\n expr = mt.random.random((8, 2), chunk_size=2) + 1\n graph = expr.build_graph(compose=False)\n serialized_graph = serialize_graph(graph)\n\n graph_ref = pool.create_actor(GraphActor, session_id, graph_key, serialized_graph,\n uid=GraphActor.gen_name(session_id, graph_key))\n\n def _mock_raises(*_):\n raise RuntimeError\n\n with patch_method(GraphActor.create_operand_actors, new=_mock_raises):\n with self.assertRaises(RuntimeError):\n graph_ref.execute_graph()\n self.assertEqual(graph_ref.get_state(), GraphState.FAILED)\n graph_ref.destroy()\n\n # interrupted during create_operand_actors\n graph_key = str(uuid.uuid4())\n graph_ref = pool.create_actor(GraphActor, session_id, graph_key, serialized_graph,\n uid=GraphActor.gen_name(session_id, graph_key))\n\n def _mock_cancels(*_):\n graph_meta_ref = pool.actor_ref(GraphMetaActor.gen_name(session_id, graph_key))\n graph_meta_ref.set_state(GraphState.CANCELLING)\n\n with patch_method(GraphActor.create_operand_actors, new=_mock_cancels):\n graph_ref.execute_graph()\n self.assertEqual(graph_ref.get_state(), GraphState.CANCELLED)\n\n # interrupted during previous steps\n graph_key = str(uuid.uuid4())\n graph_ref = pool.create_actor(GraphActor, session_id, graph_key, serialized_graph,\n uid=GraphActor.gen_name(session_id, graph_key))\n\n def _mock_cancels(*_):\n graph_meta_ref = pool.actor_ref(GraphMetaActor.gen_name(session_id, graph_key))\n graph_meta_ref.set_state(GraphState.CANCELLING)\n\n with patch_method(GraphActor.place_initial_chunks, new=_mock_cancels):\n graph_ref.execute_graph()\n self.assertEqual(graph_ref.get_state(), GraphState.CANCELLED)\n"
]
| [
[
"numpy.random.random"
]
]
|
EEdwardsA/Twitoff | [
"e1c2613c233e81c5aa50fecb89e90c75b9bbdd01"
]
| [
"twitoff/predict.py"
]
| [
"\"\"\"Prediction of Users based on tweet embeddings\"\"\"\n\nimport numpy as np\nfrom sklearn.linear_model import LogisticRegression\nfrom .models import User\nfrom .twitter import vectorize_tweet\n\ndef predict_user(user0_name, user1_name, hypo_tweet_text):\n \"\"\"\n Determine and return which user is more likely to say a hypothetical tweet\n \n Example run: predict_user('elonmusk', 'nasa', 'Tesla cars are rad')\n returns 0 (user0_name) or 1 (user1_name)\n \"\"\"\n user0 = User.query.filter(User.name == user0_name).one()\n # TODO: create try/except block\n user1 = User.query.filter(User.name == user1_name).one()\n user0_vects = np.array([tweet.vect for tweet in user0.tweets])\n user1_vects = np.array([tweet.vect for tweet in user1.tweets])\n vects = np.vstack([user0_vects, user1_vects])\n labels = np.concatenate(\n [np.zeros(len(user0.tweets)), np.ones(len(user1.tweets))])\n hypo_tweet_vect = vectorize_tweet(hypo_tweet_text)\n\n log_reg = LogisticRegression().fit(vects, labels)\n\n return log_reg.predict(hypo_tweet_vect.reshape(1, -1))\n \n\n"
]
| [
[
"sklearn.linear_model.LogisticRegression",
"numpy.array",
"numpy.vstack"
]
]
|
darrelrobinson/rdd | [
"54b9c328087ae22ac38073aab2ee930459b2364a"
]
| [
"build/lib/rdd/test.py"
]
| [
"import numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\n\nimport functions as rdd\n\n'''\nTo Do:\n - Put testing functions in another folder\n - test different input types, combos of bad items, etc\n'''\n\n# Set seed\nnp.random.seed(42)\n\n# Simulate data\nN = 10000\n# x = np.random.uniform(-.5, .5, N)\nx = np.random.normal(0, 1, N)\nepsilon = np.random.normal(0, 1, N)\nforcing = np.round(x+.5)\ny = .5 * forcing + 2 * x + 1 + epsilon\nw1 = np.random.normal(0, 1, N)\nw2 = np.random.normal(0, 4, N)\n\ndata = pd.DataFrame({'y':y, 'x': x, 'w1':w1, 'w2':w2})\nprint(data.head())\n\nh = rdd.optimal_bandwidth(data['y'], data['x'])\nprint(h)\n\n# data_rdd = rdd.truncated_data(data, 'x', h)\n\n# results = rdd.rdd(data_rdd, 'x', 'y')\n\n# print(results.summary())\n\n# data_binned = rdd.bin_data(data, 'y', 'x', 100)\n\n# plt.figure()\n# plt.scatter(data_binned['x'], data_binned['y'],\n# s = data_binned['n_obs'], facecolors='none', edgecolors='r')\n# plt.show()\n# plt.close()\n\n# print(data_binned['n_obs'].describe())\n\n# Show a spline\n# show placebo with different cuts"
]
| [
[
"numpy.random.seed",
"numpy.random.normal",
"pandas.DataFrame",
"numpy.round"
]
]
|
georgegunter/flow | [
"15848ec9bafd250364a51fa162786037645b19bf"
]
| [
"examples/Old Code/run_follower_stopper_ring.py"
]
| [
"from flow.controllers import FollowerStopper, IDMController, ContinuousRouter, OVMController\nfrom flow.core.params import SumoParams, EnvParams, InitialConfig, NetParams\nfrom flow.core.params import VehicleParams\nfrom flow.envs.ring.accel import AccelEnv, ADDITIONAL_ENV_PARAMS\nfrom flow.networks.ring import RingNetwork, ADDITIONAL_NET_PARAMS\n\n# For running a simulation:\nfrom flow.core.experiment import Experiment\n\n# For data processing:\nimport pandas as pd\nimport numpy as np\nimport os\nimport sys\nimport time\n\ndef get_flow_dict(v_des,model_params,emission_path):\n\n\talpha = model_params[0]\n\tbeta = model_params[1]\n\tv_max = model_params[2]\n\ts_star = model_params[3]\n\ts0 = model_params[4]\n\n\thuman_accel = (OVMController,{'alpha':alpha,'beta':beta,'v_max':v_max,'s_star':s_star,'s0':s0,'noise':.1})\n\n\tvehicles = VehicleParams()\n\tvehicles.add(\n\t veh_id=\"human\",\n\t acceleration_controller=human_accel,\n\t routing_controller=(ContinuousRouter, {}),\n\t num_vehicles=20)\n\n\tvehicles.add(\n\t color='red',\n\t veh_id=\"AV\",\n\t acceleration_controller=(FollowerStopper, {'v_des':v_des}),\n\t routing_controller=(ContinuousRouter, {}),\n\t num_vehicles=1)\n\n\n\tflow_params = dict(\n\t # name of the experiment\n\t exp_tag='ring',\n\n\t # name of the flow environment the experiment is running on\n\t env_name=AccelEnv,\n\n\t # name of the network class the experiment is running on\n\t network=RingNetwork,\n\n\t # simulator that is used by the experiment\n\t simulator='traci',\n\n\t # sumo-related parameters (see flow.core.params.SumoParams)\n\t sim=SumoParams(\n\t render=False,\n\t sim_step=0.1,\n\t emission_path=emission_path,\n\t ),\n\n\t # environment related parameters (see flow.core.params.EnvParams)\n\t env=EnvParams(\n\t horizon=3000,\n\t warmup_steps=750,\n\t additional_params=ADDITIONAL_ENV_PARAMS,\n\t ),\n\n\t # network-related parameters (see flow.core.params.NetParams and the\n\t # network's documentation or ADDITIONAL_NET_PARAMS component)\n\t net=NetParams(\n\t additional_params={\n\t \"length\": 260,\n\t \"lanes\": 1,\n\t \"speed_limit\": 30,\n\t \"resolution\": 40,\n\t }, ),\n\n\t # vehicles to be placed in the network at the start of a rollout (see\n\t # flow.core.params.VehicleParams)\n\t veh=vehicles,\n\n\t # parameters specifying the positioning of vehicles upon initialization/\n\t # reset (see flow.core.params.InitialConfig)\n\t # initial=InitialConfig(\n\t # bunching=20,\n\t # ),\n\t)\n\n\treturn flow_params\n\ndef run_sim(v_des,model_params,emission_path):\n\n\tflow_params = get_flow_dict(v_des,model_params,emission_path)\n\n\texp = Experiment(flow_params)\n\n\t[emission_files,info_dict] = exp.run(num_runs=1,convert_to_csv=True)\n\n\tcsv_path = emission_files[0]\n\n\treturn csv_path\n\ndef get_sim_results(csv_path):\n\tdata = pd.read_csv(csv_path,delimiter=',')\n\tids = data.id.unique() #numpy array\n\tids = list(ids)\n\n\tsim_time = np.array(data[data['id']==ids[0]]['time'])\n\tsim_length = sim_time[-1]\n\n\ttime_threshold = sim_length/2\n\n\tspeed_measurements = data[data['time'] > time_threshold]['speed']\n\n\tspeed_measurements = np.array(speed_measurements)\n\n\tave_speed = np.mean(speed_measurements)\n\n\tstd_speed = np.std(speed_measurements)\n\n\treturn [ave_speed,std_speed]\n\n\nif __name__ == \"__main__\":\n\temission_path = '/Users/vanderbilt/Desktop/Research_2020/CIRCLES/Official_Flow/flow/examples/follower_stopper_sims/'\n\n\tmodel_params = [0.6660,21.5975,8.9368,2.2146,2.8150]\n\n\tsim_results = []\n\n\tv_des_vals = np.linspace(1.0,9.0,25)\n\tv_des_vals = list(v_des_vals)\n\n\tstart_time = time.time()\n\n\tfor v_des in v_des_vals:\n\t\tsys.stdout.write('\\r'+'Simulating v_des: '+str(v_des))\n\n\t\tcsv_path = run_sim(v_des,model_params,emission_path)\n\n\t\tsim_data = get_sim_results(csv_path)\n\n\t\tsim_results.append([v_des,sim_data[0],sim_data[1]])\n\n\t\tos.remove(csv_path)\n\n\tsim_time = time.time() - start_time\n\n\tsim_results = np.array(sim_results)\n\n\tnp.savetxt('follower_stopper_sweep.csv',sim_results)\n\n\tprint('Simulation sweep finished, time to complete: '+str(sim_time))\n\n\n\n\n\n\n\n\n\n\n\n"
]
| [
[
"numpy.array",
"numpy.savetxt",
"numpy.linspace",
"numpy.mean",
"numpy.std",
"pandas.read_csv"
]
]
|
pdatlab/rpy2_utils | [
"8d563592550272604cf6453c6d4dd121f3da49b6"
]
| [
"rpy2_utils/robjects.py"
]
| [
"# -*- coding: utf-8 -*-\n\"\"\"\n\n\"\"\"\nimport rpy2\nimport pandas as pd\n\n\nclass DataFrame():\n \n def __init__(self,r_df):\n \"\"\"\n import rpy2_utils as ru\n dfh = ru.robjects.DataFrame(r_df)\n \"\"\"\n \n #TODO: Verify data type\n self.r = r_df\n \n def __contains__(self, name):\n return name in self.r.names\n \n def renameColumn(self,old_name,new_name):\n names = list(self.r.names)\n I = names.index(old_name)\n self.r.names[I] = new_name\n \n @property\n def names(self):\n return self.r.names\n \n def __getitem__(self,name):\n names = list(self.r.names)\n I = names.index(name)\n r_column = self.r[I]\n \n #Had isinstance, but factor is subclass of int\n #to generally avoid subclass comparisons, switched to type()\n if type(r_column) == rpy2.robjects.vectors.IntVector: \n return IntVector(r_column)\n elif type(r_column) == rpy2.robjects.vectors.StrVector: \n return StrVector(r_column)\n elif type(r_column) == rpy2.robjects.vectors.FloatVector:\n return FloatVector(r_column)\n elif type(r_column) == rpy2.robjects.vectors.FactorVector:\n return FactorVector(r_column)\n else:\n raise Exception('Unhandled case')\n \n def __setitem__(self, name, new_value):\n names = list(self.r.names)\n I = names.index(name)\n self.r[I] = new_value.r\n \n\n\nclass IntVector():\n def __init__(self,r):\n self.r = r\n \n def as_factor(self,levels=None,ordered=False,na=None):\n \n if na is not None:\n raise Exception('NA option not yet handled for int vector')\n \n if levels is None:\n r = rpy2.robjects.vectors.FactorVector(self.r,ordered=ordered)\n else:\n levels_r = rpy2.robjects.vectors.IntVector(levels)\n r = rpy2.robjects.vectors.FactorVector(self.r,levels=levels_r,ordered=ordered)\n \n return FactorVector(r)\n\nclass StrVector():\n \n def __init__(self,r):\n self.r = r\n \n def as_factor(self,levels=None,ordered=False,na=None):\n \n if levels is None:\n if na is not None:\n raise Exception('NA for no levels specified not yet handled')\n r = rpy2.robjects.vectors.FactorVector(self.r,ordered=ordered)\n else:\n if na is not None:\n levels.remove(na)\n \n levels_r = rpy2.robjects.vectors.StrVector(levels)\n r = rpy2.robjects.vectors.FactorVector(self.r,levels=levels_r,ordered=ordered)\n \n # if na is not None:\n # #TODO: Not sure if there is a better way of doing this ...\n # final_levels = list(r.levels)\n # I = final_levels.index(na)\n # #Note, level values are 1 based, not 0 based\n # I = I + 1\n # r_column = self.r[I]\n \n # #r_train_data.rx[r_train_data.ro == -1] = robjects.NA_Integer\n \n # import pdb\n # pdb.set_trace()\n # pass\n \n return FactorVector(r)\n\nclass FloatVector():\n def __init__(self,r):\n self.r = r\n \nclass FactorVector():\n def __init__(self,r):\n self.r = r\n \n @property\n def levels(self):\n return self.r.levels\n \n def as_factor(self,levels=None,ordered=False,na=None):\n #TODO: it is possible this changes the levels\n #Right now this occurs when we rerun code that has \n #already been converted\n return self\n \n \nclass FloatMatrix():\n def __init__(self,r):\n self.r = r \n \n def as_dataframe(self):\n #TODO: Clean this up, can we just extract column values\n # rather than build by row? Yes, slice by column\n # n_rows = 5\n # col1 = self.r[0:4]\n # col2 = self.r[5:9]\n # etc\n #\n #- make it so rownames is either a column (default) or index\n \n \n \n \n data = self.r\n col_names = ['rownames'] + list(data.colnames)\n row_names = data.rownames\n num_cols = data.ncol\n num_rows = data.nrow\n col_range = range(num_cols)\n row_range = range(num_rows)\n \n \n rows = []\n for x in row_range:\n index = [x+p*num_rows for p in col_range]\n row_values = [data[p] for p in index]\n row_values = [row_names[x]] + row_values\n row = dict(zip(col_names,row_values))\n row = pd.DataFrame(row, index=[x])\n rows.append(row)\n \n output = pd.concat(rows)\n \n return output\n "
]
| [
[
"pandas.DataFrame",
"pandas.concat"
]
]
|
TKone7/python-docs-samples | [
"ef3dd032d6fde6a47b944604788bb674e8e51b66"
]
| [
"data-science-onramp/ai-platform/modules/trainer/tfkeras_model/task.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\n# [START ai_platform_tfkeras_task]\n\"\"\"Trains a Keras model to predict number of trips\nstarted and ended at Citibike stations. \"\"\"\n\n# [START ai_platform_tfkeras_task_imports]\nimport argparse\nimport os\n\nimport tensorflow as tf\n\nfrom trainer import utils\nfrom trainer.tfkeras_model import model\n# [END ai_platform_tfkeras_task_imports]\n\n\n# [START ai_platform_tfkeras_task_args]\ndef get_args() -> argparse.Namespace:\n parser = argparse.ArgumentParser()\n parser.add_argument(\n \"--input-path\",\n type=str,\n required=True,\n help=\"path to input data\"\n )\n parser.add_argument(\n \"--num-epochs\",\n type=int,\n help=\"number of times to go through the data, default=20\",\n )\n parser.add_argument(\n \"--batch-size\",\n type=int,\n help=\"number of records to read during each training step, default=128\",\n )\n parser.add_argument(\n \"--learning-rate\",\n type=float,\n help=\"learning rate for gradient descent, default=.01\",\n )\n parser.add_argument(\n \"--verbosity\",\n choices=[\"DEBUG\", \"ERROR\", \"FATAL\", \"INFO\", \"WARN\"],\n default=\"INFO\",\n )\n parser.add_argument(\n \"--model_dir\",\n type=str,\n help=\"Output directory for the model.\",\n default=os.environ[\"AIP_MODEL_DIR\"],\n )\n return parser.parse_args()\n# [END ai_platform_tfkeras_task_args]\n\n\n# [START ai_platform_tfkeras_task_train_and_evaluate]\n# [START ai_platform_tfkeras_task_train_and_evaluate_load]\ndef train_and_evaluate(\n input_path: str,\n model_dir: str,\n num_epochs: int = 5,\n batch_size: int = 128,\n learning_rate: float = 0.01\n) -> None:\n \"\"\"Trains and evaluates the Keras model.\n\n Uses the Keras model defined in model.py. Saves the trained model in TensorFlow SavedModel\n format to the path defined in part by the --job-dir argument.\"\"\"\n\n # Split datasets into training and testing\n train_feature, eval_feature, train_target, eval_target = utils.load_data(input_path)\n# [END ai_platform_tfkeras_task_train_and_evaluate_load]\n\n # [START ai_platform_tfkeras_task_train_and_evaluate_dimensions]\n # Extract dimensions of the data\n num_train_examples, input_dim = train_feature.shape\n num_eval_examples = eval_feature.shape[1]\n output_dim = train_target.shape[1]\n # [END ai_platform_tfkeras_task_train_and_evaluate_dimensions]\n\n # [START ai_platform_tfkeras_task_train_and_evaluate_model]\n # Create the Keras Model\n keras_model = model.create_keras_model(\n input_dim=input_dim,\n output_dim=output_dim,\n learning_rate=learning_rate,\n )\n # [END ai_platform_tfkeras_task_train_and_evaluate_model]\n\n # [START ai_platform_tfkeras_task_train_and_evaluate_training_data]\n # Pass a numpy array by passing DataFrame.values\n training_dataset = model.input_fn(\n features=train_feature.values,\n labels=train_target.values,\n shuffle=True,\n num_epochs=num_epochs,\n batch_size=batch_size,\n )\n # [END ai_platform_tfkeras_task_train_and_evaluate_training_data]\n\n # [START ai_platform_tfkeras_task_train_and_evaluate_validation_data]\n # Pass a numpy array by passing DataFrame.values\n validation_dataset = model.input_fn(\n features=eval_feature.values,\n labels=eval_target.values,\n shuffle=False,\n num_epochs=num_epochs,\n batch_size=num_eval_examples,\n )\n # [END ai_platform_tfkeras_task_train_and_evaluate_validation_data]\n\n # [START ai_platform_tfkeras_task_train_and_evaluate_tensorboard]\n # Setup Learning Rate decay.\n lr_decay_cb = tf.keras.callbacks.LearningRateScheduler(\n lambda epoch: learning_rate + 0.02 * (0.5 ** (1 + epoch)), verbose=True\n )\n\n # Setup TensorBoard callback.\n tensorboard_cb = tf.keras.callbacks.TensorBoard(\n os.path.join(model_dir, \"keras_tensorboard\"), histogram_freq=1\n )\n # [END ai_platform_tfkeras_task_train_and_evaluate_tensorboard]\n\n # [START ai_platform_tfkeras_task_train_and_evaluate_fit_export]\n # Train model\n keras_model.fit(\n training_dataset,\n steps_per_epoch=int(num_train_examples / batch_size),\n epochs=num_epochs,\n validation_data=validation_dataset,\n validation_steps=1,\n verbose=1,\n callbacks=[lr_decay_cb, tensorboard_cb],\n )\n\n # Export model\n keras_model.save(model_dir)\n print(f\"Model exported to: {model_dir}\")\n # [END ai_platform_tfkeras_task_train_and_evaluate_fit_export]\n# [END ai_platform_tfkeras_task_train_and_evaluate]\n\n\nif __name__ == \"__main__\":\n args = get_args()\n\n kwargs = {}\n if args.num_epochs:\n kwargs[\"num-epochs\"] = args.num_epochs\n if args.batch_size:\n kwargs[\"batch-size\"] = args.batch_size\n if args.learning_rate:\n kwargs[\"learning-rate\"] = args.learning_rate\n\n tf.compat.v1.logging.set_verbosity(args.verbosity)\n\n train_and_evaluate(args.input_path, args.model_dir, **kwargs)\n# [END ai_platform_tfkeras_task]\n"
]
| [
[
"tensorflow.keras.callbacks.LearningRateScheduler",
"tensorflow.compat.v1.logging.set_verbosity"
]
]
|
austereantelope/pymc | [
"657eb2a7e46fa30e61d3c1b12a8ce15020794a2c"
]
| [
"pymc/bart/pgbart.py"
]
| [
"# Copyright 2020 The PyMC Developers\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport logging\n\nfrom copy import copy\n\nimport aesara\nimport numpy as np\n\nfrom aesara import function as aesara_function\n\nfrom pymc.aesaraf import inputvars, join_nonshared_inputs, make_shared_replacements\nfrom pymc.bart.bart import BARTRV\nfrom pymc.bart.tree import LeafNode, SplitNode, Tree\nfrom pymc.model import modelcontext\nfrom pymc.step_methods.arraystep import ArrayStepShared, Competence\n\n_log = logging.getLogger(\"pymc\")\n\n\nclass PGBART(ArrayStepShared):\n \"\"\"\n Particle Gibss BART sampling step\n\n Parameters\n ----------\n vars: list\n List of value variables for sampler\n num_particles : int\n Number of particles for the conditional SMC sampler. Defaults to 40\n max_stages : int\n Maximum number of iterations of the conditional SMC sampler. Defaults to 100.\n batch : int or tuple\n Number of trees fitted per step. Defaults to \"auto\", which is the 10% of the `m` trees\n during tuning and after tuning. If a tuple is passed the first element is the batch size\n during tuning and the second the batch size after tuning.\n model: PyMC Model\n Optional model for sampling step. Defaults to None (taken from context).\n \"\"\"\n\n name = \"bartsampler\"\n default_blocked = False\n generates_stats = True\n stats_dtypes = [{\"variable_inclusion\": np.ndarray, \"bart_trees\": np.ndarray}]\n\n def __init__(self, vars=None, num_particles=40, max_stages=100, batch=\"auto\", model=None):\n _log.warning(\"BART is experimental. Use with caution.\")\n model = modelcontext(model)\n initial_values = model.compute_initial_point()\n value_bart = inputvars(vars)[0]\n self.bart = model.values_to_rvs[value_bart].owner.op\n\n self.X = self.bart.X\n self.Y = self.bart.Y\n self.missing_data = np.any(np.isnan(self.X))\n self.m = self.bart.m\n self.alpha = self.bart.alpha\n self.k = self.bart.k\n self.alpha_vec = self.bart.split_prior\n if self.alpha_vec is None:\n self.alpha_vec = np.ones(self.X.shape[1])\n\n self.init_mean = self.Y.mean()\n # if data is binary\n Y_unique = np.unique(self.Y)\n if Y_unique.size == 2 and np.all(Y_unique == [0, 1]):\n self.mu_std = 6 / (self.k * self.m ** 0.5)\n # maybe we need to check for count data\n else:\n self.mu_std = (2 * self.Y.std()) / (self.k * self.m ** 0.5)\n\n self.num_observations = self.X.shape[0]\n self.num_variates = self.X.shape[1]\n self.available_predictors = list(range(self.num_variates))\n\n self.sum_trees = np.full_like(self.Y, self.init_mean).astype(aesara.config.floatX)\n self.a_tree = Tree.init_tree(\n leaf_node_value=self.init_mean / self.m,\n idx_data_points=np.arange(self.num_observations, dtype=\"int32\"),\n )\n self.mean = fast_mean()\n\n self.normal = NormalSampler()\n self.prior_prob_leaf_node = compute_prior_probability(self.alpha)\n self.ssv = SampleSplittingVariable(self.alpha_vec)\n\n self.tune = True\n\n if batch == \"auto\":\n batch = max(1, int(self.m * 0.1))\n self.batch = (batch, batch)\n else:\n if isinstance(batch, (tuple, list)):\n self.batch = batch\n else:\n self.batch = (batch, batch)\n\n self.log_num_particles = np.log(num_particles)\n self.indices = list(range(2, num_particles))\n self.len_indices = len(self.indices)\n self.max_stages = max_stages\n\n shared = make_shared_replacements(initial_values, vars, model)\n self.likelihood_logp = logp(initial_values, [model.datalogpt], vars, shared)\n self.all_particles = []\n for i in range(self.m):\n self.a_tree.leaf_node_value = self.init_mean / self.m\n p = ParticleTree(self.a_tree)\n self.all_particles.append(p)\n self.all_trees = np.array([p.tree for p in self.all_particles])\n super().__init__(vars, shared)\n\n def astep(self, _):\n variable_inclusion = np.zeros(self.num_variates, dtype=\"int\")\n\n tree_ids = np.random.choice(range(self.m), replace=False, size=self.batch[~self.tune])\n for tree_id in tree_ids:\n # Generate an initial set of SMC particles\n # at the end of the algorithm we return one of these particles as the new tree\n particles = self.init_particles(tree_id)\n # Compute the sum of trees without the old tree, that we are attempting to replace\n self.sum_trees_noi = self.sum_trees - particles[0].tree.predict_output()\n # Resample leaf values for particle 1 which is a copy of the old tree\n particles[1].sample_leafs(\n self.sum_trees,\n self.X,\n self.mean,\n self.m,\n self.normal,\n self.mu_std,\n )\n\n # The old tree and the one with new leafs do not grow so we update the weights only once\n self.update_weight(particles[0], old=True)\n self.update_weight(particles[1], old=True)\n for _ in range(self.max_stages):\n # Sample each particle (try to grow each tree), except for the first two\n stop_growing = True\n for p in particles[2:]:\n tree_grew = p.sample_tree(\n self.ssv,\n self.available_predictors,\n self.prior_prob_leaf_node,\n self.X,\n self.missing_data,\n self.sum_trees,\n self.mean,\n self.m,\n self.normal,\n self.mu_std,\n )\n if tree_grew:\n self.update_weight(p)\n if p.expansion_nodes:\n stop_growing = False\n if stop_growing:\n break\n # Normalize weights\n W_t, normalized_weights = self.normalize(particles[2:])\n\n # Resample all but first two particles\n new_indices = np.random.choice(\n self.indices, size=self.len_indices, p=normalized_weights\n )\n particles[2:] = particles[new_indices]\n\n # Set the new weights\n for p in particles[2:]:\n p.log_weight = W_t\n\n for p in particles[2:]:\n p.log_weight = p.old_likelihood_logp\n\n _, normalized_weights = self.normalize(particles)\n # Get the new tree and update\n new_particle = np.random.choice(particles, p=normalized_weights)\n new_tree = new_particle.tree\n self.all_trees[tree_id] = new_tree\n new_particle.log_weight = new_particle.old_likelihood_logp - self.log_num_particles\n self.all_particles[tree_id] = new_particle\n self.sum_trees = self.sum_trees_noi + new_tree.predict_output()\n\n if self.tune:\n self.ssv = SampleSplittingVariable(self.alpha_vec)\n for index in new_particle.used_variates:\n self.alpha_vec[index] += 1\n else:\n for index in new_particle.used_variates:\n variable_inclusion[index] += 1\n\n stats = {\"variable_inclusion\": variable_inclusion, \"bart_trees\": self.all_trees}\n return self.sum_trees, [stats]\n\n def normalize(self, particles):\n \"\"\"\n Use logsumexp trick to get W_t and softmax to get normalized_weights\n \"\"\"\n log_w = np.array([p.log_weight for p in particles])\n log_w_max = log_w.max()\n log_w_ = log_w - log_w_max\n w_ = np.exp(log_w_)\n w_sum = w_.sum()\n W_t = log_w_max + np.log(w_sum) - self.log_num_particles\n normalized_weights = w_ / w_sum\n # stabilize weights to avoid assigning exactly zero probability to a particle\n normalized_weights += 1e-12\n\n return W_t, normalized_weights\n\n def init_particles(self, tree_id: int) -> np.ndarray:\n \"\"\"\n Initialize particles\n \"\"\"\n p = self.all_particles[tree_id]\n particles = [p]\n particles.append(copy(p))\n\n for _ in self.indices:\n particles.append(ParticleTree(self.a_tree))\n\n return np.array(particles)\n\n def update_weight(self, particle, old=False):\n \"\"\"\n Update the weight of a particle\n\n Since the prior is used as the proposal,the weights are updated additively as the ratio of\n the new and old log-likelihoods.\n \"\"\"\n new_likelihood = self.likelihood_logp(self.sum_trees_noi + particle.tree.predict_output())\n if old:\n particle.log_weight = new_likelihood\n particle.old_likelihood_logp = new_likelihood\n else:\n particle.log_weight += new_likelihood - particle.old_likelihood_logp\n particle.old_likelihood_logp = new_likelihood\n\n @staticmethod\n def competence(var, has_grad):\n \"\"\"\n PGBART is only suitable for BART distributions\n \"\"\"\n dist = getattr(var.owner, \"op\", None)\n if isinstance(dist, BARTRV):\n return Competence.IDEAL\n return Competence.INCOMPATIBLE\n\n\nclass ParticleTree:\n \"\"\"\n Particle tree\n \"\"\"\n\n def __init__(self, tree):\n self.tree = tree.copy() # keeps the tree that we care at the moment\n self.expansion_nodes = [0]\n self.log_weight = 0\n self.old_likelihood_logp = 0\n self.used_variates = []\n\n def sample_tree(\n self,\n ssv,\n available_predictors,\n prior_prob_leaf_node,\n X,\n missing_data,\n sum_trees,\n mean,\n m,\n normal,\n mu_std,\n ):\n tree_grew = False\n if self.expansion_nodes:\n index_leaf_node = self.expansion_nodes.pop(0)\n # Probability that this node will remain a leaf node\n prob_leaf = prior_prob_leaf_node[self.tree[index_leaf_node].depth]\n\n if prob_leaf < np.random.random():\n index_selected_predictor = grow_tree(\n self.tree,\n index_leaf_node,\n ssv,\n available_predictors,\n X,\n missing_data,\n sum_trees,\n mean,\n m,\n normal,\n mu_std,\n )\n if index_selected_predictor is not None:\n new_indexes = self.tree.idx_leaf_nodes[-2:]\n self.expansion_nodes.extend(new_indexes)\n self.used_variates.append(index_selected_predictor)\n tree_grew = True\n\n return tree_grew\n\n def sample_leafs(self, sum_trees, X, mean, m, normal, mu_std):\n\n sample_leaf_values(self.tree, sum_trees, X, mean, m, normal, mu_std)\n\n\nclass SampleSplittingVariable:\n def __init__(self, alpha_vec):\n \"\"\"\n Sample splitting variables proportional to `alpha_vec`.\n\n This is equivalent to compute the posterior mean of a Dirichlet-Multinomial model.\n This enforce sparsity.\n \"\"\"\n self.enu = list(enumerate(np.cumsum(alpha_vec / alpha_vec.sum())))\n\n def rvs(self):\n r = np.random.random()\n for i, v in self.enu:\n if r <= v:\n return i\n\n\ndef compute_prior_probability(alpha):\n \"\"\"\n Calculate the probability of the node being a LeafNode (1 - p(being SplitNode)).\n Taken from equation 19 in [Rockova2018].\n\n Parameters\n ----------\n alpha : float\n\n Returns\n -------\n list with probabilities for leaf nodes\n\n References\n ----------\n .. [Rockova2018] Veronika Rockova, Enakshi Saha (2018). On the theory of BART.\n arXiv, `link <https://arxiv.org/abs/1810.00787>`__\n \"\"\"\n prior_leaf_prob = [0]\n depth = 1\n while prior_leaf_prob[-1] < 1:\n prior_leaf_prob.append(1 - alpha ** depth)\n depth += 1\n return prior_leaf_prob\n\n\ndef grow_tree(\n tree,\n index_leaf_node,\n ssv,\n available_predictors,\n X,\n missing_data,\n sum_trees,\n mean,\n m,\n normal,\n mu_std,\n):\n current_node = tree.get_node(index_leaf_node)\n idx_data_points = current_node.idx_data_points\n\n index_selected_predictor = ssv.rvs()\n selected_predictor = available_predictors[index_selected_predictor]\n available_splitting_values = X[idx_data_points, selected_predictor]\n if missing_data:\n idx_data_points = idx_data_points[~np.isnan(available_splitting_values)]\n available_splitting_values = available_splitting_values[\n ~np.isnan(available_splitting_values)\n ]\n\n if available_splitting_values.size > 0:\n idx_selected_splitting_values = discrete_uniform_sampler(len(available_splitting_values))\n split_value = available_splitting_values[idx_selected_splitting_values]\n\n new_idx_data_points = get_new_idx_data_points(\n split_value, idx_data_points, selected_predictor, X\n )\n current_node_children = (\n current_node.get_idx_left_child(),\n current_node.get_idx_right_child(),\n )\n\n new_nodes = []\n for idx in range(2):\n idx_data_point = new_idx_data_points[idx]\n node_value = draw_leaf_value(\n sum_trees[idx_data_point],\n X[idx_data_point, selected_predictor],\n mean,\n m,\n normal,\n mu_std,\n )\n\n new_node = LeafNode(\n index=current_node_children[idx],\n value=node_value,\n idx_data_points=idx_data_point,\n )\n new_nodes.append(new_node)\n\n new_split_node = SplitNode(\n index=index_leaf_node,\n idx_split_variable=selected_predictor,\n split_value=split_value,\n )\n\n # update tree nodes and indexes\n tree.delete_node(index_leaf_node)\n tree.set_node(index_leaf_node, new_split_node)\n tree.set_node(new_nodes[0].index, new_nodes[0])\n tree.set_node(new_nodes[1].index, new_nodes[1])\n\n return index_selected_predictor\n\n\ndef sample_leaf_values(tree, sum_trees, X, mean, m, normal, mu_std):\n\n for idx in tree.idx_leaf_nodes:\n if idx > 0:\n leaf = tree[idx]\n idx_data_points = leaf.idx_data_points\n parent_node = tree[leaf.get_idx_parent_node()]\n selected_predictor = parent_node.idx_split_variable\n node_value = draw_leaf_value(\n sum_trees[idx_data_points],\n X[idx_data_points, selected_predictor],\n mean,\n m,\n normal,\n mu_std,\n )\n leaf.value = node_value\n\n\ndef get_new_idx_data_points(split_value, idx_data_points, selected_predictor, X):\n\n left_idx = X[idx_data_points, selected_predictor] <= split_value\n left_node_idx_data_points = idx_data_points[left_idx]\n right_node_idx_data_points = idx_data_points[~left_idx]\n\n return left_node_idx_data_points, right_node_idx_data_points\n\n\ndef draw_leaf_value(Y_mu_pred, X_mu, mean, m, normal, mu_std):\n \"\"\"Draw Gaussian distributed leaf values\"\"\"\n if Y_mu_pred.size == 0:\n return 0\n else:\n norm = normal.random() * mu_std\n if Y_mu_pred.size == 1:\n mu_mean = Y_mu_pred.item() / m\n else:\n mu_mean = mean(Y_mu_pred) / m\n\n draw = norm + mu_mean\n return draw\n\n\ndef fast_mean():\n \"\"\"If available use Numba to speed up the computation of the mean.\"\"\"\n try:\n from numba import jit\n except ImportError:\n return np.mean\n\n @jit\n def mean(a):\n count = a.shape[0]\n suma = 0\n for i in range(count):\n suma += a[i]\n return suma / count\n\n return mean\n\n\ndef discrete_uniform_sampler(upper_value):\n \"\"\"Draw from the uniform distribution with bounds [0, upper_value).\n\n This is the same and np.random.randit(upper_value) but faster.\n \"\"\"\n return int(np.random.random() * upper_value)\n\n\nclass NormalSampler:\n \"\"\"\n Cache samples from a standard normal distribution\n \"\"\"\n\n def __init__(self):\n self.size = 1000\n self.cache = []\n\n def random(self):\n if not self.cache:\n self.update()\n return self.cache.pop()\n\n def update(self):\n self.cache = np.random.normal(loc=0.0, scale=1, size=self.size).tolist()\n\n\ndef logp(point, out_vars, vars, shared):\n \"\"\"Compile Aesara function of the model and the input and output variables.\n\n Parameters\n ----------\n out_vars: List\n containing :class:`pymc.Distribution` for the output variables\n vars: List\n containing :class:`pymc.Distribution` for the input variables\n shared: List\n containing :class:`aesara.tensor.Tensor` for depended shared data\n \"\"\"\n out_list, inarray0 = join_nonshared_inputs(point, out_vars, vars, shared)\n f = aesara_function([inarray0], out_list[0])\n f.trust_input = True\n return f\n"
]
| [
[
"numpy.random.normal",
"numpy.array",
"numpy.isnan",
"numpy.random.choice",
"numpy.log",
"numpy.zeros",
"numpy.ones",
"numpy.exp",
"numpy.arange",
"numpy.all",
"numpy.random.random",
"numpy.unique",
"numpy.full_like"
]
]
|
uwmisl/poretitioner | [
"0ff9f67a3b25fdcb460b11c970b2ed366da07da7"
]
| [
"src/poretitioner/hdf5/hdf5.py"
]
| [
"\"\"\"\n===================\nhdf5.py\n===================\n\nThe Hierarchical Data Format version 5 (HDF5) defines a\na file format for storing and organzing massive amounts of\nhiearchical data.\n\nThis module attempts to encapsulate the rich features of HDF5\nalongside your favorite python3.7+ constructs\n(e.g dataclasses)\n\n[1] - https://en.wikipedia.org/wiki/Hierarchical_Data_Format\n\n\"\"\"\nfrom __future__ import annotations\n\nfrom abc import ABC, abstractmethod\nfrom logging import Logger, getLogger\nfrom typing import (\n Any,\n Dict,\n Generic,\n Iterable,\n Mapping,\n Optional,\n Protocol,\n Type,\n TypedDict,\n TypeVar,\n Union,\n)\n\nimport h5py\nimport numpy as np\nfrom h5py import File as Fast5File\nfrom h5py._hl.base import Empty\n\nfrom .exceptions import HDF5_GroupSerializationException, HDF5_SerializationException\n\n# Generics\nT = TypeVar(\"T\")\nS = TypeVar(\"S\")\n\n\nclass NumpyArrayLike(np.ndarray):\n \"\"\"This class represents a numpy array with extra attributes and functionality.\n\n Subclasses of NumpyArrayLike can be treated exactly like numpy arrays computationally\n\n By default, we serialize class attributes alone.\n\n For more fine-grained control over what information is stored during serialization/pickling,\n implementers should override the `serialize_info` `deserialize_from_info`\n\n \"\"\"\n\n def __new__(cls, data: Union[np.ndarray, NumpyArrayLike]):\n obj = np.copy(data).view(\n cls\n ) # Optimization: Consider not making a copy, this is more error prone though: np.asarray(data).view(cls)\n return obj\n\n def serialize_info(self, **kwargs) -> Dict:\n \"\"\"Creates a dictionary describing the signal and its attributes.\n\n Returns\n -------\n Dict\n A serialized set of attributes.\n \"\"\"\n # When serializing, copy over any existing attributes already in self, and\n # any that don't exist in self get taken from kwargs.\n existing_info = self.__dict__\n info = {key: getattr(self, key, kwargs.get(key)) for key in kwargs.keys()}\n return {**info, **existing_info}\n\n def deserialize_from_info(self, info: Dict):\n \"\"\"Sets attributes on an object from a serialized dict.\n\n Parameters\n ----------\n info : Dict\n Dictionary of attributes to set after deserialization.\n \"\"\"\n for name, value in info.items():\n setattr(self, name, value)\n\n # Multiprocessing and Dask require pickling (i.e. serializing) their inputs.\n # By default, this will drop all our custom class data.\n # https://stackoverflow.com/questions/26598109/preserve-custom-attributes-when-pickling-subclass-of-numpy-array\n def __reduce__(self):\n reconstruct, arguments, object_state = super().__reduce__()\n # Create a custom state to pass to __setstate__ when this object is deserialized.\n info = self.serialize_info()\n new_state = object_state + (info,)\n # Return a tuple that replaces the parent's __setstate__ tuple with our own\n return (reconstruct, arguments, new_state)\n\n def __setstate__(self, state):\n info = state[-1]\n self.deserialize_from_info(info)\n # Call the parent's __setstate__ with the other tuple elements.\n super().__setstate__(state[0:-1])\n\n\n####################################\n### Fast5 Helpers ###\n####################################\n\n\n# NOTE: Sadly, many of these can't be used until \"RuntimeError: Unable to create attribute (object header message is too large)\" https://github.com/h5py/h5py/issues/1855\n# The goal is to provide high-level data-class representations of HDF5 objects, so users can just describe their structures as python dataclasses instead of finagling with h5py. \n# Unfortunately, there's currently a bug \"RuntimeError: Unable to create attribute (object header message is too large)\" that can only be fixed by delving into the low-level API ()\n\ndef hdf5_dtype(object: Any) -> Optional[np.dtype]:\n \"\"\"Returns the proper h5py dtype for an object, if one is necessary.\n Otherwise returns None.\n\n For us, this is mostly needed in the case of storing numpy data or string data,\n\n since numpy data has a specific dtype, and strings have a variable length and an assumed encoding (e.g. \"utf-8\")\n\n For more info on how h5py handles strings, see [1, 2].\n\n [1] - https://docs.h5py.org/en/stable/strings.html#strings\n [2] - https://docs.h5py.org/en/stable/special.html?highlight=string_dtype#variable-length-strings\n\n Parameters\n ----------\n object : Any\n Some object you want the dtype for if it's necessary, but are fine not having one\n if it's not.\n\n Returns\n -------\n Optional[np.dtype]\n The numpy datatype for an object if it has one, or if it's a string, and None otherwise.\n \"\"\"\n if isinstance(object, str):\n return h5py.string_dtype(length=len(object))\n elif hasattr(object, \"dtype\"):\n # Is this already a numpy-like object with a dtype? If so, just use that.\n return object.dtype\n return None # For most cases, h5py can determine the dtype from the data itself.\n\n\ndef get_class_for_name(name: str, module_name: str = __name__) -> Type:\n \"\"\"Gets a class from a module based on its name.\n Tread carefully with this. Personally I feel like it's only safe to use\n with dataclasses with known interfaces.\n\n Parameters\n ----------\n name : str\n Name of the class we're trying to get the class object for.\n\n module_name: str, optional\n Which module to get a class from, by defualt __name__.\n\n Returns\n -------\n Type\n [description]\n \"\"\"\n import importlib\n\n this_module = importlib.import_module(module_name)\n this_class = getattr(this_module, name)\n return this_class\n\n\nclass HasFast5(Protocol):\n f5: Union[Fast5File, HDF5_Group]\n\n\n###########################################################\n#\n# HDF5 Base Types\n#\n###########################################################\n\n# Note: We never create or instantiate AttributeManagers directly, instead we borrow its interface.\n# 3 Laws to keep in mind with Attributes:\n#\n#\n# 1) They may be created from any scalar or NumPy array\n#\n# 2) Each attribute should be small (generally < 64k)\n#\n# 3) There is no partial I/O (i.e. slicing); the entire attribute must be read.\n#\n# https://docs.h5py.org/en/stable/high/attr.html\n\n# Attrs are really just mappings from names to data/objects.\nHDF5_Attribute_Objects = Mapping[str, Optional[Any]]\n\n\nclass IsAttr(Protocol):\n \"\"\"A special protocol for objects that are just meant to be set data attributes, and don't\n need any special HDF5 consdiration (e.g. a class that just needs to store a few numbers).\n \"\"\"\n\n def as_attr(self) -> np.dtype:\n ...\n\n def from_attr(self, attr) -> IsAttr:\n ...\n\n\nclass HDF5IsAttr(IsAttr):\n def as_attr(self) -> np.dtype:\n ...\n\n def from_attr(self, attr) -> IsAttr:\n ...\n\n\nclass HasAttrs(Protocol):\n def get_attrs(self) -> HDF5_Attributes:\n ...\n\n def create_attr(self, name: str, value: Optional[Any], log: Optional[Logger] = None):\n \"\"\"Adds an attribute to the current object.\n\n Any existing attribute with this name will be overwritten.\n\n Parameters\n ----------\n name : str\n Name of the attribute.\n value : Optional[Any]\n Value of the attribute.\n \"\"\"\n ...\n\n def create_attrs(self, attrs: HDF5_Attributes, log: Optional[Logger] = None):\n \"\"\"Adds multiple attributes to the current object.\n\n Any existing attribute with the names in attrs will be overwritten.\n\n Parameters\n ----------\n attrs :\n Name of the attribute.\n value : Optional[Any]\n Value of the attribute.\n \"\"\"\n\n def object_from_attr(self, name: str, log: Optional[Logger] = None) -> Optional[Any]:\n \"\"\"Creates an object from an attribute (if one could be made).\n # TODO: Plugin Register via Plugins\n\n Parameters\n ----------\n name : str\n Name of the attribute.\n\n Returns\n ----------\n An instantiated object represented by this attr, or None if one couldn't be found.\n \"\"\"\n ...\n\n def objects_from_attrs(\n self, attrs: HDF5_Attributes, log: Optional[Logger] = None\n ) -> HDF5_Attribute_Objects:\n \"\"\"Creates mapping of attribute names to their serialzed objects (if one could be made).\n\n Parameters\n ----------\n name : str\n Name of the attribute.\n\n Returns\n ----------\n An instantiated object represented by this attr, or None if one couldn't be found.\n \"\"\"\n ...\n\n\nclass HDF5_AttributeHaving(HasAttrs):\n def __init__(self, has_attrs: Optional[HasAttrs]):\n super().__init__()\n self.attrs = self.get_attrs() if has_attrs is None else has_attrs.get_attrs()\n\n def get_attrs(self) -> HDF5_Attributes:\n return self.attrs\n\n def create_attr(self, name: str, value: Optional[Any], log: Optional[Logger] = None):\n \"\"\"Adds an attribute to the current object.\n\n WARNING: Any existing attribute will be overwritten!\n\n This method will coerce value to a special 'Empty' type used by HDF5 if the value\n provided is zero-length or None. For more on Attributes and Empty types, see [1, 2]\n\n [1] - https://docs.h5py.org/en/stable/high/attr.html#attributes\n [2] - https://docs.h5py.org/en/stable/high/dataset.html?highlight=Empty#creating-and-reading-empty-or-null-datasets-and-attributes\n\n Parameters\n ----------\n name : str\n Name of the attribute.\n value : Optional[Any]\n Value of the attribute. This method will coerce this value\n to a special Empty object if it's zero-length or None [2].\n \"\"\"\n\n if value is None or value == \"\" or (hasattr(value, \"__len__\") and len(value) < 1):\n empty = h5py.Empty(dtype=np.uint8)\n self.get_attrs().create(name, empty)\n elif isinstance(value, HDF5IsAttr):\n attr_value = value.as_attr()\n self.get_attrs().create(name, value, dtype=hdf5_dtype(attr_value))\n else:\n self.get_attrs().create(name, value, dtype=hdf5_dtype(value))\n\n def create_attrs(self, attrs: HDF5_Attributes, log: Optional[Logger] = None):\n for attr_name, attr_value in attrs.items():\n self.create_attr(attr_name, attr_value, log=log)\n\n def object_from_attr(self, name: str, log: Optional[Logger] = None) -> Optional[Any]:\n log = log if log is not None else getLogger()\n try:\n attr_value = self.get_attrs()[name]\n except AttributeError:\n log.warning(\n f\"Could not find an attribute with the name '{name}' on object {self!r}. Returning None\"\n )\n return None\n\n if attr_value.shape is None:\n \"\"\"\n From the Docs:\n\n An empty dataset has shape defined as None,\n which is the best way of determining whether a dataset is empty or not.\n An empty dataset can be “read” in a similar way to scalar datasets.\n\n [1] - https://docs.h5py.org/en/stable/high/dataset.html?highlight=Empty#creating-and-reading-empty-or-null-datasets-and-attributes\n \"\"\"\n return \"\"\n return bytes.decode(bytes(attr_value), encoding=\"utf-8\")\n\n def objects_from_attrs(self, log: Optional[Logger] = None) -> HDF5_Attribute_Objects:\n objects: HDF5_Attribute_Objects = {\n attr_name: self.object_from_attr(attr_name, log=log)\n for attr_name in self.get_attrs().keys()\n }\n return objects\n\n def copy_attr(self, name: str, source: HDF5_AttributeHaving):\n \"\"\"Copy a single attribute from a source.\n This will overwrite any attribute of this name, if one exists.\n\n Parameters\n ----------\n name : str\n Which attribute to copy.\n from : HDF5_AttributeHaving\n Which attribute-haver to copy from.\n \"\"\"\n self.create_attr(name, source.get_attrs()[name])\n\n def copy_all_attrs(self, source: HDF5_AttributeHaving):\n \"\"\"Copy a all attributes from a source.\n This will overwrite any attributes sharing the same names, if any exists.\n\n Parameters\n ----------\n from : HDF5_AttributeHaving\n Which attribute-haver to copy all attributes from.\n \"\"\"\n for name in source.get_attrs().keys():\n self.copy_attr(name, source)\n\n\nclass HDF5_ParentHaving:\n @property\n def parent(self) -> HDF5_Group:\n return HDF5_Group(self.parent)\n\n\nclass HDF5_Dataset(h5py.Dataset, NumpyArrayLike, HDF5_AttributeHaving, HDF5_ParentHaving):\n\n def __new__(cls, dataset: NumpyArrayLike) -> HDF5_Dataset:\n if isinstance(dataset, HDF5_Dataset):\n return dataset\n \n self = dataset\n \n\n def __init__(self, dataset: h5py.Dataset):\n self._dataset = dataset\n\n def __getattr__(self, attrib: str):\n return getattr(self._dataset, attrib)\n\n\nclass HDF5_Group(h5py.Group, HDF5_AttributeHaving, HDF5_ParentHaving):\n def __new__(cls, group: Optional[h5py.Group]) -> HDF5_Group:\n if isinstance(group, HDF5_Group):\n return group\n hdf5_group = super().__new__(cls, group)\n hdf5_group._group = group\n return hdf5_group\n\n def __init__(self, group: Optional[h5py.Group]):\n if isinstance(group, HDF5_Group):\n return\n super().__init__(group.id)\n self._group = group\n\n @property\n def parent(self) -> HDF5_Group:\n return HDF5_Group(self._group.parent)\n\n def require_group(self, name: str):\n return HDF5_Group(self._group.require_group(name))\n\n def require_dataset(self, name, data, dtype, shape, **kwds):\n return HDF5_Dataset(self._group.require_dataset(name, shape, data=data, dtype=dtype,**kwds))\n\n def __getattr__(self, attrib: str):\n return getattr(self._group, attrib)\n\n\nclass HDF5_Attributes(h5py.AttributeManager, HDF5_ParentHaving):\n def __init__(self, attrs: h5py.AttributeManager):\n self.attrs = attrs\n\n def __getattr__(self, attrib: str):\n return getattr(self.attrs, attrib)\n\n\nHDF5_Type = Union[HDF5_Dataset, HDF5_Group, HDF5_Attributes]\n\n\nclass HDF5_Serializing(ABC):\n \"\"\"Any object that can be HDFSserialized.\n\n Don't instantiate this directly, rather subclass.\n \"\"\"\n\n @classmethod\n @abstractmethod\n def from_a(cls, a: HDF5_Type, log: Optional[Logger] = None) -> HDF5_Serializing:\n \"\"\"Creates an instance of this class (from) (a) HDF5_Type.\n\n Parameters\n ----------\n a : HDF5_Types\n Instance of an HDF5Type (e.g. a h5py.Group).\n\n log : Logger, optional\n Logger to use for information/warnings/debug\n\n Returns\n -------\n HDF5_Serializing\n An instance of this class with data derived from (a) HDF5_Type.\n\n Raises\n ------\n NotImplementedError\n This method wasn't implemented, but needs to be.\n \"\"\"\n raise NotImplementedError(\n f\"{cls!s} is missing an implementation for {HDF5_Serializing.from_a.__name__}\"\n )\n\n @abstractmethod\n def as_a(\n self, a: HDF5_Type, parent: Optional[HDF5_Group] = None, log: Optional[Logger] = None\n ) -> HDF5_Type:\n \"\"\"Returns this object, formatted (as) (a) given HDF5 type (thus the name).\n\n Parameters\n ----------\n a : HDF5_Types\n One of the HDF5 types we understand.\n\n parent : Optional[HDF5_Group]\n The parent group to which this object should be added/updated.\n If parent is None, we return the HDFS_Type proxy in isolation (e.g)\n not attached to the parent if it doesn't already have one. None by default.\n\n log : Logger, optional\n Logger to use for information/warnings/debug\n\n Returns\n -------\n HDF5_Type\n This object serialized to a given HDF5 type.\n\n Raises\n ------\n NotImplementedError\n This method wasn't implemented, but needs to be.\n \"\"\"\n raise NotImplementedError(\n f\"{self!s} is missing an implementation for {HDF5_Serializing.as_a.__name__}!\"\n )\n\n @abstractmethod\n def update(self, log: Optional[Logger] = None):\n \"\"\"Makes sure any changes have been reflected in the underlying object.\n\n Parameters\n ----------\n log : Optional[Logger], optional\n Logger to use, by default None\n\n Raises\n ------\n NotImplementedError\n This method wasn't implemented.\n \"\"\"\n raise NotImplementedError(\n f\"{self!s} is missing an implementation for {HDF5_Serializing.update.__name__}!\"\n )\n\n\n###########################################################\n#\n# HDF5 Groups\n#\n###########################################################\n\n\nclass HDF5_GroupSerializing(HDF5_Serializing, HDF5_AttributeHaving):\n \"\"\"Objects adhering to the `HDF5_GroupSerializable` can be written to and\n read directly from hd5 Groups.\n \"\"\"\n\n def name(self) -> str:\n \"\"\"Group name that this object will be stored under.\n i.e. If this method returns \"patrice_lmb\", then a subsequent call to\n\n `self.as_group(Group(\"/Foo/bar/\"))`\n\n Will return a group at /Foo/bar/patrice_lmb\n\n Be double-sure to override this if you want it to be anything other than the class name.\n\n Returns\n -------\n str\n Name to use in the Fast5 file.\n \"\"\"\n return self.__class__.__name__\n\n def as_group(self, parent_group: HDF5_Group, log: Optional[Logger] = None) -> HDF5_Group:\n \"\"\"Stores and Returns this object as an HDF5 Group, rooted at the group passed in.\n This should be used to directly set the contents of an Hdf5 group.\n This method should also create the group named 'name' in the parent_group, if it doesn't already exist.\n\n class Baz(HDF5_GroupSerializable):\n def name(self):\n return \"boop\"\n # ...Implementation\n\n my_hdf5_file = h5py.File(\"/path/to/file\")\n foo_group = filts.require_group(\"/foo\")\n\n my_serial = Baz()\n baz_group = foo_group.require_group(my_serial.name()) # Make space in the file for Baz at f'/foo/{my_serial.name()}'\n my_serialized_group = my_serial.as_group(foo_group) # Sets \"/foo/boop\" group to the serialized group\n\n my_serialized_group # /boop group, rooted at /foo/\n\n Parameters\n ----------\n parent_group : h5py.Group\n Which group to store this group under. This doesn't necessarily have to be the root group of the file.\n\n Returns\n -------\n h5py.Group\n Group that stores a serialization of this instance.\n \"\"\"\n ...\n\n @classmethod\n def from_group(cls, group: HDF5_Group, log: Optional[Logger] = None) -> HDF5_GroupSerializable:\n \"\"\"Serializes this object FROM an HDF5 Group.\n\n class Baz(HDF5_GroupSerializable):\n # ...Implementation\n\n my_hdf5_file = h5py.File(\"/path/to/file\")\n baz_serialized_group = filts.require_group(\"/baz\")\n\n baz = Baz.from_group(baz_serialized_group) # I now have an instance of Baz.\n\n Parameters\n ----------\n group : h5py.Group\n HDF5 Group that can be serialized into this instance.\n\n Returns\n -------\n HDF5_GroupSerializable\n Instance of an adherent to this protocol.\n \"\"\"\n ...\n\n\nclass HDF5_GroupSerializable(HDF5_GroupSerializing):\n \"\"\"Base class for objects that can be written to and\n read directly from hd5 Groups.\n\n Not meant to be instantiated directly. Instead, subclass and make sure your\n `as_group` implementation uses the group created by `super().as_group(...)`.\n\n NOTE: Make sure to call super().as_group(...)\n \"\"\"\n\n def name(self) -> str:\n \"\"\"Group name that this object will be stored under.\n i.e. If this method returns \"patrice_lmb\", then a subsequent call to\n\n `self.as_group(Group(\"/Foo/bar/\"))`\n\n Will return a group at /Foo/bar/patrice_lmb\n\n Override this if you want it to be anything other than the class name.\n\n Returns\n -------\n str\n Name to use in the Fast5 file.\n \"\"\"\n return self.__class__.__name__\n\n def as_group(self, parent_group: HDF5_Group, log: Optional[Logger] = None) -> HDF5_Group:\n new_group = parent_group.require_group(self.name())\n parent_group[self.name()] = self\n # Note: This does nothing but register a group with the name 'name' in the parent group.\n # Implementers must now write their serialized instance to this group.\n return self\n\n @classmethod\n @abstractmethod\n def from_group(cls, group: HDF5_Group, log: Optional[Logger] = None) -> HDF5_GroupSerializable:\n raise NotImplementedError(\n f\"from_group not implemented for {cls.__name__}. Make sure you write a method that returns a serialzied version of this object.\"\n )\n\n def require_group_from_group(\n self, parent_group: HDF5_Group, log: Optional[Logger] = None\n ) -> HDF5_GroupSerializable:\n # child_group = parent_group.require_group(self.name())\n child_group = self.as_group(parent_group, log=log)\n\n @classmethod\n def from_a(cls, a: HDF5_Group, log: Logger) -> HDF5_Serializing:\n return cls.from_group(parent_group=a, log=log)\n\n def as_a(self, a: HDF5_Type, log: Logger) -> HDF5_Type:\n return self.as_group(parent_group=a, log=log)\n\n def update(self, log: Optional[Logger] = None):\n self.as_a(self._group.parent, log=log)\n\n\nclass HDF5_GroupSerialiableDict(Dict[T, S], HDF5_GroupSerializable):\n def as_group(self, parent_group: HDF5_Group, log: Optional[Logger] = None) -> HDF5_Group:\n log = log if log is not None else getLogger()\n\n my_group = parent_group.require_group(self.name())\n \"\"\"Returns this object as an HDF5 Group.\"\"\"\n for field_name, field_value in self.items():\n if isinstance(field_value, HDF5_GroupSerializable):\n # This value is actually its own group.\n # So we create a new group rooted at our dataclass's group\n # And assign it the value of whatever the group of the value is.\n field_value.as_a(my_group, log=log)\n # my_group.require_group(field_name)\n # my_group[field_name] = field_value\n elif isinstance(field_value, HDF5_DatasetSerializable):\n field_value.as_a(parent_group, log)\n else:\n my_group.create_attr(field_name, field_value)\n return my_group\n\n @classmethod\n def from_group(\n cls, group: HDF5_Group, log: Optional[Logger] = None\n ) -> HDF5_GroupSerialableDataclass:\n log = log if log is not None else getLogger()\n if not log:\n log = getLogger()\n my_instance = cls.__new__(cls)\n\n # First, copy over attrs:\n for name, value in group.attrs.items():\n object.__setattr__(my_instance, name, value)\n\n # Then, copy over any datasets or groups.\n for name, value in group.items():\n if isinstance(value, h5py.Dataset):\n # Assuming we're storing a numpy array as this dataset\n buffer = np.empty(value.shape, dtype=value.dtype)\n # Copies the values into our buffer\n value.read_direct(buffer)\n object.__setattr__(my_instance, name, NumpyArrayLike(buffer))\n elif isinstance(value, h5py.Group):\n # If it's a group, we have to do a little more work\n # 1) Find the class described by the group\n # 1.1) Verify that we actually know a class by that name. Raise an exception if we don't.\n # 1.2) Verify that that class has a method to create an instance group a group.\n # 2) Create a new class instance from that group\n # 3) Set this object's 'name' field to the object we just created.\n try:\n ThisClass = get_class_for_name(name)\n except AttributeError as e:\n serial_exception = HDF5_GroupSerializationException(\n f\"We couldn't serialize group named {name} (group is attached in the exception.\",\n e,\n group=value,\n )\n log.exception(serial_exception.msg, serial_exception)\n raise serial_exception\n\n # assert get_class_for_name(name) and isinstance(), f\"No class found that corresponds to group {name}! Make sure there's a corresponding dataclass named {name} in this module scope!\"\n\n try:\n this_instance = ThisClass.from_group(value, log=log)\n except AttributeError as e:\n serial_exception = HDF5_GroupSerializationException(\n f\"We couldn't serialize group named {name!s} from class {ThisClass!s}. It appears {ThisClass!s} doesn't implement the {HDF5_GroupSerializing.__name__} protocol. Group is attached in the exception.\",\n e,\n group=value,\n )\n log.exception(serial_exception.msg, serial_exception)\n raise serial_exception\n\n object.__setattr__(my_instance, name, this_instance)\n\n return my_instance\n\n\nclass HDF5_GroupSerialableDataclass(HDF5_GroupSerializable):\n def as_group(self, parent_group: HDF5_Group, log: Optional[Logger] = None) -> HDF5_Group:\n log = log if log is not None else getLogger()\n\n \"\"\"Returns this object as an HDF5 Group.\"\"\"\n my_group: HDF5_Group = parent_group.require_group(self.name())\n\n for field_name, field_value in vars(self).items():\n if isinstance(field_value, HDF5_GroupSerializable):\n # This value is actually its own group.\n # So we create a new group rooted at our dataclass's group\n # And assign it the value of whatever the group of the value is.\n # new_group = my_group.require_group(field_name)\n field_value.as_group(my_group)\n elif isinstance(field_value, HDF5_DatasetSerializable):\n field_value.as_a(my_group, log)\n else:\n my_group.create_attr(field_name, field_value)\n return my_group\n\n @classmethod\n def from_group(\n cls, group: HDF5_Group, log: Optional[Logger] = None\n ) -> HDF5_GroupSerialableDataclass:\n log = log if log is not None else getLogger()\n if not log:\n log = getLogger()\n my_instance = cls.__new__(cls)\n\n # First, copy over attrs:\n my_instance.create_attrs(group.get_attrs())\n\n # Then, copy over any datasets or groups.\n for name, value in group.items():\n if isinstance(value, h5py.Dataset):\n # Assuming we're storing a numpy array as this dataset\n buffer = np.empty(value.shape, dtype=value.dtype)\n # Copies the values into our buffer\n value.read_direct(buffer)\n object.__setattr__(my_instance, name, buffer)\n elif isinstance(value, h5py.Group):\n # If it's a group, we have to do a little more work\n # 1) Find the class described by the group\n # 1.1) Verify that we actually know a class by that name. Raise an exception if we don't.\n # 1.2) Verify that that class has a method to create an instance group a group.\n # 2) Create a new class instance from that group\n # 3) Set this object's 'name' field to the object we just created.\n try:\n ThisClass = get_class_for_name(name)\n except AttributeError as e:\n serial_exception = HDF5_GroupSerializationException(\n f\"We couldn't serialize group named {name} (group is attached in the exception.\",\n e,\n group=value,\n )\n log.exception(serial_exception.msg, serial_exception)\n raise serial_exception\n\n # assert get_class_for_name(name) and isinstance(), f\"No class found that corresponds to group {name}! Make sure there's a corresponding dataclass named {name} in this module scope!\"\n\n try:\n this_instance = ThisClass.from_group(value, log=log)\n except AttributeError as e:\n serial_exception = HDF5_GroupSerializationException(\n f\"We couldn't serialize group named {name!s} from class {ThisClass!s}. It appears {ThisClass!s} doesn't implement the {HDF5_GroupSerializing.__name__} protocol. Group is attached in the exception.\",\n e,\n group=value,\n )\n log.exception(serial_exception.msg, serial_exception)\n raise serial_exception\n\n object.__setattr__(my_instance, name, this_instance)\n\n return my_instance\n\n\n###########################################################\n#\n# HDF5 Datasets\n#\n###########################################################\n\n\nclass HDF5_DatasetSerializing(HDF5_Dataset, HDF5_Serializing):\n \"\"\"Objects adhering to the `HDF5_GroupSerializable` can be written to and\n read directly from hd5 Groups.\n \"\"\"\n\n def name(self) -> str:\n \"\"\"Group name that this object will be stored under.\n i.e. If this method returns \"patrice_lmb\", then a subsequent call to\n\n `self.as_group(Group(\"/Foo/bar/\"))`\n\n Will return a group at /Foo/bar/patrice_lmb\n\n Be double-sure to override this if you want it to be anything other than the class name.\n\n Returns\n -------\n str\n Name to use in the Fast5 file.\n \"\"\"\n return self.__class__.__name__\n\n\nclass HDF5_DatasetSerializable(HDF5_DatasetSerializing):\n @classmethod\n def from_a(\n cls, a: Union[HDF5_Dataset, HDF5_Group], log: Optional[Logger] = None\n ) -> HDF5_DatasetSerializable:\n # Assume A is the parent group\n # Assuming we're storing a numpy array as this dataset\n\n # Copies the values into our buffer\n try:\n buffer = np.empty(a.shape, dtype=a.dtype)\n a.read_direct(buffer)\n data = NumpyArrayLike(buffer)\n\n return HDF5_DatasetSerializable(cls.__new__(cls, buffer))\n\n except AttributeError as e:\n log.error(\"Could not convert to HDF5_DatasetSerializable from: {a!r}\")\n raise e\n # serialized = cls.__new__(cls)\n return\n\n def as_a(self, a: HDF5_Group, log: Optional[Logger] = None) -> HDF5_Dataset:\n dataset = HDF5_Dataset(a.require_dataset(self.name(), shape=self.shape, dtype=self.dtype))\n return dataset\n\n def update(self, log: Optional[Logger] = None):\n self.as_a(self._group.parent, log=log)\n\n\nclass HDF5_DatasetSerialableDataclass(HDF5_DatasetSerializable):\n def as_dataset(self, parent_group: HDF5_Group, log: Optional[Logger] = None) -> HDF5_Dataset:\n log = log if log is not None else getLogger()\n\n \"\"\"Returns this object as an HDF5 Group.\"\"\"\n dataset: HDF5_Dataset = super().as_a(parent_group)\n\n dataset.create_attrs(vars(self))\n # for field_name, field_value in vars(self).items():\n # dataset.create_attr(field_name, field_value)\n return dataset\n\n @classmethod\n def from_dataset(\n cls, dataset: HDF5_Dataset, log: Optional[Logger] = None\n ) -> HDF5_DatasetSerialableDataclass:\n log = log if log is not None else getLogger()\n if not log:\n log = getLogger()\n my_instance = cls.__new__(dataset)\n\n # First, copy over attrs:\n for name, value in dataset.objects_from_attrs():\n object.__setattr__(my_instance, name, value)\n\n return my_instance\n"
]
| [
[
"numpy.copy",
"numpy.empty"
]
]
|
elerac/codepattern | [
"8ee7d04870b1d9b64045a15c488792b0f0f9aef3"
]
| [
"examples/capture_x.py"
]
| [
"\"\"\"\nCapture projection pattern and decode x-coorde.\n\"\"\"\nimport cv2\nimport numpy as np\nimport structuredlight as sl\n\ndef imshowAndCapture(cap, img_pattern, delay=250):\n cv2.imshow(\"\", img_pattern)\n cv2.waitKey(delay)\n ret, img_frame = cap.read()\n img_gray = cv2.cvtColor(img_frame, cv2.COLOR_BGR2GRAY)\n return img_gray\n\ndef main():\n width = 640\n height = 480\n\n cap = cv2.VideoCapture(1) # External web camera\n gray = sl.Gray()\n \n # Generate and Decode x-coord\n # Generate\n imlist_posi_pat = gray.generate((width, height))\n imlist_nega_pat = sl.invert(imlist_posi_pat)\n\n # Capture\n imlist_posi_cap = [ imshowAndCapture(cap, img) for img in imlist_posi_pat]\n imlist_nega_cap = [ imshowAndCapture(cap, img) for img in imlist_nega_pat]\n \n # Decode\n img_index = gray.decode(imlist_posi_cap, imlist_nega_cap)\n\n # Visualize decode result\n img_correspondence = np.clip(img_index/width*255.0, 0, 255).astype(np.uint8)\n cv2.imshow(\"corresponnence map\", img_correspondence)\n cv2.waitKey(0)\n cv2.imwrite(\"correspondence.png\", img_correspondence)\n cv2.destroyAllWindows()\n cap.release()\n\nif __name__==\"__main__\":\n main()\n"
]
| [
[
"numpy.clip"
]
]
|
hdkai/Plasma | [
"1942d7fe5f6b41c9a16c8e2d1b6c7cf263307c39"
]
| [
"torchplasma/filters/gaussian.py"
]
| [
"# \n# Plasma\n# Copyright (c) 2021 Yusuf Olokoba.\n#\n\nfrom torch import arange, exp, tensor, Tensor\nfrom torch.nn.functional import conv2d, conv3d, pad\nfrom typing import Tuple\n\ndef gaussian_kernel (kernel_size: int, sigma: float = -1.) -> Tensor:\n \"\"\"\n Normalized 1D Gaussian kernel.\n This operation is NOT differentiable w.r.t its arguments.\n\n Parameters:\n kernel_size (int): Kernel size, should be odd.\n sigma (float): Gaussian standard deviation. If less than 1, it is automatically computed from the kernel size.\n\n Returns:\n Tensor: Normalized Gaussian kernel with shape (K,).\n \"\"\"\n sigma = 0.3 * ((kernel_size - 1) * 0.5 - 1) + 0.8 if sigma < 0 else sigma # From OpenCV ::getGaussianKernel\n x = arange(kernel_size).float() - kernel_size // 2\n x = x + 0.5 if kernel_size % 2 == 0 else x\n kernel = exp((-x.pow(2.) / (2. * sigma ** 2)))\n return kernel / kernel.sum()\n\ndef gaussian_filter (input: Tensor, kernel_size: Tuple[int, int]) -> Tensor:\n \"\"\"\n Apply a Gaussian filter to an image.\n\n Parameters:\n input (Tensor): Input image with shape (N,C,H,W).\n kernel_size (tuple): Kernel size in each dimension (Ky,Kx).\n\n Returns:\n Tensor: Filtered image with shape (N,C,H,W).\n \"\"\"\n _,channels,_,_ = input.shape\n kernel_size_y, kernel_size_x = kernel_size\n # Compute kernels\n kernel_x = gaussian_kernel(kernel_size_x).to(input.device)\n kernel_y = gaussian_kernel(kernel_size_y).to(input.device)\n # Reshape\n kernel_x = kernel_x.expand(channels, 1, 1, -1)\n kernel_y = kernel_y.expand(channels, 1, 1, -1).permute(0, 1, 3, 2).contiguous()\n # Seperable convolution\n result = conv2d(input, kernel_x, padding=(0, kernel_size_x // 2), groups=channels)\n result = conv2d(result, kernel_y, padding=(kernel_size_y // 2, 0), groups=channels)\n return result\n\ndef gaussian_filter_3d (input: Tensor, kernel_size: Tuple[int, int, int]) -> Tensor:\n \"\"\"\n Apply a Gaussian filter to a volume.\n\n Parameters:\n input (Tensor): Input volume with shape (N,C,D,H,W).\n kernel_size (tuple): Kernel size in each dimension (Kz,Ky,Kx).\n\n Returns:\n Tensor: Filtered volume with shape (N,C,D,H,W).\n \"\"\"\n _,channels,_,_,_ = input.shape\n kernel_size_z, kernel_size_y, kernel_size_x = kernel_size\n # Compute kernels\n kernel_x = gaussian_kernel(kernel_size_x).to(input.device)\n kernel_y = gaussian_kernel(kernel_size_y).to(input.device)\n kernel_z = gaussian_kernel(kernel_size_z).to(input.device)\n # Reshape\n kernel_x = kernel_x.expand(channels, 1, 1, 1, -1)\n kernel_y = kernel_y.expand(channels, 1, 1, 1, -1).permute(0, 1, 2, 4, 3).contiguous()\n kernel_z = kernel_z.expand(channels, 1, 1, 1, -1).permute(0, 1, 4, 2, 3).contiguous()\n # Seperable convolution\n result = conv3d(input, kernel_x, padding=(0, 0, kernel_size_x // 2), groups=channels)\n result = conv3d(result, kernel_y, padding=(0, kernel_size_y // 2, 0), groups=channels)\n result = conv3d(result, kernel_z, padding=(kernel_size_z // 2, 0, 0), groups=channels)\n return result"
]
| [
[
"torch.nn.functional.conv3d",
"torch.nn.functional.conv2d",
"torch.arange"
]
]
|
iheb-brini/fitness-lab | [
"2d82d7a2ecba27f535cda880865e6d9ed446eac5"
]
| [
"Modules/nn/architectures/DenseNet/classes.py"
]
| [
"from torch import nn, cat\n\nfrom .constants import NUM_CONVS_IN_DENSE_BLOCKS\n\n\ndef conv_block(in_channels, out_channels):\n blk = nn.Sequential(\n nn.BatchNorm2d(in_channels), nn.ReLU(),\n nn.Conv2d(in_channels, out_channels,\n kernel_size=3, padding=1)\n )\n\n return blk\n\n\nclass DenseBlock(nn.Module):\n def __init__(self, num_convs, in_channels, out_channels, **kwargs):\n super().__init__(**kwargs)\n block_list = []\n for i in range(num_convs):\n block_list.append(conv_block(\n out_channels*i + in_channels, out_channels))\n\n self.net = nn.Sequential(*block_list)\n\n def forward(self, X):\n for layer in self.net:\n Y = layer(X)\n # Concatenate the input and output of each block on the channel dimension\n X = cat((X, Y), axis=1)\n\n return X\n\n\ndef transitive_block(in_channels, out_channels):\n blk = nn.Sequential(\n nn.BatchNorm2d(in_channels), nn.ReLU(),\n nn.Conv2d(in_channels, out_channels,\n kernel_size=1),\n nn.AvgPool2d(kernel_size=2, stride=2)\n )\n return blk\n\n\nclass DenseNet(nn.Module):\n def __init__(self, in_channels, **kwargs):\n super().__init__(**kwargs)\n\n num_channels, growth_rate = 64, 32\n num_convs_in_dense_blocks = NUM_CONVS_IN_DENSE_BLOCKS\n\n list_blocks = [\n nn.Conv2d(in_channels, 64, kernel_size=7, stride=2, padding=3),\n nn.BatchNorm2d(64), nn.ReLU(),\n nn.MaxPool2d(kernel_size=3, stride=2, padding=1),\n ]\n\n for i, num_convs in enumerate(num_convs_in_dense_blocks):\n list_blocks.append(DenseBlock(\n num_convs, num_channels, growth_rate))\n\n num_channels += num_convs * growth_rate\n\n if i != len(num_convs_in_dense_blocks) - 1:\n list_blocks.append(transitive_block(\n num_channels, num_channels // 2))\n num_channels = num_channels // 2\n\n list_blocks.extend([nn.BatchNorm2d(num_channels), nn.ReLU(), nn.AdaptiveAvgPool2d((1, 1)),\n nn.Flatten(), nn.Linear(num_channels, 10)])\n\n self.blocks = nn.Sequential(*list_blocks)\n\n def forward(self, X):\n return self.blocks(X)\n"
]
| [
[
"torch.nn.Linear",
"torch.cat",
"torch.nn.MaxPool2d",
"torch.nn.Sequential",
"torch.nn.AvgPool2d",
"torch.nn.BatchNorm2d",
"torch.nn.ReLU",
"torch.nn.Conv2d",
"torch.nn.AdaptiveAvgPool2d",
"torch.nn.Flatten"
]
]
|
gabinsane/myGym | [
"a41c6b11a47eaf19d0c69e67aeb48cf7a999d45a",
"a41c6b11a47eaf19d0c69e67aeb48cf7a999d45a"
]
| [
"myGym/envs/base_env.py",
"myGym/stable_baselines_mygym/common/runners.py"
]
| [
"import pybullet_data\nimport glob\nimport pybullet\nimport pybullet_utils.bullet_client as bc\nimport time\nimport numpy as np\nfrom gym.utils import seeding\nimport gym\nimport os\nimport inspect\nfrom myGym.envs.camera import Camera\nimport pkg_resources\ncurrentdir = pkg_resources.resource_filename(\"myGym\", \"envs\")\nrepodir = pkg_resources.resource_filename(\"myGym\", \"./\")\n\n\nclass BaseEnv(gym.Env):\n \"\"\"\n The base class for environments without rendering\n\n Parameters:\n :param gui_on: (bool) Whether or not to use PyBullet built-in GUI\n :param objects_dir_path: (str) Path to directory with URDF files for objects\n :param max_steps: (int) The maximum number of actions per episode\n :param show_bounding_boxes_gui: (bool) Whether or not to show bounding boxes in GUI\n :param changing_light_gui: (bool) Whether or not to change light in GUI\n :param shadows_on_gui: (bool) Whether or not to show shadows in GUI\n \"\"\"\n metadata = {'render.modes': [\n 'human', 'rgb_array'], 'video.frames_per_second': 50}\n\n def __init__(self,\n gui_on=True,\n objects_dir_path=pkg_resources.resource_filename(\"myGym\", \"envs/\"),\n max_steps=1024,\n show_bounding_boxes_gui=False,\n changing_light_gui=False,\n shadows_on_gui=True,\n timestep=1./240.\n ):\n self.gui_on = gui_on\n self.max_steps = max_steps\n self.show_bounding_boxes_gui = show_bounding_boxes_gui\n self.changing_light_gui = changing_light_gui\n self.shadows_on_gui = shadows_on_gui\n\n # Set episode information\n self.episode_start_time = None\n self.episode_over = False\n self.episode_failed = False\n self.episode_reward = 0.0\n self.episode_final_reward = []\n self.episode_final_distance = []\n self.episode_number = 0\n self.episode_steps = 0\n self.episode_max_time = 300\n self.episode_info = \"\"\n\n # Set general params\n self.time_step = 1. / 240.\n #self.time_step = timestep\n self.urdf_root = pybullet_data.getDataPath()\n self.observation = {}\n\n # Set objects information\n self.objects_dir_path = objects_dir_path\n self.env_objects = []\n self.scene_objects_uids = {}\n self.all_objects_filenames = self._get_all_urdf_filenames(self.objects_dir_path)\n\n # Set GUI\n self._connect_to_physics_server()\n\n # Set env params and load models\n self._set_physics()\n self._setup_scene()\n self._set_observation_space()\n self._set_action_space()\n\n def _connect_to_physics_server(self):\n \"\"\"\n Connect to the PyBullet physics server in SHARED_MEMORY, GUI or DIRECT mode\n \"\"\"\n if self.gui_on:\n self.p = bc.BulletClient(connection_mode=pybullet.GUI)\n # if (self.p < 0):\n # self.p = bc.BulletClient(connection_mode=p.GUI)\n self._set_gui_mode()\n else:\n self.p = bc.BulletClient(connection_mode=pybullet.DIRECT)\n self.p.setPhysicsEngineParameter(enableFileCaching=0)\n\n def _set_gui_mode(self):\n \"\"\"\n Set GUI parameters: camera, shadows, extra elements\n \"\"\"\n self.p.resetDebugVisualizerCamera(3.3, -40, -41, [0.0, 0.0, 0.33])\n self.p.configureDebugVisualizer(self.p.COV_ENABLE_SHADOWS, self.shadows_on_gui)\n self.p.configureDebugVisualizer(self.p.COV_ENABLE_GUI, 0)\n\n def _set_physics(self):\n \"\"\"\n Set physics engine parameters\n \"\"\"\n self.p.setGravity(0, 0, -9.81)\n self.p.setPhysicsEngineParameter(solverResidualThreshold=0.001, numSolverIterations=150, numSubSteps=10, useSplitImpulse=1, collisionFilterMode=1, constraintSolverType=self.p.CONSTRAINT_SOLVER_LCP_DANTZIG, globalCFM=0.000001)\n self.p.setTimeStep(self.time_step)\n self.p.setRealTimeSimulation(0)\n self.p.setPhysicsEngineParameter(enableConeFriction=1)\n print(self.p.getPhysicsEngineParameters())\n\n def _setup_scene(self):\n \"\"\"\n Set up scene elements (furniture, objects, robots)\n \"\"\"\n raise NotImplementedError\n\n def _set_observation_space(self):\n \"\"\"\n Set limits of observations\n \"\"\"\n raise NotImplementedError\n\n def _set_action_space(self):\n \"\"\"\n Set limits of actions\n \"\"\"\n raise NotImplementedError\n\n def _get_observation(self):\n \"\"\"\n Get info about the state of the environment\n\n Returns:\n :return observation: (object) Observation of the environment\n \"\"\"\n raise NotImplementedError\n\n def step(self, action):\n \"\"\"\n Apply action on the environment\n\n Parameters:\n :param action: (object) An action provided by the agent\n Returns:\n :return observation: (object)\n :return reward: (float)\n :return done: (bool):\n :return info: (dict):\n \"\"\"\n raise NotImplementedError\n\n def _add_scene_object_uid(self, scene_object_uid, name):\n \"\"\"\n Call this method in order to enable texturization of object\n\n Parameters:\n :param scene_object: (int)\n \"\"\"\n self.scene_objects_uids[scene_object_uid] = name\n\n def get_scene_object_uid_by_name(self, name):\n for uid, object_name in self.scene_objects_uids.items():\n if name == object_name:\n return uid\n return None\n\n def seed(self, seed=None):\n \"\"\"\n Set the seed for this env's random number generator(s)\n \"\"\"\n self.np_random, seed = seeding.np_random(seed)\n return [seed]\n\n def hard_reset(self):\n \"\"\"\n Full reset of the simulation. Delete and load again all objects and reset physics.\n \"\"\"\n self.p.resetSimulation()\n self.p.disconnect()\n self._connect_to_physics_server()\n self.scene_objects_uids = {}\n #self.episode_number = 0\n self._set_physics()\n self._setup_scene()\n\n def _restart_episode(self):\n \"\"\"\n Reset episode information and delete all objects\n \"\"\"\n self.p.removeAllUserDebugItems()\n self.episode_start_time = time.time()\n self.episode_over = False\n self.episode_failed = False\n self.episode_reward = 0.0\n self.episode_steps = 0\n\n def reset(self, hard=False):\n \"\"\"\n Reset the state of the environment\n \"\"\"\n if hard:\n self.hard_reset()\n else:\n self._remove_all_objects()\n\n self._restart_episode()\n\n def _draw_bounding_boxes(self):\n \"\"\"\n Show bounding boxes in tne PyBullet GUI\n \"\"\"\n for object in self.env_objects:\n object.draw_bounding_box()\n\n def _compute_reward(self):\n \"\"\"\n Compute reward for the agent\n \"\"\"\n return NotImplementedError\n\n def _print_episode_summary(self, info_dict={}):\n \"\"\"\n Show an extra information about the episode\n\n Parameters:\n :param info_dict: (dict) Extra info\n \"\"\"\n if self.episode_failed:\n episode_status = \"FAILURE\"\n else:\n episode_status = \"SUCCESS\"\n\n print(\"#---------Episode-Summary---------#\")\n print(\"Episode number: \" + str(self.episode_number))\n print(\"Episode's number of steps: \" + str(self.episode_steps))\n #print(\"Episode status: \" + episode_status)\n print(\"Episode info: \" + self.episode_info)\n print(\"Episode reward: \" + str(self.episode_reward))\n #print(\"Last step reward: \" + str(self.reward.rewards_history[-1]))\n print(\"#---------------------------------#\")\n\n for key, value in info_dict.items():\n print(key + \": \" + str(value))\n\n def _get_random_urdf_filenames(self, n, used_objects=None):\n \"\"\"\n Sample random URDF files from directory with objects URDFs\n\n Parameters:\n :param n: (int) Number of URDF's\n :param used_objects: (list) Specified subset of objects\n Returns:\n :return selected_objects_filenames: (list)\n \"\"\"\n if used_objects or (self.all_objects_filenames is None):\n all_objects_filenames = []\n for object_name in used_objects:\n if \"virtual\" in object_name:\n all_objects_filenames.append(object_name)\n for file in self.all_objects_filenames:\n if '/'+object_name+'.' in file:\n all_objects_filenames.append(file)\n else:\n # uses self.all_objects_filenames\n pass\n assert all_objects_filenames is not None\n\n selected_objects_filenames = []\n total_num_objects = len(all_objects_filenames)\n if (n <= total_num_objects):\n selected_objects = np.random.choice(\n np.arange(total_num_objects), n, replace=True)\n else:\n selected_objects = list(np.arange(total_num_objects))\n remain = n - total_num_objects\n selected_objects += list(np.random.choice(\n np.arange(total_num_objects), remain))\n for object_id in selected_objects:\n selected_objects_filenames.append(all_objects_filenames[object_id])\n return selected_objects_filenames\n\n def _get_all_urdf_filenames(self, dir):\n \"\"\"\n Get all URDF filenames from directory\n\n Parameters:\n :param dir: (int) Number of URDFs\n Returns:\n :return filenames: (list)\n \"\"\"\n list_all = []\n for (dirpath, dirnames, filenames) in os.walk(self.objects_dir_path):\n if '_old' not in dirpath and 'urdf' in dirpath:\n list_all += [os.path.join(dirpath, file) for file in filenames]\n return list_all\n\n def _remove_object(self, object):\n \"\"\"\n Totally remove object from the simulation\n\n Parameters:\n :param object: (EnvObject) Object to remove\n \"\"\"\n self.env_objects.remove(object)\n self.p.removeBody(object.uid)\n\n def _remove_all_objects(self):\n \"\"\"\n Remove all objects from simulation (not scene objects or robots)\n \"\"\"\n env_objects_copy = self.env_objects[:]\n for env_object in env_objects_copy:\n self._remove_object(env_object)\n\n def get_texturizable_objects_uids(self):\n \"\"\"\n Get all objects in the environment, on which textures can be applied\n \n Returns:\n :return texturizable_objects_uids: (list)\n \"\"\"\n return [object.get_uid() for object in self.env_objects] + list(self.scene_objects_uids.keys())\n\n def get_colorizable_objects_uids(self):\n \"\"\"\n Get all objects in the environment, which color can be changed\n\n Returns:\n :return colorizable_objects_uids: (list)\n \"\"\"\n return [object.get_uid() for object in self.env_objects] + list(self.scene_objects_uids.keys())\n\n def __del__(self):\n \"\"\"\n Disconnect from the physics server\n \"\"\"\n self.p.disconnect()\n\n\nclass CameraEnv(BaseEnv):\n \"\"\"\n The class for environments with rendering\n\n Parameters:\n :param camera_resolution: (list) The number of pixels in image (WxH)\n :param shadows_on: (bool) Whether or not to use shadows while rendering, only applies to ER_TINY_RENDERER\n :param render_on: (bool) Turn on rendering\n :param renderer: (int) self.p.ER_TINY_RENDERER (CPU) or self.p.ER_BULLET_HARDWARE_OPENGL (GPU)\n :param active_cameras: (list) Set 1 at a position(=camera number) to save images from this camera\n \"\"\"\n def __init__(self, camera_resolution=[640, 480], shadows_on=True,\n render_on=True, renderer=pybullet.ER_BULLET_HARDWARE_OPENGL,\n active_cameras=None, **kwargs):\n\n super(CameraEnv, self).__init__(**kwargs)\n\n self.camera_resolution = camera_resolution\n self.shadows_on = shadows_on\n self.render_on = render_on\n self.renderer = renderer\n self.active_cameras = active_cameras\n self.cameras = []\n\n self.set_light()\n self._set_cameras()\n\n def set_light(self, light_direction=[1, 1, 1], light_color=[0.1, 0.1, 0.1],\n light_distance=1., light_ambient=1., light_diffuse=1.,\n light_specular=1.):\n \"\"\"\n Set light parameters for rendering, doesn't affect PyBullet GUI. Appart from light_direction, all parameters only apply to ER_TINY_RENDERER.\n\n Parameters:\n :param light_direction: (list) Specifies the world position of the light source\n :param light_color: (list) Directional light color in RGB in range 0..1\n :param light_distance: (float) Distance of the light along the normalized light_direction\n :param light_ambient: (float) Light ambient coefficient in range 0..1\n :param light_diffuse: (float) Light diffuse coefficient in range 0..1\n :param light_specular: (float) Light specular coefficient in range 0..1\n \"\"\"\n self.light_direction = light_direction\n self.light_color = light_color\n self.light_distance = light_distance\n self.light_ambient = light_ambient\n self.light_diffuse = light_diffuse\n self.light_specular = light_specular\n\n def get_render_parameters(self):\n \"\"\"\n Return environment parameters for rendering, initially is intended to\n use by cameras\n\n Returns:\n :return render_parameters: (dict) Render parameters\n \"\"\"\n return {\n \"width\": self.camera_resolution[0],\n \"height\": self.camera_resolution[1],\n \"lightDirection\": self.light_direction,\n \"lightColor\": self.light_color,\n \"lightDistance\": self.light_distance,\n \"shadow\": 1 if self.shadows_on else 0,\n \"lightAmbientCoeff\": self.light_ambient,\n \"lightDiffuseCoeff\": self.light_diffuse,\n \"lightSpecularCoeff\": self.light_specular,\n \"renderer\": self.renderer\n }\n\n def _set_cameras(self):\n \"\"\"\n Set cameras available to use for rendering\n \"\"\"\n raise NotImplementedError\n\n def get_cameras(self):\n return self.cameras\n\n def add_camera(self, **kwargs):\n \"\"\"\n Add new camera to the environment\n\n Parameters:\n :param position: (list) Eye position in Cartesian world coordinates\n :prarm target_position: (list) Position of the target point\n :param up_vector: (list) Up vector of the camera\n :param up_axis_index: (int) Either 1 for Y or 2 for Z axis up\n :param yaw: (float) Yaw angle in degrees left/right around up-axis\n :param pitch: (float) Pitch in degrees up/down\n :param roll: (float) Roll in degrees around forward vector\n :param distance: (float) Distance from eye to focus point\n :param field_of_view: (float) Field of view\n :param near_plane_distance: (float) Near plane distance\n :param far_plane_distance: (float) Far plane distance\n \"\"\"\n self.cameras.append(Camera(env=self, **kwargs))\n\n def set_active_cameras(self, active_cameras):\n\n if (len(active_cameras) == len(self.cameras)):\n self.active_cameras = active_cameras\n\n def change_current_camera(self, camera_num):\n print(\"Change camera to \" + str(self.current_camera))\n self.current_camera = camera_num\n\n def render(self, mode=\"rgb_array\", camera_id=None):\n \"\"\"\n Get image (image, depth, segmentation_mask) from camera or active cameras\n\n Parameters:\n :param mode: (str) rgb_array to return RGB image\n :param camera_id: (int) Get image from specified camera\n Returns:\n :return camera_data: (dict) Key: camera_id, Value: info from camera\n \"\"\"\n if mode != \"rgb_array\":\n return np.array([])\n camera_data = {}\n if self.render_on:\n if camera_id is not None:\n camera_data[camera_id] = self.cameras[camera_id].render()\n else:\n for camera_num in range(len(self.active_cameras)):\n if self.active_cameras[camera_num]:\n camera_data[camera_num] = self.cameras[camera_num].render()\n return camera_data\n\n def project_point_to_camera_image(self, point, camera_id):\n \"\"\"\n Project 3D point in Cartesian world coordinates to 2D point in pixel space\n\n Parameters:\n :param point: (list) 3D point in Cartesian world coordinates\n :param camera_id: (int) Index of camera to project on\n\n Returns:\n :return 2d_point: (list) 2D coordinates of point on imageg\n \"\"\"\n return self.cameras[camera_id].project_point_to_image(point)\n\n def get_camera_opencv_matrix_values(self, camera_id):\n \"\"\"\n Compute values of OpenCV matrix\n\n Parameters:\n :param camera_id: (int) Index of camera to get matrix from\n Returns:\n :return values: (dict) fx, fy, cx, cy values\n \"\"\"\n return self.cameras[camera_id].get_opencv_camera_matrix_values()\n",
"from abc import ABC, abstractmethod\nimport typing\nfrom typing import Union, Optional, Any\nfrom gym import spaces\nimport gym\nimport numpy as np\n\nfrom myGym.stable_baselines_mygym.common.callbacks import BaseCallback\nfrom myGym.stable_baselines_mygym.common.vec_env import VecEnv\n\nif typing.TYPE_CHECKING:\n from myGym.stable_baselines_mygym.common.base_class import BaseRLModel # pytype: disable=pyi-error\n\n\nclass AbstractEnvRunner(ABC):\n def __init__(self, *, env: Union[gym.Env, VecEnv], model: 'BaseRLModel', n_steps: int):\n \"\"\"\n Collect experience by running `n_steps` in the environment.\n Note: if this is a `VecEnv`, the total number of steps will\n be `n_steps * n_envs`.\n\n :param env: (Union[gym.Env, VecEnv]) The environment to learn from\n :param model: (BaseRLModel) The model to learn\n :param n_steps: (int) The number of steps to run for each environment\n \"\"\"\n self.env = env\n self.model = model\n n_envs = env.num_envs\n self.batch_ob_shape = (n_envs * n_steps,) + env.observation_space.shape\n self.obs = np.zeros((n_envs,) +env.envs[0].real_obsspace.shape, dtype=env.observation_space.dtype.name)\n self.obs[:] = env.envs[0].reset().reshape(1, -1)\n self.obs = self.obs.reshape(self.env.envs[0].num_robots, -1)\n self.n_steps = n_steps\n self.states = model.initial_state\n self.dones = [False for _ in range(n_envs)]\n self.callback = None # type: Optional[BaseCallback]\n self.continue_training = True\n self.n_envs = n_envs\n\n def run(self, callback: Optional[BaseCallback] = None) -> Any:\n \"\"\"\n Collect experience.\n\n :param callback: (Optional[BaseCallback]) The callback that will be called\n at each environment step.\n \"\"\"\n self.callback = callback\n self.continue_training = True\n return self._run()\n\n @abstractmethod\n def _run(self) -> Any:\n \"\"\"\n This method must be overwritten by child class.\n \"\"\"\n raise NotImplementedError\n\n\ndef traj_segment_generator(policy, env, horizon, reward_giver=None, gail=False, callback=None):\n \"\"\"\n Compute target value using TD(lambda) estimator, and advantage with GAE(lambda)\n :param policy: (MLPPolicy) the policy\n :param env: (Gym Environment) the environment\n :param horizon: (int) the number of timesteps to run per batch\n :param reward_giver: (TransitionClassifier) the reward predicter from obsevation and action\n :param gail: (bool) Whether we are using this generator for standard trpo or with gail\n :param callback: (BaseCallback)\n :return: (dict) generator that returns a dict with the following keys:\n - observations: (np.ndarray) observations\n - rewards: (numpy float) rewards (if gail is used it is the predicted reward)\n - true_rewards: (numpy float) if gail is used it is the original reward\n - vpred: (numpy float) action logits\n - dones: (numpy bool) dones (is end of episode, used for logging)\n - episode_starts: (numpy bool)\n True if first timestep of an episode, used for GAE\n - actions: (np.ndarray) actions\n - nextvpred: (numpy float) next action logits\n - ep_rets: (float) cumulated current episode reward\n - ep_lens: (int) the length of the current episode\n - ep_true_rets: (float) the real environment reward\n - continue_training: (bool) Whether to continue training\n or stop early (triggered by the callback)\n \"\"\"\n # Check when using GAIL\n assert not (gail and reward_giver is None), \"You must pass a reward giver when using GAIL\"\n\n # Initialize state variables\n step = 0\n action = env.action_space.sample() # not used, just so we have the datatype\n observation = env.reset()\n\n cur_ep_ret = 0 # return in current episode\n current_it_len = 0 # len of current iteration\n current_ep_len = 0 # len of current episode\n cur_ep_true_ret = 0\n ep_true_rets = []\n ep_rets = [] # returns of completed episodes in this segment\n ep_lens = [] # Episode lengths\n\n # Initialize history arrays\n observations = np.array([observation for _ in range(horizon)])\n true_rewards = np.zeros(horizon, 'float32')\n rewards = np.zeros(horizon, 'float32')\n vpreds = np.zeros(horizon, 'float32')\n episode_starts = np.zeros(horizon, 'bool')\n dones = np.zeros(horizon, 'bool')\n actions = np.array([action for _ in range(horizon)])\n states = policy.initial_state\n episode_start = True # marks if we're on first timestep of an episode\n done = False\n\n callback.on_rollout_start()\n\n while True:\n action, vpred, states, _ = policy.step(observation.reshape(-1, *observation.shape), states, done)\n # Slight weirdness here because we need value function at time T\n # before returning segment [0, T-1] so we get the correct\n # terminal value\n if step > 0 and step % horizon == 0:\n callback.update_locals(locals())\n callback.on_rollout_end()\n yield {\n \"observations\": observations,\n \"rewards\": rewards,\n \"dones\": dones,\n \"episode_starts\": episode_starts,\n \"true_rewards\": true_rewards,\n \"vpred\": vpreds,\n \"actions\": actions,\n \"nextvpred\": vpred[0] * (1 - episode_start),\n \"ep_rets\": ep_rets,\n \"ep_lens\": ep_lens,\n \"ep_true_rets\": ep_true_rets,\n \"total_timestep\": current_it_len,\n 'continue_training': True\n }\n _, vpred, _, _ = policy.step(observation.reshape(-1, *observation.shape))\n # Be careful!!! if you change the downstream algorithm to aggregate\n # several of these batches, then be sure to do a deepcopy\n ep_rets = []\n ep_true_rets = []\n ep_lens = []\n # Reset current iteration length\n current_it_len = 0\n callback.on_rollout_start()\n i = step % horizon\n observations[i] = observation\n vpreds[i] = vpred[0]\n actions[i] = action[0]\n episode_starts[i] = episode_start\n\n clipped_action = action\n # Clip the actions to avoid out of bound error\n if isinstance(env.action_space, gym.spaces.Box):\n clipped_action = np.clip(action, env.action_space.low, env.action_space.high)\n\n if gail:\n reward = reward_giver.get_reward(observation, clipped_action[0])\n observation, true_reward, done, info = env.step(clipped_action[0])\n else:\n observation, reward, done, info = env.step(clipped_action[0])\n true_reward = reward\n\n if callback is not None:\n callback.update_locals(locals())\n if callback.on_step() is False:\n # We have to return everything so pytype does not complain\n yield {\n \"observations\": observations,\n \"rewards\": rewards,\n \"dones\": dones,\n \"episode_starts\": episode_starts,\n \"true_rewards\": true_rewards,\n \"vpred\": vpreds,\n \"actions\": actions,\n \"nextvpred\": vpred[0] * (1 - episode_start),\n \"ep_rets\": ep_rets,\n \"ep_lens\": ep_lens,\n \"ep_true_rets\": ep_true_rets,\n \"total_timestep\": current_it_len,\n 'continue_training': False\n }\n return\n\n rewards[i] = reward\n true_rewards[i] = true_reward\n dones[i] = done\n episode_start = done\n\n cur_ep_ret += reward\n cur_ep_true_ret += true_reward\n current_it_len += 1\n current_ep_len += 1\n if done:\n # Retrieve unnormalized reward if using Monitor wrapper\n maybe_ep_info = info.get('episode')\n if maybe_ep_info is not None:\n if not gail:\n cur_ep_ret = maybe_ep_info['r']\n cur_ep_true_ret = maybe_ep_info['r']\n\n ep_rets.append(cur_ep_ret)\n ep_true_rets.append(cur_ep_true_ret)\n ep_lens.append(current_ep_len)\n cur_ep_ret = 0\n cur_ep_true_ret = 0\n current_ep_len = 0\n if not isinstance(env, VecEnv):\n observation = env.reset()\n step += 1\n"
]
| [
[
"numpy.array",
"numpy.arange"
],
[
"numpy.zeros",
"numpy.clip"
]
]
|
dsilvalo28/AIVA-DAIA | [
"55b1f547aaf850df1ea3ddd9a2f6b5a2af410889"
]
| [
"src/TreeDetector.py"
]
| [
"import cv2\nimport numpy as np\nfrom src.Detector import Detector\n\n\n# Tree detector class #\nclass TreeDetector(Detector):\n def __init__(self, image_path=None):\n self.__image_path = image_path\n self.image = None\n if image_path is not None:\n self.read(self.__image_path)\n\n # *** CONSTANTS *** #\n self.__threshold_down = 127\n self.__threshold_up = 255\n self.__totalm2 = 12000\n self.__treesperm2 = 0.6\n\n # *** PRIVATE *** #\n def __preprocess_image(self):\n \"\"\"\n :return: Preprocessed set image\n \"\"\"\n preprocessed_image = cv2.cvtColor(self.image, cv2.COLOR_BGR2GRAY)\n hsv_image = cv2.cvtColor(self.image, cv2.COLOR_BGR2HSV)\n\n return preprocessed_image, hsv_image\n\n # *** PUBLIC *** #\n def read(self, image):\n \"\"\"\n :param image: Set the image to work with\n \"\"\"\n self.image = image\n\n def read_from_path(self, image_path):\n \"\"\"\n :param image_path: Set the path to read the image and the image\n \"\"\"\n self.__image_path = image_path\n self.image = cv2.imread(self.__image_path)\n return self.image\n\n def process_image(self, lc=[0, 100, 100], uc=[120, 255, 255]):\n \"\"\"\n :param lc: [int, int, int] Lower HSV color values\n :param uc: [int, int, int] Lower HSV color values\n :return: [np.array] 3 channel segmentation mask of the set image\n \"\"\"\n preprocessed_image, hsv_image = self.__preprocess_image()\n ret, segmented_image = cv2.threshold(preprocessed_image, self.__threshold_down, self.__threshold_up,\n cv2.THRESH_BINARY)\n\n # Creaccion de mascara\n lower_color = np.array(lc, dtype='uint8')\n upper_color = np.array(uc, dtype='uint8')\n mask = cv2.inRange(hsv_image, lower_color, upper_color)\n mask_3_channels = np.dstack((mask, mask, mask))\n\n # ret2, thresh = cv2.threshold(mask, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)\n # segmented_image_boolean = segmented_image.astype(np.bool)\n return mask_3_channels\n\n def calculate_percentage(self):\n \"\"\"\n :return: Percentage of tree mass of the set image\n \"\"\"\n segmented_image = self.process_image()\n percentage = np.mean(segmented_image/2.55)\n return percentage\n\n def calculate_m2(self):\n \"\"\"\n :return: m² of tree mass of the set image\n \"\"\"\n percentage = self.calculate_percentage()\n m2 = percentage * self.__totalm2\n return m2\n\n def calculate_number_trees(self):\n \"\"\"\n :return: Number of trees of the set image\n \"\"\"\n m2 = self.calculate_m2()\n n_trees = int(m2 * self.__treesperm2)\n return n_trees\n"
]
| [
[
"numpy.dstack",
"numpy.array",
"numpy.mean"
]
]
|
aholinch/Keplers-Goat-Herd | [
"18cc49465353eb6ce6ce9e9e84d81fca9f5d3c59"
]
| [
"util/kgh.py"
]
| [
"import numpy as np, time\n\ndef mToE(m, e):\n if e <= 0.5:\n return mToE(m,e,10)\n\n if e <= 0.9:\n return mToE(m,e,25)\n\n if e <= 0.95:\n return mToE(m,e,50)\n\n if e <= 0.99:\n return mToE(m,e,128)\n\n return mToE(m,e,256)\n\n\ndef mToE(m, eccentricity, N_it):\n \"\"\"Solve Kepler's equation, E - e sin E = ell, via the contour integration method of Philcox et al. (2021)\n This uses techniques described in Ullisch (2020) to solve the `geometric goat problem'.\n\n Args:\n m: mean anomaly, in the range (0,2 pi).\n eccentricity (float): Eccentricity. Must be in the range 0<e<1.\n N_it (float): Number of grid-points.\n\n Returns:\n (float): eccentric anomaly, E.\n \"\"\"\n\n # Check inputs\n if eccentricity<=0.:\n raise Exception(\"Eccentricity must be greater than zero!\")\n elif eccentricity>=1:\n raise Exception(\"Eccentricity must be less than unity!\")\n if m>2.*np.pi:\n raise Exception(\"Mean anomaly should be in the range (0, 2 pi)\")\n if m<0:\n raise Exception(\"Mean anomaly should be in the range (0, 2 pi)\")\n if N_it<2:\n raise Exception(\"Need at least two sampling points!\")\n\n # Define sampling points\n N_points = N_it - 2\n N_fft = (N_it-1)*2\n\n # Define contour radius\n radius = eccentricity/2\n\n # Generate e^{ikx} sampling points and precompute real and imaginary parts\n j_arr = np.arange(N_points)\n freq = (2*np.pi*(j_arr+1.)/N_fft)[:,np.newaxis]\n exp2R = np.cos(freq)\n exp2I = np.sin(freq)\n ecosR= eccentricity*np.cos(radius*exp2R)\n esinR = eccentricity*np.sin(radius*exp2R)\n exp4R = exp2R*exp2R-exp2I*exp2I\n exp4I = 2.*exp2R*exp2I\n coshI = np.cosh(radius*exp2I)\n sinhI = np.sinh(radius*exp2I)\n\n # Precompute e sin(e/2) and e cos(e/2)\n esinRadius = eccentricity*np.sin(radius);\n ecosRadius = eccentricity*np.cos(radius);\n\n # Define contour center for each ell and precompute sin(center), cos(center)\n center = m-eccentricity/2.\n if m < np.pi:\n center += eccentricity\n sinC = np.sin(center)\n cosC = np.cos(center)\n output = center\n\n ## Accumulate Fourier coefficients\n # NB: we halve the integration range by symmetry, absorbing factor of 2 into ratio\n\n ## Separate out j = 0 piece, which is simpler\n\n # Compute z in real and imaginary parts (zI = 0 here)\n zR = center + radius\n\n # Compute e*sin(zR) from precomputed quantities\n tmpsin = sinC*ecosRadius+cosC*esinRadius\n\n # Compute f(z(x)) in real and imaginary parts (fxI = 0)\n fxR = zR - tmpsin - m \n\n # Add to arrays, with factor of 1/2 since an edge\n ft_gx2 = 0.5/fxR\n ft_gx1 = 0.5/fxR\n\n ## Compute j = 1 to N_points pieces\n\n # Compute z in real and imaginary parts\n zR = center + radius*exp2R\n zI = radius*exp2I\n\n # Compute f(z(x)) in real and imaginary parts\n # can use precomputed cosh / sinh / cos / sin for this!\n tmpsin = sinC*ecosR+cosC*esinR # e sin(zR)\n tmpcos = cosC*ecosR-sinC*esinR # e cos(zR)\n\n fxR = zR - tmpsin*coshI-m\n fxI = zI - tmpcos*sinhI\n\n # Compute 1/f(z) and append to array\n ftmp = fxR*fxR+fxI*fxI;\n fxR /= ftmp;\n fxI /= ftmp;\n\n ft_gx2 += np.sum(exp4R*fxR+exp4I*fxI,axis=0)\n ft_gx1 += np.sum(exp2R*fxR+exp2I*fxI,axis=0)\n\n ## Separate out j = N_it piece, which is simpler\n\n # Compute z in real and imaginary parts (zI = 0 here)\n zR = center - radius\n\n # Compute sin(zR) from precomputed quantities\n tmpsin = sinC*ecosRadius-cosC*esinRadius\n\n # Compute f(z(x)) in real and imaginary parts (fxI = 0 here)\n fxR = zR - tmpsin-m\n\n # Add to sum, with 1/2 factor for edges\n ft_gx2 += 0.5/fxR;\n ft_gx1 += -0.5/fxR;\n\n ### Compute and return the solution E(ell,e)\n output += radius*ft_gx2/ft_gx1;\n\n return output[0]\n\nif __name__==\"__main__\":\n \"\"\"Test the Python function above with a simple example\"\"\"\n\n # Parameters\n N_ell = 10000\n eccentricity = 0.5\n N_it = 10\n\n print(\"\\n##### PARAMETERS #####\")\n print(\"# N_ell = %d\"%N_ell)\n print(\"# Eccentricity = %.2f\"%eccentricity)\n print(\"# Iterations: %d\"%N_it)\n print(\"######################\")\n\n # Create ell array from E\n E_true = (2.0*np.pi*(np.arange(N_ell)+0.5))/N_ell\n ell_input = E_true - eccentricity*np.sin(E_true)\n\n E_out = [0 for i in range(len(ell_input))]\n # Time the function\n init = time.time()\n for i in range(len(ell_input)):\n E_out[i] = mToE(ell_input[i],eccentricity,N_it)\n runtime = time.time()-init\n\n print(\"\\nEstimation complete after %.1f millseconds, achieving mean error %.2e.\\n\"%(runtime*1000.,np.mean(np.abs(E_out-E_true))))\n"
]
| [
[
"numpy.sin",
"numpy.cosh",
"numpy.sum",
"numpy.arange",
"numpy.sinh",
"numpy.cos",
"numpy.abs"
]
]
|
liuky74/detr | [
"e2b59573dcb86720562dfbdb02977ef996857025"
]
| [
"models/backbone.py"
]
| [
"# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved\n\"\"\"\nBackbone modules.\n\"\"\"\nfrom collections import OrderedDict\n\nimport torch\nimport torch.nn.functional as F\nimport torchvision\nfrom torch import nn\nfrom torchvision.models._utils import IntermediateLayerGetter\nfrom typing import Dict, List\n\nfrom util.misc import NestedTensor, is_main_process\n\nfrom .position_encoding import build_position_encoding\n\n\nclass FrozenBatchNorm2d(torch.nn.Module):\n \"\"\"\n BatchNorm2d where the batch statistics and the affine parameters are fixed.\n\n Copy-paste from torchvision.misc.ops with added eps before rqsrt,\n without which any other models than torchvision.models.resnet[18,34,50,101]\n produce nans.\n \"\"\"\n\n def __init__(self, n):\n super(FrozenBatchNorm2d, self).__init__()\n self.register_buffer(\"weight\", torch.ones(n))\n self.register_buffer(\"bias\", torch.zeros(n))\n self.register_buffer(\"running_mean\", torch.zeros(n))\n self.register_buffer(\"running_var\", torch.ones(n))\n # 固定参数的batch norm,读取到本层参数时删除它\n def _load_from_state_dict(self, state_dict, prefix, local_metadata, strict,\n missing_keys, unexpected_keys, error_msgs):\n num_batches_tracked_key = prefix + 'num_batches_tracked'\n if num_batches_tracked_key in state_dict:\n del state_dict[num_batches_tracked_key]\n\n super(FrozenBatchNorm2d, self)._load_from_state_dict(\n state_dict, prefix, local_metadata, strict,\n missing_keys, unexpected_keys, error_msgs)\n\n def forward(self, x):\n # move reshapes to the beginning\n # to make it fuser-friendly\n w = self.weight.reshape(1, -1, 1, 1)\n b = self.bias.reshape(1, -1, 1, 1)\n rv = self.running_var.reshape(1, -1, 1, 1)\n rm = self.running_mean.reshape(1, -1, 1, 1)\n eps = 1e-5\n scale = w * (rv + eps).rsqrt()\n bias = b - rm * scale\n return x * scale + bias\n\n\nclass BackboneBase(nn.Module):\n\n def __init__(self, backbone: nn.Module, train_backbone: bool, num_channels: int, return_interm_layers: bool):\n super().__init__()\n for name, parameter in backbone.named_parameters():\n if not train_backbone or 'layer2' not in name and 'layer3' not in name and 'layer4' not in name: # 初始层和第一层不参与训练\n parameter.requires_grad_(False)\n if return_interm_layers: # 说明取数据的层\n return_layers = {\"layer1\": \"0\", \"layer2\": \"1\", \"layer3\": \"2\", \"layer4\": \"3\"}\n else:\n return_layers = {'layer4': \"0\"}\n self.body = IntermediateLayerGetter(backbone, return_layers=return_layers) # 这个函数可以返回一个新模型,新模型的输出为指定层名的输出\n self.num_channels = num_channels\n\n def forward(self, tensor_list: NestedTensor):\n xs = self.body(tensor_list.tensors) # 输出\n out: Dict[str, NestedTensor] = {}\n for name, x in xs.items():\n m = tensor_list.mask\n assert m is not None\n mask = F.interpolate(m[None].float(), size=x.shape[-2:]).to(torch.bool)[0]\n out[name] = NestedTensor(x, mask)\n return out\n\n\nclass Backbone(BackboneBase):\n \"\"\"ResNet backbone with frozen BatchNorm.\"\"\"\n def __init__(self, name: str,\n train_backbone: bool,\n return_interm_layers: bool,\n dilation: bool):\n backbone = getattr(torchvision.models, name)(\n replace_stride_with_dilation=[False, False, dilation],\n pretrained=is_main_process(), norm_layer=FrozenBatchNorm2d)\n num_channels = 512 if name in ('resnet18', 'resnet34') else 2048\n super().__init__(backbone, train_backbone, num_channels, return_interm_layers)\n\n\nclass Joiner(nn.Sequential):\n def __init__(self, backbone, position_embedding):\n super().__init__(backbone, position_embedding)\n\n def forward(self, tensor_list: NestedTensor):\n xs = self[0](tensor_list) # boneNet输出\n out: List[NestedTensor] = []\n pos = []\n for name, x in xs.items():\n out.append(x)\n # position encoding\n pos.append(self[1](x).to(x.tensors.dtype)) # position embedding\n\n return out, pos\n\n\ndef build_backbone(args):\n position_embedding = build_position_encoding(args) #构建特征图像素坐标\n train_backbone = args.lr_backbone > 0 # 是否训练主干网络\n return_interm_layers = args.masks\n backbone = Backbone(args.backbone, train_backbone, return_interm_layers, args.dilation) # 生成主干网络\n model = Joiner(backbone, position_embedding) # 将embedding与主函数融合\n model.num_channels = backbone.num_channels\n return model\n"
]
| [
[
"torch.zeros",
"torch.ones"
]
]
|
garciadias/k-means_on_apogee | [
"7c3315a0d305f255c121a015607e22e5a46bba82"
]
| [
"src/create_dataset.py"
]
| [
"\"\"\"Create csv with spectral data\"\"\"\nfrom os import getcwd\nfrom pathlib import Path\n\nfrom astropy.io import fits\nimport pandas as pd\n\nPROJECT_PATH = getcwd()\nSPECTRA = {}\nfor spectrum_path in Path('%s/data/fits/' % PROJECT_PATH).glob('*fits'):\n spectrum_fits = fits.open(spectrum_path)\n spectrum = spectrum_fits[1].data[0]\n SPECTRA[spectrum_fits[0].header['OBJID']] = spectrum\n Path(spectrum_path).unlink()\nwavelenght = spectrum_fits[4].data[0]\n\nall_spectra = pd.DataFrame(SPECTRA, index=wavelenght).T\n\nall_spectra.to_csv('%s/data/all_spectra.csv' % PROJECT_PATH)\n\nPath(PROJECT_PATH + '/models').mkdir(exist_ok=True)\n"
]
| [
[
"pandas.DataFrame"
]
]
|
Vishal-V/federated | [
"2575ac3c571004ba554bd0c0d11c2e307ff22d57"
]
| [
"tensorflow_federated/python/core/impl/executors/execution_context_test.py"
]
| [
"# Lint as: python3\n# Copyright 2019, The TensorFlow Federated 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\nimport collections\nimport contextlib\n\nfrom absl.testing import absltest\nimport numpy as np\nimport tensorflow as tf\n\nfrom tensorflow_federated.python.core.api import computation_types\nfrom tensorflow_federated.python.core.api import computations\nfrom tensorflow_federated.python.core.api import intrinsics\nfrom tensorflow_federated.python.core.impl.compiler import type_factory\nfrom tensorflow_federated.python.core.impl.executors import execution_context\nfrom tensorflow_federated.python.core.impl.executors import executor_stacks\n\ntf.compat.v1.enable_v2_behavior()\n\n\[email protected]\ndef _execution_context(num_clients=None):\n executor_factory = executor_stacks.local_executor_factory(num_clients)\n yield execution_context.ExecutionContext(executor_factory)\n\n\nclass RetryableErrorTest(absltest.TestCase):\n\n def test_is_retryable_error(self):\n retryable_error = execution_context.RetryableError()\n self.assertTrue(execution_context._is_retryable_error(retryable_error))\n self.assertFalse(execution_context._is_retryable_error(TypeError()))\n self.assertFalse(execution_context._is_retryable_error(1))\n self.assertFalse(execution_context._is_retryable_error('a'))\n self.assertFalse(execution_context._is_retryable_error(None))\n\n\nclass ExecutionContextIntegrationTest(absltest.TestCase):\n\n def test_simple_no_arg_tf_computation_with_int_result(self):\n\n @computations.tf_computation\n def comp():\n return tf.constant(10)\n\n with _execution_context():\n result = comp()\n\n self.assertEqual(result, 10)\n\n def test_one_arg_tf_computation_with_int_param_and_result(self):\n\n @computations.tf_computation(tf.int32)\n def comp(x):\n return tf.add(x, 10)\n\n with _execution_context():\n result = comp(3)\n\n self.assertEqual(result, 13)\n\n def test_three_arg_tf_computation_with_int_params_and_result(self):\n\n @computations.tf_computation(tf.int32, tf.int32, tf.int32)\n def comp(x, y, z):\n return tf.multiply(tf.add(x, y), z)\n\n with _execution_context():\n result = comp(3, 4, 5)\n\n self.assertEqual(result, 35)\n\n def test_tf_computation_with_dataset_params_and_int_result(self):\n\n @computations.tf_computation(computation_types.SequenceType(tf.int32))\n def comp(ds):\n return ds.reduce(np.int32(0), lambda x, y: x + y)\n\n with _execution_context():\n ds = tf.data.Dataset.range(10).map(lambda x: tf.cast(x, tf.int32))\n result = comp(ds)\n\n self.assertEqual(result, 45)\n\n def test_tf_computation_with_structured_result(self):\n\n @computations.tf_computation\n def comp():\n return collections.OrderedDict([\n ('a', tf.constant(10)),\n ('b', tf.constant(20)),\n ])\n\n with _execution_context():\n result = comp()\n\n self.assertIsInstance(result, collections.OrderedDict)\n self.assertDictEqual(result, {'a': 10, 'b': 20})\n\n def test_with_temperature_sensor_example(self):\n\n @computations.tf_computation(\n computation_types.SequenceType(tf.float32), tf.float32)\n def count_over(ds, t):\n return ds.reduce(\n np.float32(0), lambda n, x: n + tf.cast(tf.greater(x, t), tf.float32))\n\n @computations.tf_computation(computation_types.SequenceType(tf.float32))\n def count_total(ds):\n return ds.reduce(np.float32(0.0), lambda n, _: n + 1.0)\n\n @computations.federated_computation(\n type_factory.at_clients(computation_types.SequenceType(tf.float32)),\n type_factory.at_server(tf.float32))\n def comp(temperatures, threshold):\n return intrinsics.federated_mean(\n intrinsics.federated_map(\n count_over,\n intrinsics.federated_zip(\n [temperatures,\n intrinsics.federated_broadcast(threshold)])),\n intrinsics.federated_map(count_total, temperatures))\n\n with _execution_context():\n to_float = lambda x: tf.cast(x, tf.float32)\n temperatures = [\n tf.data.Dataset.range(10).map(to_float),\n tf.data.Dataset.range(20).map(to_float),\n tf.data.Dataset.range(30).map(to_float),\n ]\n threshold = 15.0\n result = comp(temperatures, threshold)\n self.assertAlmostEqual(result, 8.333, places=3)\n\n num_clients = 3\n with _execution_context(num_clients):\n to_float = lambda x: tf.cast(x, tf.float32)\n temperatures = [\n tf.data.Dataset.range(10).map(to_float),\n tf.data.Dataset.range(20).map(to_float),\n tf.data.Dataset.range(30).map(to_float),\n ]\n threshold = 15.0\n result = comp(temperatures, threshold)\n self.assertAlmostEqual(result, 8.333, places=3)\n\n def test_changing_cardinalities_across_calls(self):\n\n @computations.federated_computation(type_factory.at_clients(tf.int32))\n def comp(x):\n return x\n\n five_ints = list(range(5))\n ten_ints = list(range(10))\n\n with _execution_context():\n five = comp(five_ints)\n ten = comp(ten_ints)\n\n self.assertEqual(five, five_ints)\n self.assertEqual(ten, ten_ints)\n\n def test_conflicting_cardinalities_within_call(self):\n\n @computations.federated_computation(\n [type_factory.at_clients(tf.int32),\n type_factory.at_clients(tf.int32)])\n def comp(x):\n return x\n\n five_ints = list(range(5))\n ten_ints = list(range(10))\n\n with _execution_context():\n with self.assertRaisesRegex(ValueError, 'Conflicting cardinalities'):\n comp([five_ints, ten_ints])\n\n\nif __name__ == '__main__':\n absltest.main()\n"
]
| [
[
"tensorflow.compat.v1.enable_v2_behavior",
"tensorflow.data.Dataset.range",
"tensorflow.constant",
"numpy.float32",
"tensorflow.greater",
"numpy.int32",
"tensorflow.add",
"tensorflow.cast"
]
]
|
ronghanghu/cmn | [
"85644ad56f8f62d04a5e8636ad3efe9ef7b34705",
"85644ad56f8f62d04a5e8636ad3efe9ef7b34705"
]
| [
"util/im_processing.py",
"models/visual7w_attention_model.py"
]
| [
"from __future__ import absolute_import, division, print_function\n\nimport skimage.transform\nimport numpy as np\n\ndef rectify_bboxes(bboxes, height, width):\n bboxes = np.maximum(bboxes, 0)\n bboxes[:, 2:4] = np.maximum(bboxes[:, 0:2], bboxes[:, 2:4])\n bboxes[:, 0] = np.minimum(bboxes[:, 0], width-1)\n bboxes[:, 1] = np.minimum(bboxes[:, 1], height-1)\n bboxes[:, 2] = np.minimum(bboxes[:, 2], width-1)\n bboxes[:, 3] = np.minimum(bboxes[:, 3], height-1)\n return bboxes\n\ndef resize_and_pad(im, input_h, input_w):\n # Resize and pad im to input_h x input_w size\n im_h, im_w = im.shape[:2]\n scale = min(input_h / im_h, input_w / im_w)\n resized_h = int(np.round(im_h * scale))\n resized_w = int(np.round(im_w * scale))\n pad_h = int(np.floor(input_h - resized_h) / 2)\n pad_w = int(np.floor(input_w - resized_w) / 2)\n\n resized_im = skimage.transform.resize(im, [resized_h, resized_w])\n if im.ndim > 2:\n new_im = np.zeros((input_h, input_w, im.shape[2]), dtype=resized_im.dtype)\n else:\n new_im = np.zeros((input_h, input_w), dtype=resized_im.dtype)\n new_im[pad_h:pad_h+resized_h, pad_w:pad_w+resized_w, ...] = resized_im\n\n return new_im\n\ndef resize_and_crop(im, input_h, input_w):\n # Resize and crop im to input_h x input_w size\n im_h, im_w = im.shape[:2]\n scale = max(input_h / im_h, input_w / im_w)\n resized_h = int(np.round(im_h * scale))\n resized_w = int(np.round(im_w * scale))\n crop_h = int(np.floor(resized_h - input_h) / 2)\n crop_w = int(np.floor(resized_w - input_w) / 2)\n\n resized_im = skimage.transform.resize(im, [resized_h, resized_w])\n if im.ndim > 2:\n new_im = np.zeros((input_h, input_w, im.shape[2]), dtype=resized_im.dtype)\n else:\n new_im = np.zeros((input_h, input_w), dtype=resized_im.dtype)\n new_im[...] = resized_im[crop_h:crop_h+input_h, crop_w:crop_w+input_w, ...]\n\n return new_im\n\ndef crop_bboxes_subtract_mean(im, bboxes, crop_size, image_mean):\n if isinstance(bboxes, list):\n bboxes = np.array(bboxes)\n bboxes = bboxes.reshape((-1, 4))\n\n im = skimage.img_as_ubyte(im)\n num_bbox = bboxes.shape[0]\n imcrop_batch = np.zeros((num_bbox, crop_size, crop_size, 3), dtype=np.float32)\n for n_bbox in range(bboxes.shape[0]):\n xmin, ymin, xmax, ymax = bboxes[n_bbox]\n # crop and resize\n imcrop = im[ymin:ymax+1, xmin:xmax+1, :]\n imcrop_batch[n_bbox, ...] = skimage.img_as_ubyte(\n skimage.transform.resize(imcrop, [crop_size, crop_size]))\n imcrop_batch -= image_mean\n return imcrop_batch\n\ndef bboxes_from_masks(masks):\n if masks.ndim == 2:\n masks = masks[np.newaxis, ...]\n num_mask = masks.shape[0]\n bboxes = np.zeros((num_mask, 4), dtype=np.int32)\n for n_mask in range(num_mask):\n idx = np.nonzero(masks[n_mask])\n xmin, xmax = np.min(idx[1]), np.max(idx[1])\n ymin, ymax = np.min(idx[0]), np.max(idx[0])\n bboxes[n_mask, :] = [xmin, ymin, xmax, ymax]\n return bboxes\n\ndef crop_masks_subtract_mean(im, masks, crop_size, image_mean):\n if masks.ndim == 2:\n masks = masks[np.newaxis, ...]\n num_mask = masks.shape[0]\n\n im = skimage.img_as_ubyte(im)\n bboxes = bboxes_from_masks(masks)\n imcrop_batch = np.zeros((num_mask, crop_size, crop_size, 3), dtype=np.float32)\n for n_mask in range(num_mask):\n xmin, ymin, xmax, ymax = bboxes[n_mask]\n\n # crop and resize\n im_masked = im.copy()\n mask = masks[n_mask, ..., np.newaxis]\n im_masked *= mask\n im_masked += image_mean.astype(np.uint8) * (1 - mask)\n imcrop = im_masked[ymin:ymax+1, xmin:xmax+1, :]\n imcrop_batch[n_mask, ...] = skimage.img_as_ubyte(skimage.transform.resize(imcrop, [224, 224]))\n\n imcrop_batch -= image_mean\n return imcrop_batch\n",
"from models import modules, fastrcnn_vgg_net, lstm_net\n\nimport tensorflow as tf\nfrom tensorflow import convert_to_tensor as to_T\n\ndef visual7w_attbilstm_net(input_batch, bbox_batch1, spatial_batch1,\n bbox_batch2, spatial_batch2, expr_obj, num_vocab, embed_dim, lstm_dim,\n vgg_dropout, lstm_dropout):\n # a sentence is parsed into [expr_obj1, expr_relation, expr_obj2]\n # bbox_batch1 has shape [N_batch*N1, 5] and\n # spatial_batch1 has shape [N_batch, N1, D_spatial] and\n # bbox_batch2 has shape [N2, 5] and\n # spatial_batch2 has shape [1, N2, D_spatial] and\n # expr_obj has shape [T, N_batch]\n # where N1 is the number of choices (= 4 in Visual 7W) and\n # N2 is the number of proposals (~ 300 for RPN in Faster RCNN)\n\n N_batch = tf.shape(spatial_batch1)[0]\n N1 = tf.shape(spatial_batch1)[1]\n N2 = tf.shape(spatial_batch2)[1]\n\n # Extract visual features\n vis_feat1 = fastrcnn_vgg_net.vgg_roi_fc7(input_batch,\n tf.reshape(bbox_batch1, [-1, 5]), \"vgg_local\",\n apply_dropout=vgg_dropout)\n D_vis = vis_feat1.get_shape().as_list()[-1]\n vis_feat1 = tf.reshape(vis_feat1, to_T([N_batch, N1, D_vis]))\n vis_feat1.set_shape([None, None, D_vis])\n\n # Reshape and tile vis_feat2 and spatial_batch2\n vis_feat2 = fastrcnn_vgg_net.vgg_roi_fc7(input_batch,\n tf.reshape(bbox_batch2, [-1, 5]), \"vgg_local\",\n apply_dropout=vgg_dropout, reuse=True)\n vis_feat2 = tf.reshape(vis_feat2, to_T([1, N2, D_vis]))\n vis_feat2 = tf.tile(vis_feat2, to_T([N_batch, 1, 1]))\n vis_feat2.set_shape([None, None, D_vis])\n spatial_batch2 = tf.tile(spatial_batch2, to_T([N_batch, 1, 1]))\n\n # Extract representation using attention\n lang_obj1, lang_obj2, lang_relation = lstm_net.attbilstm(\n expr_obj, \"lstm\", num_vocab=num_vocab, embed_dim=embed_dim,\n lstm_dim=lstm_dim, apply_dropout=lstm_dropout)\n\n # Score for each bounding box matching the first object\n # scores_obj1 has shape [N_batch, N1, 1]\n scores_obj1 = modules.localization_module_batch_score(vis_feat1,\n spatial_batch1, lang_obj1)\n # Score for each bounding box matching the second object\n # scores_obj2 has shape [N_batch, N2, 1]\n scores_obj2 = modules.localization_module_batch_score(vis_feat2,\n spatial_batch2, lang_obj2, reuse=True)\n\n # Scores for each pair of bounding box matching the relationship\n # Tile the scores by broadcasting add\n # scores_rel has shape [N_batch, N1, N2, 1]\n scores_rel = modules.relationship_module_spatial_only_batch_score(\n spatial_batch1, scores_obj1, spatial_batch2, scores_obj2, lang_relation,\n rescale_scores=True)\n # marginal_scores has shape [N_batch, N1, 1]\n tf.add_to_collection(\"s_pair\", scores_rel)\n\n marginal_scores = tf.reduce_max(scores_rel, reduction_indices=2)\n final_scores = tf.reshape(marginal_scores, to_T([N_batch, -1]))\n\n return final_scores\n"
]
| [
[
"numpy.max",
"numpy.array",
"numpy.zeros",
"numpy.minimum",
"numpy.round",
"numpy.min",
"numpy.nonzero",
"numpy.floor",
"numpy.maximum"
],
[
"tensorflow.convert_to_tensor",
"tensorflow.shape",
"tensorflow.reshape",
"tensorflow.reduce_max",
"tensorflow.add_to_collection"
]
]
|
PrathikShirolkar/AutomaticImageColization | [
"981a011cbd32f741668738cafc1dd9ed44965402"
]
| [
"viewFile.py"
]
| [
"from tensorflow.python import pywrap_tensorflow\ncheckpoint_path = 'tmodel.ckpt-100'\n#checkpoint_path = \"deeplab_resnet_init.ckpt\"\nreader = pywrap_tensorflow.NewCheckpointReader(checkpoint_path)\nvar_to_shape_map = reader.get_variable_to_shape_map()\nfor key in var_to_shape_map:\n print(\"tensor_name: \", key)\n print(reader.get_tensor(key))\n"
]
| [
[
"tensorflow.python.pywrap_tensorflow.NewCheckpointReader"
]
]
|
skn123/FAST | [
"d66522260bf65c5ab74d75050131d5a353cbf602"
]
| [
"source/FAST/Examples/Python/convert_video_to_image_frames.py"
]
| [
"## @example convert_video_to_image_frames.py\n# This example loads a video and converts to a stream of image frames and display the\n# individual frames with matplotlib.\n#\n# Note that additional dependencies are required to stream videos in FAST:\n# Linux: sudo apt install ubuntu-restricted-extras libgstreamer1.0-dev libgstreamer-plugins-bad1.0-dev libgstreamer-plugins-base1.0-dev libgstreamer-plugins-good1.0-dev\n# Windows: K-lite codec pack https://codecguide.com/download_kl.htm\nimport fast\nimport matplotlib.pyplot as plt\nimport numpy as np\n\n#fast.Reporter.setGlobalReportMethod(fast.Reporter.COUT) # Uncomment to show debug info\n\nfast.downloadTestDataIfNotExists() # This will download the test data needed to run the example\n\nstreamer = fast.MovieStreamer.New()\nstreamer.setFilename(fast.Config.getTestDataPath() + 'US/sagittal_spine.avi')\n\ndataChannel = streamer.getOutputPort()\nstreamer.update() # Start pipeline\n\nframe_list = []\ncounter = 0\nwhile True:\n frame = dataChannel.getNextImage()\n counter += 1\n if frame.isLastFrame():\n break\n\n # Only show every X frame\n if counter % 20 == 0: frame_list.append((np.asarray(frame), counter))\n\n if len(frame_list) == 9:\n # Display the 9 last frames\n f, axes = plt.subplots(3,3, figsize=(10,10))\n for i in range(3):\n for j in range(3):\n axes[j, i].set_title('Frame: ' + str(frame_list[i + j*3][1]))\n axes[j, i].imshow(frame_list[i + j*3][0][..., 0], cmap='gray')\n plt.show()\n frame_list.clear()\n"
]
| [
[
"matplotlib.pyplot.show",
"numpy.asarray",
"matplotlib.pyplot.subplots"
]
]
|
shankharaj29/tensor2tensor | [
"5a867d031bd493eeb7d2776e1118d1594ff0a623",
"5a867d031bd493eeb7d2776e1118d1594ff0a623",
"5a867d031bd493eeb7d2776e1118d1594ff0a623"
]
| [
"tensor2tensor/models/video/savp.py",
"tensor2tensor/bin/t2t_attack.py",
"tensor2tensor/data_generators/algorithmic.py"
]
| [
"# coding=utf-8\n# Copyright 2018 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\"\"\"Stochastic Adversarial Video Prediction model.\n\nReference: https://arxiv.org/abs/1804.01523\n\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\nimport numbers\nimport numpy as np\n\nfrom tensor2tensor.layers import common_layers\nfrom tensor2tensor.layers import common_video\nfrom tensor2tensor.models.video import savp_params # pylint: disable=unused-import\nfrom tensor2tensor.models.video import sv2p\nfrom tensor2tensor.utils import registry\nfrom tensor2tensor.utils import update_ops_hook\n\nimport tensorflow as tf\n\ngan_losses = tf.contrib.gan.losses.wargs\n\n\nclass NextFrameSavpBase(object):\n \"\"\"Main function for Stochastic Adversarial Video Prediction.\"\"\"\n\n def encoder(self, inputs, n_layers=3):\n \"\"\"Convnet that encodes inputs into mean and std of a gaussian.\n\n Args:\n inputs: 5-D Tensor, shape (batch_size, num_frames, width, height, channels)\n n_layers: Number of layers.\n\n Returns:\n z_mu: Mean of the latent gaussians.\n z_log_var: log(var) of the latent gaussians.\n\n Raises:\n ValueError: If inputs is not a 5-D tensor or not float32.\n \"\"\"\n latent_dims = self.hparams.z_dim\n\n shape_as_list = inputs.shape.as_list()\n if len(shape_as_list) != 5:\n raise ValueError(\"Expected inputs to be a 5-D, got %d\" %\n len(shape_as_list))\n if inputs.dtype != tf.float32:\n raise ValueError(\"Expected dtype tf.float32, got %s\" % inputs.dtype)\n\n # Flatten (N,T,W,H,C) into (NT,W,H,C)\n batch_size, _ = shape_as_list[:2]\n inputs = tf.reshape(inputs, [-1] + list(inputs.shape)[2:])\n n_filters = 64\n rectified = None\n\n # Applies 3 layer conv-net with padding, instance normalization\n # and leaky relu as per the encoder in\n # https://github.com/alexlee-gk/video_prediction\n padding = [[0, 0], [1, 1], [1, 1], [0, 0]]\n for i in range(n_layers):\n with tf.variable_scope(\"layer_%d\" % (i + 1)):\n n_filters *= 2**i\n if i:\n padded = tf.pad(rectified, padding)\n else:\n padded = tf.pad(inputs, padding)\n convolved = tf.layers.conv2d(padded, filters=n_filters, kernel_size=4,\n strides=2, padding=\"VALID\")\n normalized = tf.contrib.layers.instance_norm(convolved)\n rectified = tf.nn.leaky_relu(normalized, alpha=0.2)\n\n # Mean pooling across all spatial dimensions.\n pooled = tf.nn.avg_pool(\n rectified, [1] + rectified.shape[1:3].as_list() + [1],\n strides=[1, 1, 1, 1], padding=\"VALID\")\n squeezed = tf.squeeze(pooled, [1, 2])\n\n # Down-project and output the mean and log of the standard deviation of\n # the latents.\n with tf.variable_scope(\"z_mu\"):\n z_mu = tf.layers.dense(squeezed, latent_dims)\n with tf.variable_scope(\"z_log_sigma_sq\"):\n z_log_var = tf.layers.dense(squeezed, latent_dims)\n z_log_var = tf.clip_by_value(z_log_var, -10, 10)\n\n # Reshape to (batch_size X num_frames X latent_dims)\n z_mu = tf.reshape(z_mu, (batch_size, -1, latent_dims))\n z_log_var = tf.reshape(\n z_log_var, (batch_size, -1, latent_dims))\n return z_mu, z_log_var\n\n def expected_output_shape(self, input_shape, stride, padding, kernel_size):\n return (input_shape + 2*padding - kernel_size) // stride + 1\n\n def get_fc_dimensions(self, strides, kernel_sizes):\n \"\"\"Get expected fully connected shape after a series of convolutions.\"\"\"\n output_height, output_width, _ = self.hparams.problem.frame_shape\n output_steps = self.hparams.video_num_target_frames\n output_shape = np.array([output_steps, output_height, output_width])\n for curr_stride, kernel_size in zip(strides, kernel_sizes):\n output_shape = self.expected_output_shape(\n output_shape, np.array(curr_stride), 1, kernel_size)\n return np.prod(output_shape) * self.hparams.num_discriminator_filters * 8\n\n def discriminator(self, frames):\n \"\"\"3-D SNGAN discriminator.\n\n Args:\n frames: a list of batch-major tensors indexed by time.\n\n Returns:\n logits: 1-D Tensor with shape=batch_size.\n Positive logits imply that the discriminator thinks that it\n belongs to the true class.\n \"\"\"\n ndf = self.hparams.num_discriminator_filters\n frames = tf.stack(frames)\n\n # Switch from time-major axis to batch-major axis.\n frames = common_video.swap_time_and_batch_axes(frames)\n\n # 3-D Conv-net mapping inputs to activations.\n num_outputs = [ndf, ndf*2, ndf*2, ndf*4, ndf*4, ndf*8, ndf*8]\n kernel_sizes = [3, 4, 3, 4, 3, 4, 3]\n strides = [[1, 1, 1], [1, 2, 2], [1, 1, 1], [1, 2, 2], [1, 1, 1],\n [2, 2, 2], [1, 1, 1]]\n\n names = [\"video_sn_conv0_0\", \"video_sn_conv0_1\", \"video_sn_conv1_0\",\n \"video_sn_conv1_1\", \"video_sn_conv2_0\", \"video_sn_conv2_1\",\n \"video_sn_conv3_0\"]\n iterable = zip(num_outputs, kernel_sizes, strides, names)\n activations = frames\n for num_filters, kernel_size, stride, name in iterable:\n activations = self.pad_conv3d_lrelu(activations, num_filters, kernel_size,\n stride, name)\n num_fc_dimensions = self.get_fc_dimensions(strides, kernel_sizes)\n activations = tf.reshape(activations, (-1, num_fc_dimensions))\n return tf.squeeze(tf.layers.dense(activations, 1))\n\n def d_step(self, true_frames, gen_frames):\n \"\"\"Performs the discriminator step in computing the GAN loss.\n\n Applies stop-gradient to the generated frames while computing the\n discriminator loss to make sure that the gradients are not back-propagated\n to the generator. This makes sure that only the discriminator is updated.\n\n Args:\n true_frames: True outputs\n gen_frames: Generated frames.\n Returns:\n d_loss: Loss component due to the discriminator.\n \"\"\"\n hparam_to_disc_loss = {\n \"least_squares\": gan_losses.least_squares_discriminator_loss,\n \"cross_entropy\": gan_losses.modified_discriminator_loss,\n \"wasserstein\": gan_losses.wasserstein_discriminator_loss}\n\n # Concat across batch-axis.\n _, batch_size, _, _, _ = common_layers.shape_list(true_frames)\n all_frames = tf.concat(\n [true_frames, tf.stop_gradient(gen_frames)], axis=1)\n\n all_logits = self.discriminator(all_frames)\n true_logits, fake_logits_stop = \\\n all_logits[:batch_size], all_logits[batch_size:]\n mean_true_logits = tf.reduce_mean(true_logits)\n tf.summary.scalar(\"mean_true_logits\", mean_true_logits)\n\n mean_fake_logits_stop = tf.reduce_mean(fake_logits_stop)\n tf.summary.scalar(\"mean_fake_logits_stop\", mean_fake_logits_stop)\n\n discriminator_loss_func = hparam_to_disc_loss[self.hparams.gan_loss]\n gan_d_loss = discriminator_loss_func(\n discriminator_real_outputs=true_logits,\n discriminator_gen_outputs=fake_logits_stop,\n add_summaries=True)\n return gan_d_loss, true_logits, fake_logits_stop\n\n def g_step(self, gen_frames, fake_logits_stop):\n \"\"\"Performs the generator step in computing the GAN loss.\n\n Args:\n gen_frames: Generated frames\n fake_logits_stop: Logits corresponding to the generated frames as per\n the discriminator. Assumed to have a stop-gradient term.\n Returns:\n gan_g_loss_pos_d: Loss.\n gan_g_loss_neg_d: -gan_g_loss_pos_d but with a stop gradient on generator.\n \"\"\"\n hparam_to_gen_loss = {\n \"least_squares\": gan_losses.least_squares_generator_loss,\n \"cross_entropy\": gan_losses.modified_generator_loss,\n \"wasserstein\": gan_losses.wasserstein_generator_loss\n }\n\n fake_logits = self.discriminator(gen_frames)\n mean_fake_logits = tf.reduce_mean(fake_logits)\n tf.summary.scalar(\"mean_fake_logits\", mean_fake_logits)\n\n # Generator loss.\n # Using gan_g_loss_pos_d updates the discriminator as well.\n # To avoid this add gan_g_loss_neg_d = -gan_g_loss_pos_d\n # but with stop gradient on the generator.\n # This makes sure that the net gradient on the discriminator is zero and\n # net-gradient on the generator is just due to the gan_g_loss_pos_d.\n generator_loss_func = hparam_to_gen_loss[self.hparams.gan_loss]\n gan_g_loss_pos_d = generator_loss_func(\n discriminator_gen_outputs=fake_logits, add_summaries=True)\n gan_g_loss_neg_d = -generator_loss_func(\n discriminator_gen_outputs=fake_logits_stop, add_summaries=True)\n return gan_g_loss_pos_d, gan_g_loss_neg_d\n\n def get_gan_loss(self, true_frames, gen_frames, name):\n \"\"\"Get the discriminator + generator loss at every step.\n\n This performs an 1:1 update of the discriminator and generator at every\n step.\n\n Args:\n true_frames: 5-D Tensor of shape (num_steps, batch_size, H, W, C)\n Assumed to be ground truth.\n gen_frames: 5-D Tensor of shape (num_steps, batch_size, H, W, C)\n Assumed to be fake.\n name: discriminator scope.\n Returns:\n loss: 0-D Tensor, with d_loss + g_loss\n \"\"\"\n # D - STEP\n with tf.variable_scope(\"%s_discriminator\" % name, reuse=tf.AUTO_REUSE):\n gan_d_loss, _, fake_logits_stop = self.d_step(\n true_frames, gen_frames)\n\n # G - STEP\n with tf.variable_scope(\"%s_discriminator\" % name, reuse=True):\n gan_g_loss_pos_d, gan_g_loss_neg_d = self.g_step(\n gen_frames, fake_logits_stop)\n gan_g_loss = gan_g_loss_pos_d + gan_g_loss_neg_d\n tf.summary.scalar(\"gan_loss_%s\" % name, gan_g_loss_pos_d + gan_d_loss)\n\n if self.hparams.gan_optimization == \"joint\":\n gan_loss = gan_g_loss + gan_d_loss\n else:\n curr_step = self.get_iteration_num()\n gan_loss = tf.cond(\n tf.logical_not(curr_step % 2 == 0), lambda: gan_g_loss,\n lambda: gan_d_loss)\n return gan_loss\n\n def get_extra_loss(self, latent_means=None, latent_stds=None,\n true_frames=None, gen_frames=None):\n \"\"\"Gets extra loss from VAE and GAN.\"\"\"\n if not self.is_training:\n return 0.0\n\n vae_loss, d_vae_loss, d_gan_loss = 0.0, 0.0, 0.0\n # Use sv2p's KL divergence computation.\n if self.hparams.use_vae:\n vae_loss = super(NextFrameSavpBase, self).get_extra_loss(\n latent_means=latent_means, latent_stds=latent_stds)\n\n if self.hparams.use_gan:\n # Strip out the first context_frames for the true_frames\n # Strip out the first context_frames - 1 for the gen_frames\n context_frames = self.hparams.video_num_input_frames\n true_frames = tf.stack(\n tf.unstack(true_frames, axis=0)[context_frames:])\n\n # discriminator for VAE.\n if self.hparams.use_vae:\n gen_enc_frames = tf.stack(\n tf.unstack(gen_frames, axis=0)[context_frames-1:])\n d_vae_loss = self.get_gan_loss(true_frames, gen_enc_frames, name=\"vae\")\n\n # discriminator for GAN.\n gen_prior_frames = tf.stack(\n tf.unstack(self.gen_prior_video, axis=0)[context_frames-1:])\n d_gan_loss = self.get_gan_loss(true_frames, gen_prior_frames, name=\"gan\")\n\n return (\n vae_loss + self.hparams.gan_loss_multiplier * d_gan_loss +\n self.hparams.gan_vae_loss_multiplier * d_vae_loss)\n\n def pad_conv3d_lrelu(self, activations, n_filters, kernel_size, strides,\n scope):\n \"\"\"Pad, apply 3-D convolution and leaky relu.\"\"\"\n padding = [[0, 0], [1, 1], [1, 1], [1, 1], [0, 0]]\n\n # tf.nn.conv3d accepts a list of 5 values for strides\n # with first and last value equal to 1\n if isinstance(strides, numbers.Integral):\n strides = [strides] * 3\n strides = [1] + strides + [1]\n\n # Filter_shape = [K, K, K, num_input, num_output]\n filter_shape = (\n [kernel_size]*3 + activations.shape[-1:].as_list() + [n_filters])\n\n with tf.variable_scope(scope, reuse=tf.AUTO_REUSE):\n conv_filter = tf.get_variable(\n \"conv_filter\", shape=filter_shape,\n initializer=tf.truncated_normal_initializer(stddev=0.02))\n\n if self.hparams.use_spectral_norm:\n conv_filter, assign_op = common_layers.apply_spectral_norm(conv_filter)\n if self.is_training:\n tf.add_to_collection(tf.GraphKeys.UPDATE_OPS, assign_op)\n\n padded = tf.pad(activations, padding)\n convolved = tf.nn.conv3d(\n padded, conv_filter, strides=strides, padding=\"VALID\")\n rectified = tf.nn.leaky_relu(convolved, alpha=0.2)\n return rectified\n\n @staticmethod\n def train_hooks(hook_context):\n del hook_context\n return [update_ops_hook.UpdateOpsHook()]\n\n\[email protected]_model\nclass NextFrameSAVP(NextFrameSavpBase, sv2p.NextFrameSv2pLegacy):\n \"\"\"Stochastic Adversarial Video Prediction.\"\"\"\n\n def construct_model(self, images, actions, rewards):\n \"\"\"Model that takes in images and returns predictions.\n\n Args:\n images: list of 4-D Tensors indexed by time.\n (batch_size, width, height, channels)\n actions: list of action tensors\n each action should be in the shape ?x1xZ\n rewards: list of reward tensors\n each reward should be in the shape ?x1xZ\n\n Returns:\n video: list of 4-D predicted frames.\n all_rewards: predicted rewards.\n latent_means: list of gaussian means conditioned on the input at\n every frame.\n latent_stds: list of gaussian stds conditioned on the input at\n every frame.\n\n Raises:\n ValueError: If not exactly one of self.hparams.vae or self.hparams.gan\n is set to True.\n \"\"\"\n if not self.hparams.use_vae and not self.hparams.use_gan:\n raise ValueError(\"Set at least one of use_vae or use_gan to be True\")\n if self.hparams.gan_optimization not in [\"joint\", \"sequential\"]:\n raise ValueError(\"self.hparams.gan_optimization should be either joint \"\n \"or sequential got %s\" % self.hparams.gan_optimization)\n\n images = tf.unstack(images, axis=0)\n actions = tf.unstack(actions, axis=0)\n rewards = tf.unstack(rewards, axis=0)\n\n latent_dims = self.hparams.z_dim\n context_frames = self.hparams.video_num_input_frames\n seq_len = len(images)\n input_shape = common_layers.shape_list(images[0])\n batch_size = input_shape[0]\n\n # Model does not support reward-conditioned frame generation.\n fake_rewards = rewards[:-1]\n\n # Concatenate x_{t-1} and x_{t} along depth and encode it to\n # produce the mean and standard deviation of z_{t-1}\n image_pairs = tf.concat([images[:seq_len - 1],\n images[1:seq_len]], axis=-1)\n\n z_mu, z_log_sigma_sq = self.encoder(image_pairs)\n # Unstack z_mu and z_log_sigma_sq along the time dimension.\n z_mu = tf.unstack(z_mu, axis=0)\n z_log_sigma_sq = tf.unstack(z_log_sigma_sq, axis=0)\n iterable = zip(images[:-1], actions[:-1], fake_rewards,\n z_mu, z_log_sigma_sq)\n\n # Initialize LSTM State\n lstm_state = [None] * 7\n gen_cond_video, gen_prior_video, all_rewards, latent_means, latent_stds = \\\n [], [], [], [], []\n pred_image = tf.zeros_like(images[0])\n prior_latent_state, cond_latent_state = None, None\n train_mode = self.hparams.mode == tf.estimator.ModeKeys.TRAIN\n\n # Create scheduled sampling function\n ss_func = self.get_scheduled_sample_func(batch_size)\n\n with tf.variable_scope(\"prediction\", reuse=tf.AUTO_REUSE):\n\n for step, (image, action, reward, mu, log_sigma_sq) in enumerate(iterable): # pylint:disable=line-too-long\n # Sample latents using a gaussian centered at conditional mu and std.\n latent = common_video.get_gaussian_tensor(mu, log_sigma_sq)\n\n # Sample prior latents from isotropic normal distribution.\n prior_latent = tf.random_normal(tf.shape(latent), dtype=tf.float32)\n\n # LSTM that encodes correlations between conditional latents.\n # Pg 22 in https://arxiv.org/pdf/1804.01523.pdf\n enc_cond_latent, cond_latent_state = common_video.basic_lstm(\n latent, cond_latent_state, latent_dims, name=\"cond_latent\")\n\n # LSTM that encodes correlations between prior latents.\n enc_prior_latent, prior_latent_state = common_video.basic_lstm(\n prior_latent, prior_latent_state, latent_dims, name=\"prior_latent\")\n\n # Scheduled Sampling\n done_warm_start = step > context_frames - 1\n groundtruth_items = [image]\n generated_items = [pred_image]\n input_image, = self.get_scheduled_sample_inputs(\n done_warm_start, groundtruth_items, generated_items, ss_func)\n\n all_latents = tf.concat([enc_cond_latent, enc_prior_latent], axis=0)\n all_image = tf.concat([input_image, input_image], axis=0)\n all_action = tf.concat([action, action], axis=0)\n all_rewards = tf.concat([reward, reward], axis=0)\n\n all_pred_images, lstm_state, _ = self.construct_predictive_tower(\n all_image, all_rewards, all_action, lstm_state, all_latents,\n concat_latent=True)\n\n cond_pred_images, prior_pred_images = \\\n all_pred_images[:batch_size], all_pred_images[batch_size:]\n\n if train_mode and self.hparams.use_vae:\n pred_image = cond_pred_images\n else:\n pred_image = prior_pred_images\n\n gen_cond_video.append(cond_pred_images)\n gen_prior_video.append(prior_pred_images)\n latent_means.append(mu)\n latent_stds.append(log_sigma_sq)\n\n gen_cond_video = tf.stack(gen_cond_video, axis=0)\n self.gen_prior_video = tf.stack(gen_prior_video, axis=0)\n fake_rewards = tf.stack(fake_rewards, axis=0)\n\n if train_mode and self.hparams.use_vae:\n return gen_cond_video, fake_rewards, latent_means, latent_stds\n else:\n return self.gen_prior_video, fake_rewards, latent_means, latent_stds\n\n\[email protected]_model\nclass NextFrameSavpRl(NextFrameSavpBase, sv2p.NextFrameSv2p):\n \"\"\"Stochastic Adversarial Video Prediction for RL pipeline.\"\"\"\n\n def video_features(\n self, all_frames, all_actions, all_rewards, all_raw_frames):\n \"\"\"No video wide feature.\"\"\"\n del all_actions, all_rewards, all_raw_frames\n # Concatenate x_{t-1} and x_{t} along depth and encode it to\n # produce the mean and standard deviation of z_{t-1}\n seq_len = len(all_frames)\n image_pairs = tf.concat([all_frames[:seq_len-1],\n all_frames[1:seq_len]], axis=-1)\n z_mu, z_log_sigma_sq = self.encoder(image_pairs)\n # Unstack z_mu and z_log_sigma_sq along the time dimension.\n z_mu = tf.unstack(z_mu, axis=0)\n z_log_sigma_sq = tf.unstack(z_log_sigma_sq, axis=0)\n return [z_mu, z_log_sigma_sq]\n\n def video_extra_loss(self, frames_predicted, frames_target,\n internal_states, video_features):\n\n if not self.is_training:\n return 0.0\n\n latent_means, latent_stds = video_features\n true_frames, gen_frames = frames_target, frames_predicted\n\n loss = super(NextFrameSavpRl, self).get_extra_loss(\n latent_means=latent_means, latent_stds=latent_stds,\n true_frames=true_frames, gen_frames=gen_frames)\n return loss\n\n def next_frame(self, frames, actions, rewards, target_frame,\n internal_states, video_features):\n del target_frame\n\n if not self.hparams.use_vae or self.hparams.use_gan:\n raise NotImplementedError(\"Only supporting VAE for now.\")\n\n if self.has_pred_actions or self.has_values:\n raise NotImplementedError(\"Parameter sharing with policy not supported.\")\n\n image, action, reward = frames[0], actions[0], rewards[0]\n latent_dims = self.hparams.z_dim\n batch_size = common_layers.shape_list(image)[0]\n\n if internal_states is None:\n # Initialize LSTM State\n frame_index = 0\n lstm_state = [None] * 7\n cond_latent_state, prior_latent_state = None, None\n gen_prior_video = []\n else:\n (frame_index, lstm_state, cond_latent_state,\n prior_latent_state, gen_prior_video) = internal_states\n\n z_mu, log_sigma_sq = video_features\n z_mu, log_sigma_sq = z_mu[frame_index], log_sigma_sq[frame_index]\n\n # Sample latents using a gaussian centered at conditional mu and std.\n latent = common_video.get_gaussian_tensor(z_mu, log_sigma_sq)\n\n # Sample prior latents from isotropic normal distribution.\n prior_latent = tf.random_normal(tf.shape(latent), dtype=tf.float32)\n\n # # LSTM that encodes correlations between conditional latents.\n # # Pg 22 in https://arxiv.org/pdf/1804.01523.pdf\n enc_cond_latent, cond_latent_state = common_video.basic_lstm(\n latent, cond_latent_state, latent_dims, name=\"cond_latent\")\n\n # LSTM that encodes correlations between prior latents.\n enc_prior_latent, prior_latent_state = common_video.basic_lstm(\n prior_latent, prior_latent_state, latent_dims, name=\"prior_latent\")\n\n all_latents = tf.concat([enc_cond_latent, enc_prior_latent], axis=0)\n all_image = tf.concat([image, image], 0)\n all_action = tf.concat([action, action], 0) if self.has_actions else None\n\n all_pred_images, lstm_state = self.construct_predictive_tower(\n all_image, None, all_action, lstm_state, all_latents,\n concat_latent=True)\n\n cond_pred_images, prior_pred_images = \\\n all_pred_images[:batch_size], all_pred_images[batch_size:]\n\n if self.is_training and self.hparams.use_vae:\n pred_image = cond_pred_images\n else:\n pred_image = prior_pred_images\n\n gen_prior_video.append(prior_pred_images)\n internal_states = (frame_index + 1, lstm_state, cond_latent_state,\n prior_latent_state, gen_prior_video)\n\n if not self.has_rewards:\n return pred_image, None, 0.0, internal_states\n\n pred_reward = self.reward_prediction(\n pred_image, action, reward, latent)\n return pred_image, pred_reward, None, None, 0.0, internal_states\n",
"# coding=utf-8\n# Copyright 2018 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\nr\"\"\"Adversarially attack a model.\n\nThis script adversarially attacks a model and evaluates accuracy at various\n epsilons.\n\nParams such as which epsilons to evaluate at and the attack algorithm are\n specified by attack_params, see models/resnet.py for examples.\n\n--ignore_incorrect will only attack those examples that are already correctly\n classified by the model.\n\n--surrogate_attack will attack a model (A) and evaluate adversarial examples for\n A on a different model (B).\n\nExample run:\n- train a resnet on cifar10:\n bin/t2t_trainer.py --problem=image_cifar10 --hparams_set=resnet_cifar_32 \\\n --model=resnet\n\n- evaluate robustness using the FGSM attack:\n bin/t2t_attack.py --attack_params_set=resnet_fgsm --problem=image_cifar10\\\n --hparams_set=resnet_cifar_32 --model=resnet\n\"\"\"\n\nimport os\n\nfrom tensor2tensor.bin import t2t_trainer\nfrom tensor2tensor.data_generators import problem as problem_lib # pylint: disable=unused-import\nfrom tensor2tensor.utils import adv_attack_utils\nfrom tensor2tensor.utils import cloud_mlengine\nfrom tensor2tensor.utils import registry\nfrom tensor2tensor.utils import t2t_model\nfrom tensor2tensor.utils import trainer_lib\nfrom tensor2tensor.utils import usr_dir\n\nimport tensorflow as tf\n\nflags = tf.flags\nFLAGS = flags.FLAGS\n\n# See flags.py for additional command-line flags.\nflags.DEFINE_string(\"attack_params_set\", None,\n \"Which attack parameters to use.\")\nflags.DEFINE_boolean(\"surrogate_attack\", False,\n \"Perform an attack on a surrogate model.\")\nflags.DEFINE_string(\"surrogate_model\", None, \"Surrogate model to attack.\")\nflags.DEFINE_string(\"surrogate_hparams_set\", None,\n \"Surrogate model's hyperparameter set.\")\nflags.DEFINE_string(\"surrogate_output_dir\", None,\n \"Directory storing surrogate model's weights.\")\nflags.DEFINE_boolean(\n \"ignore_incorrect\", False, \"Ignore examples that are \"\n \"incorrectly classified to begin with.\")\n\n\ndef create_attack_params():\n return registry.attack_params(FLAGS.attack_params_set)\n\n\ndef create_attack(attack):\n return registry.attack(attack)\n\n\ndef create_surrogate_hparams():\n return trainer_lib.create_hparams(FLAGS.surrogate_hparams_set, None)\n\n\ndef create_surrogate_run_config(hp):\n \"\"\"Create a run config.\n\n Args:\n hp: model hyperparameters\n Returns:\n a run config\n \"\"\"\n save_ckpt_steps = max(FLAGS.iterations_per_loop, FLAGS.local_eval_frequency)\n save_ckpt_secs = FLAGS.save_checkpoints_secs or None\n if save_ckpt_secs:\n save_ckpt_steps = None\n assert FLAGS.surrogate_output_dir\n # the various custom getters we have written do not play well together yet.\n # TODO(noam): ask rsepassi for help here.\n daisy_chain_variables = (\n hp.daisy_chain_variables and hp.activation_dtype == \"float32\" and\n hp.weight_dtype == \"float32\")\n return trainer_lib.create_run_config(\n model_name=FLAGS.model,\n model_dir=os.path.expanduser(FLAGS.surrogate_output_dir),\n master=FLAGS.master,\n iterations_per_loop=FLAGS.iterations_per_loop,\n num_shards=FLAGS.tpu_num_shards,\n log_device_placement=FLAGS.log_device_placement,\n save_checkpoints_steps=save_ckpt_steps,\n save_checkpoints_secs=save_ckpt_secs,\n keep_checkpoint_max=FLAGS.keep_checkpoint_max,\n keep_checkpoint_every_n_hours=FLAGS.keep_checkpoint_every_n_hours,\n num_gpus=FLAGS.worker_gpu,\n gpu_order=FLAGS.gpu_order,\n num_async_replicas=FLAGS.worker_replicas,\n gpu_mem_fraction=FLAGS.worker_gpu_memory_fraction,\n enable_graph_rewriter=FLAGS.enable_graph_rewriter,\n use_tpu=FLAGS.use_tpu,\n schedule=FLAGS.schedule,\n no_data_parallelism=hp.no_data_parallelism,\n daisy_chain_variables=daisy_chain_variables,\n ps_replicas=FLAGS.ps_replicas,\n ps_job=FLAGS.ps_job,\n ps_gpu=FLAGS.ps_gpu,\n sync=FLAGS.sync,\n worker_id=FLAGS.worker_id,\n worker_job=FLAGS.worker_job,\n random_seed=FLAGS.random_seed,\n tpu_infeed_sleep_secs=FLAGS.tpu_infeed_sleep_secs,\n inter_op_parallelism_threads=FLAGS.inter_op_parallelism_threads,\n log_step_count_steps=FLAGS.log_step_count_steps,\n intra_op_parallelism_threads=FLAGS.intra_op_parallelism_threads)\n\n\ndef prepare_data(problem, hparams, params, config):\n \"\"\"Construct input pipeline.\"\"\"\n input_fn = problem.make_estimator_input_fn(\n tf.estimator.ModeKeys.EVAL, hparams, force_repeat=True)\n dataset = input_fn(params, config)\n features, _ = dataset.make_one_shot_iterator().get_next()\n inputs, labels = features[\"targets\"], features[\"inputs\"]\n inputs = tf.to_float(inputs)\n input_shape = inputs.shape.as_list()\n inputs = tf.reshape(inputs, [hparams.batch_size] + input_shape[1:])\n labels = tf.reshape(labels, [hparams.batch_size])\n return inputs, labels, features\n\n\ndef main(argv):\n tf.logging.set_verbosity(tf.logging.INFO)\n trainer_lib.set_random_seed(FLAGS.random_seed)\n usr_dir.import_usr_dir(FLAGS.t2t_usr_dir)\n t2t_trainer.maybe_log_registry_and_exit()\n\n\n if FLAGS.cloud_mlengine:\n cloud_mlengine.launch()\n return\n\n if FLAGS.generate_data:\n t2t_trainer.generate_data()\n\n if cloud_mlengine.job_dir():\n FLAGS.output_dir = cloud_mlengine.job_dir()\n\n if argv:\n t2t_trainer.set_hparams_from_args(argv[1:])\n\n if FLAGS.surrogate_attack:\n tf.logging.warn(\"Performing surrogate model attack.\")\n sur_hparams = create_surrogate_hparams()\n trainer_lib.add_problem_hparams(sur_hparams, FLAGS.problem)\n\n hparams = t2t_trainer.create_hparams()\n trainer_lib.add_problem_hparams(hparams, FLAGS.problem)\n\n attack_params = create_attack_params()\n attack_params.add_hparam(attack_params.epsilon_name, 0.0)\n\n if FLAGS.surrogate_attack:\n sur_config = create_surrogate_run_config(sur_hparams)\n config = t2t_trainer.create_run_config(hparams)\n params = {\n \"batch_size\": hparams.batch_size,\n \"use_tpu\": FLAGS.use_tpu,\n }\n\n # add \"_rev\" as a hack to avoid image standardization\n problem = registry.problem(FLAGS.problem + \"_rev\")\n\n inputs, labels, features = prepare_data(problem, hparams, params, config)\n\n sess = tf.Session()\n\n if FLAGS.surrogate_attack:\n sur_model_fn = t2t_model.T2TModel.make_estimator_model_fn(\n FLAGS.surrogate_model, sur_hparams, use_tpu=FLAGS.use_tpu)\n sur_ch_model = adv_attack_utils.T2TAttackModel(\n sur_model_fn, features, params, sur_config, scope=\"surrogate\")\n # Dummy call to construct graph\n sur_ch_model.get_probs(inputs)\n\n checkpoint_path = os.path.expanduser(FLAGS.surrogate_output_dir)\n tf.train.init_from_checkpoint(\n tf.train.latest_checkpoint(checkpoint_path), {\"/\": \"surrogate/\"})\n sess.run(tf.global_variables_initializer())\n\n other_vars = set(tf.global_variables())\n\n model_fn = t2t_model.T2TModel.make_estimator_model_fn(\n FLAGS.model, hparams)\n ch_model = adv_attack_utils.T2TAttackModel(model_fn, features, params, config)\n\n acc_mask = None\n probs = ch_model.get_probs(inputs)\n if FLAGS.ignore_incorrect:\n preds = tf.argmax(probs, -1, output_type=labels.dtype)\n preds = tf.reshape(preds, labels.shape)\n acc_mask = tf.to_float(tf.equal(labels, preds))\n one_hot_labels = tf.one_hot(labels, probs.shape[-1])\n\n if FLAGS.surrogate_attack:\n attack = create_attack(attack_params.attack)(sur_ch_model, sess=sess)\n else:\n attack = create_attack(attack_params.attack)(ch_model, sess=sess)\n\n new_vars = set(tf.global_variables()) - other_vars\n\n # Restore weights\n saver = tf.train.Saver(new_vars)\n checkpoint_path = os.path.expanduser(FLAGS.output_dir)\n saver.restore(sess, tf.train.latest_checkpoint(checkpoint_path))\n\n # reuse variables\n tf.get_variable_scope().reuse_variables()\n\n def compute_accuracy(x, l, mask):\n \"\"\"Compute model accuracy.\"\"\"\n preds = ch_model.get_probs(x)\n preds = tf.squeeze(preds)\n preds = tf.argmax(preds, -1, output_type=l.dtype)\n\n _, acc_update_op = tf.metrics.accuracy(l, preds, weights=mask)\n\n if FLAGS.surrogate_attack:\n preds = sur_ch_model.get_probs(x)\n preds = tf.squeeze(preds)\n preds = tf.argmax(preds, -1, output_type=l.dtype)\n acc_update_op = tf.tuple((acc_update_op,\n tf.metrics.accuracy(l, preds, weights=mask)[1]))\n\n sess.run(tf.initialize_local_variables())\n for i in range(FLAGS.eval_steps):\n tf.logging.info(\n \"\\tEvaluating batch [%d / %d]\" % (i + 1, FLAGS.eval_steps))\n acc = sess.run(acc_update_op)\n if FLAGS.surrogate_attack:\n tf.logging.info(\"\\tFinal acc: (%.4f, %.4f)\" % (acc[0], acc[1]))\n else:\n tf.logging.info(\"\\tFinal acc: %.4f\" % acc)\n return acc\n\n epsilon_acc_pairs = []\n for epsilon in attack_params.attack_epsilons:\n tf.logging.info(\"Attacking @ eps=%.4f\" % epsilon)\n attack_params.set_hparam(attack_params.epsilon_name, epsilon)\n adv_x = attack.generate(inputs, y=one_hot_labels, **attack_params.values())\n acc = compute_accuracy(adv_x, labels, acc_mask)\n epsilon_acc_pairs.append((epsilon, acc))\n\n for epsilon, acc in epsilon_acc_pairs:\n if FLAGS.surrogate_attack:\n tf.logging.info(\n \"Accuracy @ eps=%.4f: (%.4f, %.4f)\" % (epsilon, acc[0], acc[1]))\n else:\n tf.logging.info(\"Accuracy @ eps=%.4f: %.4f\" % (epsilon, acc))\n\n\nif __name__ == \"__main__\":\n tf.logging.set_verbosity(tf.logging.INFO)\n tf.app.run()\n",
"# coding=utf-8\n# Copyright 2018 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\"\"\"Algorithmic data generators.\"\"\"\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport os\nimport shutil\nimport numpy as np\nfrom six.moves import range # pylint: disable=redefined-builtin\nfrom tensor2tensor.data_generators import generator_utils as utils\nfrom tensor2tensor.data_generators import problem\nfrom tensor2tensor.data_generators import text_encoder\nfrom tensor2tensor.layers import modalities\nfrom tensor2tensor.utils import metrics\nfrom tensor2tensor.utils import registry\nimport tensorflow as tf\n\n\nclass AlgorithmicProblem(problem.Problem):\n \"\"\"Base class for algorithmic problems.\"\"\"\n\n @property\n def num_symbols(self):\n raise NotImplementedError()\n\n def generator(self, nbr_symbols, max_length, nbr_cases):\n \"\"\"Generates the data.\"\"\"\n raise NotImplementedError()\n\n @property\n def train_length(self):\n return 40\n\n @property\n def dev_length(self):\n return 400\n\n @property\n def train_size(self):\n return 100000\n\n @property\n def dev_size(self):\n return 10000\n\n @property\n def num_shards(self):\n return 10\n\n def generate_data(self, data_dir, _, task_id=-1):\n\n def generator_eos(nbr_symbols, max_length, nbr_cases):\n \"\"\"Shift by NUM_RESERVED_IDS and append EOS token.\"\"\"\n for case in self.generator(nbr_symbols, max_length, nbr_cases):\n new_case = {}\n for feature in case:\n new_case[feature] = [\n i + text_encoder.NUM_RESERVED_TOKENS for i in case[feature]\n ] + [text_encoder.EOS_ID]\n yield new_case\n\n utils.generate_dataset_and_shuffle(\n generator_eos(self.num_symbols, self.train_length, self.train_size),\n self.training_filepaths(data_dir, self.num_shards, shuffled=True),\n generator_eos(self.num_symbols, self.dev_length, self.dev_size),\n self.dev_filepaths(data_dir, 1, shuffled=True),\n shuffle=False)\n\n def hparams(self, defaults, unused_model_hparams):\n p = defaults\n vocab_size = self.num_symbols + text_encoder.NUM_RESERVED_TOKENS\n p.modality = {\"inputs\": modalities.ModalityType.SYMBOL,\n \"targets\": modalities.ModalityType.SYMBOL}\n p.vocab_size = {\"inputs\": vocab_size,\n \"targets\": vocab_size}\n p.input_space_id = problem.SpaceID.DIGIT_0\n p.target_space_id = problem.SpaceID.DIGIT_1\n\n\[email protected]_problem\nclass AlgorithmicIdentityBinary40(AlgorithmicProblem):\n \"\"\"Problem spec for algorithmic binary identity task.\"\"\"\n\n @property\n def num_symbols(self):\n return 2\n\n def generator(self, nbr_symbols, max_length, nbr_cases):\n \"\"\"Generator for the identity (copy) task on sequences of symbols.\n\n The length of the sequence is drawn uniformly at random from [1, max_length]\n and then symbols are drawn uniformly at random from [0, nbr_symbols) until\n nbr_cases sequences have been produced.\n\n Args:\n nbr_symbols: number of symbols to use in each sequence.\n max_length: integer, maximum length of sequences to generate.\n nbr_cases: the number of cases to generate.\n\n Yields:\n A dictionary {\"inputs\": input-list, \"targets\": target-list} where\n input-list and target-list are the same.\n \"\"\"\n for _ in range(nbr_cases):\n l = np.random.randint(max_length) + 1\n inputs = [np.random.randint(nbr_symbols) for _ in range(l)]\n yield {\"inputs\": inputs, \"targets\": inputs}\n\n\[email protected]_problem\nclass AlgorithmicIdentityDecimal40(AlgorithmicIdentityBinary40):\n \"\"\"Problem spec for algorithmic decimal identity task.\"\"\"\n\n @property\n def num_symbols(self):\n return 10\n\n\[email protected]_problem\nclass AlgorithmicShiftDecimal40(AlgorithmicProblem):\n \"\"\"Problem spec for algorithmic decimal shift task.\"\"\"\n\n @property\n def num_symbols(self):\n return 20\n\n def generator(self, nbr_symbols, max_length, nbr_cases):\n \"\"\"Generator for the shift task on sequences of symbols.\n\n The length of the sequence is drawn uniformly at random from [1, max_length]\n and then symbols are drawn uniformly at random from [0, nbr_symbols - shift]\n until nbr_cases sequences have been produced (output[i] = input[i] + shift).\n\n Args:\n nbr_symbols: number of symbols to use in each sequence (input + output).\n max_length: integer, maximum length of sequences to generate.\n nbr_cases: the number of cases to generate.\n\n Yields:\n A dictionary {\"inputs\": input-list, \"targets\": target-list} where\n target-list[i] = input-list[i] + shift.\n \"\"\"\n shift = 10\n for _ in range(nbr_cases):\n l = np.random.randint(max_length) + 1\n inputs = [np.random.randint(nbr_symbols - shift) for _ in range(l)]\n yield {\"inputs\": inputs, \"targets\": [i + shift for i in inputs]}\n\n @property\n def dev_length(self):\n return 80\n\n\[email protected]_problem\nclass AlgorithmicReverseBinary40(AlgorithmicProblem):\n \"\"\"Problem spec for algorithmic binary reversing task.\"\"\"\n\n @property\n def num_symbols(self):\n return 2\n\n def generator(self, nbr_symbols, max_length, nbr_cases):\n \"\"\"Generator for the reversing task on sequences of symbols.\n\n The length of the sequence is drawn uniformly at random from [1, max_length]\n and then symbols are drawn uniformly at random from [0, nbr_symbols) until\n nbr_cases sequences have been produced.\n\n Args:\n nbr_symbols: number of symbols to use in each sequence.\n max_length: integer, maximum length of sequences to generate.\n nbr_cases: the number of cases to generate.\n\n Yields:\n A dictionary {\"inputs\": input-list, \"targets\": target-list} where\n target-list is input-list reversed.\n \"\"\"\n for _ in range(nbr_cases):\n l = np.random.randint(max_length) + 1\n inputs = [np.random.randint(nbr_symbols) for _ in range(l)]\n yield {\"inputs\": inputs, \"targets\": list(reversed(inputs))}\n\n\[email protected]_problem\nclass AlgorithmicReverseDecimal40(AlgorithmicReverseBinary40):\n \"\"\"Problem spec for algorithmic decimal reversing task.\"\"\"\n\n @property\n def num_symbols(self):\n return 10\n\n\ndef zipf_distribution(nbr_symbols, alpha):\n \"\"\"Helper function: Create a Zipf distribution.\n\n Args:\n nbr_symbols: number of symbols to use in the distribution.\n alpha: float, Zipf's Law Distribution parameter. Default = 1.5.\n Usually for modelling natural text distribution is in\n the range [1.1-1.6].\n\n Returns:\n distr_map: list of float, Zipf's distribution over nbr_symbols.\n\n \"\"\"\n tmp = np.power(np.arange(1, nbr_symbols + 1), -alpha)\n zeta = np.r_[0.0, np.cumsum(tmp)]\n return [x / zeta[-1] for x in zeta]\n\n\ndef zipf_random_sample(distr_map, sample_len):\n \"\"\"Helper function: Generate a random Zipf sample of given length.\n\n Args:\n distr_map: list of float, Zipf's distribution over nbr_symbols.\n sample_len: integer, length of sequence to generate.\n\n Returns:\n sample: list of integer, Zipf's random sample over nbr_symbols.\n\n \"\"\"\n u = np.random.random(sample_len)\n # Random produces values in range [0.0,1.0); even if it is almost\n # improbable(but possible) that it can generate a clear 0.000..0.\n return list(np.searchsorted(distr_map, u))\n\n\ndef reverse_generator_nlplike(nbr_symbols,\n max_length,\n nbr_cases,\n scale_std_dev=100,\n alpha=1.5):\n \"\"\"Generator for the reversing nlp-like task on sequences of symbols.\n\n The length of the sequence is drawn from a Gaussian(Normal) distribution\n at random from [1, max_length] and with std deviation of 1%,\n then symbols are drawn from Zipf's law at random from [0, nbr_symbols) until\n nbr_cases sequences have been produced.\n\n Args:\n nbr_symbols: integer, number of symbols.\n max_length: integer, maximum length of sequences to generate.\n nbr_cases: the number of cases to generate.\n scale_std_dev: float, Normal distribution's standard deviation scale factor\n used to draw the length of sequence. Default = 1% of the max_length.\n alpha: float, Zipf's Law Distribution parameter. Default = 1.5.\n Usually for modelling natural text distribution is in\n the range [1.1-1.6].\n\n Yields:\n A dictionary {\"inputs\": input-list, \"targets\": target-list} where\n target-list is input-list reversed.\n \"\"\"\n std_dev = max_length / scale_std_dev\n distr_map = zipf_distribution(nbr_symbols, alpha)\n for _ in range(nbr_cases):\n l = int(abs(np.random.normal(loc=max_length / 2, scale=std_dev)) + 1)\n inputs = zipf_random_sample(distr_map, l)\n yield {\"inputs\": inputs, \"targets\": list(reversed(inputs))}\n\n\[email protected]_problem\nclass AlgorithmicReverseNlplike8k(AlgorithmicProblem):\n \"\"\"Problem spec for algorithmic nlp-like reversing task.\"\"\"\n\n @property\n def num_symbols(self):\n return 8000\n\n def generator(self, nbr_symbols, max_length, nbr_cases):\n return reverse_generator_nlplike(nbr_symbols, max_length, nbr_cases, 10,\n 1.300)\n\n @property\n def train_length(self):\n return 70\n\n @property\n def dev_length(self):\n return 70\n\n\[email protected]_problem\nclass AlgorithmicReverseNlplike32k(AlgorithmicReverseNlplike8k):\n \"\"\"Problem spec for algorithmic nlp-like reversing task, 32k vocab.\"\"\"\n\n @property\n def num_symbols(self):\n return 32000\n\n def generator(self, nbr_symbols, max_length, nbr_cases):\n return reverse_generator_nlplike(nbr_symbols, max_length, nbr_cases, 10,\n 1.050)\n\n\ndef lower_endian_to_number(l, base):\n \"\"\"Helper function: convert a list of digits in the given base to a number.\"\"\"\n return sum([d * (base**i) for i, d in enumerate(l)])\n\n\ndef number_to_lower_endian(n, base):\n \"\"\"Helper function: convert a number to a list of digits in the given base.\"\"\"\n if n < base:\n return [n]\n return [n % base] + number_to_lower_endian(n // base, base)\n\n\ndef random_number_lower_endian(length, base):\n \"\"\"Helper function: generate a random number as a lower-endian digits list.\"\"\"\n if length == 1: # Last digit can be 0 only if length is 1.\n return [np.random.randint(base)]\n prefix = [np.random.randint(base) for _ in range(length - 1)]\n return prefix + [np.random.randint(base - 1) + 1] # Last digit is not 0.\n\n\[email protected]_problem\nclass AlgorithmicAdditionBinary40(AlgorithmicProblem):\n \"\"\"Problem spec for algorithmic binary addition task.\"\"\"\n\n @property\n def num_symbols(self):\n return 2\n\n def generator(self, base, max_length, nbr_cases): # pylint: disable=arguments-differ\n \"\"\"Generator for the addition task.\n\n The length of each number is drawn uniformly at random in [1, max_length/2]\n and then digits are drawn uniformly at random. The numbers are added and\n separated by [base] in the input. Stops at nbr_cases.\n\n Args:\n base: in which base are the numbers.\n max_length: integer, maximum length of sequences to generate.\n nbr_cases: the number of cases to generate.\n\n Yields:\n A dictionary {\"inputs\": input-list, \"targets\": target-list} where\n input-list are the 2 numbers and target-list is the result of adding them.\n\n Raises:\n ValueError: if max_length is lower than 3.\n \"\"\"\n if max_length < 3:\n raise ValueError(\"Maximum length must be at least 3.\")\n for _ in range(nbr_cases):\n l1 = np.random.randint(max_length // 2) + 1\n l2 = np.random.randint(max_length - l1 - 1) + 1\n n1 = random_number_lower_endian(l1, base)\n n2 = random_number_lower_endian(l2, base)\n result = lower_endian_to_number(n1, base) + lower_endian_to_number(\n n2, base)\n inputs = n1 + [base] + n2\n targets = number_to_lower_endian(result, base)\n yield {\"inputs\": inputs, \"targets\": targets}\n\n\[email protected]_problem\nclass AlgorithmicAdditionDecimal40(AlgorithmicAdditionBinary40):\n \"\"\"Problem spec for algorithmic decimal addition task.\"\"\"\n\n @property\n def num_symbols(self):\n return 10\n\n\[email protected]_problem\nclass AlgorithmicMultiplicationBinary40(AlgorithmicProblem):\n \"\"\"Problem spec for algorithmic binary multiplication task.\"\"\"\n\n @property\n def num_symbols(self):\n return 2\n\n def generator(self, base, max_length, nbr_cases): # pylint: disable=arguments-differ\n \"\"\"Generator for the multiplication task.\n\n The length of each number is drawn uniformly at random in [1, max_length/2]\n and then digits are drawn uniformly at random. The numbers are multiplied\n and separated by [base] in the input. Stops at nbr_cases.\n\n Args:\n base: in which base are the numbers.\n max_length: integer, maximum length of sequences to generate.\n nbr_cases: the number of cases to generate.\n\n Yields:\n A dictionary {\"inputs\": input-list, \"targets\": target-list} where\n input-list are the 2 numbers and target-list is the result of multiplying\n them.\n\n Raises:\n ValueError: if max_length is lower than 3.\n \"\"\"\n if max_length < 3:\n raise ValueError(\"Maximum length must be at least 3.\")\n for _ in range(nbr_cases):\n l1 = np.random.randint(max_length // 2) + 1\n l2 = np.random.randint(max_length - l1 - 1) + 1\n n1 = random_number_lower_endian(l1, base)\n n2 = random_number_lower_endian(l2, base)\n result = lower_endian_to_number(n1, base) * lower_endian_to_number(\n n2, base)\n inputs = n1 + [base] + n2\n targets = number_to_lower_endian(result, base)\n yield {\"inputs\": inputs, \"targets\": targets}\n\n\[email protected]_problem\nclass AlgorithmicMultiplicationDecimal40(AlgorithmicMultiplicationBinary40):\n \"\"\"Problem spec for algorithmic decimal multiplication task.\"\"\"\n\n @property\n def num_symbols(self):\n return 10\n\n\[email protected]_problem\nclass AlgorithmicReverseBinary40Test(AlgorithmicReverseBinary40):\n \"\"\"Test Problem with tiny dataset.\"\"\"\n\n @property\n def train_length(self):\n return 10\n\n @property\n def dev_length(self):\n return 10\n\n @property\n def train_size(self):\n return 1000\n\n @property\n def dev_size(self):\n return 100\n\n @property\n def num_shards(self):\n return 1\n\n\[email protected]_problem\nclass AlgorithmicSortProblem(AlgorithmicProblem):\n \"\"\"Problem spec for sorting numbers.\"\"\"\n\n @property\n def num_symbols(self):\n return max(self.train_length, self.dev_length)\n\n @property\n def train_length(self):\n return 10\n\n @property\n def dev_length(self):\n return self.train_length * 2\n\n @property\n def unique(self):\n \"\"\"Unique numbers wo/ replacement or w/ replacement in sorting task.\"\"\"\n return False\n\n def generator(self, nbr_symbols, max_length, nbr_cases):\n \"\"\"Generating for sorting task on sequence of symbols.\n\n The length of the sequence is drawn uniformly at random from [1, max_length]\n and then symbols are drawn (uniquely w/ or w/o replacement) uniformly at\n random from [0, nbr_symbols) until nbr_cases sequences have been produced.\n\n Args:\n nbr_symbols: number of symbols to use in each sequence.\n max_length: integer, maximum length of sequences to generate.\n nbr_cases: the number of cases to generate.\n\n Yields:\n A dictionary {\"inputs\": input-list, \"targets\": target-list} where\n target-list is input-list sorted.\n \"\"\"\n for _ in range(nbr_cases):\n # Sample the sequence length.\n length = np.random.randint(max_length) + 1\n\n if self.unique:\n # Sample our inputs w/o replacement.\n inputs = np.arange(nbr_symbols)\n np.random.shuffle(inputs)\n\n # Truncate to the desired length.\n inputs = inputs[:length]\n inputs = list(inputs)\n else:\n inputs = list(np.random.randint(nbr_symbols, size=length))\n\n # Targets are simply the sorted inputs.\n targets = list(sorted(inputs))\n\n yield {\"inputs\": inputs, \"targets\": targets}\n\n def eval_metrics(self):\n defaults = super(AlgorithmicSortProblem, self).eval_metrics()\n return defaults + [metrics.Metrics.EDIT_DISTANCE]\n\n\[email protected]_problem\nclass TinyAlgo(AlgorithmicIdentityBinary40):\n \"\"\"A small algorthmic problem for testing.\"\"\"\n\n def generate_data(self, data_dir, tmp_dir, task_id=-1):\n \"\"\"Ganerate data for this problem.\"\"\"\n\n del tmp_dir, task_id\n identity_problem = AlgorithmicIdentityBinary40()\n utils.generate_files(\n identity_problem.generator(self.num_symbols, 40, 100000),\n self.training_filepaths(data_dir, 1, shuffled=True), 100)\n utils.generate_files(\n identity_problem.generator(self.num_symbols, 400, 10000),\n self.dev_filepaths(data_dir, 1, shuffled=True), 100)\n\n @classmethod\n def setup_for_test(cls):\n \"\"\"Setup directories and files required to run the problem.\"\"\"\n\n tmp_dir = tf.test.get_temp_dir()\n shutil.rmtree(tmp_dir)\n os.mkdir(tmp_dir)\n cls.data_dir = tmp_dir\n\n # Generate a small test dataset\n cls().generate_data(TinyAlgo.data_dir, None)\n"
]
| [
[
"tensorflow.logical_not",
"tensorflow.reshape",
"tensorflow.zeros_like",
"tensorflow.clip_by_value",
"tensorflow.stack",
"tensorflow.add_to_collection",
"tensorflow.shape",
"tensorflow.concat",
"tensorflow.nn.leaky_relu",
"tensorflow.variable_scope",
"numpy.prod",
"tensorflow.squeeze",
"tensorflow.layers.dense",
"tensorflow.pad",
"tensorflow.contrib.layers.instance_norm",
"numpy.array",
"tensorflow.nn.conv3d",
"tensorflow.summary.scalar",
"tensorflow.layers.conv2d",
"tensorflow.unstack",
"tensorflow.truncated_normal_initializer",
"tensorflow.reduce_mean",
"tensorflow.stop_gradient"
],
[
"tensorflow.logging.set_verbosity",
"tensorflow.train.latest_checkpoint",
"tensorflow.argmax",
"tensorflow.Session",
"tensorflow.train.Saver",
"tensorflow.global_variables",
"tensorflow.reshape",
"tensorflow.logging.info",
"tensorflow.app.run",
"tensorflow.equal",
"tensorflow.initialize_local_variables",
"tensorflow.metrics.accuracy",
"tensorflow.squeeze",
"tensorflow.get_variable_scope",
"tensorflow.to_float",
"tensorflow.one_hot",
"tensorflow.global_variables_initializer",
"tensorflow.logging.warn"
],
[
"numpy.random.normal",
"numpy.random.shuffle",
"numpy.random.randint",
"numpy.arange",
"tensorflow.test.get_temp_dir",
"numpy.cumsum",
"numpy.searchsorted",
"numpy.random.random"
]
]
|
ealopez/pycroscopy | [
"9f7c0543b67eaa0668296295fc5f492360c130a0"
]
| [
"pycroscopy/analysis/fitter.py"
]
| [
"\"\"\"\nCreated on 7/17/16 10:08 AM\n@author: Numan Laanait, Suhas Somnath, Chris Smith\n\"\"\"\n\nfrom __future__ import division, print_function, absolute_import, unicode_literals\n\nimport numpy as np\nimport psutil\nimport scipy\nimport h5py\nimport time as tm\nfrom .guess_methods import GuessMethods\nfrom .fit_methods import Fit_Methods\nfrom ..core.io.pycro_data import PycroDataset\nfrom ..core.io.io_utils import get_available_memory, recommend_cpu_cores, format_time\nfrom ..core.io.hdf_utils import check_for_old, find_results_groups, check_for_matching_attrs, get_attr\nfrom .optimize import Optimize\n\n\nclass Fitter(object):\n \"\"\"\n Encapsulates the typical routines performed during model-dependent analysis of data.\n This abstract class should be extended to cover different types of imaging modalities.\n \"\"\"\n\n def __init__(self, h5_main, variables=['Frequency'], parallel=True, verbose=False):\n \"\"\"\n For now, we assume that the guess dataset has not been generated for this dataset but we will relax this\n requirement after testing the basic components.\n\n Parameters\n ----------\n h5_main : h5py.Dataset instance\n The dataset over which the analysis will be performed. This dataset should be linked to the spectroscopic\n indices and values, and position indices and values datasets.\n variables : list(string), Default ['Frequency']\n Lists of attributes that h5_main should possess so that it may be analyzed by Model.\n parallel : bool, optional\n Should the parallel implementation of the fitting be used. Default True\n verbose : bool, optional. default = False\n Whether or not to print statements that aid in debugging\n\n \"\"\"\n\n if not isinstance(h5_main, PycroDataset):\n h5_main = PycroDataset(h5_main)\n\n # Checking if dataset has the proper dimensions for the model to run.\n if self._is_legal(h5_main, variables):\n self.h5_main = h5_main\n\n else:\n raise ValueError('Provided dataset is not a \"Main\" dataset with necessary ancillary datasets')\n\n # Checking if parallel processing will be used\n self._parallel = parallel\n self._verbose = verbose\n\n # Determining the max size of the data that can be put into memory\n self._set_memory_and_cores()\n\n self._start_pos = 0\n self._end_pos = self.h5_main.shape[0]\n self.h5_guess = None\n self.h5_fit = None\n self.h5_results_grp = None\n\n # TODO: do NOT expose a lot of innards. Turn it into private with _var_name\n self.data = None\n self.guess = None\n self.fit = None\n\n self._fitter_name = None # Reset this in the extended classes\n self._parms_dict = dict()\n\n def _set_memory_and_cores(self):\n \"\"\"\n Checks hardware limitations such as memory, # cpus and sets the recommended datachunk sizes and the\n number of cores to be used by analysis methods.\n \"\"\"\n\n if self._parallel:\n self._maxCpus = max(1, psutil.cpu_count() - 2)\n else:\n self._maxCpus = 1\n\n if self._maxCpus == 1:\n self._parallel = False\n\n self._maxMemoryMB = get_available_memory() / 1024 ** 2 # in Mb\n\n self._maxDataChunk = int(self._maxMemoryMB / self._maxCpus)\n\n # Now calculate the number of positions that can be stored in memory in one go.\n mb_per_position = self.h5_main.dtype.itemsize * self.h5_main.shape[1] / 1024.0 ** 2\n\n # TODO: The size of the chunk should be determined by BOTH the computation time and memory restrictions\n self._max_pos_per_read = int(np.floor(self._maxDataChunk / mb_per_position))\n if self._verbose:\n print('Allowed to read {} pixels per chunk'.format(self._max_pos_per_read))\n\n def _is_legal(self, h5_main, variables):\n \"\"\"\n Checks whether or not the provided object can be analyzed by this Model class.\n Classes that extend this class will do additional checks to ensure that the supplied dataset is legal.\n\n Parameters\n ----\n h5_main : PycroDataset instance\n The dataset over which the analysis will be performed. This dataset should be linked to the spectroscopic\n indices and values, and position indices and values datasets.\n\n variables : list(string)\n The dimensions needed to be present in the attributes of h5_main to analyze the data with Model.\n\n Returns\n -------\n legal : Boolean\n Whether or not this dataset satisfies the necessary conditions for analysis\n\n \"\"\"\n return np.all(np.isin(variables, h5_main.spec_dim_labels))\n\n def _get_data_chunk(self):\n \"\"\"\n Reads the next chunk of data for the guess or the fit into memory\n \"\"\"\n if self._start_pos < self.h5_main.shape[0]:\n self._end_pos = int(min(self.h5_main.shape[0], self._start_pos + self._max_pos_per_read))\n self.data = self.h5_main[self._start_pos:self._end_pos, :]\n if self._verbose:\n print('\\nReading pixels {} to {} of {}'.format(self._start_pos, self._end_pos, self.h5_main.shape[0]))\n\n else:\n if self._verbose:\n print('Finished reading all data!')\n self.data = None\n\n def _get_guess_chunk(self):\n \"\"\"\n Returns a chunk of guess dataset corresponding to the main dataset.\n Should be called BEFORE _get_data_chunk since it relies upon current values of\n `self._start_pos`, `self._end_pos`\n\n Parameters\n -----\n None\n\n Returns\n --------\n\n \"\"\"\n if self.data is None:\n self._end_pos = int(min(self.h5_main.shape[0], self._start_pos + self._max_pos_per_read))\n self.guess = self.h5_guess[self._start_pos:self._end_pos, :]\n else:\n self.guess = self.h5_guess[self._start_pos:self._end_pos, :]\n\n if self._verbose:\n print('Guess of shape: {}'.format(self.guess.shape))\n\n def _set_results(self, is_guess=False):\n \"\"\"\n Writes the provided guess or fit results into appropriate datasets.\n Given that the guess and fit datasets are relatively small, we should be able to hold them in memory just fine\n\n Parameters\n ---------\n is_guess : bool, optional\n Default - False\n Flag that differentiates the guess from the fit\n \"\"\"\n statement = 'guess'\n\n if is_guess:\n targ_dset = self.h5_guess\n source_dset = self.guess\n else:\n statement = 'fit'\n targ_dset = self.h5_fit\n source_dset = self.fit\n\n if self._verbose:\n print('Writing data to positions: {} to {}'.format(self._start_pos, self._end_pos))\n targ_dset[self._start_pos: self._end_pos, :] = source_dset\n\n # This flag will let us resume the computation if it is aborted\n targ_dset.attrs['last_pixel'] = self._end_pos\n\n # Now update the start position\n self._start_pos = self._end_pos\n\n # flush the file\n self.h5_main.file.flush()\n if self._verbose:\n print('Finished writing ' + statement + ' results (chunk) to file!')\n\n def _create_guess_datasets(self):\n \"\"\"\n Model specific call that will write the h5 group, guess dataset, corresponding spectroscopic datasets and also\n link the guess dataset to the spectroscopic datasets. It is recommended that the ancillary datasets be populated\n within this function.\n\n The guess dataset will NOT be populated here but will be populated by the __setData function\n The fit dataset should NOT be populated here unless the user calls the optimize function.\n\n Parameters\n --------\n None\n\n Returns\n -------\n None\n\n \"\"\"\n self.guess = None # replace with actual h5 dataset\n raise NotImplementedError('Please override the _create_guess_datasets specific to your model')\n\n def _create_fit_datasets(self):\n \"\"\"\n Model specific call that will write the h5 group, fit dataset, corresponding spectroscopic datasets and also\n link the fit dataset to the spectroscopic datasets. It is recommended that the ancillary datasets be populated\n within this function.\n\n The fit dataset will NOT be populated here but will be populated by the __setData function\n The guess dataset should NOT be populated here unless the user calls the optimize function.\n\n Parameters\n --------\n None\n\n Returns\n -------\n None\n\n \"\"\"\n self.fit = None # replace with actual h5 dataset\n raise NotImplementedError('Please override the _create_fit_datasets specific to your model')\n\n def _check_for_old_guess(self):\n \"\"\"\n Returns a list of datasets where the same parameters have already been used to compute Guesses for this dataset\n\n Returns\n -------\n list\n List of datasets with results from do_guess on this dataset\n \"\"\"\n groups = check_for_old(self.h5_main, self._fitter_name, new_parms=self._parms_dict, target_dset='Guess',\n verbose=self._verbose)\n datasets = [grp['Guess'] for grp in groups]\n\n # Now sort these datasets into partial and complete:\n completed_dsets = []\n partial_dsets = []\n\n for dset in datasets:\n try:\n last_pix = get_attr(dset, 'last_pixel')\n except KeyError:\n last_pix = None\n \n # Skip datasets without last_pixel attribute\n if last_pix is None:\n continue\n elif last_pix < self.h5_main.shape[0]:\n partial_dsets.append(dset)\n else:\n completed_dsets.append(dset)\n\n return partial_dsets, completed_dsets\n\n def do_guess(self, processors=None, strategy=None, options=dict(), h5_partial_guess=None, override=False):\n \"\"\"\n Parameters\n ----------\n strategy: string (optional)\n Default is 'Wavelet_Peaks'.\n Can be one of ['wavelet_peaks', 'relative_maximum', 'gaussian_processes'].\n For updated list, run GuessMethods.methods\n processors : int (optional)\n Number of cores to use for computing. Default = all available - 2 cores\n options: dict\n Default, options for wavelet_peaks {\"peaks_widths\": np.array([10,200]), \"peak_step\":20}.\n Dictionary of options passed to strategy. For more info see GuessMethods documentation.\n h5_partial_guess : h5py.group. optional, default = None\n Datagroup containing (partially computed) guess results. do_guess will resume computation if provided.\n override : bool, optional. default = False\n By default, will simply return duplicate results to avoid recomputing or resume computation on a\n group with partial results. Set to True to force fresh computation.\n\n Returns\n -------\n h5_guess : h5py.Dataset\n Dataset containing guesses that can be passed on to do_fit()\n \"\"\"\n gm = GuessMethods()\n if strategy not in gm.methods:\n raise KeyError('Error: %s is not implemented in pycroscopy.analysis.GuessMethods to find guesses' %\n strategy)\n\n # ################## CHECK FOR DUPLICATES AND RESUME PARTIAL #######################################\n\n # Prepare the parms dict that will be used for comparison:\n self._parms_dict = options.copy()\n self._parms_dict.update({'strategy': strategy})\n\n # check for old:\n partial_dsets, completed_dsets = self._check_for_old_guess()\n\n if len(completed_dsets) == 0 and len(partial_dsets) == 0:\n print('No existing datasets found')\n override = True\n\n if not override:\n # First try to simply return any completed computation\n if len(completed_dsets) > 0:\n print('Returned previously computed results at ' + completed_dsets[-1].name)\n self.h5_guess = PycroDataset(completed_dsets[-1])\n return\n\n # Next attempt to resume automatically if nothing is provided\n if len(partial_dsets) > 0:\n # attempt to use whatever the user provided (if legal)\n target_partial_dset = partial_dsets[-1]\n if h5_partial_guess is not None:\n if not isinstance(h5_partial_guess, h5py.Dataset):\n raise ValueError('Provided parameter is not an h5py.Dataset object')\n if h5_partial_guess not in partial_dsets:\n raise ValueError('Provided dataset for partial Guesses is not compatible')\n if self._verbose:\n print('Provided partial Guess dataset was acceptable')\n target_partial_dset = h5_partial_guess\n\n # Finally resume from this dataset\n print('Resuming computation in group: ' + target_partial_dset.name)\n self.h5_guess = target_partial_dset\n self._start_pos = target_partial_dset.attrs['last_pixel']\n\n # No completed / partials available or forced via override:\n if self.h5_guess is None:\n if self._verbose:\n print('Starting a fresh computation!')\n self._start_pos = 0\n self._create_guess_datasets()\n\n # ################## BEGIN THE ACTUAL COMPUTING #######################################\n\n if processors is None:\n processors = self._maxCpus\n else:\n processors = min(int(processors), self._maxCpus)\n processors = recommend_cpu_cores(self._max_pos_per_read, processors, verbose=self._verbose)\n\n print(\"Using %s to find guesses...\\n\" % strategy)\n\n time_per_pix = 0\n num_pos = self.h5_main.shape[0] - self._start_pos\n orig_start_pos = self._start_pos\n\n print('You can abort this computation at any time and resume at a later time!\\n'\n '\\tIf you are operating in a python console, press Ctrl+C or Cmd+C to abort\\n'\n '\\tIf you are in a Jupyter notebook, click on \"Kernel\">>\"Interrupt\"\\n')\n\n self._get_data_chunk()\n while self.data is not None:\n\n t_start = tm.time()\n\n opt = Optimize(data=self.data, parallel=self._parallel)\n temp = opt.computeGuess(processors=processors, strategy=strategy, options=options)\n\n # reorder to get one numpy array out\n temp = self._reformat_results(temp, strategy)\n self.guess = np.hstack(tuple(temp))\n\n # Write to file\n self._set_results(is_guess=True)\n\n # basic timing logs\n tot_time = np.round(tm.time() - t_start, decimals=2) # in seconds\n if self._verbose:\n print('Done parallel computing in {} or {} per pixel'.format(format_time(tot_time),\n format_time(tot_time / self.data.shape[0])))\n if self._start_pos == orig_start_pos:\n time_per_pix = tot_time / self._end_pos # in seconds\n else:\n time_remaining = (num_pos - self._end_pos) * time_per_pix # in seconds\n print('Time remaining: ' + format_time(time_remaining))\n\n # get next batch of data\n self._get_data_chunk()\n\n print('Completed computing guess')\n print()\n return PycroDataset(self.h5_guess)\n\n def _reformat_results(self, results, strategy='wavelet_peaks'):\n \"\"\"\n Model specific restructuring / reformatting of the parallel compute results\n\n Parameters\n ----------\n results : array-like\n Results to be formatted for writing\n strategy : str\n The strategy used in the fit. Determines how the results will be reformatted.\n Default 'wavelet_peaks'\n\n Returns\n -------\n results : numpy.ndarray\n Formatted array that is ready to be writen to the HDF5 file \n\n \"\"\"\n return np.array(results)\n\n def _check_for_old_fit(self):\n \"\"\"\n Returns three lists of h5py.Dataset objects where the group contained:\n 1. Completed guess only\n 2. Partial Fit\n 3. Completed Fit\n\n Returns\n -------\n\n \"\"\"\n # First find all groups that match the basic condition of matching tool name\n all_groups = find_results_groups(self.h5_main, self._fitter_name)\n if self._verbose:\n print('Groups that matched the nomenclature: {}'.format(all_groups))\n\n # Next sort these groups into three categories:\n completed_guess = []\n partial_fits = []\n completed_fits = []\n\n for h5_group in all_groups:\n\n if 'Fit' in h5_group.keys():\n # check group for fit attribute\n\n h5_fit = h5_group['Fit']\n\n # check Fit dataset against parms_dict\n if not check_for_matching_attrs(h5_fit, new_parms=self._parms_dict, verbose=self._verbose):\n if self._verbose:\n print('{} did not match the given parameters'.format(h5_fit.name))\n continue\n\n # sort this dataset:\n try:\n last_pix = get_attr(h5_fit, 'last_pixel')\n except KeyError:\n last_pix = None\n\n # For now skip any fits that are missing 'last_pixel'\n if last_pix is None:\n continue\n elif last_pix < self.h5_main.shape[0]:\n partial_fits.append(h5_fit.parent)\n else:\n completed_fits.append(h5_fit)\n else:\n if 'Guess' in h5_group.keys():\n h5_guess = h5_group['Guess']\n\n # sort this dataset:\n try:\n last_pix = get_attr(h5_guess, 'last_pixel')\n except KeyError:\n last_pix = None\n\n # For now skip any fits that are missing 'last_pixel'\n if last_pix is None:\n continue\n elif last_pix == self.h5_main.shape[0]:\n if self._verbose:\n print('{} was a completed Guess'.format(h5_guess.name))\n completed_guess.append(h5_guess)\n else:\n if self._verbose:\n print('{} did not not have completed Guesses'.format(h5_guess.name))\n else:\n if self._verbose:\n print('{} did not even have Guess. Categorizing as defective Group'.format(h5_group.name))\n\n return completed_guess, partial_fits, completed_fits\n\n def do_fit(self, processors=None, solver_type='least_squares', solver_options=None, obj_func=None,\n h5_partial_fit=None, h5_guess=None, override=False):\n \"\"\"\n Generates the fit for the given dataset and writes back to file\n\n Parameters\n ----------\n processors : int\n Number of cpu cores the user wishes to run on. The minimum of this and self._maxCpus is used.\n solver_type : str\n The name of the solver in scipy.optimize to use for the fit\n solver_options : dict\n Dictionary of parameters to pass to the solver specified by `solver_type`\n obj_func : dict\n Dictionary defining the class and method containing the function to be fit as well as any \n additional function parameters.\n h5_partial_fit : h5py.group. optional, default = None\n Datagroup containing (partially computed) fit results. do_fit will resume computation if provided.\n h5_guess : h5py.group. optional, default = None\n Datagroup containing guess results. do_fit will use this if provided.\n override : bool, optional. default = False\n By default, will simply return duplicate results to avoid recomputing or resume computation on a\n group with partial results. Set to True to force fresh computation.\n\n Returns\n -------\n h5_results : h5py.Dataset object\n Dataset with the fit parameters\n \"\"\"\n\n # ################## PREPARE THE SOLVER #######################################\n\n legit_solver = solver_type in scipy.optimize.__dict__.keys()\n\n if not legit_solver:\n raise KeyError('Error: Objective Functions \"%s\" is not implemented in pycroscopy.analysis.Fit_Methods' %\n obj_func['obj_func'])\n\n obj_func_name = obj_func['obj_func']\n legit_obj_func = obj_func_name in Fit_Methods().methods\n\n if not legit_obj_func:\n raise KeyError('Error: Solver \"%s\" does not exist!. For additional info see scipy.optimize\\n' % solver_type)\n\n # ################## CHECK FOR DUPLICATES AND RESUME PARTIAL #######################################\n\n def _get_group_to_resume(legal_groups, provided_partial_fit):\n for h5_group in legal_groups:\n if h5_group['Fit'] == provided_partial_fit:\n return h5_group\n return None\n\n def _resume_fit(fitter, h5_group):\n fitter.h5_guess = h5_group['Guess']\n fitter.h5_fit = h5_group['Fit']\n fitter._start_pos = fitter.h5_fit.attrs['last_pixel']\n\n def _start_fresh_fit(fitter, h5_guess_legal):\n fitter.h5_guess = h5_guess_legal\n fitter._create_fit_datasets()\n fitter._start_pos = 0\n\n # Prepare the parms dict that will be used for comparison:\n self._parms_dict = solver_options.copy()\n self._parms_dict.update({'solver_type': solver_type})\n self._parms_dict.update(obj_func)\n\n completed_guess, partial_fit_groups, completed_fits = self._check_for_old_fit()\n\n override = override or (h5_partial_fit is not None or h5_guess is not None)\n\n if not override:\n # First try to simply return completed results\n if len(completed_fits) > 0:\n print('Returned previously computed results at ' + completed_fits[-1].name)\n self.h5_fit = PycroDataset(completed_fits[-1])\n return\n\n # Next, attempt to resume automatically:\n elif len(partial_fit_groups) > 0:\n print('Will resume fitting in {}. '\n 'You can supply a dataset using the h5_partial_fit argument'.format(partial_fit_groups[-1].name))\n _resume_fit(self, partial_fit_groups[-1])\n\n # Finally, attempt to do fresh fitting using completed Guess:\n elif len(completed_guess) > 0:\n print('Will use {} for generating new Fit. '\n 'You can supply a dataset using the h5_guess argument'.format(completed_guess[-1].name))\n _start_fresh_fit(self, completed_guess[-1])\n\n else:\n raise ValueError('Could not find a compatible Guess to use for Fit. Call do_guess() before do_fit()')\n\n else:\n if h5_partial_fit is not None:\n h5_group = _get_group_to_resume(partial_fit_groups, h5_partial_fit)\n if h5_group is None:\n raise ValueError('Provided dataset with partial Fit was not found to be compatible')\n _resume_fit(self, h5_group)\n\n elif h5_guess is not None:\n if h5_guess not in completed_guess:\n raise ValueError('Provided dataset with completed Guess was not found to be compatible')\n _start_fresh_fit(self, h5_guess)\n\n else:\n raise ValueError('Please provide a completed guess or partially completed Fit to resume')\n\n # ################## BEGIN THE ACTUAL FITTING #######################################\n\n print(\"Using solver %s and objective function %s to fit your data\\n\" % (solver_type, obj_func['obj_func']))\n\n if processors is None:\n processors = self._maxCpus\n else:\n processors = min(processors, self._maxCpus)\n processors = recommend_cpu_cores(self._max_pos_per_read, processors, verbose=self._verbose)\n\n time_per_pix = 0\n num_pos = self.h5_main.shape[0] - self._start_pos\n orig_start_pos = self._start_pos\n\n print('You can abort this computation at any time and resume at a later time!\\n'\n '\\tIf you are operating in a python console, press Ctrl+C or Cmd+C to abort\\n'\n '\\tIf you are in a Jupyter notebook, click on \"Kernel\">>\"Interrupt\"\\n')\n\n self._get_guess_chunk()\n self._get_data_chunk()\n\n while self.data is not None:\n\n t_start = tm.time()\n\n opt = Optimize(data=self.data, guess=self.guess, parallel=self._parallel)\n temp = opt.computeFit(processors=processors, solver_type=solver_type, solver_options=solver_options,\n obj_func=obj_func.copy())\n\n # TODO: need a different .reformatResults to process fitting results\n # reorder to get one numpy array out\n temp = self._reformat_results(temp, obj_func_name)\n self.fit = np.hstack(tuple(temp))\n\n # Write to file\n self._set_results(is_guess=False)\n\n # basic timing logs\n tot_time = np.round(tm.time() - t_start, decimals=2) # in seconds\n if self._verbose:\n print('Done parallel computing in {} or {} per pixel'.format(format_time(tot_time),\n format_time(\n tot_time / self.data.shape[0])))\n if self._start_pos == orig_start_pos:\n time_per_pix = tot_time / self._end_pos # in seconds\n else:\n time_remaining = (num_pos - self._end_pos) * time_per_pix # in seconds\n print('Time remaining: ' + format_time(time_remaining))\n\n # get next batch of data\n self._get_guess_chunk()\n self._get_data_chunk()\n\n print('Completed computing fit. Writing to file.')\n\n return PycroDataset(self.h5_fit)\n"
]
| [
[
"scipy.optimize.__dict__.keys",
"numpy.array",
"numpy.isin",
"numpy.floor"
]
]
|
Maxew42/Trashedy | [
"e7e43f172ef4a039e134cac26980f59fede24423"
]
| [
"web-site/server/helpers/coco_eval.py"
]
| [
"import json\nimport tempfile\n\nimport numpy as np\nimport copy\nimport time\nimport torch\nimport torch._six\n\nfrom pycocotools.cocoeval import COCOeval\nfrom pycocotools.coco import COCO\nimport pycocotools.mask as mask_util\n\nfrom collections import defaultdict\n\nimport helpers.utils as utils\n\n\nclass CocoEvaluator(object):\n def __init__(self, coco_gt, iou_types):\n assert isinstance(iou_types, (list, tuple))\n coco_gt = copy.deepcopy(coco_gt)\n self.coco_gt = coco_gt\n\n self.iou_types = iou_types\n self.coco_eval = {}\n for iou_type in iou_types:\n self.coco_eval[iou_type] = COCOeval(coco_gt, iouType=iou_type)\n\n self.img_ids = []\n self.eval_imgs = {k: [] for k in iou_types}\n\n def update(self, predictions):\n img_ids = list(np.unique(list(predictions.keys())))\n self.img_ids.extend(img_ids)\n\n for iou_type in self.iou_types:\n results = self.prepare(predictions, iou_type)\n coco_dt = loadRes(self.coco_gt, results) if results else COCO()\n coco_eval = self.coco_eval[iou_type]\n\n coco_eval.cocoDt = coco_dt\n coco_eval.params.imgIds = list(img_ids)\n img_ids, eval_imgs = evaluate(coco_eval)\n\n self.eval_imgs[iou_type].append(eval_imgs)\n\n def synchronize_between_processes(self):\n for iou_type in self.iou_types:\n self.eval_imgs[iou_type] = np.concatenate(self.eval_imgs[iou_type], 2)\n create_common_coco_eval(self.coco_eval[iou_type], self.img_ids, self.eval_imgs[iou_type])\n\n def accumulate(self):\n for coco_eval in self.coco_eval.values():\n coco_eval.accumulate()\n\n def summarize(self):\n for iou_type, coco_eval in self.coco_eval.items():\n print(\"IoU metric: {}\".format(iou_type))\n coco_eval.summarize()\n\n def prepare(self, predictions, iou_type):\n if iou_type == \"bbox\":\n return self.prepare_for_coco_detection(predictions)\n elif iou_type == \"segm\":\n return self.prepare_for_coco_segmentation(predictions)\n elif iou_type == \"keypoints\":\n return self.prepare_for_coco_keypoint(predictions)\n else:\n raise ValueError(\"Unknown iou type {}\".format(iou_type))\n\n def prepare_for_coco_detection(self, predictions):\n coco_results = []\n for original_id, prediction in predictions.items():\n if len(prediction) == 0:\n continue\n\n boxes = prediction[\"boxes\"]\n boxes = convert_to_xywh(boxes).tolist()\n scores = prediction[\"scores\"].tolist()\n labels = prediction[\"labels\"].tolist()\n\n coco_results.extend(\n [\n {\n \"image_id\": original_id,\n \"category_id\": labels[k],\n \"bbox\": box,\n \"score\": scores[k],\n }\n for k, box in enumerate(boxes)\n ]\n )\n return coco_results\n\n def prepare_for_coco_segmentation(self, predictions):\n coco_results = []\n for original_id, prediction in predictions.items():\n if len(prediction) == 0:\n continue\n\n scores = prediction[\"scores\"]\n labels = prediction[\"labels\"]\n masks = prediction[\"masks\"]\n\n masks = masks > 0.5\n\n scores = prediction[\"scores\"].tolist()\n labels = prediction[\"labels\"].tolist()\n\n rles = [\n mask_util.encode(np.array(mask[0, :, :, np.newaxis], dtype=np.uint8, order=\"F\"))[0]\n for mask in masks\n ]\n for rle in rles:\n rle[\"counts\"] = rle[\"counts\"].decode(\"utf-8\")\n\n coco_results.extend(\n [\n {\n \"image_id\": original_id,\n \"category_id\": labels[k],\n \"segmentation\": rle,\n \"score\": scores[k],\n }\n for k, rle in enumerate(rles)\n ]\n )\n return coco_results\n\n def prepare_for_coco_keypoint(self, predictions):\n coco_results = []\n for original_id, prediction in predictions.items():\n if len(prediction) == 0:\n continue\n\n boxes = prediction[\"boxes\"]\n boxes = convert_to_xywh(boxes).tolist()\n scores = prediction[\"scores\"].tolist()\n labels = prediction[\"labels\"].tolist()\n keypoints = prediction[\"keypoints\"]\n keypoints = keypoints.flatten(start_dim=1).tolist()\n\n coco_results.extend(\n [\n {\n \"image_id\": original_id,\n \"category_id\": labels[k],\n 'keypoints': keypoint,\n \"score\": scores[k],\n }\n for k, keypoint in enumerate(keypoints)\n ]\n )\n return coco_results\n\n\ndef convert_to_xywh(boxes):\n xmin, ymin, xmax, ymax = boxes.unbind(1)\n return torch.stack((xmin, ymin, xmax - xmin, ymax - ymin), dim=1)\n\n\ndef merge(img_ids, eval_imgs):\n all_img_ids = utils.all_gather(img_ids)\n all_eval_imgs = utils.all_gather(eval_imgs)\n\n merged_img_ids = []\n for p in all_img_ids:\n merged_img_ids.extend(p)\n\n merged_eval_imgs = []\n for p in all_eval_imgs:\n merged_eval_imgs.append(p)\n\n merged_img_ids = np.array(merged_img_ids)\n merged_eval_imgs = np.concatenate(merged_eval_imgs, 2)\n\n # keep only unique (and in sorted order) images\n merged_img_ids, idx = np.unique(merged_img_ids, return_index=True)\n merged_eval_imgs = merged_eval_imgs[..., idx]\n\n return merged_img_ids, merged_eval_imgs\n\n\ndef create_common_coco_eval(coco_eval, img_ids, eval_imgs):\n img_ids, eval_imgs = merge(img_ids, eval_imgs)\n img_ids = list(img_ids)\n eval_imgs = list(eval_imgs.flatten())\n\n coco_eval.evalImgs = eval_imgs\n coco_eval.params.imgIds = img_ids\n coco_eval._paramsEval = copy.deepcopy(coco_eval.params)\n\n\n#################################################################\n# From pycocotools, just removed the prints and fixed\n# a Python3 bug about unicode not defined\n#################################################################\n\n# Ideally, pycocotools wouldn't have hard-coded prints\n# so that we could avoid copy-pasting those two functions\n\ndef createIndex(self):\n # create index\n # print('creating index...')\n anns, cats, imgs = {}, {}, {}\n imgToAnns, catToImgs = defaultdict(list), defaultdict(list)\n if 'annotations' in self.dataset:\n for ann in self.dataset['annotations']:\n imgToAnns[ann['image_id']].append(ann)\n anns[ann['id']] = ann\n\n if 'images' in self.dataset:\n for img in self.dataset['images']:\n imgs[img['id']] = img\n\n if 'categories' in self.dataset:\n for cat in self.dataset['categories']:\n cats[cat['id']] = cat\n\n if 'annotations' in self.dataset and 'categories' in self.dataset:\n for ann in self.dataset['annotations']:\n catToImgs[ann['category_id']].append(ann['image_id'])\n\n # print('index created!')\n\n # create class members\n self.anns = anns\n self.imgToAnns = imgToAnns\n self.catToImgs = catToImgs\n self.imgs = imgs\n self.cats = cats\n\n\nmaskUtils = mask_util\n\n\ndef loadRes(self, resFile):\n \"\"\"\n Load result file and return a result api object.\n Args:\n self (obj): coco object with ground truth annotations\n resFile (str): file name of result file\n Returns:\n res (obj): result api object\n \"\"\"\n res = COCO()\n res.dataset['images'] = [img for img in self.dataset['images']]\n\n # print('Loading and preparing results...')\n # tic = time.time()\n if isinstance(resFile, torch._six.string_classes):\n anns = json.load(open(resFile))\n elif type(resFile) == np.ndarray:\n anns = self.loadNumpyAnnotations(resFile)\n else:\n anns = resFile\n assert type(anns) == list, 'results in not an array of objects'\n annsImgIds = [ann['image_id'] for ann in anns]\n assert set(annsImgIds) == (set(annsImgIds) & set(self.getImgIds())), \\\n 'Results do not correspond to current coco set'\n if 'caption' in anns[0]:\n imgIds = set([img['id'] for img in res.dataset['images']]) & set([ann['image_id'] for ann in anns])\n res.dataset['images'] = [img for img in res.dataset['images'] if img['id'] in imgIds]\n for id, ann in enumerate(anns):\n ann['id'] = id + 1\n elif 'bbox' in anns[0] and not anns[0]['bbox'] == []:\n res.dataset['categories'] = copy.deepcopy(self.dataset['categories'])\n for id, ann in enumerate(anns):\n bb = ann['bbox']\n x1, x2, y1, y2 = [bb[0], bb[0] + bb[2], bb[1], bb[1] + bb[3]]\n if 'segmentation' not in ann:\n ann['segmentation'] = [[x1, y1, x1, y2, x2, y2, x2, y1]]\n ann['area'] = bb[2] * bb[3]\n ann['id'] = id + 1\n ann['iscrowd'] = 0\n elif 'segmentation' in anns[0]:\n res.dataset['categories'] = copy.deepcopy(self.dataset['categories'])\n for id, ann in enumerate(anns):\n # now only support compressed RLE format as segmentation results\n ann['area'] = maskUtils.area(ann['segmentation'])\n if 'bbox' not in ann:\n ann['bbox'] = maskUtils.toBbox(ann['segmentation'])\n ann['id'] = id + 1\n ann['iscrowd'] = 0\n elif 'keypoints' in anns[0]:\n res.dataset['categories'] = copy.deepcopy(self.dataset['categories'])\n for id, ann in enumerate(anns):\n s = ann['keypoints']\n x = s[0::3]\n y = s[1::3]\n x1, x2, y1, y2 = np.min(x), np.max(x), np.min(y), np.max(y)\n ann['area'] = (x2 - x1) * (y2 - y1)\n ann['id'] = id + 1\n ann['bbox'] = [x1, y1, x2 - x1, y2 - y1]\n # print('DONE (t={:0.2f}s)'.format(time.time()- tic))\n\n res.dataset['annotations'] = anns\n createIndex(res)\n return res\n\n\ndef evaluate(self):\n '''\n Run per image evaluation on given images and store results (a list of dict) in self.evalImgs\n :return: None\n '''\n # tic = time.time()\n # print('Running per image evaluation...')\n p = self.params\n # add backward compatibility if useSegm is specified in params\n if p.useSegm is not None:\n p.iouType = 'segm' if p.useSegm == 1 else 'bbox'\n print('useSegm (deprecated) is not None. Running {} evaluation'.format(p.iouType))\n # print('Evaluate annotation type *{}*'.format(p.iouType))\n p.imgIds = list(np.unique(p.imgIds))\n if p.useCats:\n p.catIds = list(np.unique(p.catIds))\n p.maxDets = sorted(p.maxDets)\n self.params = p\n\n self._prepare()\n # loop through images, area range, max detection number\n catIds = p.catIds if p.useCats else [-1]\n\n if p.iouType == 'segm' or p.iouType == 'bbox':\n computeIoU = self.computeIoU\n elif p.iouType == 'keypoints':\n computeIoU = self.computeOks\n self.ious = {\n (imgId, catId): computeIoU(imgId, catId)\n for imgId in p.imgIds\n for catId in catIds}\n\n evaluateImg = self.evaluateImg\n maxDet = p.maxDets[-1]\n evalImgs = [\n evaluateImg(imgId, catId, areaRng, maxDet)\n for catId in catIds\n for areaRng in p.areaRng\n for imgId in p.imgIds\n ]\n # this is NOT in the pycocotools code, but could be done outside\n evalImgs = np.asarray(evalImgs).reshape(len(catIds), len(p.areaRng), len(p.imgIds))\n self._paramsEval = copy.deepcopy(self.params)\n # toc = time.time()\n # print('DONE (t={:0.2f}s).'.format(toc-tic))\n return p.imgIds, evalImgs\n"
]
| [
[
"numpy.concatenate",
"numpy.max",
"numpy.array",
"torch.stack",
"numpy.asarray",
"numpy.min",
"numpy.unique"
]
]
|
Sinovel/QUANTAXIS | [
"97f1ea2140f58c92ff5c84b851886d9eda1f9ac3"
]
| [
"QUANTAXIS/QAUtil/QATransform.py"
]
| [
"# coding:utf-8\n#\n# The MIT License (MIT)\n#\n# Copyright (c) 2016-2019 yutiansut/QUANTAXIS\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\nimport csv\nimport json\n\nimport numpy as np\nimport pandas as pd\n\n\ndef QA_util_to_json_from_pandas(data):\n \"\"\"\n explanation:\n 将pandas数据转换成json格式\t\t\n\n params:\n * data ->:\n meaning: pandas数据\n type: null\n optional: [null]\n\n return:\n dict\n\n demonstrate:\n Not described\n\n output:\n Not described\n \"\"\"\n\n \"\"\"需要对于datetime 和date 进行转换, 以免直接被变成了时间戳\"\"\"\n if 'datetime' in data.columns:\n data.datetime = data.datetime.apply(str)\n if 'date' in data.columns:\n data.date = data.date.apply(str)\n return json.loads(data.to_json(orient='records'))\n\n\ndef QA_util_to_json_from_numpy(data):\n pass\n\n\ndef QA_util_to_json_from_list(data):\n pass\n\n\ndef QA_util_to_list_from_pandas(data):\n \"\"\"\n explanation:\n 将pandas数据转换成列表\t\t\n\n params:\n * data ->:\n meaning: pandas数据\n type: null\n optional: [null]\n\n return:\n list\n\n demonstrate:\n Not described\n\n output:\n Not described\n \"\"\"\n\n return np.asarray(data).tolist()\n\n\ndef QA_util_to_list_from_numpy(data):\n \"\"\"\n explanation:\n 将numpy数据转换为列表\t\t\n\n params:\n * data ->:\n meaning: numpy数据\n type: null\n optional: [null]\n\n return:\n None\n\n demonstrate:\n Not described\n\n output:\n Not described\n \"\"\"\n\n return data.tolist()\n\n\ndef QA_util_to_pandas_from_json(data):\n \"\"\"\n explanation:\n 将json数据载入为pandas数据\t\t\n\n params:\n * data ->:\n meaning: json数据\n type: null\n optional: [null]\n\n return:\n DataFrame\n\n demonstrate:\n Not described\n\n output:\n Not described\n \"\"\"\n if isinstance(data, dict):\n return pd.DataFrame(data=[data, ])\n else:\n return pd.DataFrame(data=[{'value': data}])\n\n\ndef QA_util_to_pandas_from_list(data):\n \"\"\"\n explanation:\n 将列表数据转换为pandas\t\n\n params:\n * data ->:\n meaning: 列表数据\n type: list\n optional: [null]\n\n return:\n DataFrame\n\n demonstrate:\n Not described\n\n output:\n Not described\n \"\"\"\n\n if isinstance(data, list):\n return pd.DataFrame(data=data)\n"
]
| [
[
"pandas.DataFrame",
"numpy.asarray"
]
]
|
google/parallel_accel | [
"b58fda1c3a22f2aaa9a97337d602cd72c49ee8be"
]
| [
"parallel_accel/Analysis/benchmarks/gralt/gralt_benchmarks.py"
]
| [
"# Copyright 2021 The ParallelAccel 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\"\"\"\nTest the speed of GRALTool on standard benchmark acyclic_graphs.\n\nThis is deprecated code and is included for reference. New benchmarks should use the\nBenchmark and BenchmarkSuite models.\n\"\"\"\n\nimport json\nimport os\nimport time\n\nimport benchmarks.acyclic_graphs.benchmark_acyclic_graphs as acyclic_graphs\nfrom benchmarks.acyclic_graphs import pbaxisum\nimport benchmarks.gralt.settings as settings\n\nimport linear_algebra\nimport tensorflow as tf\nimport grapal_tool as gralt\n\nsample_subgraph = gralt.subgraphs.Sample()\nexpectation_subgraph = gralt.subgraphs.Expectation()\nstate_subgraph = gralt.subgraphs.State()\n\n\ndef exp_and_grad_call(\n acyclic_graph_t, symbol_names_t, symbol_values_t, ops_t, num_samples_t):\n with tf.GradientTape() as g:\n g.watch(symbol_values_t)\n exp = expectation_subgraph(\n acyclic_graph_t, symbol_names=symbol_names_t, symbol_values=symbol_values_t,\n operators=ops_t)\n grad = g.gradient(exp, symbol_values_t)\n return exp, grad\n\n\ncall_dict = {\n \"samples\": lambda acyclic_graph_t, symbol_names_t, symbol_values_t, ops_t,\n num_samples_t: sample_subgraph(\n acyclic_graph_t, symbol_names=symbol_names_t, symbol_values=symbol_values_t,\n repetitions=num_samples_t),\n \"exp\": lambda acyclic_graph_t, symbol_names_t, symbol_values_t, ops_t,\n num_samples_t: expectation_subgraph(\n acyclic_graph_t, symbol_names=symbol_names_t, symbol_values=symbol_values_t,\n operators=ops_t),\n \"exp_and_grad\": exp_and_grad_call,\n \"state\": lambda acyclic_graph_t, symbol_names_t, symbol_values_t, ops_t,\n num_samples_t: state_subgraph(\n acyclic_graph_t, symbol_names=symbol_names_t, symbol_values=symbol_values_t),\n}\n\n\nget_num_samples_dict = {\n \"samples\": lambda settings_dict:\n tf.constant([settings_dict[\"num_samples\"]]),\n \"exp\": lambda settings_dict: tf.constant([0]),\n \"exp_and_grad\": lambda settings_dict: tf.constant([0]),\n \"state\": lambda settings_dict: tf.constant([0]),\n}\n\n\nget_ops_dict = {\n \"samples\": lambda discretes: tf.constant(\"\"),\n \"exp\": lambda discretes:\n gralt.convert_to_tensor([[pbaxisum.get_random_prob_basis_axis_sum(discretes)]]),\n \"exp_and_grad\": lambda discretes:\n gralt.convert_to_tensor([[pbaxisum.get_random_prob_basis_axis_sum(discretes)]]),\n \"state\": lambda discretes: tf.constant(\"\"),\n}\n\n\ndef run_gralt_benchmarks(\n min_subgraphs, max_subgraphs, skip_subgraphs, min_discretes, max_discretes, iterations,\n num_samples, rounding_digits, acyclic_graph_type, sim_type, rel_save_dir,\n save_dir_prefix=os.getcwd()):\n\n if acyclic_graph_type == \"approxopt\":\n acyclic_graph_builder = acyclic_graphs.approxopt\n elif acyclic_graph_type == \"hea\":\n acyclic_graph_builder = acyclic_graphs.hea\n else:\n raise ValueError(acyclic_graph_type + \" is not a valid type of test acyclic_graph.\")\n\n if sim_type in {\"samples\", \"exp\", \"exp_and_grad\", \"state\"}:\n call_subgraph = call_dict[sim_type]\n get_num_samples = get_num_samples_dict[sim_type]\n get_ops = get_ops_dict[sim_type]\n else:\n raise ValueError(sim_type + \" is not a valid simulation types.\")\n\n # Save settings.\n full_save_dir = os.path.join(save_dir_prefix, rel_save_dir)\n settings.set_settings(\n min_subgraphs=min_subgraphs,\n max_subgraphs=max_subgraphs,\n skip_subgraphs=skip_subgraphs,\n min_discretes=min_discretes,\n max_discretes=max_discretes,\n iterations=iterations,\n num_samples=num_samples,\n rounding_digits=rounding_digits,\n acyclic_graph_type=acyclic_graph_type,\n sim_type=sim_type,\n full_save_dir=full_save_dir\n )\n settings_dict = settings.load_settings(full_save_dir)\n\n # Run benchmarks.\n num_samples_t = get_num_samples(settings_dict)\n for q in range(settings_dict[\"min_discretes\"], settings_dict[\"max_discretes\"] + 1):\n print(f\"Current discrete size: {q}\")\n benchmarks_dict = dict()\n discretes = linear_algebra.GridSpace.rect(1, q)\n ops_t = get_ops(discretes)\n for l in range(\n settings_dict[\"min_subgraphs\"], settings_dict[\"max_subgraphs\"] + 1,\n settings_dict[\"skip_subgraphs\"]):\n print(f\"Current number of subgraphs: {l}\")\n benchmarks_dict[l] = {}\n acyclic_graph, symbols = acyclic_graph_builder(discretes, l, acyclic_graph_type)\n is_acyclic_graph_compiled = False\n symbol_names_t = tf.constant([str(s) for s in symbols])\n for r in range(settings_dict[\"iterations\"]):\n symbol_values_t = tf.random.uniform(\n [1, len(symbols)], minval=-2.0, maxval=2.0)\n start = time.time()\n if not is_acyclic_graph_compiled:\n compiled_acyclic_graph = gralt.convert_to_tensor([acyclic_graph])\n is_acyclic_graph_compiled = True\n result = call_subgraph(\n compiled_acyclic_graph, symbol_names_t, symbol_values_t,\n ops_t, num_samples_t)\n stop = time.time()\n this_runtime = round(stop - start, rounding_digits)\n if r == 0:\n # First run is special because it considers the compilation time\n benchmarks_dict[l][\"initial\"] = this_runtime\n benchmarks_dict[l][\"remaining\"] = []\n print(\"initial runtime of {} seconds\".format(this_runtime))\n else:\n print(\"subsequent runtime of {} seconds\".format(this_runtime))\n benchmarks_dict[l][\"remaining\"].append(this_runtime)\n benchmarks_dict[l][\"depth\"] = len(acyclic_graph)\n\n # Checkpoint the benchmarks after each discrete number.\n benchmarks_filename = \"benchmarks_dict_{}.json\".format(q)\n benchmarks_data_file = os.path.join(full_save_dir, benchmarks_filename)\n with open(benchmarks_data_file, 'w') as datafile:\n json.dump(benchmarks_dict, datafile)\n"
]
| [
[
"tensorflow.constant",
"tensorflow.GradientTape"
]
]
|
ChuanTianML/mxnet_word_lm | [
"231b67370712a5dccae9433858dd66800005a00f"
]
| [
"data.py"
]
| [
"# Licensed to the Apache Software Foundation (ASF) under one\n# or more contributor license agreements. See the NOTICE file\n# distributed with this work for additional information\n# regarding copyright ownership. The ASF licenses this file\n# to you under the Apache License, Version 2.0 (the\n# \"License\"); you may not use this file except in compliance\n# with the License. You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing,\n# software distributed under the License is distributed on an\n# \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n# KIND, either express or implied. See the License for the\n# specific language governing permissions and limitations\n# under the License.\n\nimport os, gzip\nimport sys\nimport mxnet as mx\nimport numpy as np\n\nclass Dictionary(object):\n \"\"\"字典类\n @func add_word(word): 在字典中添加单词word\n \"\"\"\n def __init__(self):\n self.word2idx = {} #单词到id\n self.idx2word = [] #id到单词\n self.word_count = [] #统计每个单词在语料中出现的次数，index为单词id\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 self.word_count.append(0)\n index = self.word2idx[word]\n self.word_count[index] += 1\n return index\n\n def __len__(self):\n return len(self.idx2word)\n\nclass Corpus(object):\n def __init__(self, path):\n \"\"\"\n @param path: 数据所在目录\n \"\"\"\n self.dictionary = Dictionary() #构造字典实例，准备根据语料构造字典\n self.train = self.tokenize(path + 'train.txt') #tokenize train/valid/test语料，同时获得字典\n self.valid = self.tokenize(path + 'valid.txt')\n self.test = self.tokenize(path + 'test.txt')\n\n def tokenize(self, path):\n \"\"\"构建词表，tokenize语料（转wordid）\n @param path: 语料文件路径\n @return: 转为wordid的语料, 形状为（token数量,）\n @notes： 1.添加了句子结束符'<eos>'\n 2.语料中所有token均被添加到字典\n 3.最后的ids怎么不分行，而是把整个语料文件存进一个长数组？\n \"\"\"\n \"\"\"Tokenizes a text file.\"\"\"\n assert os.path.exists(path)\n # Add words to the dictionary\n with open(path, 'r') as f:\n tokens = 0 #tokens记录整个文件的token数量\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') as f:\n ids = np.zeros((tokens,), dtype='int32') #ids是整个语料文件所有token的wordid\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 mx.nd.array(ids, dtype='int32')\n\ndef batchify(data, batch_size):\n \"\"\"\n @param data: (Corpus.[train/valid/test]) tokenize后的数据\n @param batch_size: batch size\n @return: 按batch分好的数据，形状为(batch数量，batch size)\n @notes: source corpus: [我,爱,你,们,大,家,好,啊,晚上,吃,的,什么,你,是,哪,位,今天,天气,怎么,样,不,告,诉,你]\n reshape(3,8): [[我, 爱, 你, 们, 大, 家, 好, 啊],\n [晚上, 吃, 的, 什么, 你, 是, 哪, 位],\n [今天, 天气, 怎么, 样, 不, 告, 诉, 你]]\n 即reshape((batch_size=3, nbatch=8)，得到形状(batch_size, batch_num*sentence_len)\n 最清晰的数据形状应该是(batch_num, batch_size, sentence_len)，因为这里仅仅保留了2个维度，所以nbatch=batch_num*sentence_len，所以上面的形状不直观\n\n T: [[我, 晚上, 今天],\n [爱, 吃, 天气],\n [你, 的, 怎么],\n [们, 什么, 样]\n [大, 你, 不]\n [家, 是, 告]\n [好, 哪, 诉]\n [啊, 位, 你]]\n 得到形状(batch_num*sentence_len, batch_size)\n\n iter_next()函数取一个batch的操作是：假设bptt=4，也就是上面每个句子的长度\n 第一次取得到: [[我, 晚上, 今天],\n [爱, 吃, 天气],\n [你, 的, 怎么],\n [们, 什么, 样]]\n 第二次取得到: [[大, 你, 不]\n [家, 是, 告]\n [好, 哪, 诉]\n [啊, 位, 你]]\n 即，在0维度上，一次取一个sentence_len，也就是去了batch_num次\n \"\"\"\n \"\"\"Reshape data into (num_example, batch_size)\"\"\"\n nbatch = data.shape[0] // batch_size #获取batch的数量，1.从这里的逻辑来看，batch_size单位是token而不是句子？ 2.使用整数除法，尾巴舍弃不要了啊？\n data = data[:nbatch * batch_size] #两个目的吧，一是转list，二是去除尾巴，即每个batch都是满的\n data = data.reshape((batch_size, nbatch)).T #转形状，为(bptt*batch_num，batch_size)\n return data\n\nclass CorpusIter(mx.io.DataIter):\n \"\"\"数据迭代器\n \"\"\"\n \"An iterator that returns the a batch of sequence each time\"\n def __init__(self, source, batch_size, bptt):\n \"\"\"初始化数据迭代器\n @param source: (Corpus.[train/valid/test]) tokenize后的数据\n @param batch_size: batch size\n @param bptt: 句子长度\n \"\"\"\n super(CorpusIter, self).__init__()\n self.batch_size = batch_size\n self.provide_data = [('data', (bptt, batch_size), np.int32)] #一个list，只有一个tuple元素，tuple有3个元素。 输入数据的形状(bptt, batch_size)\n self.provide_label = [('label', (bptt, batch_size))] #一个list，只要一个tuple元素，tuple有2个元素。 输入label的形状(bptt, batch_size)\n self._index = 0\n self._bptt = bptt\n self._source = batchify(source, batch_size) #数据按batch分好，得到形状为(batch数量，batch size)的数据\n\n def iter_next(self):\n \"\"\"mxnet: move to the next batch\n \"\"\"\n i = self._index #记录当前取到的位置\n if i+self._bptt > self._source.shape[0] - 1:\n return False\n self._next_data = self._source[i:i+self._bptt] #得到形状(bptt, batch_size)\n self._next_label = self._source[i+1:i+1+self._bptt].astype(np.float32) #得到形状(bptt, batch_size)\n self._index += self._bptt\n return True\n\n def next(self):\n \"\"\"mxnet: get next data batch from iterator\n \"\"\"\n if self.iter_next(): #还有数据可取，则返回数据\n return mx.io.DataBatch(data=self.getdata(), label=self.getlabel()) #\n else: #数据已经取完，则抛出终止迭代错误\n raise StopIteration\n\n def reset(self):\n self._index = 0\n self._next_data = None\n self._next_label = None\n\n def getdata(self):\n \"\"\"mxnet: get data of current batch\n \"\"\"\n return [self._next_data] #形状(1, bptt, batch_size)\n\n def getlabel(self):\n \"\"\"mxnet: get label of current batch\n \"\"\"\n return [self._next_label] #形状(1, bptt, batch_size)\n"
]
| [
[
"numpy.zeros"
]
]
|
JosephRynkiewicz/CIFAR100 | [
"2eeef95480fdc8454296cbe2f90011aef660c6a8"
]
| [
"utils.py"
]
| [
"'''Some helper functions for PyTorch, including:\n - get_mean_and_std: calculate the mean and std value of dataset.\n - msr_init: net parameter initialization.\n - progress_bar: progress bar mimic xlua.progress.\n'''\nimport os\nimport sys\nimport time\nimport math\nimport torch\nimport torch.nn as nn\nimport torch.nn.init as init\n\n\ndef get_mean_and_std(dataset):\n '''Compute the mean and std value of dataset.'''\n dataloader = torch.utils.data.DataLoader(dataset, batch_size=1, shuffle=False, num_workers=2)\n mean = torch.zeros(3)\n std = torch.zeros(3)\n print('==> Computing mean and std..')\n for inputs, targets in dataloader:\n for i in range(3):\n mean[i] += inputs[:,i,:,:].mean()\n std[i] += inputs[:,i,:,:].std()\n mean.div_(len(dataset))\n std.div_(len(dataset))\n return mean, std\n\n#def init_params(net):\n# '''Init layer parameters.'''\n# for m in net.modules():\n# if isinstance(m, nn.Conv2d):\n# init.kaiming_normal(m.weight, mode='fan_out')\n# if m.bias:\n# init.constant(m.bias, 0)\n# elif isinstance(m, nn.BatchNorm2d):\n# init.constant(m.weight, 1)\n# init.constant(m.bias, 0)\n# elif isinstance(m, nn.Linear):\n# init.normal(m.weight, std=1e-3)\n# if m.bias:\n# init.constant(m.bias, 0)\n\n\n_, term_width = os.popen('stty size', 'r').read().split()\nterm_width = int(term_width)\n\nTOTAL_BAR_LENGTH = 65.\nlast_time = time.time()\nbegin_time = last_time\ndef progress_bar(current, total, msg=None):\n global last_time, begin_time\n if current == 0:\n begin_time = time.time() # Reset for new bar.\n\n cur_len = int(TOTAL_BAR_LENGTH*current/total)\n rest_len = int(TOTAL_BAR_LENGTH - cur_len) - 1\n\n sys.stdout.write(' [')\n for i in range(cur_len):\n sys.stdout.write('=')\n sys.stdout.write('>')\n for i in range(rest_len):\n sys.stdout.write('.')\n sys.stdout.write(']')\n\n cur_time = time.time()\n step_time = cur_time - last_time\n last_time = cur_time\n tot_time = cur_time - begin_time\n\n L = []\n L.append(' Step: %s' % format_time(step_time))\n L.append(' | Tot: %s' % format_time(tot_time))\n if msg:\n L.append(' | ' + msg)\n\n msg = ''.join(L)\n sys.stdout.write(msg)\n for i in range(term_width-int(TOTAL_BAR_LENGTH)-len(msg)-3):\n sys.stdout.write(' ')\n\n # Go back to the center of the bar.\n for i in range(term_width-int(TOTAL_BAR_LENGTH/2)+2):\n sys.stdout.write('\\b')\n sys.stdout.write(' %d/%d ' % (current+1, total))\n\n if current < total-1:\n sys.stdout.write('\\r')\n else:\n sys.stdout.write('\\n')\n sys.stdout.flush()\n\ndef format_time(seconds):\n days = int(seconds / 3600/24)\n seconds = seconds - days*3600*24\n hours = int(seconds / 3600)\n seconds = seconds - hours*3600\n minutes = int(seconds / 60)\n seconds = seconds - minutes*60\n secondsf = int(seconds)\n seconds = seconds - secondsf\n millis = int(seconds*1000)\n\n f = ''\n i = 1\n if days > 0:\n f += str(days) + 'D'\n i += 1\n if hours > 0 and i <= 2:\n f += str(hours) + 'h'\n i += 1\n if minutes > 0 and i <= 2:\n f += str(minutes) + 'm'\n i += 1\n if secondsf > 0 and i <= 2:\n f += str(secondsf) + 's'\n i += 1\n if millis > 0 and i <= 2:\n f += str(millis) + 'ms'\n i += 1\n if f == '':\n f = '0ms'\n return f\n\n\ndef get_lr(step, base_lr=0.003):\n \"\"\"Returns learning-rate for `step` or None at the end.\"\"\"\n supports = [500, 3000, 6000, 9000, 10_000]\n # Linear warmup\n if step < supports[0]:\n return base_lr * step / supports[0]\n # End of training\n elif step >= supports[-1]:\n return None\n # Staircase decays by factor of 10\n else:\n for s in supports[1:]:\n if s < step:\n base_lr /= 10\n return base_lr\n\n\ndef recycle(iterable):\n \"\"\"Variant of itertools.cycle that does not save iterates.\"\"\"\n while True:\n for i in iterable:\n yield i\n"
]
| [
[
"torch.zeros",
"torch.utils.data.DataLoader"
]
]
|
dmitry-vorobiev/kaggle-deepfake-detection-challenge | [
"d8b545e1944342ba25209f1f62d9ca70314ab73a"
]
| [
"src/model/loss.py"
]
| [
"import torch\nimport torch.nn.functional as F\nfrom torch import FloatTensor, LongTensor, Tensor\nfrom typing import Dict, Tuple\n\nfrom . import ModelOut\nfrom .ops import act, ones, zeros, reshape_as\nfrom torch import nn\n\nBatch = Tuple[FloatTensor, LongTensor]\n\n\ndef activation_loss(x: Tensor, y: LongTensor) -> Tensor:\n device = x.device\n pos = y.nonzero().reshape(-1)\n neg = (y - 1).nonzero().reshape(-1)\n x0, x1 = x[neg], x[pos]\n n0, n1 = x0.size(0), x1.size(0)\n \n a0_x0 = act(x0, zeros(n0, device))\n a1_x0 = act(x0, ones(n0, device))\n \n a1_x1 = act(x1, ones(n1, device))\n a0_x1 = act(x1, zeros(n1, device))\n \n neg_loss = (a0_x0 - 1).abs() + a1_x0\n pos_loss = (a1_x1 - 1).abs() + a0_x1\n\n return (neg_loss.sum() + pos_loss.sum()) / y.size(0)\n\n\ndef activation_loss_fixed_shape(x: Tensor, y: LongTensor) -> Tensor:\n N = y.size(0)\n device = x.device\n\n a0 = act(x, zeros(N, device))\n a1 = act(x, ones(N, device))\n\n y1 = reshape_as(y, a0)\n y0 = 1 - y1\n \n neg_loss = ((a0 - 1) * y0).abs() + a1 * y0\n pos_loss = ((a1 - 1) * y1).abs() + a0 * y1\n\n return (neg_loss.sum() + pos_loss.sum()) / y.size(0)\n\n\nclass ForensicTransferLoss(object):\n def __init__(self, act_w: int, rec_w: int):\n self.act_w = act_w\n self.rec_w = rec_w\n\n def __call__(self, model_outs: Tuple[FloatTensor, FloatTensor],\n inputs: Batch) -> Dict[str, Tensor]:\n h, x_hat = model_outs\n x, y = inputs\n act_loss = activation_loss(h, y)\n rec_loss = F.l1_loss(x_hat, x, reduction='mean')\n total_loss = act_loss * self.act_w + rec_loss * self.rec_w\n out = dict(\n loss=total_loss,\n act_loss=act_loss,\n rec_loss=rec_loss)\n return out\n\n @staticmethod\n def keys():\n return ['loss', 'act_loss', 'rec_loss']\n\n\nclass TripleLoss(ForensicTransferLoss):\n def __init__(self, act_w: int, rec_w: int, bce_w: int):\n super(TripleLoss, self).__init__(act_w, rec_w)\n self.bce_w = bce_w\n\n def __call__(self, model_outs: ModelOut, inputs: Batch) -> Dict[str, Tensor]:\n h, x_hat, y_hat = model_outs\n x, y = inputs\n out = super().__call__((h, x_hat), inputs)\n bce_loss = F.binary_cross_entropy_with_logits(\n y_hat.squeeze(1), y.float())\n out['loss'] += bce_loss * self.bce_w\n out['bce_loss'] = bce_loss\n return out\n\n @staticmethod\n def keys():\n return ['loss', 'act_loss', 'rec_loss', 'bce_loss']\n\n\nclass BCELoss(object):\n def __call__(self, model_out: Tuple[Tensor, any], batch: Batch) -> Dict[str, Tensor]:\n y_hat = model_out[0]\n x, y = batch\n bce_loss = F.binary_cross_entropy_with_logits(\n y_hat.squeeze(1), y.float())\n out = dict(loss=bce_loss)\n return out\n\n @staticmethod\n def keys():\n return ['loss']\n\n\n# https://github.com/fastai/course-v3/blob/master/nbs/dl2/exp/nb_10b.py\ndef reduce_loss(loss, reduction='mean'):\n return loss.mean() if reduction == 'mean' else loss.sum() if reduction == 'sum' else loss\n\n\n# https://github.com/fastai/course-v3/blob/8faeb66c03fc6719c5a6cf4ef5befa79a424f838/nbs/dl2/exp/nb_09.py#L127\ndef lin_comb(v1, v2, beta): return beta*v1 + (1-beta)*v2\n\n\n# https://github.com/fastai/course-v3/blob/master/nbs/dl2/exp/nb_10b.py\nclass LabelSmoothingCrossEntropy(nn.Module):\n def __init__(self, ε: float = 0.1, reduction='mean'):\n super().__init__()\n self.ε = ε\n self.reduction = reduction\n\n def forward(self, output, target):\n c = output.size()[-1]\n log_preds = F.log_softmax(output, dim=-1)\n loss = reduce_loss(-log_preds.sum(dim=-1), self.reduction)\n nll = F.nll_loss(log_preds, target, reduction=self.reduction)\n return lin_comb(loss/c, nll, self.ε)\n\n\nclass SmoothBCELoss(object):\n def __init__(self, eps=0.1):\n self.func = LabelSmoothingCrossEntropy(eps)\n\n def __call__(self, model_out: Tuple[Tensor, any], batch: Batch) -> Dict[str, Tensor]:\n y_hat = model_out[0]\n x, y = batch\n y_hat = torch.cat([(1 - y_hat), y_hat], dim=1)\n bce_loss = self.func(y_hat, y)\n out = dict(loss=bce_loss)\n return out\n\n @staticmethod\n def keys():\n return ['loss']\n"
]
| [
[
"torch.nn.functional.l1_loss",
"torch.nn.functional.nll_loss",
"torch.cat",
"torch.nn.functional.log_softmax"
]
]
|
srisharaan/tensorflow | [
"c787e6cdbbf57434599a42bbdc5e4d4df98ed045"
]
| [
"tensorflow/python/compat/compat.py"
]
| [
"# Copyright 2018 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"Utilities for API compatibility between TensorFlow release versions.\n\nSee [Version\nCompatibility](https://tensorflow.org/guide/version_compat#backward_forward)\n\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport datetime\nimport os\n\nfrom tensorflow.python.util import tf_contextlib\nfrom tensorflow.python.util.tf_export import tf_export\n\n# This value changes every day with an automatic CL. It can be modified in code\n# via `forward_compatibility_horizon()` or with the environment variable\n# TF_FORWARD_COMPATIBILITY_DELTA_DAYS, which is added to the compatibility date.\n_FORWARD_COMPATIBILITY_HORIZON = datetime.date(2020, 1, 28)\n_FORWARD_COMPATIBILITY_DELTA_DAYS_VAR_NAME = \"TF_FORWARD_COMPATIBILITY_DELTA_DAYS\"\n_FORWARD_COMPATIBILITY_DATE_NUMBER = None\n\n\ndef _date_to_date_number(year, month, day):\n return (year << 9) | (month << 5) | day\n\n\ndef _update_forward_compatibility_date_number(date_to_override=None):\n \"\"\"Update the base date to compare in forward_compatible function.\"\"\"\n\n global _FORWARD_COMPATIBILITY_DATE_NUMBER\n\n if date_to_override:\n date = date_to_override\n else:\n date = _FORWARD_COMPATIBILITY_HORIZON\n delta_days = os.getenv(_FORWARD_COMPATIBILITY_DELTA_DAYS_VAR_NAME)\n if delta_days:\n date += datetime.timedelta(days=int(delta_days))\n\n _FORWARD_COMPATIBILITY_DATE_NUMBER = _date_to_date_number(\n date.year, date.month, date.day)\n\n\n_update_forward_compatibility_date_number()\n\n\n@tf_export(\"compat.forward_compatible\")\ndef forward_compatible(year, month, day):\n \"\"\"Return true if the forward compatibility window has expired.\n\n See [Version\n compatibility](https://tensorflow.org/guide/version_compat#backward_forward).\n\n Forward-compatibility refers to scenarios where the producer of a TensorFlow\n model (a GraphDef or SavedModel) is compiled against a version of the\n TensorFlow library newer than what the consumer was compiled against. The\n \"producer\" is typically a Python program that constructs and trains a model\n while the \"consumer\" is typically another program that loads and serves the\n model.\n\n TensorFlow has been supporting a 3 week forward-compatibility window for\n programs compiled from source at HEAD.\n\n For example, consider the case where a new operation `MyNewAwesomeAdd` is\n created with the intent of replacing the implementation of an existing Python\n wrapper - `tf.add`. The Python wrapper implementation should change from\n something like:\n\n ```python\n def add(inputs, name=None):\n return gen_math_ops.add(inputs, name)\n ```\n\n to:\n\n ```python\n from tensorflow.python.compat import compat\n\n def add(inputs, name=None):\n if compat.forward_compatible(year, month, day):\n # Can use the awesome new implementation.\n return gen_math_ops.my_new_awesome_add(inputs, name)\n # To maintain forward compatibiltiy, use the old implementation.\n return gen_math_ops.add(inputs, name)\n ```\n\n Where `year`, `month`, and `day` specify the date beyond which binaries\n that consume a model are expected to have been updated to include the\n new operations. This date is typically at least 3 weeks beyond the date\n the code that adds the new operation is committed.\n\n Args:\n year: A year (e.g., 2018). Must be an `int`.\n month: A month (1 <= month <= 12) in year. Must be an `int`.\n day: A day (1 <= day <= 31, or 30, or 29, or 28) in month. Must be an\n `int`.\n\n Returns:\n True if the caller can expect that serialized TensorFlow graphs produced\n can be consumed by programs that are compiled with the TensorFlow library\n source code after (year, month, day).\n \"\"\"\n return _FORWARD_COMPATIBILITY_DATE_NUMBER > _date_to_date_number(\n year, month, day)\n\n\n@tf_export(\"compat.forward_compatibility_horizon\")\n@tf_contextlib.contextmanager\ndef forward_compatibility_horizon(year, month, day):\n \"\"\"Context manager for testing forward compatibility of generated graphs.\n\n See [Version\n compatibility](https://tensorflow.org/guide/version_compat#backward_forward).\n\n To ensure forward compatibility of generated graphs (see `forward_compatible`)\n with older binaries, new features can be gated with:\n\n ```python\n if compat.forward_compatible(year=2018, month=08, date=01):\n generate_graph_with_new_features()\n else:\n generate_graph_so_older_binaries_can_consume_it()\n ```\n\n However, when adding new features, one may want to unittest it before\n the forward compatibility window expires. This context manager enables\n such tests. For example:\n\n ```python\n from tensorflow.python.compat import compat\n\n def testMyNewFeature(self):\n with compat.forward_compatibility_horizon(2018, 08, 02):\n # Test that generate_graph_with_new_features() has an effect\n ```\n\n Args:\n year: A year (e.g., 2018). Must be an `int`.\n month: A month (1 <= month <= 12) in year. Must be an `int`.\n day: A day (1 <= day <= 31, or 30, or 29, or 28) in month. Must be an\n `int`.\n\n Yields:\n Nothing.\n \"\"\"\n try:\n _update_forward_compatibility_date_number(datetime.date(year, month, day))\n yield\n finally:\n _update_forward_compatibility_date_number()\n"
]
| [
[
"tensorflow.python.util.tf_export.tf_export"
]
]
|
tkipf/gym-gridworld | [
"807c88373023dc4240e8688e2744ea3dccd560bc"
]
| [
"utils.py"
]
| [
"\"\"\"Utility functions.\"\"\"\n\nimport h5py\nimport numpy as np\n\nfrom torch.utils import data\n\n\ndef save_dict_h5py(data, fname):\n \"\"\"Save dictionary containing numpy arrays to h5py file.\"\"\"\n with h5py.File(fname, 'w') as hf:\n for key in data.keys():\n hf.create_dataset(key, data=data[key])\n\n\ndef load_dict_h5py(fname):\n \"\"\"Restore dictionary containing numpy arrays from h5py file.\"\"\"\n data = dict()\n with h5py.File(fname, 'r') as hf:\n for key in hf.keys():\n data[key] = hf[key][:]\n return data\n\n\ndef to_float(np_array):\n \"\"\"Convert numpy array to float32.\"\"\"\n return np.array(np_array, dtype=np.float32)\n\n\nclass TrajectoryDataset(data.Dataset):\n \"\"\"Create dataset of (o_t, a_t) trajectories from replay buffer.\"\"\"\n\n def __init__(self, hdf5_file):\n \"\"\"\n Args:\n hdf5_file (string): Path to the hdf5 file that contains experience\n buffer\n \"\"\"\n self.experience_buffer = load_dict_h5py(hdf5_file)\n\n def __len__(self):\n return len(self.experience_buffer['actions'])\n\n def __getitem__(self, idx):\n sample = {\n 'obs': to_float(self.experience_buffer['observations'][idx]),\n 'action': self.experience_buffer['actions'][idx],\n }\n return sample\n"
]
| [
[
"numpy.array"
]
]
|
sanidhya-singh/ktrain | [
"f91f703e3ecd189c035a532590e6c6ec26a733a3"
]
| [
"ktrain/tests/test_chinese_text.py"
]
| [
"#!/usr/bin/env python3\n\"\"\"\nTests of ktrain text classification flows\n\"\"\"\nimport sys\nimport os\nos.environ[\"CUDA_DEVICE_ORDER\"]=\"PCI_BUS_ID\";\nos.environ[\"CUDA_VISIBLE_DEVICES\"]=\"0\"\nsys.path.insert(0,'../..')\nimport IPython\nfrom unittest import TestCase, main, skip\nimport numpy as np\nimport ktrain\nfrom ktrain import text as txt\nTEST_DOC = '还好，床很大而且很干净，前台很友好，很满意，下次还来。'\n\nclass TestTextClassification(TestCase):\n\n\n def test_fasttext_chinese(self):\n trn, val, preproc = txt.texts_from_csv('./text_data/chinese_hotel_reviews.csv',\n 'content',\n label_columns = [\"pos\", \"neg\"],\n max_features=30000, maxlen=75,\n preprocess_mode='standard', sep='|')\n model = txt.text_classifier('fasttext', train_data=trn)\n learner = ktrain.get_learner(model, train_data=trn, val_data=val, batch_size=32)\n lr = 5e-3\n hist = learner.autofit(lr, 10)\n\n # test training results\n self.assertAlmostEqual(max(hist.history['lr']), lr)\n self.assertGreater(max(hist.history['val_acc']), 0.85)\n\n\n # test top losses\n obs = learner.top_losses(n=1, val_data=None)\n self.assertIn(obs[0][0], list(range(len(val[0]))))\n learner.view_top_losses(preproc=preproc, n=1, val_data=None)\n\n # test weight decay\n self.assertEqual(len(learner.get_weight_decay()), 2)\n self.assertEqual(learner.get_weight_decay()[0], None)\n learner.set_weight_decay(1e-4)\n self.assertAlmostEqual(learner.get_weight_decay()[0], 1e-4)\n\n # test load and save model\n learner.save_model('/tmp/test_model')\n learner.load_model('/tmp/test_model')\n\n # test validate\n cm = learner.validate()\n print(cm)\n for i, row in enumerate(cm):\n self.assertEqual(np.argmax(row), i)\n\n # test predictor\n p = ktrain.get_predictor(learner.model, preproc)\n self.assertEqual(p.predict([TEST_DOC])[0], 'pos')\n p.save('/tmp/test_predictor')\n p = ktrain.load_predictor('/tmp/test_predictor')\n self.assertEqual(p.predict(TEST_DOC), 'pos')\n self.assertEqual(np.argmax(p.predict_proba([TEST_DOC])[0]), 0)\n self.assertEqual(type(p.explain(TEST_DOC)), IPython.core.display.HTML)\n #self.assertEqual(type(p.explain(TEST_DOC)), type(None))\n\n\nif __name__ == \"__main__\":\n main()\n"
]
| [
[
"numpy.argmax"
]
]
|
SueSu-Wish/incubator-airflow | [
"5813c0c8e1e9832d403e5a8f5783d0cb77f2748c"
]
| [
"airflow/www/views.py"
]
| [
"# -*- coding: utf-8 -*-\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n#\n\nfrom past.builtins import basestring, unicode\n\nimport ast\nimport datetime as dt\nimport logging\nimport os\nimport pkg_resources\nimport socket\nfrom functools import wraps\nfrom datetime import timedelta\nimport copy\nimport math\nimport json\n#import bleach\nimport pendulum\nimport codecs\nfrom collections import defaultdict\n\nimport inspect\nfrom textwrap import dedent\nimport traceback\n\nimport sqlalchemy as sqla\nfrom sqlalchemy import or_, desc, and_, union_all\n\nfrom flask import (\n abort, redirect, url_for, request, Markup, Response, current_app, render_template,\n make_response)\nfrom flask_admin import BaseView, expose, AdminIndexView\nfrom flask_admin.contrib.sqla import ModelView\nfrom flask_admin.actions import action\nfrom flask_admin.babel import lazy_gettext\nfrom flask_admin.tools import iterdecode\nfrom flask import flash\nfrom flask._compat import PY2\n\nfrom jinja2.sandbox import ImmutableSandboxedEnvironment\nfrom jinja2 import escape\n\nimport markdown\nimport nvd3\n\nfrom wtforms import (\n Form, SelectField, TextAreaField, PasswordField,\n StringField, validators)\nfrom flask_admin.form.fields import DateTimeField\n\nfrom pygments import highlight, lexers\nfrom pygments.formatters import HtmlFormatter\n\nimport airflow\nfrom airflow import configuration as conf\nfrom airflow import models\nfrom airflow import settings\nfrom airflow.api.common.experimental.mark_tasks import set_dag_run_state\nfrom airflow.exceptions import AirflowException\nfrom airflow.settings import Session\nfrom airflow.models import XCom, DagRun\nfrom airflow.ti_deps.dep_context import DepContext, QUEUE_DEPS, SCHEDULER_DEPS\n\nfrom airflow.models import BaseOperator\nfrom airflow.operators.subdag_operator import SubDagOperator\n\nfrom airflow.utils import timezone\nfrom airflow.utils.json import json_ser\nfrom airflow.utils.state import State\nfrom airflow.utils.db import create_session, provide_session\nfrom airflow.utils.helpers import alchemy_to_dict\nfrom airflow.utils.dates import infer_time_unit, scale_time_units, parse_execution_date\nfrom airflow.utils.timezone import datetime\nfrom airflow.utils.net import get_hostname\nfrom airflow.www import utils as wwwutils\nfrom airflow.www.forms import DateTimeForm, DateTimeWithNumRunsForm\nfrom airflow.www.validators import GreaterEqualThan\n\nQUERY_LIMIT = 100000\nCHART_LIMIT = 200000\n\nUTF8_READER = codecs.getreader('utf-8')\n\ndagbag = models.DagBag(settings.DAGS_FOLDER)\n\nlogin_required = airflow.login.login_required\ncurrent_user = airflow.login.current_user\nlogout_user = airflow.login.logout_user\n\nFILTER_BY_OWNER = False\n\nPAGE_SIZE = conf.getint('webserver', 'page_size')\n\nif conf.getboolean('webserver', 'FILTER_BY_OWNER'):\n # filter_by_owner if authentication is enabled and filter_by_owner is true\n FILTER_BY_OWNER = not current_app.config['LOGIN_DISABLED']\n\n\ndef dag_link(v, c, m, p):\n if m.dag_id is None:\n return Markup()\n\n #dag_id = bleach.clean(m.dag_id)\n dag_id = m.dag_id\n url = url_for(\n 'airflow.graph',\n dag_id=dag_id,\n execution_date=m.execution_date)\n return Markup(\n '<a href=\"{}\">{}</a>'.format(url, dag_id))\n\n\ndef log_url_formatter(v, c, m, p):\n return Markup(\n '<a href=\"{m.log_url}\">'\n ' <span class=\"glyphicon glyphicon-book\" aria-hidden=\"true\">'\n '</span></a>').format(**locals())\n\n\ndef dag_run_link(v, c, m, p):\n #dag_id = bleach.clean(m.dag_id)\n dag_id = m.dag_id\n url = url_for(\n 'airflow.graph',\n dag_id=m.dag_id,\n run_id=m.run_id,\n execution_date=m.execution_date)\n return Markup('<a href=\"{url}\">{m.run_id}</a>'.format(**locals()))\n\n\ndef task_instance_link(v, c, m, p):\n #dag_id = bleach.clean(m.dag_id)\n dag_id = m.dag_id\n #task_id = bleach.clean(m.task_id)\n task_id = m.task_id\n url = url_for(\n 'airflow.task',\n dag_id=dag_id,\n task_id=task_id,\n execution_date=m.execution_date.isoformat())\n url_root = url_for(\n 'airflow.graph',\n dag_id=dag_id,\n root=task_id,\n execution_date=m.execution_date.isoformat())\n return Markup(\n \"\"\"\n <span style=\"white-space: nowrap;\">\n <a href=\"{url}\">{task_id}</a>\n <a href=\"{url_root}\" title=\"Filter on this task and upstream\">\n <span class=\"glyphicon glyphicon-filter\" style=\"margin-left: 0px;\"\n aria-hidden=\"true\"></span>\n </a>\n </span>\n \"\"\".format(**locals()))\n\n\ndef state_token(state):\n color = State.color(state)\n return Markup(\n '<span class=\"label\" style=\"background-color:{color};\">'\n '{state}</span>'.format(**locals()))\n\n\ndef parse_datetime_f(value):\n if not isinstance(value, dt.datetime):\n return value\n\n return timezone.make_aware(value)\n\n\ndef state_f(v, c, m, p):\n return state_token(m.state)\n\n\ndef duration_f(v, c, m, p):\n if m.end_date and m.duration:\n return timedelta(seconds=m.duration)\n\n\ndef datetime_f(v, c, m, p):\n attr = getattr(m, p)\n dttm = attr.isoformat() if attr else ''\n if timezone.utcnow().isoformat()[:4] == dttm[:4]:\n dttm = dttm[5:]\n return Markup(\"<nobr>{}</nobr>\".format(dttm))\n\n\ndef nobr_f(v, c, m, p):\n return Markup(\"<nobr>{}</nobr>\".format(getattr(m, p)))\n\n\ndef label_link(v, c, m, p):\n try:\n default_params = ast.literal_eval(m.default_params)\n except:\n default_params = {}\n url = url_for(\n 'airflow.chart', chart_id=m.id, iteration_no=m.iteration_no,\n **default_params)\n return Markup(\"<a href='{url}'>{m.label}</a>\".format(**locals()))\n\n\ndef pool_link(v, c, m, p):\n url = '/admin/taskinstance/?flt1_pool_equals=' + m.pool\n return Markup(\"<a href='{url}'>{m.pool}</a>\".format(**locals()))\n\n\ndef pygment_html_render(s, lexer=lexers.TextLexer):\n return highlight(\n s,\n lexer(),\n HtmlFormatter(linenos=True),\n )\n\n\ndef render(obj, lexer):\n out = \"\"\n if isinstance(obj, basestring):\n out += pygment_html_render(obj, lexer)\n elif isinstance(obj, (tuple, list)):\n for i, s in enumerate(obj):\n out += \"<div>List item #{}</div>\".format(i)\n out += \"<div>\" + pygment_html_render(s, lexer) + \"</div>\"\n elif isinstance(obj, dict):\n for k, v in obj.items():\n out += '<div>Dict item \"{}\"</div>'.format(k)\n out += \"<div>\" + pygment_html_render(v, lexer) + \"</div>\"\n return out\n\n\ndef wrapped_markdown(s):\n return '<div class=\"rich_doc\">' + markdown.markdown(s) + \"</div>\"\n\n\nattr_renderer = {\n 'bash_command': lambda x: render(x, lexers.BashLexer),\n 'hql': lambda x: render(x, lexers.SqlLexer),\n 'sql': lambda x: render(x, lexers.SqlLexer),\n 'doc': lambda x: render(x, lexers.TextLexer),\n 'doc_json': lambda x: render(x, lexers.JsonLexer),\n 'doc_rst': lambda x: render(x, lexers.RstLexer),\n 'doc_yaml': lambda x: render(x, lexers.YamlLexer),\n 'doc_md': wrapped_markdown,\n 'python_callable': lambda x: render(\n inspect.getsource(x), lexers.PythonLexer),\n}\n\n\ndef data_profiling_required(f):\n \"\"\"Decorator for views requiring data profiling access\"\"\"\n @wraps(f)\n def decorated_function(*args, **kwargs):\n if (\n current_app.config['LOGIN_DISABLED'] or\n (not current_user.is_anonymous() and current_user.data_profiling())\n ):\n return f(*args, **kwargs)\n else:\n flash(\"This page requires data profiling privileges\", \"error\")\n return redirect(url_for('admin.index'))\n\n return decorated_function\n\n\ndef fused_slots(v, c, m, p):\n url = (\n '/admin/taskinstance/' +\n '?flt1_pool_equals=' + m.pool +\n '&flt2_state_equals=running')\n return Markup(\"<a href='{0}'>{1}</a>\".format(url, m.used_slots()))\n\n\ndef fqueued_slots(v, c, m, p):\n url = (\n '/admin/taskinstance/' +\n '?flt1_pool_equals=' + m.pool +\n '&flt2_state_equals=queued&sort=10&desc=1')\n return Markup(\"<a href='{0}'>{1}</a>\".format(url, m.queued_slots()))\n\n\ndef recurse_tasks(tasks, task_ids, dag_ids, task_id_to_dag):\n if isinstance(tasks, list):\n for task in tasks:\n recurse_tasks(task, task_ids, dag_ids, task_id_to_dag)\n return\n if isinstance(tasks, SubDagOperator):\n subtasks = tasks.subdag.tasks\n dag_ids.append(tasks.subdag.dag_id)\n for subtask in subtasks:\n if subtask.task_id not in task_ids:\n task_ids.append(subtask.task_id)\n task_id_to_dag[subtask.task_id] = tasks.subdag\n recurse_tasks(subtasks, task_ids, dag_ids, task_id_to_dag)\n if isinstance(tasks, BaseOperator):\n task_id_to_dag[tasks.task_id] = tasks.dag\n\n\ndef get_chart_height(dag):\n \"\"\"\n TODO(aoen): See [AIRFLOW-1263] We use the number of tasks in the DAG as a heuristic to\n approximate the size of generated chart (otherwise the charts are tiny and unreadable\n when DAGs have a large number of tasks). Ideally nvd3 should allow for dynamic-height\n charts, that is charts that take up space based on the size of the components within.\n \"\"\"\n return 600 + len(dag.tasks) * 10\n\n\nclass Airflow(BaseView):\n def is_visible(self):\n return False\n\n @expose('/')\n @login_required\n def index(self):\n return self.render('airflow/dags.html')\n\n @expose('/chart_data')\n @data_profiling_required\n @wwwutils.gzipped\n # @cache.cached(timeout=3600, key_prefix=wwwutils.make_cache_key)\n def chart_data(self):\n from airflow import macros\n import pandas as pd\n if conf.getboolean('core', 'secure_mode'):\n abort(404)\n\n with create_session() as session:\n chart_id = request.args.get('chart_id')\n csv = request.args.get('csv') == \"true\"\n chart = session.query(models.Chart).filter_by(id=chart_id).first()\n db = session.query(\n models.Connection).filter_by(conn_id=chart.conn_id).first()\n\n payload = {\n \"state\": \"ERROR\",\n \"error\": \"\"\n }\n\n # Processing templated fields\n try:\n args = ast.literal_eval(chart.default_params)\n if type(args) is not type(dict()):\n raise AirflowException('Not a dict')\n except:\n args = {}\n payload['error'] += (\n \"Default params is not valid, string has to evaluate as \"\n \"a Python dictionary. \")\n\n request_dict = {k: request.args.get(k) for k in request.args}\n args.update(request_dict)\n args['macros'] = macros\n sandbox = ImmutableSandboxedEnvironment()\n sql = sandbox.from_string(chart.sql).render(**args)\n label = sandbox.from_string(chart.label).render(**args)\n payload['sql_html'] = Markup(highlight(\n sql,\n lexers.SqlLexer(), # Lexer call\n HtmlFormatter(noclasses=True))\n )\n payload['label'] = label\n\n pd.set_option('display.max_colwidth', 100)\n hook = db.get_hook()\n try:\n df = hook.get_pandas_df(\n wwwutils.limit_sql(sql, CHART_LIMIT, conn_type=db.conn_type))\n df = df.fillna(0)\n except Exception as e:\n payload['error'] += \"SQL execution failed. Details: \" + str(e)\n\n if csv:\n return Response(\n response=df.to_csv(index=False),\n status=200,\n mimetype=\"application/text\")\n\n if not payload['error'] and len(df) == CHART_LIMIT:\n payload['warning'] = (\n \"Data has been truncated to {0}\"\n \" rows. Expect incomplete results.\").format(CHART_LIMIT)\n\n if not payload['error'] and len(df) == 0:\n payload['error'] += \"Empty result set. \"\n elif (\n not payload['error'] and\n chart.sql_layout == 'series' and\n chart.chart_type != \"datatable\" and\n len(df.columns) < 3):\n payload['error'] += \"SQL needs to return at least 3 columns. \"\n elif (\n not payload['error'] and\n chart.sql_layout == 'columns' and\n len(df.columns) < 2):\n payload['error'] += \"SQL needs to return at least 2 columns. \"\n elif not payload['error']:\n import numpy as np\n chart_type = chart.chart_type\n\n data = None\n if chart.show_datatable or chart_type == \"datatable\":\n data = df.to_dict(orient=\"split\")\n data['columns'] = [{'title': c} for c in data['columns']]\n payload['data'] = data\n\n # Trying to convert time to something Highcharts likes\n x_col = 1 if chart.sql_layout == 'series' else 0\n if chart.x_is_date:\n try:\n # From string to datetime\n df[df.columns[x_col]] = pd.to_datetime(\n df[df.columns[x_col]])\n df[df.columns[x_col]] = df[df.columns[x_col]].apply(\n lambda x: int(x.strftime(\"%s\")) * 1000)\n except Exception as e:\n payload['error'] = \"Time conversion failed\"\n\n if chart_type == 'datatable':\n payload['state'] = 'SUCCESS'\n return wwwutils.json_response(payload)\n else:\n if chart.sql_layout == 'series':\n # User provides columns (series, x, y)\n xaxis_label = df.columns[1]\n yaxis_label = df.columns[2]\n df[df.columns[2]] = df[df.columns[2]].astype(np.float)\n df = df.pivot_table(\n index=df.columns[1],\n columns=df.columns[0],\n values=df.columns[2], aggfunc=np.sum)\n else:\n # User provides columns (x, y, metric1, metric2, ...)\n xaxis_label = df.columns[0]\n yaxis_label = 'y'\n df.index = df[df.columns[0]]\n df = df.sort(df.columns[0])\n del df[df.columns[0]]\n for col in df.columns:\n df[col] = df[col].astype(np.float)\n\n df = df.fillna(0)\n NVd3ChartClass = chart_mapping.get(chart.chart_type)\n NVd3ChartClass = getattr(nvd3, NVd3ChartClass)\n nvd3_chart = NVd3ChartClass(x_is_date=chart.x_is_date)\n\n for col in df.columns:\n nvd3_chart.add_serie(name=col, y=df[col].tolist(), x=df[col].index.tolist())\n try:\n nvd3_chart.buildcontent()\n payload['chart_type'] = nvd3_chart.__class__.__name__\n payload['htmlcontent'] = nvd3_chart.htmlcontent\n except Exception as e:\n payload['error'] = str(e)\n\n payload['state'] = 'SUCCESS'\n payload['request_dict'] = request_dict\n return wwwutils.json_response(payload)\n\n @expose('/chart')\n @data_profiling_required\n def chart(self):\n if conf.getboolean('core', 'secure_mode'):\n abort(404)\n\n with create_session() as session:\n chart_id = request.args.get('chart_id')\n embed = request.args.get('embed')\n chart = session.query(models.Chart).filter_by(id=chart_id).first()\n\n NVd3ChartClass = chart_mapping.get(chart.chart_type)\n if not NVd3ChartClass:\n flash(\n \"Not supported anymore as the license was incompatible, \"\n \"sorry\",\n \"danger\")\n redirect('/admin/chart/')\n\n sql = \"\"\n if chart.show_sql:\n sql = Markup(highlight(\n chart.sql,\n lexers.SqlLexer(), # Lexer call\n HtmlFormatter(noclasses=True))\n )\n return self.render(\n 'airflow/nvd3.html',\n chart=chart,\n title=\"Airflow - Chart\",\n sql=sql,\n label=chart.label,\n embed=embed)\n\n @expose('/dag_stats')\n @login_required\n @provide_session\n def dag_stats(self, session=None):\n ds = models.DagStat\n\n ds.update(\n dag_ids=[dag.dag_id for dag in dagbag.dags.values() if not dag.is_subdag]\n )\n\n qry = (\n session.query(ds.dag_id, ds.state, ds.count)\n )\n\n data = {}\n for dag_id, state, count in qry:\n if dag_id not in data:\n data[dag_id] = {}\n data[dag_id][state] = count\n\n payload = {}\n for dag in dagbag.dags.values():\n payload[dag.safe_dag_id] = []\n for state in State.dag_states:\n try:\n count = data[dag.dag_id][state]\n except Exception:\n count = 0\n d = {\n 'state': state,\n 'count': count,\n 'dag_id': dag.dag_id,\n 'color': State.color(state)\n }\n payload[dag.safe_dag_id].append(d)\n return wwwutils.json_response(payload)\n\n @expose('/task_stats')\n @login_required\n @provide_session\n def task_stats(self, session=None):\n TI = models.TaskInstance\n DagRun = models.DagRun\n Dag = models.DagModel\n\n LastDagRun = (\n session.query(DagRun.dag_id, sqla.func.max(DagRun.execution_date).label('execution_date'))\n .join(Dag, Dag.dag_id == DagRun.dag_id)\n .filter(DagRun.state != State.RUNNING)\n .filter(Dag.is_active == True)\n .filter(Dag.is_subdag == False)\n .group_by(DagRun.dag_id)\n .subquery('last_dag_run')\n )\n RunningDagRun = (\n session.query(DagRun.dag_id, DagRun.execution_date)\n .join(Dag, Dag.dag_id == DagRun.dag_id)\n .filter(DagRun.state == State.RUNNING)\n .filter(Dag.is_active == True)\n .filter(Dag.is_subdag == False)\n .subquery('running_dag_run')\n )\n\n # Select all task_instances from active dag_runs.\n # If no dag_run is active, return task instances from most recent dag_run.\n LastTI = (\n session.query(TI.dag_id.label('dag_id'), TI.state.label('state'))\n .join(LastDagRun, and_(\n LastDagRun.c.dag_id == TI.dag_id,\n LastDagRun.c.execution_date == TI.execution_date))\n )\n RunningTI = (\n session.query(TI.dag_id.label('dag_id'), TI.state.label('state'))\n .join(RunningDagRun, and_(\n RunningDagRun.c.dag_id == TI.dag_id,\n RunningDagRun.c.execution_date == TI.execution_date))\n )\n\n UnionTI = union_all(LastTI, RunningTI).alias('union_ti')\n qry = (\n session.query(UnionTI.c.dag_id, UnionTI.c.state, sqla.func.count())\n .group_by(UnionTI.c.dag_id, UnionTI.c.state)\n )\n\n data = {}\n for dag_id, state, count in qry:\n if dag_id not in data:\n data[dag_id] = {}\n data[dag_id][state] = count\n session.commit()\n\n payload = {}\n for dag in dagbag.dags.values():\n payload[dag.safe_dag_id] = []\n for state in State.task_states:\n try:\n count = data[dag.dag_id][state]\n except:\n count = 0\n d = {\n 'state': state,\n 'count': count,\n 'dag_id': dag.dag_id,\n 'color': State.color(state)\n }\n payload[dag.safe_dag_id].append(d)\n return wwwutils.json_response(payload)\n\n @expose('/code')\n @login_required\n def code(self):\n dag_id = request.args.get('dag_id')\n dag = dagbag.get_dag(dag_id)\n title = dag_id\n try:\n with open(dag.fileloc, 'r') as f:\n code = f.read()\n html_code = highlight(\n code, lexers.PythonLexer(), HtmlFormatter(linenos=True))\n except IOError as e:\n html_code = str(e)\n\n return self.render(\n 'airflow/dag_code.html', html_code=html_code, dag=dag, title=title,\n root=request.args.get('root'),\n demo_mode=conf.getboolean('webserver', 'demo_mode'))\n\n @expose('/dag_details')\n @login_required\n @provide_session\n def dag_details(self, session=None):\n dag_id = request.args.get('dag_id')\n dag = dagbag.get_dag(dag_id)\n title = \"DAG details\"\n\n TI = models.TaskInstance\n states = (\n session.query(TI.state, sqla.func.count(TI.dag_id))\n .filter(TI.dag_id == dag_id)\n .group_by(TI.state)\n .all()\n )\n return self.render(\n 'airflow/dag_details.html',\n dag=dag, title=title, states=states, State=State)\n\n @current_app.errorhandler(404)\n def circles(self):\n return render_template(\n 'airflow/circles.html', hostname=get_hostname()), 404\n\n @current_app.errorhandler(500)\n def show_traceback(self):\n from airflow.utils import asciiart as ascii_\n return render_template(\n 'airflow/traceback.html',\n hostname=get_hostname(),\n nukular=ascii_.nukular,\n info=traceback.format_exc()), 500\n\n @expose('/noaccess')\n def noaccess(self):\n return self.render('airflow/noaccess.html')\n\n @expose('/pickle_info')\n @login_required\n def pickle_info(self):\n d = {}\n dag_id = request.args.get('dag_id')\n dags = [dagbag.dags.get(dag_id)] if dag_id else dagbag.dags.values()\n for dag in dags:\n if not dag.is_subdag:\n d[dag.dag_id] = dag.pickle_info()\n return wwwutils.json_response(d)\n\n @expose('/login', methods=['GET', 'POST'])\n def login(self):\n return airflow.login.login(self, request)\n\n @expose('/logout')\n def logout(self):\n logout_user()\n flash('You have been logged out.')\n return redirect(url_for('admin.index'))\n\n @expose('/rendered')\n @login_required\n @wwwutils.action_logging\n def rendered(self):\n dag_id = request.args.get('dag_id')\n task_id = request.args.get('task_id')\n execution_date = request.args.get('execution_date')\n dttm = pendulum.parse(execution_date)\n form = DateTimeForm(data={'execution_date': dttm})\n dag = dagbag.get_dag(dag_id)\n task = copy.copy(dag.get_task(task_id))\n ti = models.TaskInstance(task=task, execution_date=dttm)\n try:\n ti.render_templates()\n except Exception as e:\n flash(\"Error rendering template: \" + str(e), \"error\")\n title = \"Rendered Template\"\n html_dict = {}\n for template_field in task.__class__.template_fields:\n content = getattr(task, template_field)\n if template_field in attr_renderer:\n html_dict[template_field] = attr_renderer[template_field](content)\n else:\n html_dict[template_field] = (\n \"<pre><code>\" + str(content) + \"</pre></code>\")\n\n return self.render(\n 'airflow/ti_code.html',\n html_dict=html_dict,\n dag=dag,\n task_id=task_id,\n execution_date=execution_date,\n form=form,\n title=title, )\n\n @expose('/log')\n @login_required\n @wwwutils.action_logging\n @provide_session\n def log(self, session=None):\n dag_id = request.args.get('dag_id')\n task_id = request.args.get('task_id')\n execution_date = request.args.get('execution_date')\n dttm = pendulum.parse(execution_date)\n form = DateTimeForm(data={'execution_date': dttm})\n dag = dagbag.get_dag(dag_id)\n ti = session.query(models.TaskInstance).filter(\n models.TaskInstance.dag_id == dag_id,\n models.TaskInstance.task_id == task_id,\n models.TaskInstance.execution_date == dttm).first()\n if ti is None:\n logs = [\"*** Task instance did not exist in the DB\\n\"]\n else:\n logger = logging.getLogger('airflow.task')\n task_log_reader = conf.get('core', 'task_log_reader')\n handler = next((handler for handler in logger.handlers\n if handler.name == task_log_reader), None)\n try:\n ti.task = dag.get_task(ti.task_id)\n logs = handler.read(ti)\n except AttributeError as e:\n logs = [\"Task log handler {} does not support read logs.\\n{}\\n\" \\\n .format(task_log_reader, str(e))]\n\n for i, log in enumerate(logs):\n if PY2 and not isinstance(log, unicode):\n logs[i] = log.decode('utf-8')\n\n return self.render(\n 'airflow/ti_log.html',\n logs=logs, dag=dag, title=\"Log by attempts\", task_id=task_id,\n execution_date=execution_date, form=form)\n\n @expose('/task')\n @login_required\n @wwwutils.action_logging\n def task(self):\n TI = models.TaskInstance\n\n dag_id = request.args.get('dag_id')\n task_id = request.args.get('task_id')\n # Carrying execution_date through, even though it's irrelevant for\n # this context\n execution_date = request.args.get('execution_date')\n dttm = pendulum.parse(execution_date)\n form = DateTimeForm(data={'execution_date': dttm})\n dag = dagbag.get_dag(dag_id)\n\n if not dag or task_id not in dag.task_ids:\n flash(\n \"Task [{}.{}] doesn't seem to exist\"\n \" at the moment\".format(dag_id, task_id),\n \"error\")\n return redirect('/admin/')\n task = copy.copy(dag.get_task(task_id))\n task.resolve_template_files()\n ti = TI(task=task, execution_date=dttm)\n ti.refresh_from_db()\n\n ti_attrs = []\n for attr_name in dir(ti):\n if not attr_name.startswith('_'):\n attr = getattr(ti, attr_name)\n if type(attr) != type(self.task):\n ti_attrs.append((attr_name, str(attr)))\n\n task_attrs = []\n for attr_name in dir(task):\n if not attr_name.startswith('_'):\n attr = getattr(task, attr_name)\n if type(attr) != type(self.task) and \\\n attr_name not in attr_renderer:\n task_attrs.append((attr_name, str(attr)))\n\n # Color coding the special attributes that are code\n special_attrs_rendered = {}\n for attr_name in attr_renderer:\n if hasattr(task, attr_name):\n source = getattr(task, attr_name)\n special_attrs_rendered[attr_name] = attr_renderer[attr_name](source)\n\n no_failed_deps_result = [(\n \"Unknown\",\n dedent(\"\"\"\\\n All dependencies are met but the task instance is not running. In most cases this just means that the task will probably be scheduled soon unless:<br/>\n - The scheduler is down or under heavy load<br/>\n {}\n <br/>\n If this task instance does not start soon please contact your Airflow \"\"\"\n \"\"\"administrator for assistance.\"\"\"\n .format(\n \"- This task instance already ran and had its state changed \"\n \"manually (e.g. cleared in the UI)<br/>\"\n if ti.state == State.NONE else \"\")))]\n\n # Use the scheduler's context to figure out which dependencies are not met\n dep_context = DepContext(SCHEDULER_DEPS)\n failed_dep_reasons = [(dep.dep_name, dep.reason) for dep in\n ti.get_failed_dep_statuses(\n dep_context=dep_context)]\n\n title = \"Task Instance Details\"\n return self.render(\n 'airflow/task.html',\n task_attrs=task_attrs,\n ti_attrs=ti_attrs,\n failed_dep_reasons=failed_dep_reasons or no_failed_deps_result,\n task_id=task_id,\n execution_date=execution_date,\n special_attrs_rendered=special_attrs_rendered,\n form=form,\n dag=dag, title=title)\n\n @expose('/xcom')\n @login_required\n @wwwutils.action_logging\n @provide_session\n def xcom(self, session=None):\n dag_id = request.args.get('dag_id')\n task_id = request.args.get('task_id')\n # Carrying execution_date through, even though it's irrelevant for\n # this context\n execution_date = request.args.get('execution_date')\n dttm = pendulum.parse(execution_date)\n form = DateTimeForm(data={'execution_date': dttm})\n dag = dagbag.get_dag(dag_id)\n if not dag or task_id not in dag.task_ids:\n flash(\n \"Task [{}.{}] doesn't seem to exist\"\n \" at the moment\".format(dag_id, task_id),\n \"error\")\n return redirect('/admin/')\n\n xcomlist = session.query(XCom).filter(\n XCom.dag_id == dag_id, XCom.task_id == task_id,\n XCom.execution_date == dttm).all()\n\n attributes = []\n for xcom in xcomlist:\n if not xcom.key.startswith('_'):\n attributes.append((xcom.key, xcom.value))\n\n title = \"XCom\"\n return self.render(\n 'airflow/xcom.html',\n attributes=attributes,\n task_id=task_id,\n execution_date=execution_date,\n form=form,\n dag=dag, title=title)\n\n @expose('/run')\n @login_required\n @wwwutils.action_logging\n @wwwutils.notify_owner\n def run(self):\n dag_id = request.args.get('dag_id')\n task_id = request.args.get('task_id')\n origin = request.args.get('origin')\n dag = dagbag.get_dag(dag_id)\n task = dag.get_task(task_id)\n\n execution_date = request.args.get('execution_date')\n execution_date = pendulum.parse(execution_date)\n ignore_all_deps = request.args.get('ignore_all_deps') == \"true\"\n ignore_task_deps = request.args.get('ignore_task_deps') == \"true\"\n ignore_ti_state = request.args.get('ignore_ti_state') == \"true\"\n\n try:\n from airflow.executors import GetDefaultExecutor\n from airflow.executors.celery_executor import CeleryExecutor\n executor = GetDefaultExecutor()\n if not isinstance(executor, CeleryExecutor):\n flash(\"Only works with the CeleryExecutor, sorry\", \"error\")\n return redirect(origin)\n except ImportError:\n # in case CeleryExecutor cannot be imported it is not active either\n flash(\"Only works with the CeleryExecutor, sorry\", \"error\")\n return redirect(origin)\n\n ti = models.TaskInstance(task=task, execution_date=execution_date)\n ti.refresh_from_db()\n\n # Make sure the task instance can be queued\n dep_context = DepContext(\n deps=QUEUE_DEPS,\n ignore_all_deps=ignore_all_deps,\n ignore_task_deps=ignore_task_deps,\n ignore_ti_state=ignore_ti_state)\n failed_deps = list(ti.get_failed_dep_statuses(dep_context=dep_context))\n if failed_deps:\n failed_deps_str = \", \".join(\n [\"{}: {}\".format(dep.dep_name, dep.reason) for dep in failed_deps])\n flash(\"Could not queue task instance for execution, dependencies not met: \"\n \"{}\".format(failed_deps_str),\n \"error\")\n return redirect(origin)\n\n executor.start()\n executor.queue_task_instance(\n ti,\n ignore_all_deps=ignore_all_deps,\n ignore_task_deps=ignore_task_deps,\n ignore_ti_state=ignore_ti_state)\n executor.heartbeat()\n flash(\n \"Sent {} to the message queue, \"\n \"it should start any moment now.\".format(ti))\n return redirect(origin)\n\n @expose('/trigger')\n @login_required\n @wwwutils.action_logging\n @wwwutils.notify_owner\n def trigger(self):\n dag_id = request.args.get('dag_id')\n origin = request.args.get('origin') or \"/admin/\"\n dag = dagbag.get_dag(dag_id)\n\n if not dag:\n flash(\"Cannot find dag {}\".format(dag_id))\n return redirect(origin)\n\n execution_date = timezone.utcnow()\n run_id = \"manual__{0}\".format(execution_date.isoformat())\n\n dr = DagRun.find(dag_id=dag_id, run_id=run_id)\n if dr:\n flash(\"This run_id {} already exists\".format(run_id))\n return redirect(origin)\n\n run_conf = {}\n\n dag.create_dagrun(\n run_id=run_id,\n execution_date=execution_date,\n state=State.RUNNING,\n conf=run_conf,\n external_trigger=True\n )\n\n flash(\n \"Triggered {}, \"\n \"it should start any moment now.\".format(dag_id))\n return redirect(origin)\n\n def _clear_dag_tis(self, dag, start_date, end_date, origin,\n recursive=False, confirmed=False):\n if confirmed:\n count = dag.clear(\n start_date=start_date,\n end_date=end_date,\n include_subdags=recursive)\n\n flash(\"{0} task instances have been cleared\".format(count))\n return redirect(origin)\n\n tis = dag.clear(\n start_date=start_date,\n end_date=end_date,\n include_subdags=recursive,\n dry_run=True)\n if not tis:\n flash(\"No task instances to clear\", 'error')\n response = redirect(origin)\n else:\n details = \"\\n\".join([str(t) for t in tis])\n\n response = self.render(\n 'airflow/confirm.html',\n message=(\"Here's the list of task instances you are about \"\n \"to clear:\"),\n details=details)\n\n return response\n\n @expose('/clear')\n @login_required\n @wwwutils.action_logging\n @wwwutils.notify_owner\n def clear(self):\n dag_id = request.args.get('dag_id')\n task_id = request.args.get('task_id')\n origin = request.args.get('origin')\n dag = dagbag.get_dag(dag_id)\n\n execution_date = request.args.get('execution_date')\n execution_date = pendulum.parse(execution_date)\n confirmed = request.args.get('confirmed') == \"true\"\n upstream = request.args.get('upstream') == \"true\"\n downstream = request.args.get('downstream') == \"true\"\n future = request.args.get('future') == \"true\"\n past = request.args.get('past') == \"true\"\n recursive = request.args.get('recursive') == \"true\"\n\n dag = dag.sub_dag(\n task_regex=r\"^{0}$\".format(task_id),\n include_downstream=downstream,\n include_upstream=upstream)\n\n end_date = execution_date if not future else None\n start_date = execution_date if not past else None\n\n return self._clear_dag_tis(dag, start_date, end_date, origin,\n recursive=recursive, confirmed=confirmed)\n\n @expose('/dagrun_clear')\n @login_required\n @wwwutils.action_logging\n @wwwutils.notify_owner\n def dagrun_clear(self):\n dag_id = request.args.get('dag_id')\n task_id = request.args.get('task_id')\n origin = request.args.get('origin')\n execution_date = request.args.get('execution_date')\n confirmed = request.args.get('confirmed') == \"true\"\n\n dag = dagbag.get_dag(dag_id)\n execution_date = pendulum.parse(execution_date)\n start_date = execution_date\n end_date = execution_date\n\n return self._clear_dag_tis(dag, start_date, end_date, origin,\n recursive=True, confirmed=confirmed)\n\n @expose('/blocked')\n @login_required\n @provide_session\n def blocked(self, session=None):\n DR = models.DagRun\n dags = (\n session.query(DR.dag_id, sqla.func.count(DR.id))\n .filter(DR.state == State.RUNNING)\n .group_by(DR.dag_id)\n .all()\n )\n payload = []\n for dag_id, active_dag_runs in dags:\n max_active_runs = 0\n if dag_id in dagbag.dags:\n max_active_runs = dagbag.dags[dag_id].max_active_runs\n payload.append({\n 'dag_id': dag_id,\n 'active_dag_run': active_dag_runs,\n 'max_active_runs': max_active_runs,\n })\n return wwwutils.json_response(payload)\n\n @expose('/dagrun_success')\n @login_required\n @wwwutils.action_logging\n @wwwutils.notify_owner\n def dagrun_success(self):\n dag_id = request.args.get('dag_id')\n execution_date = request.args.get('execution_date')\n confirmed = request.args.get('confirmed') == 'true'\n origin = request.args.get('origin')\n\n if not execution_date:\n flash('Invalid execution date', 'error')\n return redirect(origin)\n\n execution_date = pendulum.parse(execution_date)\n dag = dagbag.get_dag(dag_id)\n\n if not dag:\n flash('Cannot find DAG: {}'.format(dag_id), 'error')\n return redirect(origin)\n\n new_dag_state = set_dag_run_state(dag, execution_date, state=State.SUCCESS,\n commit=confirmed)\n\n if confirmed:\n flash('Marked success on {} task instances'.format(len(new_dag_state)))\n return redirect(origin)\n\n else:\n details = '\\n'.join([str(t) for t in new_dag_state])\n\n response = self.render('airflow/confirm.html',\n message=(\"Here's the list of task instances you are \"\n \"about to mark as successful:\"),\n details=details)\n\n return response\n\n @expose('/success')\n @login_required\n @wwwutils.action_logging\n @wwwutils.notify_owner\n def success(self):\n dag_id = request.args.get('dag_id')\n task_id = request.args.get('task_id')\n origin = request.args.get('origin')\n dag = dagbag.get_dag(dag_id)\n task = dag.get_task(task_id)\n task.dag = dag\n\n execution_date = request.args.get('execution_date')\n execution_date = pendulum.parse(execution_date)\n confirmed = request.args.get('confirmed') == \"true\"\n upstream = request.args.get('upstream') == \"true\"\n downstream = request.args.get('downstream') == \"true\"\n future = request.args.get('future') == \"true\"\n past = request.args.get('past') == \"true\"\n\n if not dag:\n flash(\"Cannot find DAG: {}\".format(dag_id))\n return redirect(origin)\n\n if not task:\n flash(\"Cannot find task {} in DAG {}\".format(task_id, dag.dag_id))\n return redirect(origin)\n\n from airflow.api.common.experimental.mark_tasks import set_state\n\n if confirmed:\n altered = set_state(task=task, execution_date=execution_date,\n upstream=upstream, downstream=downstream,\n future=future, past=past, state=State.SUCCESS,\n commit=True)\n\n flash(\"Marked success on {} task instances\".format(len(altered)))\n return redirect(origin)\n\n to_be_altered = set_state(task=task, execution_date=execution_date,\n upstream=upstream, downstream=downstream,\n future=future, past=past, state=State.SUCCESS,\n commit=False)\n\n details = \"\\n\".join([str(t) for t in to_be_altered])\n\n response = self.render(\"airflow/confirm.html\",\n message=(\"Here's the list of task instances you are \"\n \"about to mark as successful:\"),\n details=details)\n\n return response\n\n @expose('/tree')\n @login_required\n @wwwutils.gzipped\n @wwwutils.action_logging\n @provide_session\n def tree(self, session=None):\n dag_id = request.args.get('dag_id')\n blur = conf.getboolean('webserver', 'demo_mode')\n dag = dagbag.get_dag(dag_id)\n root = request.args.get('root')\n if root:\n dag = dag.sub_dag(\n task_regex=root,\n include_downstream=False,\n include_upstream=True)\n\n base_date = request.args.get('base_date')\n num_runs = request.args.get('num_runs')\n num_runs = int(num_runs) if num_runs else 25\n\n if base_date:\n base_date = timezone.parse(base_date)\n else:\n base_date = dag.latest_execution_date or timezone.utcnow()\n\n dates = dag.date_range(base_date, num=-abs(num_runs))\n min_date = dates[0] if dates else datetime(2000, 1, 1)\n\n DR = models.DagRun\n dag_runs = (\n session.query(DR)\n .filter(\n DR.dag_id == dag.dag_id,\n DR.execution_date <= base_date,\n DR.execution_date >= min_date)\n .all()\n )\n dag_runs = {\n dr.execution_date: alchemy_to_dict(dr) for dr in dag_runs}\n\n dates = sorted(list(dag_runs.keys()))\n max_date = max(dates) if dates else None\n\n tis = dag.get_task_instances(\n session, start_date=min_date, end_date=base_date)\n task_instances = {}\n for ti in tis:\n tid = alchemy_to_dict(ti)\n dr = dag_runs.get(ti.execution_date)\n tid['external_trigger'] = dr['external_trigger'] if dr else False\n task_instances[(ti.task_id, ti.execution_date)] = tid\n\n expanded = []\n # The default recursion traces every path so that tree view has full\n # expand/collapse functionality. After 5,000 nodes we stop and fall\n # back on a quick DFS search for performance. See PR #320.\n node_count = [0]\n node_limit = 5000 / max(1, len(dag.roots))\n\n def recurse_nodes(task, visited):\n visited.add(task)\n node_count[0] += 1\n\n children = [\n recurse_nodes(t, visited) for t in task.upstream_list\n if node_count[0] < node_limit or t not in visited]\n\n # D3 tree uses children vs _children to define what is\n # expanded or not. The following block makes it such that\n # repeated nodes are collapsed by default.\n children_key = 'children'\n if task.task_id not in expanded:\n expanded.append(task.task_id)\n elif children:\n children_key = \"_children\"\n\n def set_duration(tid):\n if (isinstance(tid, dict) and tid.get(\"state\") == State.RUNNING and\n tid[\"start_date\"] is not None):\n d = timezone.utcnow() - pendulum.parse(tid[\"start_date\"])\n tid[\"duration\"] = d.total_seconds()\n return tid\n\n return {\n 'name': task.task_id,\n 'instances': [\n set_duration(task_instances.get((task.task_id, d))) or {\n 'execution_date': d.isoformat(),\n 'task_id': task.task_id\n }\n for d in dates],\n children_key: children,\n 'num_dep': len(task.upstream_list),\n 'operator': task.task_type,\n 'retries': task.retries,\n 'owner': task.owner,\n 'start_date': task.start_date,\n 'end_date': task.end_date,\n 'depends_on_past': task.depends_on_past,\n 'ui_color': task.ui_color,\n }\n\n data = {\n 'name': '[DAG]',\n 'children': [recurse_nodes(t, set()) for t in dag.roots],\n 'instances': [\n dag_runs.get(d) or {'execution_date': d.isoformat()}\n for d in dates],\n }\n\n data = json.dumps(data, indent=4, default=json_ser)\n session.commit()\n\n form = DateTimeWithNumRunsForm(data={'base_date': max_date,\n 'num_runs': num_runs})\n return self.render(\n 'airflow/tree.html',\n operators=sorted(\n list(set([op.__class__ for op in dag.tasks])),\n key=lambda x: x.__name__\n ),\n root=root,\n form=form,\n dag=dag, data=data, blur=blur)\n\n @expose('/graph')\n @login_required\n @wwwutils.gzipped\n @wwwutils.action_logging\n @provide_session\n def graph(self, session=None):\n dag_id = request.args.get('dag_id')\n blur = conf.getboolean('webserver', 'demo_mode')\n dag = dagbag.get_dag(dag_id)\n if dag_id not in dagbag.dags:\n flash('DAG \"{0}\" seems to be missing.'.format(dag_id), \"error\")\n return redirect('/admin/')\n\n root = request.args.get('root')\n if root:\n dag = dag.sub_dag(\n task_regex=root,\n include_upstream=True,\n include_downstream=False)\n\n arrange = request.args.get('arrange', dag.orientation)\n\n nodes = []\n edges = []\n for task in dag.tasks:\n nodes.append({\n 'id': task.task_id,\n 'value': {\n 'label': task.task_id,\n 'labelStyle': \"fill:{0};\".format(task.ui_fgcolor),\n 'style': \"fill:{0};\".format(task.ui_color),\n }\n })\n\n def get_upstream(task):\n for t in task.upstream_list:\n edge = {\n 'u': t.task_id,\n 'v': task.task_id,\n }\n if edge not in edges:\n edges.append(edge)\n get_upstream(t)\n\n for t in dag.roots:\n get_upstream(t)\n\n dttm = request.args.get('execution_date')\n if dttm:\n dttm = pendulum.parse(dttm)\n else:\n dttm = dag.latest_execution_date or timezone.utcnow()\n\n DR = models.DagRun\n drs = (\n session.query(DR)\n .filter_by(dag_id=dag_id)\n .order_by(desc(DR.execution_date)).all()\n )\n dr_choices = []\n dr_state = None\n for dr in drs:\n dr_choices.append((dr.execution_date.isoformat(), dr.run_id))\n if dttm == dr.execution_date:\n dr_state = dr.state\n\n class GraphForm(Form):\n execution_date = SelectField(\"DAG run\", choices=dr_choices)\n arrange = SelectField(\"Layout\", choices=(\n ('LR', \"Left->Right\"),\n ('RL', \"Right->Left\"),\n ('TB', \"Top->Bottom\"),\n ('BT', \"Bottom->Top\"),\n ))\n\n form = GraphForm(\n data={'execution_date': dttm.isoformat(), 'arrange': arrange})\n\n task_instances = {\n ti.task_id: alchemy_to_dict(ti)\n for ti in dag.get_task_instances(session, dttm, dttm)}\n tasks = {\n t.task_id: {\n 'dag_id': t.dag_id,\n 'task_type': t.task_type,\n }\n for t in dag.tasks}\n if not tasks:\n flash(\"No tasks found\", \"error\")\n session.commit()\n doc_md = markdown.markdown(dag.doc_md) if hasattr(dag, 'doc_md') and dag.doc_md else ''\n\n return self.render(\n 'airflow/graph.html',\n dag=dag,\n form=form,\n width=request.args.get('width', \"100%\"),\n height=request.args.get('height', \"800\"),\n execution_date=dttm.isoformat(),\n state_token=state_token(dr_state),\n doc_md=doc_md,\n arrange=arrange,\n operators=sorted(\n list(set([op.__class__ for op in dag.tasks])),\n key=lambda x: x.__name__\n ),\n blur=blur,\n root=root or '',\n task_instances=json.dumps(task_instances, indent=2),\n tasks=json.dumps(tasks, indent=2),\n nodes=json.dumps(nodes, indent=2),\n edges=json.dumps(edges, indent=2), )\n\n @expose('/duration')\n @login_required\n @wwwutils.action_logging\n @provide_session\n def duration(self, session=None):\n dag_id = request.args.get('dag_id')\n dag = dagbag.get_dag(dag_id)\n base_date = request.args.get('base_date')\n num_runs = request.args.get('num_runs')\n num_runs = int(num_runs) if num_runs else 25\n\n if base_date:\n base_date = pendulum.parse(base_date)\n else:\n base_date = dag.latest_execution_date or timezone.utcnow()\n\n dates = dag.date_range(base_date, num=-abs(num_runs))\n min_date = dates[0] if dates else datetime(2000, 1, 1)\n\n root = request.args.get('root')\n if root:\n dag = dag.sub_dag(\n task_regex=root,\n include_upstream=True,\n include_downstream=False)\n\n chart_height = get_chart_height(dag)\n chart = nvd3.lineChart(\n name=\"lineChart\", x_is_date=True, height=chart_height, width=\"1200\")\n cum_chart = nvd3.lineChart(\n name=\"cumLineChart\", x_is_date=True, height=chart_height, width=\"1200\")\n\n y = defaultdict(list)\n x = defaultdict(list)\n cum_y = defaultdict(list)\n\n tis = dag.get_task_instances(\n session, start_date=min_date, end_date=base_date)\n TF = models.TaskFail\n ti_fails = (\n session\n .query(TF)\n .filter(\n TF.dag_id == dag.dag_id,\n TF.execution_date >= min_date,\n TF.execution_date <= base_date,\n TF.task_id.in_([t.task_id for t in dag.tasks]))\n .all()\n )\n\n fails_totals = defaultdict(int)\n for tf in ti_fails:\n dict_key = (tf.dag_id, tf.task_id, tf.execution_date)\n fails_totals[dict_key] += tf.duration\n\n for ti in tis:\n if ti.duration:\n dttm = wwwutils.epoch(ti.execution_date)\n x[ti.task_id].append(dttm)\n y[ti.task_id].append(float(ti.duration))\n fails_dict_key = (ti.dag_id, ti.task_id, ti.execution_date)\n fails_total = fails_totals[fails_dict_key]\n cum_y[ti.task_id].append(float(ti.duration + fails_total))\n\n # determine the most relevant time unit for the set of task instance\n # durations for the DAG\n y_unit = infer_time_unit([d for t in y.values() for d in t])\n cum_y_unit = infer_time_unit([d for t in cum_y.values() for d in t])\n # update the y Axis on both charts to have the correct time units\n chart.create_y_axis('yAxis', format='.02f', custom_format=False,\n label='Duration ({})'.format(y_unit))\n chart.axislist['yAxis']['axisLabelDistance'] = '40'\n cum_chart.create_y_axis('yAxis', format='.02f', custom_format=False,\n label='Duration ({})'.format(cum_y_unit))\n cum_chart.axislist['yAxis']['axisLabelDistance'] = '40'\n for task in dag.tasks:\n if x[task.task_id]:\n chart.add_serie(name=task.task_id, x=x[task.task_id],\n y=scale_time_units(y[task.task_id], y_unit))\n cum_chart.add_serie(name=task.task_id, x=x[task.task_id],\n y=scale_time_units(cum_y[task.task_id],\n cum_y_unit))\n\n dates = sorted(list({ti.execution_date for ti in tis}))\n max_date = max([ti.execution_date for ti in tis]) if dates else None\n\n session.commit()\n\n form = DateTimeWithNumRunsForm(data={'base_date': max_date,\n 'num_runs': num_runs})\n chart.buildcontent()\n cum_chart.buildcontent()\n s_index = cum_chart.htmlcontent.rfind('});')\n cum_chart.htmlcontent = (cum_chart.htmlcontent[:s_index] +\n \"$(function() {$( document ).trigger('chartload') })\" +\n cum_chart.htmlcontent[s_index:])\n\n return self.render(\n 'airflow/duration_chart.html',\n dag=dag,\n demo_mode=conf.getboolean('webserver', 'demo_mode'),\n root=root,\n form=form,\n chart=chart.htmlcontent,\n cum_chart=cum_chart.htmlcontent\n )\n\n @expose('/tries')\n @login_required\n @wwwutils.action_logging\n @provide_session\n def tries(self, session=None):\n dag_id = request.args.get('dag_id')\n dag = dagbag.get_dag(dag_id)\n base_date = request.args.get('base_date')\n num_runs = request.args.get('num_runs')\n num_runs = int(num_runs) if num_runs else 25\n\n if base_date:\n base_date = pendulum.parse(base_date)\n else:\n base_date = dag.latest_execution_date or timezone.utcnow()\n\n dates = dag.date_range(base_date, num=-abs(num_runs))\n min_date = dates[0] if dates else datetime(2000, 1, 1)\n\n root = request.args.get('root')\n if root:\n dag = dag.sub_dag(\n task_regex=root,\n include_upstream=True,\n include_downstream=False)\n\n chart_height = get_chart_height(dag)\n chart = nvd3.lineChart(\n name=\"lineChart\", x_is_date=True, y_axis_format='d', height=chart_height,\n width=\"1200\")\n\n for task in dag.tasks:\n y = []\n x = []\n for ti in task.get_task_instances(session, start_date=min_date,\n end_date=base_date):\n dttm = wwwutils.epoch(ti.execution_date)\n x.append(dttm)\n y.append(ti.try_number)\n if x:\n chart.add_serie(name=task.task_id, x=x, y=y)\n\n tis = dag.get_task_instances(\n session, start_date=min_date, end_date=base_date)\n tries = sorted(list({ti.try_number for ti in tis}))\n max_date = max([ti.execution_date for ti in tis]) if tries else None\n\n session.commit()\n\n form = DateTimeWithNumRunsForm(data={'base_date': max_date,\n 'num_runs': num_runs})\n\n chart.buildcontent()\n\n return self.render(\n 'airflow/chart.html',\n dag=dag,\n demo_mode=conf.getboolean('webserver', 'demo_mode'),\n root=root,\n form=form,\n chart=chart.htmlcontent\n )\n\n @expose('/landing_times')\n @login_required\n @wwwutils.action_logging\n @provide_session\n def landing_times(self, session=None):\n dag_id = request.args.get('dag_id')\n dag = dagbag.get_dag(dag_id)\n base_date = request.args.get('base_date')\n num_runs = request.args.get('num_runs')\n num_runs = int(num_runs) if num_runs else 25\n\n if base_date:\n base_date = pendulum.parse(base_date)\n else:\n base_date = dag.latest_execution_date or timezone.utcnow()\n\n dates = dag.date_range(base_date, num=-abs(num_runs))\n min_date = dates[0] if dates else datetime(2000, 1, 1)\n\n root = request.args.get('root')\n if root:\n dag = dag.sub_dag(\n task_regex=root,\n include_upstream=True,\n include_downstream=False)\n\n chart_height = get_chart_height(dag)\n chart = nvd3.lineChart(\n name=\"lineChart\", x_is_date=True, height=chart_height, width=\"1200\")\n y = {}\n x = {}\n for task in dag.tasks:\n y[task.task_id] = []\n x[task.task_id] = []\n for ti in task.get_task_instances(session, start_date=min_date,\n end_date=base_date):\n ts = ti.execution_date\n if dag.schedule_interval and dag.following_schedule(ts):\n ts = dag.following_schedule(ts)\n if ti.end_date:\n dttm = wwwutils.epoch(ti.execution_date)\n secs = (ti.end_date - ts).total_seconds()\n x[ti.task_id].append(dttm)\n y[ti.task_id].append(secs)\n\n # determine the most relevant time unit for the set of landing times\n # for the DAG\n y_unit = infer_time_unit([d for t in y.values() for d in t])\n # update the y Axis to have the correct time units\n chart.create_y_axis('yAxis', format='.02f', custom_format=False,\n label='Landing Time ({})'.format(y_unit))\n chart.axislist['yAxis']['axisLabelDistance'] = '40'\n for task in dag.tasks:\n if x[task.task_id]:\n chart.add_serie(name=task.task_id, x=x[task.task_id],\n y=scale_time_units(y[task.task_id], y_unit))\n\n tis = dag.get_task_instances(\n session, start_date=min_date, end_date=base_date)\n dates = sorted(list({ti.execution_date for ti in tis}))\n max_date = max([ti.execution_date for ti in tis]) if dates else None\n\n form = DateTimeWithNumRunsForm(data={'base_date': max_date,\n 'num_runs': num_runs})\n chart.buildcontent()\n return self.render(\n 'airflow/chart.html',\n dag=dag,\n chart=chart.htmlcontent,\n height=str(chart_height + 100) + \"px\",\n demo_mode=conf.getboolean('webserver', 'demo_mode'),\n root=root,\n form=form,\n )\n\n @expose('/paused', methods=['POST'])\n @login_required\n @wwwutils.action_logging\n @provide_session\n def paused(self, session=None):\n DagModel = models.DagModel\n dag_id = request.args.get('dag_id')\n orm_dag = session.query(\n DagModel).filter(DagModel.dag_id == dag_id).first()\n if request.args.get('is_paused') == 'false':\n orm_dag.is_paused = True\n else:\n orm_dag.is_paused = False\n session.merge(orm_dag)\n session.commit()\n\n dagbag.get_dag(dag_id)\n return \"OK\"\n\n @expose('/refresh')\n @login_required\n @wwwutils.action_logging\n @provide_session\n def refresh(self, session=None):\n DagModel = models.DagModel\n dag_id = request.args.get('dag_id')\n orm_dag = session.query(\n DagModel).filter(DagModel.dag_id == dag_id).first()\n\n if orm_dag:\n orm_dag.last_expired = timezone.utcnow()\n session.merge(orm_dag)\n session.commit()\n\n dagbag.get_dag(dag_id)\n flash(\"DAG [{}] is now fresh as a daisy\".format(dag_id))\n return redirect(request.referrer)\n\n @expose('/refresh_all')\n @login_required\n @wwwutils.action_logging\n def refresh_all(self):\n dagbag.collect_dags(only_if_updated=False)\n flash(\"All DAGs are now up to date\")\n return redirect('/')\n\n @expose('/gantt')\n @login_required\n @wwwutils.action_logging\n @provide_session\n def gantt(self, session=None):\n dag_id = request.args.get('dag_id')\n dag = dagbag.get_dag(dag_id)\n demo_mode = conf.getboolean('webserver', 'demo_mode')\n\n root = request.args.get('root')\n if root:\n dag = dag.sub_dag(\n task_regex=root,\n include_upstream=True,\n include_downstream=False)\n\n dttm = request.args.get('execution_date')\n if dttm:\n dttm = pendulum.parse(dttm)\n else:\n dttm = dag.latest_execution_date or timezone.utcnow()\n\n form = DateTimeForm(data={'execution_date': dttm})\n\n tis = [\n ti for ti in dag.get_task_instances(session, dttm, dttm)\n if ti.start_date]\n tis = sorted(tis, key=lambda ti: ti.start_date)\n\n tasks = []\n for ti in tis:\n end_date = ti.end_date if ti.end_date else timezone.utcnow()\n tasks.append({\n 'startDate': wwwutils.epoch(ti.start_date),\n 'endDate': wwwutils.epoch(end_date),\n 'isoStart': ti.start_date.isoformat()[:-4],\n 'isoEnd': end_date.isoformat()[:-4],\n 'taskName': ti.task_id,\n 'duration': \"{}\".format(end_date - ti.start_date)[:-4],\n 'status': ti.state,\n 'executionDate': ti.execution_date.isoformat(),\n })\n states = {ti.state: ti.state for ti in tis}\n data = {\n 'taskNames': [ti.task_id for ti in tis],\n 'tasks': tasks,\n 'taskStatus': states,\n 'height': len(tis) * 25 + 25,\n }\n\n session.commit()\n\n return self.render(\n 'airflow/gantt.html',\n dag=dag,\n execution_date=dttm.isoformat(),\n form=form,\n data=json.dumps(data, indent=2),\n base_date='',\n demo_mode=demo_mode,\n root=root,\n )\n\n @expose('/object/task_instances')\n @login_required\n @wwwutils.action_logging\n @provide_session\n def task_instances(self, session=None):\n dag_id = request.args.get('dag_id')\n dag = dagbag.get_dag(dag_id)\n\n dttm = request.args.get('execution_date')\n if dttm:\n dttm = pendulum.parse(dttm)\n else:\n return (\"Error: Invalid execution_date\")\n\n task_instances = {\n ti.task_id: alchemy_to_dict(ti)\n for ti in dag.get_task_instances(session, dttm, dttm)}\n\n return json.dumps(task_instances)\n\n @expose('/variables/<form>', methods=[\"GET\", \"POST\"])\n @login_required\n @wwwutils.action_logging\n def variables(self, form):\n try:\n if request.method == 'POST':\n data = request.json\n if data:\n with create_session() as session:\n var = models.Variable(key=form, val=json.dumps(data))\n session.add(var)\n session.commit()\n return \"\"\n else:\n return self.render(\n 'airflow/variables/{}.html'.format(form)\n )\n except:\n # prevent XSS\n form = escape(form)\n return (\"Error: form airflow/variables/{}.html \"\n \"not found.\").format(form), 404\n\n @expose('/varimport', methods=[\"GET\", \"POST\"])\n @login_required\n @wwwutils.action_logging\n def varimport(self):\n try:\n d = json.load(UTF8_READER(request.files['file']))\n except Exception as e:\n flash(\"Missing file or syntax error: {}.\".format(e))\n else:\n for k, v in d.items():\n models.Variable.set(k, v, serialize_json=isinstance(v, dict))\n flash(\"{} variable(s) successfully updated.\".format(len(d)))\n return redirect('/admin/variable')\n\n\nclass HomeView(AdminIndexView):\n @expose(\"/\")\n @login_required\n @provide_session\n def index(self, session=None):\n DM = models.DagModel\n\n # restrict the dags shown if filter_by_owner and current user is not superuser\n do_filter = FILTER_BY_OWNER and (not current_user.is_superuser())\n owner_mode = conf.get('webserver', 'OWNER_MODE').strip().lower()\n\n hide_paused_dags_by_default = conf.getboolean('webserver',\n 'hide_paused_dags_by_default')\n show_paused_arg = request.args.get('showPaused', 'None')\n\n def get_int_arg(value, default=0):\n try:\n return int(value)\n except ValueError:\n return default\n\n arg_current_page = request.args.get('page', '0')\n arg_search_query = request.args.get('search', None)\n\n dags_per_page = PAGE_SIZE\n current_page = get_int_arg(arg_current_page, default=0)\n\n if show_paused_arg.strip().lower() == 'false':\n hide_paused = True\n elif show_paused_arg.strip().lower() == 'true':\n hide_paused = False\n else:\n hide_paused = hide_paused_dags_by_default\n\n # read orm_dags from the db\n sql_query = session.query(DM)\n\n if do_filter and owner_mode == 'ldapgroup':\n sql_query = sql_query.filter(\n ~DM.is_subdag,\n DM.is_active,\n DM.owners.in_(current_user.ldap_groups)\n )\n elif do_filter and owner_mode == 'user':\n sql_query = sql_query.filter(\n ~DM.is_subdag, DM.is_active,\n DM.owners == current_user.user.username\n )\n else:\n sql_query = sql_query.filter(\n ~DM.is_subdag, DM.is_active\n )\n\n # optionally filter out \"paused\" dags\n if hide_paused:\n sql_query = sql_query.filter(~DM.is_paused)\n\n orm_dags = {dag.dag_id: dag for dag\n in sql_query\n .all()}\n\n import_errors = session.query(models.ImportError).all()\n for ie in import_errors:\n flash(\n \"Broken DAG: [{ie.filename}] {ie.stacktrace}\".format(ie=ie),\n \"error\")\n\n # get a list of all non-subdag dags visible to everyone\n # optionally filter out \"paused\" dags\n if hide_paused:\n unfiltered_webserver_dags = [dag for dag in dagbag.dags.values() if\n not dag.parent_dag and not dag.is_paused]\n\n else:\n unfiltered_webserver_dags = [dag for dag in dagbag.dags.values() if\n not dag.parent_dag]\n\n # optionally filter to get only dags that the user should see\n if do_filter and owner_mode == 'ldapgroup':\n # only show dags owned by someone in @current_user.ldap_groups\n webserver_dags = {\n dag.dag_id: dag\n for dag in unfiltered_webserver_dags\n if dag.owner in current_user.ldap_groups\n }\n elif do_filter and owner_mode == 'user':\n # only show dags owned by @current_user.user.username\n webserver_dags = {\n dag.dag_id: dag\n for dag in unfiltered_webserver_dags\n if dag.owner == current_user.user.username\n }\n else:\n webserver_dags = {\n dag.dag_id: dag\n for dag in unfiltered_webserver_dags\n }\n\n if arg_search_query:\n lower_search_query = arg_search_query.lower()\n # filter by dag_id\n webserver_dags_filtered = {\n dag_id: dag\n for dag_id, dag in webserver_dags.items()\n if (lower_search_query in dag_id.lower() or\n lower_search_query in dag.owner.lower())\n }\n\n all_dag_ids = (set([dag.dag_id for dag in orm_dags.values()\n if lower_search_query in dag.dag_id.lower() or\n lower_search_query in dag.owners.lower()]) |\n set(webserver_dags_filtered.keys()))\n\n sorted_dag_ids = sorted(all_dag_ids)\n else:\n webserver_dags_filtered = webserver_dags\n sorted_dag_ids = sorted(set(orm_dags.keys()) | set(webserver_dags.keys()))\n\n start = current_page * dags_per_page\n end = start + dags_per_page\n\n num_of_all_dags = len(sorted_dag_ids)\n page_dag_ids = sorted_dag_ids[start:end]\n num_of_pages = int(math.ceil(num_of_all_dags / float(dags_per_page)))\n\n auto_complete_data = set()\n for dag in webserver_dags_filtered.values():\n auto_complete_data.add(dag.dag_id)\n auto_complete_data.add(dag.owner)\n for dag in orm_dags.values():\n auto_complete_data.add(dag.dag_id)\n auto_complete_data.add(dag.owners)\n\n return self.render(\n 'airflow/dags.html',\n webserver_dags=webserver_dags_filtered,\n orm_dags=orm_dags,\n hide_paused=hide_paused,\n current_page=current_page,\n search_query=arg_search_query if arg_search_query else '',\n page_size=dags_per_page,\n num_of_pages=num_of_pages,\n num_dag_from=start + 1,\n num_dag_to=min(end, num_of_all_dags),\n num_of_all_dags=num_of_all_dags,\n paging=wwwutils.generate_pages(current_page, num_of_pages,\n search=arg_search_query,\n showPaused=not hide_paused),\n dag_ids_in_page=page_dag_ids,\n auto_complete_data=auto_complete_data)\n\n\nclass QueryView(wwwutils.DataProfilingMixin, BaseView):\n @expose('/', methods=['POST', 'GET'])\n @wwwutils.gzipped\n @provide_session\n def query(self, session=None):\n dbs = session.query(models.Connection).order_by(\n models.Connection.conn_id).all()\n session.expunge_all()\n db_choices = list(\n ((db.conn_id, db.conn_id) for db in dbs if db.get_hook()))\n conn_id_str = request.form.get('conn_id')\n csv = request.form.get('csv') == \"true\"\n sql = request.form.get('sql')\n\n class QueryForm(Form):\n conn_id = SelectField(\"Layout\", choices=db_choices)\n sql = TextAreaField(\"SQL\", widget=wwwutils.AceEditorWidget())\n\n data = {\n 'conn_id': conn_id_str,\n 'sql': sql,\n }\n results = None\n has_data = False\n error = False\n if conn_id_str:\n db = [db for db in dbs if db.conn_id == conn_id_str][0]\n hook = db.get_hook()\n try:\n df = hook.get_pandas_df(wwwutils.limit_sql(sql, QUERY_LIMIT, conn_type=db.conn_type))\n # df = hook.get_pandas_df(sql)\n has_data = len(df) > 0\n df = df.fillna('')\n results = df.to_html(\n classes=[\n 'table', 'table-bordered', 'table-striped', 'no-wrap'],\n index=False,\n na_rep='',\n ) if has_data else ''\n except Exception as e:\n flash(str(e), 'error')\n error = True\n\n if has_data and len(df) == QUERY_LIMIT:\n flash(\n \"Query output truncated at \" + str(QUERY_LIMIT) +\n \" rows\", 'info')\n\n if not has_data and error:\n flash('No data', 'error')\n\n if csv:\n return Response(\n response=df.to_csv(index=False),\n status=200,\n mimetype=\"application/text\")\n\n form = QueryForm(request.form, data=data)\n session.commit()\n return self.render(\n 'airflow/query.html', form=form,\n title=\"Ad Hoc Query\",\n results=results or '',\n has_data=has_data)\n\n\nclass AirflowModelView(ModelView):\n list_template = 'airflow/model_list.html'\n edit_template = 'airflow/model_edit.html'\n create_template = 'airflow/model_create.html'\n column_display_actions = True\n page_size = PAGE_SIZE\n\n\nclass ModelViewOnly(wwwutils.LoginMixin, AirflowModelView):\n \"\"\"\n Modifying the base ModelView class for non edit, browse only operations\n \"\"\"\n named_filter_urls = True\n can_create = False\n can_edit = False\n can_delete = False\n column_display_pk = True\n\n\nclass PoolModelView(wwwutils.SuperUserMixin, AirflowModelView):\n column_list = ('pool', 'slots', 'used_slots', 'queued_slots')\n column_formatters = dict(\n pool=pool_link, used_slots=fused_slots, queued_slots=fqueued_slots)\n named_filter_urls = True\n form_args = {\n 'pool': {\n 'validators': [\n validators.DataRequired(),\n ]\n }\n }\n\n\nclass SlaMissModelView(wwwutils.SuperUserMixin, ModelViewOnly):\n verbose_name_plural = \"SLA misses\"\n verbose_name = \"SLA miss\"\n column_list = (\n 'dag_id', 'task_id', 'execution_date', 'email_sent', 'timestamp')\n column_formatters = dict(\n task_id=task_instance_link,\n execution_date=datetime_f,\n timestamp=datetime_f,\n dag_id=dag_link)\n named_filter_urls = True\n column_searchable_list = ('dag_id', 'task_id',)\n column_filters = (\n 'dag_id', 'task_id', 'email_sent', 'timestamp', 'execution_date')\n filter_converter = wwwutils.UtcFilterConverter()\n form_widget_args = {\n 'email_sent': {'disabled': True},\n 'timestamp': {'disabled': True},\n }\n\n\n@provide_session\ndef _connection_ids(session=None):\n return [\n (c.conn_id, c.conn_id)\n for c in (\n session.query(models.Connection.conn_id)\n .group_by(models.Connection.conn_id)\n )\n ]\n\n\nclass ChartModelView(wwwutils.DataProfilingMixin, AirflowModelView):\n verbose_name = \"chart\"\n verbose_name_plural = \"charts\"\n form_columns = (\n 'label',\n 'owner',\n 'conn_id',\n 'chart_type',\n 'show_datatable',\n 'x_is_date',\n 'y_log_scale',\n 'show_sql',\n 'height',\n 'sql_layout',\n 'sql',\n 'default_params',\n )\n column_list = (\n 'label',\n 'conn_id',\n 'chart_type',\n 'owner',\n 'last_modified',\n )\n column_sortable_list = (\n 'label',\n 'conn_id',\n 'chart_type',\n ('owner', 'owner.username'),\n 'last_modified',\n )\n column_formatters = dict(label=label_link, last_modified=datetime_f)\n column_default_sort = ('last_modified', True)\n create_template = 'airflow/chart/create.html'\n edit_template = 'airflow/chart/edit.html'\n column_filters = ('label', 'owner.username', 'conn_id')\n column_searchable_list = ('owner.username', 'label', 'sql')\n column_descriptions = {\n 'label': \"Can include {{ templated_fields }} and {{ macros }}\",\n 'chart_type': \"The type of chart to be displayed\",\n 'sql': \"Can include {{ templated_fields }} and {{ macros }}.\",\n 'height': \"Height of the chart, in pixels.\",\n 'conn_id': \"Source database to run the query against\",\n 'x_is_date': (\n \"Whether the X axis should be casted as a date field. Expect most \"\n \"intelligible date formats to get casted properly.\"\n ),\n 'owner': (\n \"The chart's owner, mostly used for reference and filtering in \"\n \"the list view.\"\n ),\n 'show_datatable':\n \"Whether to display an interactive data table under the chart.\",\n 'default_params': (\n 'A dictionary of {\"key\": \"values\",} that define what the '\n 'templated fields (parameters) values should be by default. '\n 'To be valid, it needs to \"eval\" as a Python dict. '\n 'The key values will show up in the url\\'s querystring '\n 'and can be altered there.'\n ),\n 'show_sql': \"Whether to display the SQL statement as a collapsible \"\n \"section in the chart page.\",\n 'y_log_scale': \"Whether to use a log scale for the Y axis.\",\n 'sql_layout': (\n \"Defines the layout of the SQL that the application should \"\n \"expect. Depending on the tables you are sourcing from, it may \"\n \"make more sense to pivot / unpivot the metrics.\"\n ),\n }\n column_labels = {\n 'sql': \"SQL\",\n 'height': \"Chart Height\",\n 'sql_layout': \"SQL Layout\",\n 'show_sql': \"Display the SQL Statement\",\n 'default_params': \"Default Parameters\",\n }\n form_choices = {\n 'chart_type': [\n ('line', 'Line Chart'),\n ('spline', 'Spline Chart'),\n ('bar', 'Bar Chart'),\n ('column', 'Column Chart'),\n ('area', 'Overlapping Area Chart'),\n ('stacked_area', 'Stacked Area Chart'),\n ('percent_area', 'Percent Area Chart'),\n ('datatable', 'No chart, data table only'),\n ],\n 'sql_layout': [\n ('series', 'SELECT series, x, y FROM ...'),\n ('columns', 'SELECT x, y (series 1), y (series 2), ... FROM ...'),\n ],\n 'conn_id': _connection_ids()\n }\n\n def on_model_change(self, form, model, is_created=True):\n if model.iteration_no is None:\n model.iteration_no = 0\n else:\n model.iteration_no += 1\n if not model.user_id and current_user and hasattr(current_user, 'id'):\n model.user_id = current_user.id\n model.last_modified = timezone.utcnow()\n\n\nchart_mapping = (\n ('line', 'lineChart'),\n ('spline', 'lineChart'),\n ('bar', 'multiBarChart'),\n ('column', 'multiBarChart'),\n ('area', 'stackedAreaChart'),\n ('stacked_area', 'stackedAreaChart'),\n ('percent_area', 'stackedAreaChart'),\n ('datatable', 'datatable'),\n)\nchart_mapping = dict(chart_mapping)\n\n\nclass KnownEventView(wwwutils.DataProfilingMixin, AirflowModelView):\n verbose_name = \"known event\"\n verbose_name_plural = \"known events\"\n form_columns = (\n 'label',\n 'event_type',\n 'start_date',\n 'end_date',\n 'reported_by',\n 'description',\n )\n form_args = {\n 'label': {\n 'validators': [\n validators.DataRequired(),\n ],\n },\n 'event_type': {\n 'validators': [\n validators.DataRequired(),\n ],\n },\n 'start_date': {\n 'validators': [\n validators.DataRequired(),\n ],\n 'filters': [\n parse_datetime_f,\n ],\n },\n 'end_date': {\n 'validators': [\n validators.DataRequired(),\n GreaterEqualThan(fieldname='start_date'),\n ],\n 'filters': [\n parse_datetime_f,\n ]\n },\n 'reported_by': {\n 'validators': [\n validators.DataRequired(),\n ],\n }\n }\n column_list = (\n 'label',\n 'event_type',\n 'start_date',\n 'end_date',\n 'reported_by',\n )\n column_default_sort = (\"start_date\", True)\n column_sortable_list = (\n 'label',\n # todo: yes this has a spelling error\n ('event_type', 'event_type.know_event_type'),\n 'start_date',\n 'end_date',\n ('reported_by', 'reported_by.username'),\n )\n filter_converter = wwwutils.UtcFilterConverter()\n form_overrides = dict(start_date=DateTimeField, end_date=DateTimeField)\n\n\nclass KnownEventTypeView(wwwutils.DataProfilingMixin, AirflowModelView):\n pass\n\n\n# NOTE: For debugging / troubleshooting\n# mv = KnowEventTypeView(\n# models.KnownEventType,\n# Session, name=\"Known Event Types\", category=\"Manage\")\n# admin.add_view(mv)\n# class DagPickleView(SuperUserMixin, ModelView):\n# pass\n# mv = DagPickleView(\n# models.DagPickle,\n# Session, name=\"Pickles\", category=\"Manage\")\n# admin.add_view(mv)\n\n\nclass VariableView(wwwutils.DataProfilingMixin, AirflowModelView):\n verbose_name = \"Variable\"\n verbose_name_plural = \"Variables\"\n list_template = 'airflow/variable_list.html'\n\n def hidden_field_formatter(view, context, model, name):\n if wwwutils.should_hide_value_for_key(model.key):\n return Markup('*' * 8)\n try:\n return getattr(model, name)\n except AirflowException:\n return Markup('<span class=\"label label-danger\">Invalid</span>')\n\n form_columns = (\n 'key',\n 'val',\n )\n column_list = ('key', 'val', 'is_encrypted',)\n column_filters = ('key', 'val')\n column_searchable_list = ('key', 'val')\n column_default_sort = ('key', False)\n form_widget_args = {\n 'is_encrypted': {'disabled': True},\n 'val': {\n 'rows': 20,\n }\n }\n form_args = {\n 'key': {\n 'validators': {\n validators.DataRequired(),\n },\n },\n }\n column_sortable_list = (\n 'key',\n 'val',\n 'is_encrypted',\n )\n column_formatters = {\n 'val': hidden_field_formatter,\n }\n\n # Default flask-admin export functionality doesn't handle serialized json\n @action('varexport', 'Export', None)\n @provide_session\n def action_varexport(self, ids, session=None):\n V = models.Variable\n qry = session.query(V).filter(V.id.in_(ids)).all()\n\n var_dict = {}\n d = json.JSONDecoder()\n for var in qry:\n val = None\n try:\n val = d.decode(var.val)\n except:\n val = var.val\n var_dict[var.key] = val\n\n response = make_response(json.dumps(var_dict, sort_keys=True, indent=4))\n response.headers[\"Content-Disposition\"] = \"attachment; filename=variables.json\"\n return response\n\n def on_form_prefill(self, form, id):\n if wwwutils.should_hide_value_for_key(form.key.data):\n form.val.data = '*' * 8\n\n\nclass XComView(wwwutils.SuperUserMixin, AirflowModelView):\n verbose_name = \"XCom\"\n verbose_name_plural = \"XComs\"\n\n form_columns = (\n 'key',\n 'value',\n 'execution_date',\n 'task_id',\n 'dag_id',\n )\n\n form_extra_fields = {\n 'value': StringField('Value'),\n }\n\n form_args = {\n 'execution_date': {\n 'filters': [\n parse_datetime_f,\n ]\n }\n }\n\n column_filters = ('key', 'timestamp', 'execution_date', 'task_id', 'dag_id')\n column_searchable_list = ('key', 'timestamp', 'execution_date', 'task_id', 'dag_id')\n filter_converter = wwwutils.UtcFilterConverter()\n form_overrides = dict(execution_date=DateTimeField)\n\n\nclass JobModelView(ModelViewOnly):\n verbose_name_plural = \"jobs\"\n verbose_name = \"job\"\n column_display_actions = False\n column_default_sort = ('start_date', True)\n column_filters = (\n 'job_type', 'dag_id', 'state',\n 'unixname', 'hostname', 'start_date', 'end_date', 'latest_heartbeat')\n column_formatters = dict(\n start_date=datetime_f,\n end_date=datetime_f,\n hostname=nobr_f,\n state=state_f,\n latest_heartbeat=datetime_f)\n filter_converter = wwwutils.UtcFilterConverter()\n\n\nclass DagRunModelView(ModelViewOnly):\n verbose_name_plural = \"DAG Runs\"\n can_edit = True\n can_create = True\n column_editable_list = ('state',)\n verbose_name = \"dag run\"\n column_default_sort = ('execution_date', True)\n form_choices = {\n 'state': [\n ('success', 'success'),\n ('running', 'running'),\n ('failed', 'failed'),\n ],\n }\n form_args = dict(\n dag_id=dict(validators=[validators.DataRequired()])\n )\n column_list = (\n 'state', 'dag_id', 'execution_date', 'run_id', 'external_trigger')\n column_filters = column_list\n filter_converter = wwwutils.UtcFilterConverter()\n column_searchable_list = ('dag_id', 'state', 'run_id')\n column_formatters = dict(\n execution_date=datetime_f,\n state=state_f,\n start_date=datetime_f,\n dag_id=dag_link,\n run_id=dag_run_link\n )\n\n @action('new_delete', \"Delete\", \"Are you sure you want to delete selected records?\")\n @provide_session\n def action_new_delete(self, ids, session=None):\n deleted = set(session.query(models.DagRun)\n .filter(models.DagRun.id.in_(ids))\n .all())\n session.query(models.DagRun) \\\n .filter(models.DagRun.id.in_(ids)) \\\n .delete(synchronize_session='fetch')\n session.commit()\n dirty_ids = []\n for row in deleted:\n dirty_ids.append(row.dag_id)\n models.DagStat.update(dirty_ids, dirty_only=False, session=session)\n\n @action('set_running', \"Set state to 'running'\", None)\n def action_set_running(self, ids):\n self.set_dagrun_state(ids, State.RUNNING)\n\n @action('set_failed', \"Set state to 'failed'\", None)\n def action_set_failed(self, ids):\n self.set_dagrun_state(ids, State.FAILED)\n\n @action('set_success', \"Set state to 'success'\", None)\n def action_set_success(self, ids):\n self.set_dagrun_state(ids, State.SUCCESS)\n\n @provide_session\n def set_dagrun_state(self, ids, target_state, session=None):\n try:\n DR = models.DagRun\n count = 0\n dirty_ids = []\n for dr in session.query(DR).filter(DR.id.in_(ids)).all():\n dirty_ids.append(dr.dag_id)\n count += 1\n dr.state = target_state\n if target_state == State.RUNNING:\n dr.start_date = timezone.utcnow()\n else:\n dr.end_date = timezone.utcnow()\n session.commit()\n models.DagStat.update(dirty_ids, session=session)\n flash(\n \"{count} dag runs were set to '{target_state}'\".format(**locals()))\n except Exception as ex:\n if not self.handle_view_exception(ex):\n raise Exception(\"Ooops\")\n flash('Failed to set state', 'error')\n\n\nclass LogModelView(ModelViewOnly):\n verbose_name_plural = \"logs\"\n verbose_name = \"log\"\n column_display_actions = False\n column_default_sort = ('dttm', True)\n column_filters = ('dag_id', 'task_id', 'execution_date')\n filter_converter = wwwutils.UtcFilterConverter()\n column_formatters = dict(\n dttm=datetime_f, execution_date=datetime_f, dag_id=dag_link)\n\n\nclass TaskInstanceModelView(ModelViewOnly):\n verbose_name_plural = \"task instances\"\n verbose_name = \"task instance\"\n column_filters = (\n 'state', 'dag_id', 'task_id', 'execution_date', 'hostname',\n 'queue', 'pool', 'operator', 'start_date', 'end_date')\n filter_converter = wwwutils.UtcFilterConverter()\n named_filter_urls = True\n column_formatters = dict(\n log_url=log_url_formatter,\n task_id=task_instance_link,\n hostname=nobr_f,\n state=state_f,\n execution_date=datetime_f,\n start_date=datetime_f,\n end_date=datetime_f,\n queued_dttm=datetime_f,\n dag_id=dag_link,\n run_id=dag_run_link,\n duration=duration_f)\n column_searchable_list = ('dag_id', 'task_id', 'state')\n column_default_sort = ('job_id', True)\n form_choices = {\n 'state': [\n ('success', 'success'),\n ('running', 'running'),\n ('failed', 'failed'),\n ],\n }\n column_list = (\n 'state', 'dag_id', 'task_id', 'execution_date', 'operator',\n 'start_date', 'end_date', 'duration', 'job_id', 'hostname',\n 'unixname', 'priority_weight', 'queue', 'queued_dttm', 'try_number',\n 'pool', 'log_url')\n page_size = PAGE_SIZE\n\n @action('set_running', \"Set state to 'running'\", None)\n def action_set_running(self, ids):\n self.set_task_instance_state(ids, State.RUNNING)\n\n @action('set_failed', \"Set state to 'failed'\", None)\n def action_set_failed(self, ids):\n self.set_task_instance_state(ids, State.FAILED)\n\n @action('set_success', \"Set state to 'success'\", None)\n def action_set_success(self, ids):\n self.set_task_instance_state(ids, State.SUCCESS)\n\n @action('set_retry', \"Set state to 'up_for_retry'\", None)\n def action_set_retry(self, ids):\n self.set_task_instance_state(ids, State.UP_FOR_RETRY)\n\n @provide_session\n @action('clear',\n lazy_gettext('Clear'),\n lazy_gettext(\n 'Are you sure you want to clear the state of the selected task instance(s)'\n ' and set their dagruns to the running state?'))\n def action_clear(self, ids, session=None):\n try:\n TI = models.TaskInstance\n\n dag_to_task_details = {}\n dag_to_tis = {}\n\n # Collect dags upfront as dagbag.get_dag() will reset the session\n for id_str in ids:\n task_id, dag_id, execution_date = id_str.split(',')\n dag = dagbag.get_dag(dag_id)\n task_details = dag_to_task_details.setdefault(dag, [])\n task_details.append((task_id, execution_date))\n\n for dag, task_details in dag_to_task_details.items():\n for task_id, execution_date in task_details:\n execution_date = parse_execution_date(execution_date)\n\n ti = session.query(TI).filter(TI.task_id == task_id,\n TI.dag_id == dag.dag_id,\n TI.execution_date == execution_date).one()\n\n tis = dag_to_tis.setdefault(dag, [])\n tis.append(ti)\n\n for dag, tis in dag_to_tis.items():\n models.clear_task_instances(tis, session, dag=dag)\n\n session.commit()\n\n flash(\"{0} task instances have been cleared\".format(len(ids)))\n\n except Exception as ex:\n if not self.handle_view_exception(ex):\n raise Exception(\"Ooops\")\n flash('Failed to clear task instances', 'error')\n\n @provide_session\n def set_task_instance_state(self, ids, target_state, session=None):\n try:\n TI = models.TaskInstance\n count = len(ids)\n for id in ids:\n task_id, dag_id, execution_date = id.split(',')\n execution_date = parse_execution_date(execution_date)\n\n ti = session.query(TI).filter(TI.task_id == task_id,\n TI.dag_id == dag_id,\n TI.execution_date == execution_date).one()\n ti.state = target_state\n session.commit()\n flash(\n \"{count} task instances were set to '{target_state}'\".format(**locals()))\n except Exception as ex:\n if not self.handle_view_exception(ex):\n raise Exception(\"Ooops\")\n flash('Failed to set state', 'error')\n\n def get_one(self, id):\n \"\"\"\n As a workaround for AIRFLOW-252, this method overrides Flask-Admin's ModelView.get_one().\n\n TODO: this method should be removed once the below bug is fixed on Flask-Admin side.\n https://github.com/flask-admin/flask-admin/issues/1226\n \"\"\"\n task_id, dag_id, execution_date = iterdecode(id)\n execution_date = pendulum.parse(execution_date)\n return self.session.query(self.model).get((task_id, dag_id, execution_date))\n\n\nclass ConnectionModelView(wwwutils.SuperUserMixin, AirflowModelView):\n create_template = 'airflow/conn_create.html'\n edit_template = 'airflow/conn_edit.html'\n list_template = 'airflow/conn_list.html'\n form_columns = (\n 'conn_id',\n 'conn_type',\n 'host',\n 'schema',\n 'login',\n 'password',\n 'port',\n 'extra',\n 'extra__jdbc__drv_path',\n 'extra__jdbc__drv_clsname',\n 'extra__google_cloud_platform__project',\n 'extra__google_cloud_platform__key_path',\n 'extra__google_cloud_platform__keyfile_dict',\n 'extra__google_cloud_platform__scope',\n )\n verbose_name = \"Connection\"\n verbose_name_plural = \"Connections\"\n column_default_sort = ('conn_id', False)\n column_list = ('conn_id', 'conn_type', 'host', 'port', 'is_encrypted', 'is_extra_encrypted',)\n form_overrides = dict(_password=PasswordField, _extra=TextAreaField)\n form_widget_args = {\n 'is_extra_encrypted': {'disabled': True},\n 'is_encrypted': {'disabled': True},\n }\n # Used to customized the form, the forms elements get rendered\n # and results are stored in the extra field as json. All of these\n # need to be prefixed with extra__ and then the conn_type ___ as in\n # extra__{conn_type}__name. You can also hide form elements and rename\n # others from the connection_form.js file\n form_extra_fields = {\n 'extra__jdbc__drv_path': StringField('Driver Path'),\n 'extra__jdbc__drv_clsname': StringField('Driver Class'),\n 'extra__google_cloud_platform__project': StringField('Project Id'),\n 'extra__google_cloud_platform__key_path': StringField('Keyfile Path'),\n 'extra__google_cloud_platform__keyfile_dict': PasswordField('Keyfile JSON'),\n 'extra__google_cloud_platform__scope': StringField('Scopes (comma separated)'),\n\n }\n form_choices = {\n 'conn_type': models.Connection._types\n }\n\n def on_model_change(self, form, model, is_created):\n formdata = form.data\n if formdata['conn_type'] in ['jdbc', 'google_cloud_platform']:\n extra = {\n key: formdata[key]\n for key in self.form_extra_fields.keys() if key in formdata}\n model.extra = json.dumps(extra)\n\n @classmethod\n def alert_fernet_key(cls):\n fk = None\n try:\n fk = conf.get('core', 'fernet_key')\n except:\n pass\n return fk is None\n\n @classmethod\n def is_secure(cls):\n \"\"\"\n Used to display a message in the Connection list view making it clear\n that the passwords and `extra` field can't be encrypted.\n \"\"\"\n is_secure = False\n try:\n import cryptography\n conf.get('core', 'fernet_key')\n is_secure = True\n except:\n pass\n return is_secure\n\n def on_form_prefill(self, form, id):\n try:\n d = json.loads(form.data.get('extra', '{}'))\n except Exception:\n d = {}\n\n for field in list(self.form_extra_fields.keys()):\n value = d.get(field, '')\n if value:\n field = getattr(form, field)\n field.data = value\n\n\nclass UserModelView(wwwutils.SuperUserMixin, AirflowModelView):\n verbose_name = \"User\"\n verbose_name_plural = \"Users\"\n column_default_sort = 'username'\n\n\nclass VersionView(wwwutils.SuperUserMixin, BaseView):\n @expose('/')\n def version(self):\n # Look at the version from setup.py\n try:\n airflow_version = pkg_resources.require(\"apache-airflow\")[0].version\n except Exception as e:\n airflow_version = None\n logging.error(e)\n\n # Get the Git repo and git hash\n git_version = None\n try:\n with open(os.path.join(*[settings.AIRFLOW_HOME, 'airflow', 'git_version'])) as f:\n git_version = f.readline()\n except Exception as e:\n logging.error(e)\n\n # Render information\n title = \"Version Info\"\n return self.render('airflow/version.html',\n title=title,\n airflow_version=airflow_version,\n git_version=git_version)\n\n\nclass ConfigurationView(wwwutils.SuperUserMixin, BaseView):\n @expose('/')\n def conf(self):\n raw = request.args.get('raw') == \"true\"\n title = \"Airflow Configuration\"\n subtitle = conf.AIRFLOW_CONFIG\n if conf.getboolean(\"webserver\", \"expose_config\"):\n with open(conf.AIRFLOW_CONFIG, 'r') as f:\n config = f.read()\n table = [(section, key, value, source)\n for section, parameters in conf.as_dict(True, True).items()\n for key, (value, source) in parameters.items()]\n\n else:\n config = (\n \"# Your Airflow administrator chose not to expose the \"\n \"configuration, most likely for security reasons.\")\n table = None\n if raw:\n return Response(\n response=config,\n status=200,\n mimetype=\"application/text\")\n else:\n code_html = Markup(highlight(\n config,\n lexers.IniLexer(), # Lexer call\n HtmlFormatter(noclasses=True))\n )\n return self.render(\n 'airflow/config.html',\n pre_subtitle=settings.HEADER + \" v\" + airflow.__version__,\n code_html=code_html, title=title, subtitle=subtitle,\n table=table)\n\n\nclass DagModelView(wwwutils.SuperUserMixin, ModelView):\n column_list = ('dag_id', 'owners')\n column_editable_list = ('is_paused',)\n form_excluded_columns = ('is_subdag', 'is_active')\n column_searchable_list = ('dag_id',)\n column_filters = (\n 'dag_id', 'owners', 'is_paused', 'is_active', 'is_subdag',\n 'last_scheduler_run', 'last_expired')\n filter_converter = wwwutils.UtcFilterConverter()\n form_widget_args = {\n 'last_scheduler_run': {'disabled': True},\n 'fileloc': {'disabled': True},\n 'is_paused': {'disabled': True},\n 'last_pickled': {'disabled': True},\n 'pickle_id': {'disabled': True},\n 'last_loaded': {'disabled': True},\n 'last_expired': {'disabled': True},\n 'pickle_size': {'disabled': True},\n 'scheduler_lock': {'disabled': True},\n 'owners': {'disabled': True},\n }\n column_formatters = dict(\n dag_id=dag_link,\n )\n can_delete = False\n can_create = False\n page_size = PAGE_SIZE\n list_template = 'airflow/list_dags.html'\n named_filter_urls = True\n\n def get_query(self):\n \"\"\"\n Default filters for model\n \"\"\"\n return (\n super(DagModelView, self)\n .get_query()\n .filter(or_(models.DagModel.is_active, models.DagModel.is_paused))\n .filter(~models.DagModel.is_subdag)\n )\n\n def get_count_query(self):\n \"\"\"\n Default filters for model\n \"\"\"\n return (\n super(DagModelView, self)\n .get_count_query()\n .filter(models.DagModel.is_active)\n .filter(~models.DagModel.is_subdag)\n )\n"
]
| [
[
"pandas.to_datetime",
"pandas.set_option"
]
]
|
emanuele-albini/emutils | [
"d5e3939da8a14b629879f06d87d4bd371e7117ab",
"d5e3939da8a14b629879f06d87d4bd371e7117ab"
]
| [
"src/emutils/tf/math.py",
"src/emutils/dsutils/utils.py"
]
| [
"import tensorflow as tf\n\n\ndef cov(x):\n mean_x = tf.reduce_mean(x, axis=0, keepdims=True)\n mx = tf.matmul(tf.transpose(mean_x), mean_x)\n vx = tf.matmul(tf.transpose(x), x) / tf.cast(tf.shape(x)[0], tf.float64)\n cov_xx = vx - mx\n return cov_xx\n\n\ndef inv_cov(x):\n return tf.linalg.inv(cov(x))\n",
"import numpy as np\nimport pandas as pd\n\nfrom typing import Union, Iterable, Dict\n\nfrom ..mlutils import MultiColumnLabelEncoderDecoder\n\n\ndef generate_combinatorial_dataset(names: Dict[str, Union[np.ndarray, list]], variables: Iterable[str] = None):\n \"\"\"\n Generate the combinatorial dataset for a list of variables\n\n names : a dictionary\n names.key = name of the variable\n names.value = values that the variable can assume\n variables : the iterables with the list of variables/columns for which to generate the dataset\n If variables = None, all the names.keys() will be used\n\n Returns\n -----------------------\n pd.DataFrame\n\n A dataframe with the combinatorial dataset\n \"\"\"\n variables = np.array(variables) if variables is not None else np.array(list(names.keys()))\n generator = [names[node] for node in variables]\n return pd.DataFrame(np.array(np.meshgrid(*generator)).T.reshape(-1, len(variables)), columns=variables)\n\n\ndef number_of_combinations_encoder(encdec: MultiColumnLabelEncoderDecoder, variables: Iterable = None):\n if variables is None:\n variables = encdec.get_encoder().keys()\n\n combs = 1\n for var in variables:\n combs *= len(encdec.get_encoder()[var])\n return combs\n\n\ndef random_combinatorial_sample(encdec: MultiColumnLabelEncoderDecoder, size: int, variables: Iterable = None, replace=True):\n if variables is None:\n variables = encdec.get_encoder().keys()\n if not replace:\n size = min(size, number_of_combinations_encoder(encdec, variables))\n sample = pd.DataFrame()\n while len(sample) < size:\n tempsample = pd.DataFrame()\n for var in variables:\n var_bowl = np.array(list(encdec.get_encoder()[var].keys()))\n tempsample[var] = np.random.choice(var_bowl, size - len(sample), replace=True)\n sample = pd.concat([sample, tempsample], axis=0)\n if not replace:\n sample.drop_duplicates(inplace=True)\n sample.reset_index(inplace=True, drop=True)\n return sample\n\n\ndef get_features_encodings(X: pd.DataFrame):\n \"\"\"\n Return the uniques values for each feature\n \"\"\"\n feature_encodings = {}\n for f in X.columns:\n u = X[f].unique()\n feature_encodings[f] = sorted(u)\n return feature_encodings\n\n\ndef number_of_combinations_categorical(X: [pd.DataFrame, MultiColumnLabelEncoderDecoder]):\n \"\"\"\n Return the number of combinations of inputs\n \"\"\"\n combs = 1\n feature_encodings = get_features_encodings(X)\n for f, encods in feature_encodings.items():\n combs *= len(encods)\n return combs"
]
| [
[
"tensorflow.reduce_mean",
"tensorflow.shape",
"tensorflow.transpose"
],
[
"pandas.DataFrame",
"numpy.array",
"numpy.meshgrid",
"pandas.concat"
]
]
|
lite-david/polymath | [
"cf1addc75e203fa606ebc6d32bc552fb3975ea99"
]
| [
"polymath/srdfg/base.py"
]
| [
"\nfrom polymath import UNSET_SHAPE, DEFAULT_SHAPES\nimport builtins\nimport operator\nfrom collections import OrderedDict, Mapping, Sequence, deque\nimport functools\nfrom numbers import Integral, Rational, Real\nimport contextlib\nimport traceback\nimport uuid\nimport numpy as np\nimport importlib\nfrom .graph import Graph\nfrom .domain import Domain\nfrom .util import _noop_callback, _flatten_iterable, node_hash, \\\n _is_node_type_instance, is_iterable\n\nclass Node(object):\n \"\"\"\n Base class for nodes.\n\n Parameters\n ----------\n args : tuple\n Positional arguments passed to the `_evaluate` method.\n name : str or None\n Name of the node or `None` to use a random, unique identifier.\n shape : tuple or None\n Shape of the output for a node. This can be a tuple of integers or parameter node names.\n graph : Node or None\n Parent graph of this node. If graph is `None`, this is the top-level graph.\n op_name : str\n Operation name which describes the node functionality.\n value : Any or None\n If a node has a default value to use for execution, it can be set using `value`.\n kwargs : dict\n Keyword arguments passed to the `_evaluate` method.\n \"\"\"\n _graph_stack = deque([None])\n _eval_stack = []\n stack_size = 5\n evaluated_nodes = 0\n def __init__(self, *args,\n name=None,\n shape=None,\n graph=None,\n dependencies=None,\n op_name=None,\n value=None,\n **kwargs):\n self.nodes = Graph()\n self.value = value\n self.dependencies = []\n self._args = []\n self._predeecessors = []\n self._succesors = []\n self.args = args\n if \"name\" in kwargs:\n kwargs.pop(\"name\")\n self.added_attrs = []\n # TODO: CHange this to underscore private variable\n self.kwargs = kwargs\n self.graph = graph\n self._shape = OrderedDict()\n self.shape = shape or tuple([])\n\n\n # Get a list of all dependencies relevant to this node\n self.dependencies = [] if dependencies is None else dependencies\n if self.graph:\n self.dependencies.extend(self.graph.dependencies)\n # Choose a name for the node and add the node to the graph\n self._name = None\n self.name = name or uuid.uuid4().hex\n self._op_name = None\n self.op_name = op_name\n # Get the stack context so we can report where the node was defined\n self._stack = traceback.extract_stack(limit=1)\n\n\n @property\n def graph(self):\n \"\"\"\n polymath.srdfg.graph.Graph : Parent graph of this node. If graph is `None`, this is the top-level graph.\n \"\"\"\n return self._graph\n\n def preds(self):\n return self._preds\n\n def succs(self):\n return self._preds\n\n def add_predecessor(self, pred):\n if isinstance(pred, Node):\n self._predecessors.append(pred.gname)\n else:\n self._predecessors.append(pred)\n\n def add_successor(self, succ):\n if isinstance(succ, Node):\n self._succesors.append(succ.gname)\n else:\n self._succesors.append(succ)\n\n def set_edges(self):\n for e in self.args:\n self.add_predecessor(e)\n if isinstance(e, Node):\n e.add_successor(self)\n\n @property\n def domain(self):\n return Domain(tuple([]))\n\n @property\n def args(self):\n \"\"\"\n tuple : Positional arguments which are used for executing this node.\n \"\"\"\n return tuple(self._args)\n\n @property\n def argnames(self):\n return [a.name if isinstance(a, Node) else a for a in self.args]\n\n @property\n def shape(self):\n \"\"\"\n tuple : Shape of the output for a node. This can be a tuple of integers or parameter node names.\n \"\"\"\n return self._shape\n\n @property\n def var(self):\n return self\n\n @property\n def name(self):\n \"\"\"str : Unique name of the node\"\"\"\n return self._name\n\n @property\n def op_name(self):\n \"\"\"\n str : Operation name which describes the node functionality.\n\n \"\"\"\n return self._op_name\n\n @op_name.setter\n def op_name(self, op_name):\n\n if op_name:\n self._op_name = op_name\n elif self.__class__.__name__ == \"Node\":\n self._op_name = self.name\n else:\n self._op_name = self.__class__.__name__\n\n @name.setter\n def name(self, name):\n self.set_name(name)\n\n @args.setter\n def args(self, args):\n new_args = []\n for arg in args:\n if isinstance(arg, Node):\n if self.__class__.__name__ == \"Node\":\n self.nodes[arg.name] = self.graph[arg.name]\n new_args.append(arg)\n self._args = tuple(new_args)\n\n @shape.setter\n def shape(self, shape):\n self.set_shape(shape, init=True)\n\n @graph.setter\n def graph(self, graph):\n self._graph = Node.get_active_graph(graph)\n\n @property\n def gname(self):\n scope_names = [self.name]\n cgraph = self.graph\n while cgraph:\n scope_names.append(cgraph.name)\n cgraph = cgraph.graph\n return \"/\".join(list(reversed(scope_names)))\n\n def __enter__(self):\n Node._graph_stack.append(self)\n return self\n\n def __exit__(self, *args):\n assert self == Node._graph_stack.pop()\n\n def __repr__(self):\n return \"<node '%s'>\" % self.name\n\n def add_attribute(self, key, value):\n self.added_attrs.append(key)\n self.kwargs[key] = value\n\n def is_shape_finalized(self):\n if self.shape == UNSET_SHAPE:\n return False\n for s in self.shape:\n if not isinstance(s, Integral):\n return False\n return True\n\n def set_shape(self, shape=None, init=False):\n if isinstance(shape, float):\n self._shape = tuple([np.int(shape)])\n elif isinstance(shape, Integral):\n self._shape = tuple([shape])\n elif isinstance(shape, Node):\n self._shape = tuple([shape])\n elif not shape or len(shape) == 0:\n # TODO: Change in order to enable \"is shape finalized\" to work\n self._shape = UNSET_SHAPE\n else:\n shapes = []\n for dim in shape:\n if isinstance(dim, (Node, Integral)):\n shapes.append(dim)\n elif isinstance(dim, float):\n shapes.append(int(dim))\n else:\n raise TypeError(f\"Shape value must be placeholder or integer value for {self.name}\\n\"\n f\"\\tDim: {dim}\"\n f\"\\n\\t{self.kwargs} \")\n self._shape = tuple(shapes)\n\n @staticmethod\n def get_active_graph(graph=None):\n \"\"\"\n Obtain the currently active graph instance by returning the explicitly given graph or using\n the default graph.\n\n Parameters\n ----------\n graph : Node or None\n Graph to return or `None` to use the default graph.\n\n Raises\n ------\n ValueError\n If no `Graph` instance can be obtained.\n \"\"\"\n\n graph = graph or Node._graph_stack[-1]\n return graph\n\n def instantiate_node(self, node): # pylint:disable=W0621\n \"\"\"\n Instantiate nodes by retrieving the node object associated with the node name.\n\n Parameters\n ----------\n node : Node or str\n Node instance or name of an node.\n\n Returns\n -------\n instantiated_node : Node\n Node instance.\n\n Raises\n ------\n ValueError\n If `node` is not an `Node` instance or an node name.\n RuntimeError\n If `node` is an `Node` instance but does not belong to this graph.\n \"\"\"\n if isinstance(node, str):\n return self.nodes[node]\n\n if isinstance(node, Node):\n if node.name not in self.nodes and (node.graph != self):\n raise RuntimeError(f\"node '{node}' does not belong to {self} graph, instead belongs to\"\n f\" {node.graph}\")\n return node\n\n raise ValueError(f\"'{node}' is not an `Node` instance or node name\")\n\n def instantiate_graph(self, context, **kwargs):\n \"\"\"\n Instantiate a graph by replacing all node names with node instances.\n\n .. note::\n This function modifies the context in place. Use :code:`context=context.copy()` to avoid\n the context being modified.\n\n Parameters\n ----------\n context : dict[Node or str, object]\n Context whose keys are node instances or names.\n kwargs : dict[str, object]\n Additional context information keyed by variable name.\n\n Returns\n -------\n normalized_context : dict[Node, object]\n Normalized context whose keys are node instances.\n\n Raises\n ------\n ValueError\n If the context specifies more than one value for any node.\n ValueError\n If `context` is not a mapping.\n \"\"\"\n if context is None:\n context = {}\n elif not isinstance(context, Mapping):\n raise ValueError(\"`context` must be a mapping.\")\n\n nodes = list(context)\n # Add the keyword arguments\n for node in nodes: # pylint:disable=W0621\n value = context.pop(node)\n node = self.instantiate_node(node)\n if node in context:\n raise ValueError(f\"duplicate unequal value for node '{node}'\")\n context[node] = value\n if node.op_name in [\"placeholder\", \"state\", \"input\", \"output\", \"temp\"] and not node.is_shape_finalized():\n context[node] = node.evaluate(context)\n\n for name, value in kwargs.items():\n node = self.nodes[name]\n if node in context:\n raise ValueError(f\"duplicate value for node '{node}'\")\n context[node] = value\n if node.op_name in [\"placeholder\", \"state\", \"input\", \"output\", \"temp\"] and not node.is_shape_finalized():\n context[node] = node.evaluate(context)\n\n return context\n\n def run(self, fetches, context=None, *, callback=None, **kwargs):\n \"\"\"\n Evaluate one or more nodes given a dictionary of node names with their values.\n\n .. note::\n This function modifies the context in place. Use :code:`context=context.copy()` to avoid\n the context being modified.\n\n Parameters\n ----------\n fetches : list[str or Node] or str or Node\n One or more `Node` instances or names to evaluate.\n context : dict or None\n Context in which to evaluate the nodes.\n callback : callable or None\n Callback to be evaluated when an node is evaluated.\n kwargs : dict\n Additional context information keyed by variable name.\n\n Returns\n -------\n values : Node or tuple[object]\n Output of the nodes given the context.\n\n Raises\n ------\n ValueError\n If `fetches` is not an `Node` instance, node name, or a sequence thereof.\n \"\"\"\n if isinstance(fetches, (str, Node)):\n fetches = [fetches]\n single = True\n elif isinstance(fetches, Sequence):\n single = False\n else:\n raise ValueError(\"`fetches` must be an `Node` instance, node name, or a \"\n \"sequence thereof.\")\n fetches = [self.instantiate_node(node) for node in fetches]\n context = self.instantiate_graph(context, **kwargs)\n for c in context:\n if c in fetches and c.op_name in [\"output\", \"state\", \"temp\"]:\n write_name = \"/\".join([f\"{i}{c.write_count-1}\" for i in c.name.split(\"/\")]) if c.write_count > 0 else c.name\n fetches[fetches.index(c)] = c.graph.nodes[write_name]\n\n values = [fetch.evaluate_node(fetch, context, callback=callback) for fetch in fetches]\n\n return values[0] if single else tuple(values)\n\n def __getstate__(self):\n return self.__dict__\n\n def __setstate__(self, data):\n self.__dict__.update(data)\n\n def set_name(self, name):\n \"\"\"\n Set the name of the node and update the graph.\n\n Parameters\n ----------\n value : str\n Unique name of the node.\n\n Returns\n -------\n self : Node\n This node.\n\n Raises\n ------\n ValueError\n If an node with `value` already exists in the associated graph.\n KeyError\n If the current name of the node cannot be found in the associated graph.\n \"\"\"\n\n name = name or uuid.uuid4().hex\n # TODO: Need a way to check if the existing node is not equal to the current ndoe as ewll\n if self.graph and name in self.graph.nodes:\n raise ValueError(f\"duplicate name '{name}' in {self.graph.name}:\\n\\t\"\n f\"Existing: {self.graph.nodes[name].args}\\n\\t\"\n f\"New: {self.args}\")\n\n if self.graph:\n graph = self.graph\n if self._name and self._name in graph.nodes:\n graph.update_graph_key(self._name, name)\n else:\n graph.nodes[name] = self\n\n self._name = name\n return self\n\n def evaluate_dependencies(self, context, callback=None):\n \"\"\"\n Evaluate the dependencies of this node and discard the values.\n\n Parameters\n ----------\n context : dict\n Normalised context in which to evaluate the node.\n callback : callable or None\n Callback to be evaluated when an node is evaluated.\n \"\"\"\n for node in self.dependencies:\n node.evaluate(context, callback)\n\n def evaluate(self, context, callback=None):\n \"\"\"\n Evaluate the node given a context.\n\n Parameters\n ----------\n context : dict\n Normalised context in which to evaluate the node.\n callback : callable or None\n Callback to be evaluated when an node is evaluated.\n\n Returns\n -------\n value : object\n Output of the node given the context.\n \"\"\"\n # Evaluate all explicit dependencies first\n\n self.evaluate_dependencies(context, callback)\n\n if self in context:\n return context[self]\n\n # Evaluate the parents\n partial = functools.partial(self.evaluate_node, context=context, callback=callback)\n\n args = [partial(arg) for arg in self.args]\n kwargs = {key: partial(value) for key, value in self.kwargs.items() if key not in self.added_attrs}\n # Evaluate the node\n callback = callback or _noop_callback\n with callback(self, context):\n if self.__class__.__name__ == \"Node\":\n context[self] = self.value = self._evaluate(*args, context=context, **kwargs)\n else:\n context[self] = self.value = self._evaluate(*args, **kwargs)\n return self.value\n\n def _evaluate(self, *args, context=None, **kwargs):\n \"\"\"\n Inheriting nodes should implement this function to evaluate the node.\n \"\"\"\n return self(*args, context, **kwargs)\n\n @classmethod\n def evaluate_node(cls, node, context, **kwargs):\n \"\"\"\n Evaluate an node or constant given a context.\n \"\"\"\n Node.evaluated_nodes += 1\n try:\n if isinstance(node, Node):\n Node._eval_stack.append(node.name)\n return node.evaluate(context, **kwargs)\n partial = functools.partial(cls.evaluate_node, context=context, **kwargs)\n if isinstance(node, tuple):\n return tuple(partial(element) for element in node)\n if isinstance(node, list):\n return [partial(element) for element in node]\n if isinstance(node, dict):\n return {partial(key): partial(value) for key, value in node.items()}\n if isinstance(node, slice):\n return slice(*[partial(getattr(node, attr))\n for attr in ['start', 'stop', 'step']])\n return node\n except Exception as ex: # pragma: no cover\n messages = []\n interactive = False\n if isinstance(node, Node) or not is_iterable(node):\n node = [node]\n\n for n in node:\n stack = []\n if isinstance(n, Node):\n\n for frame in reversed(n._stack): # pylint: disable=protected-access\n # Do not capture any internal stack traces\n fname = frame.filename\n if 'polymath' in fname:\n continue\n # Stop tracing at the last interactive cell\n if interactive and not fname.startswith('<'):\n break # pragma: no cover\n interactive = fname.startswith('<')\n stack.append(frame)\n stack = \"\".join(traceback.format_list(reversed(stack)))\n message = \"Failed to evaluate node `%s` defined at:\\n\\n%s\" % (n, stack)\n messages.append(message)\n raise ex from EvaluationError(\"\".join(messages))\n\n\n @classmethod\n def init_from_args(cls, *args,\n name=None,\n shape=None,\n graph=None,\n dependencies=None,\n op_name=None,\n value=None,\n **kwargs):\n if len(args) == 0:\n n = cls(name=name,\n shape=shape,\n graph=graph,\n op_name=op_name,\n dependencies=dependencies,\n value=value,\n **kwargs)\n else:\n n = cls(*args,\n name=name,\n shape=shape,\n graph=graph,\n op_name=op_name,\n dependencies=dependencies,\n value=value,\n **kwargs)\n return n\n\n def __bool__(self):\n return True\n\n def __hash__(self):\n return id(self)\n\n def func_hash(self):\n \"\"\"\n This returns the functional hash of a particular node. The default hash returns an object id, whereas this function\n returns a hash of all attributes and subgraphs of a node.\n \"\"\"\n return node_hash(self)\n\n def find_node(self, name):\n g = self.graph\n while g is not None and name not in g.nodes:\n g = g.graph\n if name in g.nodes:\n return g.nodes[name]\n raise RuntimeError(f\"Cannot find {name} in graph nodes. Graph: {self.graph}\")\n\n def __len__(self):\n #TODO: Update this to check for finalzied shape\n if self.shape == UNSET_SHAPE:\n raise TypeError(f'`shape` must be specified explicitly for nodes {self}')\n return self.shape[0]\n\n def __iter__(self):\n num = len(self)\n for i in range(num):\n yield self[i]\n\n def __eq__(self, other):\n return hash(self) == hash(other)\n\n def __getattr__(self, name):\n return getattr_(self, name, graph=self.graph)\n\n def __getitem__(self, key):\n if self.__class__.__name__ != \"Node\":\n if isinstance(key, (slice, Integral)):\n return getitem(self, key, graph=self.graph)\n else:\n if isinstance(key, (list)):\n return var_index(self, key, graph=self)\n elif isinstance(key, tuple):\n return var_index(self, list(key), graph=self)\n else:\n return var_index(self, [key], graph=self)\n else:\n return self.nodes[key]\n\n def __add__(self, other):\n return add(self, other, graph=self.graph) if not _is_node_type_instance(other, (\"slice_op\", \"var_index\", \"index\")) else other.__radd__(self)\n\n def __radd__(self, other):\n return add(other, self, graph=self.graph) if not _is_node_type_instance(other, (\"slice_op\", \"var_index\", \"index\")) else other.__add__(self)\n\n def __sub__(self, other):\n return sub(self, other, graph=self.graph) if not _is_node_type_instance(other, (\"slice_op\", \"var_index\", \"index\")) else other.__rsub__(self)\n\n def __rsub__(self, other):\n return sub(other, self, graph=self.graph) if not _is_node_type_instance(other, (\"slice_op\", \"var_index\", \"index\")) else other.__sub__(self)\n\n def __pow__(self, other):\n return pow_(self, other, graph=self.graph) if not _is_node_type_instance(other, (\"slice_op\", \"var_index\", \"index\")) else other.__rpow__(self)\n\n def __rpow__(self, other):\n return pow_(other, self, graph=self.graph) if not _is_node_type_instance(other, (\"slice_op\", \"var_index\", \"index\")) else other.__rpow__(self)\n\n def __matmul__(self, other):\n return matmul(self, other, graph=self.graph)\n\n def __rmatmul__(self, other):\n return matmul(other, self, graph=self.graph)\n\n def __mul__(self, other):\n return mul(self, other, graph=self.graph) if not _is_node_type_instance(other, (\"slice_op\", \"var_index\", \"index\")) else other.__rmul__(self)\n\n def __rmul__(self, other):\n return mul(other, self, graph=self.graph) if not _is_node_type_instance(other, (\"slice_op\", \"var_index\", \"index\")) else other.__mul__(self)\n\n def __truediv__(self, other):\n return truediv(self, other, graph=self.graph) if not _is_node_type_instance(other, (\"slice_op\", \"var_index\", \"index\")) else other.__truediv__(self)\n\n def __rtruediv__(self, other):\n return truediv(other, self, graph=self.graph) if not _is_node_type_instance(other, (\"slice_op\", \"var_index\", \"index\")) else other.__rtruediv__(self)\n\n def __floordiv__(self, other):\n return floordiv(self, other, graph=self.graph) if not _is_node_type_instance(other, (\"slice_op\", \"var_index\", \"index\")) else other.__rfloordiv__(self)\n\n def __rfloordiv__(self, other):\n return floordiv(other, self, graph=self.graph) if not _is_node_type_instance(other, (\"slice_op\", \"var_index\", \"index\")) else other.__floordiv__(self)\n\n def __mod__(self, other):\n return mod(self, other, graph=self.graph) if not _is_node_type_instance(other, (\"slice_op\", \"var_index\", \"index\")) else other.__rmod__(self)\n\n def __rmod__(self, other):\n return mod(other, self, graph=self.graph) if not _is_node_type_instance(other, (\"slice_op\", \"var_index\", \"index\")) else other.__mod__(self)\n\n def __lshift__(self, other):\n return lshift(self, other, graph=self.graph) if not _is_node_type_instance(other, (\"slice_op\", \"var_index\", \"index\")) else other.__rlshift__(self)\n\n def __rlshift__(self, other):\n return lshift(other, self, graph=self.graph) if not _is_node_type_instance(other, (\"slice_op\", \"var_index\", \"index\")) else other.__lshift__(self)\n\n def __rshift__(self, other):\n return rshift(self, other, graph=self.graph) if not _is_node_type_instance(other, (\"slice_op\", \"var_index\", \"index\")) else other.__rrshift__(self)\n\n def __rrshift__(self, other):\n return rshift(other, self, graph=self.graph) if not _is_node_type_instance(other, (\"slice_op\", \"var_index\", \"index\")) else other.__rshift__(self)\n\n def __and__(self, other):\n return and_(self, other, graph=self.graph) if not _is_node_type_instance(other, (\"slice_op\", \"var_index\", \"index\")) else other.__rand__(self)\n\n def __rand__(self, other):\n return and_(other, self, graph=self.graph) if not _is_node_type_instance(other, (\"slice_op\", \"var_index\", \"index\")) else other.__and__(self)\n\n def __or__(self, other):\n return or_(self, other, graph=self.graph) if not _is_node_type_instance(other, (\"slice_op\", \"var_index\", \"index\")) else other.__ror__(self)\n\n def __ror__(self, other):\n return or_(other, self, graph=self.graph) if not _is_node_type_instance(other, (\"slice_op\", \"var_index\", \"index\")) else other.__or__(self)\n\n def __xor__(self, other):\n return xor(self, other, graph=self.graph) if not _is_node_type_instance(other, (\"slice_op\", \"var_index\", \"index\")) else other.__rxor__(self)\n\n def __rxor__(self, other):\n return xor(other, self, graph=self.graph) if not _is_node_type_instance(other, (\"slice_op\", \"var_index\", \"index\")) else other.__xor__(self)\n\n def __lt__(self, other):\n return lt(self, other, graph=self.graph) if not _is_node_type_instance(other, (\"slice_op\", \"var_index\", \"index\")) else other.__gt__(self)\n\n def __le__(self, other):\n return le(self, other, graph=self.graph) if not _is_node_type_instance(other, (\"slice_op\", \"var_index\", \"index\")) else other.__ge__(self)\n\n\n def __ne__(self, other):\n return ne(self, other, graph=self.graph) if not _is_node_type_instance(other, (\"slice_op\", \"var_index\", \"index\")) else other.__ne__(self)\n\n def __gt__(self, other):\n return gt(self, other, graph=self.graph) if not _is_node_type_instance(other, (\"slice_op\", \"var_index\", \"index\")) else other.__lt__(self)\n\n def __ge__(self, other):\n return ge(self, other, graph=self.graph) if not _is_node_type_instance(other, (\"slice_op\", \"var_index\", \"index\")) else other.__le__(self)\n\n def __invert__(self):\n return inv(self, graph=self.graph)\n\n def __neg__(self):\n return neg(self, graph=self.graph)\n\n def __abs__(self):\n return abs_(self, graph=self.graph)\n\n def __pos__(self):\n return pos(self, graph=self.graph)\n\n def __reversed__(self):\n return reversed_(self, graph=self.graph)\n\n\n def update_graph_key(self, old_key, new_key):\n n = list(map(lambda k: (new_key, self.nodes[k]) if k == old_key else (k, self.nodes[k]), self.nodes.keys()))\n self.nodes = Graph(n)\n\n def insert_node(self, node, idx):\n node_list = list(self.nodes.items())\n node_list.insert(idx, (node.name, node))\n self.nodes = Graph(node_list)\n\n def __call__(self, *args, **kwargs):\n return self.run(*args, **kwargs)\n\nclass EvaluationError(RuntimeError):\n \"\"\"\n Failed to evaluate an node.\n \"\"\"\n\n\nclass var_index(Node): # pylint: disable=C0103,W0223\n \"\"\"\n Node representing values of a variable corresponding to input index values.\n\n Parameters\n ----------\n var : Node\n The multi-dimensional variable used for indexing into.\n idx : tuple\n Tuple of either integer values or index/index_op nodes.\n \"\"\"\n def __init__(self, var, idx, name=None, **kwargs): # pylint: disable=W0235\n if \"domain\" in kwargs:\n domain = tuple(kwargs.pop(\"domain\")) if isinstance(kwargs[\"domain\"], list) else kwargs.pop(\"domain\")\n else:\n domain = Domain(idx)\n\n super(var_index, self).__init__(var, idx, name=name, domain=domain, **kwargs)\n\n @property\n def domain(self):\n return self.kwargs[\"domain\"]\n\n @property\n def var(self):\n var, index_list = self.args\n return var\n\n def set_name(self, name):\n \"\"\"\n Set the name for a variable index, making sure to replicate the new name with\n a unique stringwhich corresponds to the variable, index combination.\n\n Parameters\n ----------\n value : str\n Unique name of the node.\n\n Returns\n -------\n self : Node\n This node.\n\n Raises\n ------\n ValueError\n If an node with `value` already exists in the associated graph.\n KeyError\n If the current name of the node cannot be found in the associated graph.\n \"\"\"\n\n # TODO: Need a way to check if the existing node is not equal to the current ndoe as ewll\n if self.graph and name in self.graph.nodes:\n raise ValueError(f\"duplicate name '{name}' in {self.graph.name}:\"\n f\"Existing: {self.graph.nodes[name].args}\\n\"\n f\"New: {self.args}\")\n\n if self.graph:\n graph = self.graph\n if self._name is not None and self._name in graph.nodes:\n graph.update_graph_key(self._name, name)\n else:\n graph.nodes[name] = self\n\n self._name = name\n return self\n\n def __getitem__(self, key):\n if self.is_shape_finalized() and len(self.nodes) >= np.prod(self.shape):\n if isinstance(key, Integral):\n key = tuple([key])\n idx = np.ravel_multi_index(key, dims=self.shape, order='C')\n ret = self.nodes.item_by_index(idx)\n return ret\n else:\n if isinstance(key, (list)):\n ret = var_index(self.var, tuple(key), graph=self)\n elif isinstance(key, tuple):\n ret = var_index(self.var, key, graph=self)\n else:\n ret = var_index(self.var, tuple([key]), graph=self)\n return ret\n\n def is_scalar(self, val=None):\n if val is not None and (not isinstance(val, np.ndarray) or (len(val.shape) == 1 and val.shape[0] == 1)):\n if self.var.shape != DEFAULT_SHAPES[0] and (len(self.var.shape) == 1 and not isinstance(self.var.shape[0],Node)):\n raise ValueError(f\"Invalid shape var for var index {self} with variable shape {self.var.shape}\")\n return True\n else:\n return self.var.shape == DEFAULT_SHAPES[0]\n\n def scalar_result(self):\n return all([isinstance(v, int) for v in self.args[1]])\n\n def _evaluate(self, var, indices, **kwargs):\n\n if self.is_scalar(var):\n out_shape = (1,)\n indices = (0,)\n single = True\n else:\n out_shape = self.domain.shape_from_indices(indices)\n indices = self.domain.compute_pairs()\n single = False\n if isinstance(var, (Integral, Real, str)):\n var = np.asarray([var])\n elif not isinstance(var, (np.ndarray, list)):\n raise TypeError(f\"Variable {var} with type {type(var)} is not a list or numpy array, and cannot be sliced for {self.name}\")\n elif isinstance(var, list):\n var = np.asarray(var)\n if len(var.shape) != len(out_shape) and np.prod(var.shape) == np.prod(out_shape):\n if len(out_shape) > len(var.shape):\n for i in range(len(out_shape)):\n if out_shape[i] == 1:\n var = np.expand_dims(var, axis=i)\n else:\n var = np.squeeze(var)\n\n if len(var.shape) != len(out_shape) and np.prod(var.shape) != np.prod(out_shape):\n raise ValueError(f\"Index list does not match {var.shape} in {self.var.name} - {self.var.op_name}\"\n f\"dimensions for slice {self.args[0].name} with {out_shape}.\\n\"\n f\"Domain: {self.domain}\\n\"\n f\"Eval Stack: {Node._eval_stack}\")\n\n if not single and not all([(idx_val - 1) >= indices[-1][idx] for idx, idx_val in enumerate(var.shape)]):\n\n raise ValueError(f\"var_index {self.name} has indices which are greater than the variable shape:\\n\"\n f\"\\tArgs: {self.args}\\n\"\n f\"\\tVar shape: {var.shape}\\n\"\n f\"\\tNode shape: {self.var.shape}\\n\"\n f\"\\tIndex Upper bounds: {indices[-1]}\")\n\n indices = list(map(lambda x: x.tolist() if isinstance(x, np.ndarray) else x, indices))\n\n res = var[indices] if single else np.asarray([var[idx] for idx in indices]).reshape(out_shape)\n if out_shape == (1,) and len(indices) == 1:\n res = res[0]\n self.domain.set_computed(out_shape, indices)\n\n return res\n\n def __add__(self, other):\n return slice_op(operator.add, self, other, graph=self.graph)\n\n def __radd__(self, other):\n return slice_op(operator.add, other, self, graph=self.graph)\n\n def __sub__(self, other):\n return slice_op(operator.sub, self, other, graph=self.graph)\n\n def __rsub__(self, other):\n return slice_op(operator.sub, other, self, graph=self.graph)\n\n def __pow__(self, other):\n return slice_op(builtins.pow, self, other, graph=self.graph)\n\n def __rpow__(self, other):\n return slice_op(builtins.pow, other, self, graph=self.graph)\n\n def __mul__(self, other):\n return slice_op(operator.mul, self, other, graph=self.graph)\n\n def __rmul__(self, other):\n return slice_op(operator.mul, other, self, graph=self.graph)\n\n def __truediv__(self, other):\n return slice_op(operator.truediv, self, other, graph=self.graph)\n\n def __rtruediv__(self, other):\n return slice_op(operator.truediv, other, self, graph=self.graph)\n\n def __floordiv__(self, other):\n return slice_op(operator.floordiv, self, other, graph=self.graph)\n\n def __rfloordiv__(self, other):\n return slice_op(operator.floordiv, other, self, graph=self.graph)\n\n def __mod__(self, other):\n return slice_op(operator.mod, self, other, graph=self.graph)\n\n def __rmod__(self, other):\n return slice_op(operator.mod, other, self, graph=self.graph)\n\n def __lshift__(self, other):\n return slice_op(operator.lshift, self, other, graph=self.graph)\n\n def __rlshift__(self, other):\n return slice_op(operator.lshift, other, self, graph=self.graph)\n\n def __rshift__(self, other):\n return slice_op(operator.rshift, self, other, graph=self.graph)\n\n def __rrshift__(self, other):\n return slice_op(operator.rshift, other, self, graph=self.graph)\n\n def __and__(self, other):\n return slice_op(operator.and_, self, other, graph=self.graph)\n\n def __rand__(self, other):\n return slice_op(operator.and_, other, self, graph=self.graph)\n\n def __or__(self, other):\n return slice_op(operator.or_, self, other, graph=self.graph)\n\n def __ror__(self, other):\n return slice_op(operator.or_, other, self, graph=self.graph)\n\n def __xor__(self, other):\n return slice_op(operator.xor, self, other, graph=self.graph)\n\n def __rxor__(self, other):\n return slice_op(operator.xor, other, self, graph=self.graph)\n\n def __lt__(self, other):\n return slice_op(operator.lt, self, other, graph=self.graph)\n\n def __le__(self, other):\n return slice_op(operator.lt, other, self, graph=self.graph)\n\n def __ne__(self, other):\n return slice_op(operator.ne, self, other, graph=self.graph)\n\n def __gt__(self, other):\n return slice_op(operator.gt, self, other, graph=self.graph)\n\n def __ge__(self, other):\n return slice_op(operator.ge, self, other, graph=self.graph)\n\n def __repr__(self):\n return \"<var_index name=%s, index=%s>\" % (self.name, self.args)\n\nclass slice_op(Node):\n \"\"\"\n Node representing multi-dimensional operations performed on a node.\n\n Parameters\n ----------\n target : cal\n The multi-dimensional variable used for indexing into.\n idx : tuple\n Tuple of either integer values or index/index_op nodes.\n \"\"\"\n def __init__(self, target, *args, **kwargs):\n\n if \"domain\" in kwargs:\n domain = tuple(kwargs.pop(\"domain\")) if isinstance(kwargs[\"domain\"], list) else kwargs.pop(\"domain\")\n else:\n all_args = _flatten_iterable(args)\n slice1_var, slice1_idx, slice2_var, slice2_idx = self.get_index_nodes(all_args[0], all_args[1])\n domain = slice1_idx.combine_set_domains(slice2_idx)\n\n if \"op_name\" in kwargs:\n kwargs.pop(\"op_name\")\n\n target_name = f\"{target.__module__}.{target.__name__}\"\n super(slice_op, self).__init__(*args, target=target_name, domain=domain, op_name=f\"slice_{target.__name__}\", **kwargs)\n self.target = target\n\n\n @property\n def domain(self):\n return self.kwargs[\"domain\"]\n\n def __getitem__(self, key):\n\n if isinstance(key, (tuple, list, np.ndarray)) and len(key) == 0:\n return self\n elif self.is_shape_finalized() and len(self.nodes) > 0:\n if isinstance(key, (int, Node)):\n key = tuple([key])\n if len(key) != len(self.shape):\n raise KeyError(f\"Invalid key shape for {self.name}:\\n\"\n f\"Shape: {self.shape}\\n\"\n f\"Key: {key}\")\n if isinstance(key, list):\n key = tuple(key)\n name = f\"{self.name}{key}\"\n if name not in self.nodes.keys():\n raise KeyError(f\"{name} not in {self.name} keys:\\n\"\n f\"Node keys: {list(self.nodes.keys())}\")\n ret = self.nodes[name]\n return ret\n else:\n name = []\n if isinstance(key, Node):\n name.append(key.name)\n elif hasattr(key, \"__len__\") and not isinstance(key, str):\n for k in key:\n if isinstance(k, Node):\n name.append(k.name)\n else:\n name.append(k)\n\n else:\n name.append(key)\n name = tuple(name)\n name = self.var.name + str(name)\n if name in self.graph.nodes:\n return self.graph.nodes[name]\n elif isinstance(key, (list)):\n return var_index(self, key, name=name, graph=self.graph)\n elif isinstance(key, tuple):\n return var_index(self, list(key), name=name, graph=self.graph)\n else:\n return var_index(self, [key], name=name, graph=self.graph)\n\n def set_shape(self, shape=None, init=False):\n s = []\n assert isinstance(shape, (tuple, list))\n if all([isinstance(sv, Integral) for sv in shape]) and len(self.domain) == np.product(shape) and len(shape) > 0:\n self._shape = shape if isinstance(shape, tuple) else tuple(shape)\n else:\n\n for idx, d in enumerate(self.domain.dom_set):\n if shape and isinstance(shape[idx], (func_op, Integral)):\n s.append(shape[idx])\n elif shape and isinstance(shape[idx], float):\n s.append(int(shape[idx]))\n elif isinstance(d, float):\n s.append(int(d))\n elif isinstance(d, var_index):\n s.append(d.domain)\n else:\n s.append(d)\n\n self._shape = tuple(s)\n\n def is_scalar(self, val):\n return not isinstance(val, np.ndarray) or (len(val.shape) == 1 and val.shape[0] == 1)\n\n def scalar_result(self):\n return False\n\n def _evaluate(self, op1, op2, context=None, **kwargs):\n if self.is_scalar(op1) or self.is_scalar(op2):\n value = self.target(op1, op2)\n else:\n arg0_dom = self.args[0].domain\n arg1_dom = self.args[1].domain\n op1_idx = self.domain.map_sub_domain(arg0_dom) if isinstance(self.args[0], Node) else tuple([])\n op2_idx = self.domain.map_sub_domain(arg1_dom) if isinstance(self.args[1], Node) else tuple([])\n op1 = np.asarray(list(map(lambda x: op1[x], op1_idx))).reshape(self.domain.computed_shape)\n op2 = np.asarray(list(map(lambda x: op2[x], op2_idx))).reshape(self.domain.computed_shape)\n value = self.target(op1, op2)\n return value\n\n\n\n def get_index_nodes(self, slice1_var=None, slice2_var=None):\n if slice1_var is None and slice2_var is None:\n slice1_var, slice2_var = self.args\n\n if isinstance(slice1_var, (slice_op, var_index)) or _is_node_type_instance(slice1_var, \"GroupNode\"):\n slice1_idx = slice1_var.domain\n elif _is_node_type_instance(slice1_var, \"index\"):\n slice1_idx = slice1_var.domain\n else:\n slice1_idx = Domain(tuple([]))\n\n if isinstance(slice2_var, (slice_op, var_index)) or _is_node_type_instance(slice2_var, \"GroupNode\"):\n slice2_idx = slice2_var.domain\n elif _is_node_type_instance(slice2_var, \"index\"):\n slice2_idx = slice2_var.domain\n else:\n slice2_idx = Domain(tuple([]))\n return slice1_var, slice1_idx, slice2_var, slice2_idx\n\n def __add__(self, other):\n return slice_op(operator.add, self, other, graph=self.graph)\n\n def __radd__(self, other):\n return slice_op(operator.add, other, self, graph=self.graph)\n\n def __sub__(self, other):\n return slice_op(operator.sub, self, other, graph=self.graph)\n\n def __rsub__(self, other):\n return slice_op(operator.sub, other, self, graph=self.graph)\n\n def __pow__(self, other):\n return slice_op(builtins.pow, self, other, graph=self.graph)\n\n def __rpow__(self, other):\n return slice_op(builtins.pow, other, self, graph=self.graph)\n\n def __mul__(self, other):\n return slice_op(operator.mul, self, other, graph=self.graph)\n\n def __rmul__(self, other):\n return slice_op(operator.mul, other, self, graph=self.graph)\n\n def __truediv__(self, other):\n return slice_op(operator.truediv, self, other, graph=self.graph)\n\n def __rtruediv__(self, other):\n return slice_op(operator.truediv, other, self, graph=self.graph)\n\n def __floordiv__(self, other):\n return slice_op(operator.floordiv, self, other, graph=self.graph)\n\n def __rfloordiv__(self, other):\n return slice_op(operator.floordiv, other, self, graph=self.graph)\n\n def __mod__(self, other):\n return slice_op(operator.mod, self, other, graph=self.graph)\n\n def __rmod__(self, other):\n return slice_op(operator.mod, other, self, graph=self.graph)\n\n def __lshift__(self, other):\n return slice_op(operator.lshift, self, other, graph=self.graph)\n\n def __rlshift__(self, other):\n return slice_op(operator.lshift, other, self, graph=self.graph)\n\n def __rshift__(self, other):\n return slice_op(operator.rshift, self, other, graph=self.graph)\n\n def __rrshift__(self, other):\n return slice_op(operator.rshift, other, self, graph=self.graph)\n\n def __and__(self, other):\n return slice_op(operator.and_, self, other, graph=self.graph)\n\n def __rand__(self, other):\n return slice_op(operator.and_, other, self, graph=self.graph)\n\n def __or__(self, other):\n return slice_op(operator.or_, self, other, graph=self.graph)\n\n def __ror__(self, other):\n return slice_op(operator.or_, other, self, graph=self.graph)\n\n def __xor__(self, other):\n return slice_op(operator.xor, self, other, graph=self.graph)\n\n def __rxor__(self, other):\n return slice_op(operator.xor, other, self, graph=self.graph)\n\n def __lt__(self, other):\n return slice_op(operator.lt, self, other, graph=self.graph)\n\n def __le__(self, other):\n return slice_op(operator.lt, other, self, graph=self.graph)\n\n def __ne__(self, other):\n return slice_op(operator.ne, self, other, graph=self.graph)\n\n def __gt__(self, other):\n return slice_op(operator.gt, self, other, graph=self.graph)\n\n def __ge__(self, other):\n return slice_op(operator.ge, self, other, graph=self.graph)\n\n def __repr__(self):\n return \"<slice_%s '%s'>\" % (self.target.__name__, self.name)\n\n\nclass func_op(Node): # pylint: disable=C0103,R0903\n \"\"\"\n Node wrapper for stateless functions.\n\n Parameters\n ----------\n target : callable\n function to evaluate the node\n args : tuple\n positional arguments passed to the target\n kwargs : dict\n keywoard arguments passed to the target\n \"\"\"\n def __init__(self, target, *args, **kwargs):\n kwargs[\"op_name\"] = kwargs[\"op_name\"] if \"op_name\" in kwargs \\\n else f\"{target.__name__}\"\n if \"domain\" in kwargs:\n domain = tuple(kwargs.pop(\"domain\")) if isinstance(kwargs[\"domain\"], list) else kwargs.pop(\"domain\")\n elif len(args) == 2:\n all_args = _flatten_iterable(args)\n slice1_var, slice1_idx, slice2_var, slice2_idx = self.get_index_nodes(all_args[0], all_args[1])\n domain = slice1_idx.combine_set_domains(slice2_idx)\n else:\n domain = Domain(tuple([]))\n self._target = None\n super(func_op, self).__init__(*args, target=f\"{target.__module__}.{target.__name__}\", domain=domain, **kwargs)\n self.target = target\n self.added_attrs += [\"domain\", \"target\"]\n\n @property\n def target(self):\n return self._target\n\n @target.setter\n def target(self, fnc):\n self._target = fnc\n self.op_name = f\"{fnc.__name__}\"\n self.kwargs[\"target\"] = f\"{fnc.__module__}.{fnc.__name__}\"\n\n def __getitem__(self, key):\n return self\n\n @property\n def domain(self):\n return self.kwargs[\"domain\"]\n\n def get_index_nodes(self, slice1_var=None, slice2_var=None):\n if slice1_var is None and slice2_var is None:\n slice1_var, slice2_var = self.args\n\n if isinstance(slice1_var, (slice_op, var_index)) or _is_node_type_instance(slice1_var, \"GroupNode\"):\n slice1_idx = slice1_var.domain\n else:\n slice1_idx = Domain(tuple([]))\n\n if isinstance(slice2_var, (slice_op, var_index)) or _is_node_type_instance(slice2_var, \"GroupNode\"):\n slice2_idx = slice2_var.domain\n else:\n slice2_idx = Domain(tuple([]))\n return slice1_var, slice1_idx, slice2_var, slice2_idx\n\n def _evaluate(self, *args, **kwargs):\n\n for aa in list(kwargs.keys()):\n if aa in self.added_attrs:\n kwargs.pop(aa)\n return self.target(*args, **kwargs)\n\n def __call__(self, *args, **kwargs):\n return call(self, *args, **kwargs)\n\n def __repr__(self):\n return \"<func_op '%s' target=%s args=<%d items>>\" % \\\n (self.name, self.kwargs[\"target\"], len(self.args))\n\ndef nodeop(target=None, **kwargs):\n \"\"\"\n Decorator for creating nodes from functions.\n \"\"\"\n # This is called when the decorator is used with arguments\n if target is None:\n return functools.partial(nodeop, **kwargs)\n\n # This is called when the decorator is used without arguments\n @functools.wraps(target)\n def _wrapper(*args, **kwargs_inner):\n return func_op(target, *args, **kwargs_inner, **kwargs)\n return _wrapper\n\n\n@nodeop\ndef call(func, *args, **kwargs):\n \"\"\"\n Call `func` with positional arguments `args` and keyword arguments `kwargs`.\n\n Parameters\n ----------\n func : callable\n Function to call when the node is executed.\n args : list\n Sequence of positional arguments passed to `func`.\n kwargs : dict\n Mapping of keyword arguments passed to `func`.\n \"\"\"\n return func(*args, **kwargs)\n\[email protected]\ndef control_dependencies(dependencies, graph=None):\n \"\"\"\n Ensure that all `dependencies` are executed before any nodes in this scope.\n\n Parameters\n ----------\n dependencies : list\n Sequence of nodes to be evaluted before evaluating any nodes defined in this\n scope.\n \"\"\"\n # Add dependencies to the graph\n graph = Node.get_active_graph(graph)\n graph.dependencies.extend(dependencies)\n yield\n # Remove dependencies from the graph\n del graph.dependencies[-len(dependencies):]\n\n#pylint: disable=C0103\nabs_ = nodeop(builtins.abs)\ndict_ = nodeop(builtins.dict)\nhelp_ = nodeop(builtins.help)\nmin_ = nodeop(builtins.min)\nsetattr_ = nodeop(builtins.setattr)\nall_ = nodeop(builtins.all)\ndir_ = nodeop(builtins.dir)\nhex_ = nodeop(builtins.hex)\nnext_ = nodeop(builtins.next)\nslice_ = nodeop(builtins.slice)\nany_ = nodeop(builtins.any)\ndivmod_ = nodeop(builtins.divmod)\nid_ = nodeop(builtins.id)\nobject_ = nodeop(builtins.object)\nsorted_ = nodeop(builtins.sorted)\nascii_ = nodeop(builtins.ascii)\nenumerate_ = nodeop(builtins.enumerate)\ninput_ = nodeop(builtins.input)\noct_ = nodeop(builtins.oct)\nstaticmethod_ = nodeop(builtins.staticmethod)\nbin_ = nodeop(builtins.bin)\neval_ = nodeop(builtins.eval)\nint_ = nodeop(builtins.int)\nopen_ = nodeop(builtins.open)\nstr_ = nodeop(builtins.str)\nbool_ = nodeop(builtins.bool)\nexec_ = nodeop(builtins.exec)\nisinstance_ = nodeop(builtins.isinstance)\nord_ = nodeop(builtins.ord)\nsum_ = nodeop(builtins.sum)\nbytearray_ = nodeop(builtins.bytearray)\nfilter_ = nodeop(builtins.filter)\nissubclass_ = nodeop(builtins.issubclass)\npow_ = nodeop(builtins.pow)\nsuper_ = nodeop(builtins.super)\nbytes_ = nodeop(builtins.bytes)\nfloat_ = nodeop(builtins.float)\niter_ = nodeop(builtins.iter)\nprint_ = nodeop(builtins.print)\ntuple_ = nodeop(builtins.tuple)\ncallable_ = nodeop(builtins.callable)\nformat_ = nodeop(builtins.format)\nlen_ = nodeop(builtins.len)\nproperty_ = nodeop(builtins.property)\ntype_ = nodeop(builtins.type)\nchr_ = nodeop(builtins.chr)\nfrozenset_ = nodeop(builtins.frozenset)\nlist_ = nodeop(builtins.list)\nrange_ = nodeop(builtins.range)\nvars_ = nodeop(builtins.vars)\nclassmethod_ = nodeop(builtins.classmethod)\ngetattr_ = nodeop(builtins.getattr)\nlocals_ = nodeop(builtins.locals)\nrepr_ = nodeop(builtins.repr)\nzip_ = nodeop(builtins.zip)\ncompile_ = nodeop(builtins.compile)\nglobals_ = nodeop(builtins.globals)\nmap_ = nodeop(builtins.map)\nreversed_ = nodeop(builtins.reversed)\ncomplex_ = nodeop(builtins.complex)\nhasattr_ = nodeop(builtins.hasattr)\nmax_ = nodeop(builtins.max)\nround_ = nodeop(builtins.round)\ndelattr_ = nodeop(builtins.delattr)\nhash_ = nodeop(builtins.hash)\nmemoryview_ = nodeop(builtins.memoryview)\nset_ = nodeop(builtins.set)\nadd = nodeop(operator.add)\nand_ = nodeop(operator.and_)\nattrgetter = nodeop(operator.attrgetter)\nconcat = nodeop(operator.concat)\ncontains = nodeop(operator.contains)\ncountOf = nodeop(operator.countOf)\ndelitem = nodeop(operator.delitem)\neq = nodeop(operator.eq)\nfloordiv = nodeop(operator.floordiv)\nge = nodeop(operator.ge)\ngetitem = nodeop(operator.getitem)\ngt = nodeop(operator.gt)\nindex = nodeop(operator.index)\nindexOf = nodeop(operator.indexOf)\ninv = nodeop(operator.inv)\ninvert = nodeop(operator.invert)\nior = nodeop(operator.ior)\nipow = nodeop(operator.ipow)\nirshift = nodeop(operator.irshift)\nis_ = nodeop(operator.is_)\nis_not = nodeop(operator.is_not)\nitemgetter = nodeop(operator.itemgetter)\nle = nodeop(operator.le)\nlength_hint = nodeop(operator.length_hint)\nlshift = nodeop(operator.lshift)\nlt = nodeop(operator.lt)\nmatmul = nodeop(operator.matmul)\nmethodcaller = nodeop(operator.methodcaller)\nmod = nodeop(operator.mod)\nmul = nodeop(operator.mul)\nne = nodeop(operator.ne)\nneg = nodeop(operator.neg)\nnot_ = nodeop(operator.not_)\nor_ = nodeop(operator.or_)\npos = nodeop(operator.pos)\nrshift = nodeop(operator.rshift)\nsetitem = nodeop(operator.setitem)\nsub = nodeop(operator.sub)\ntruediv = nodeop(operator.truediv)\ntruth = nodeop(operator.truth)\nxor = nodeop(operator.xor)\nimport_ = nodeop(importlib.import_module)\n\n\n\n\n\n"
]
| [
[
"numpy.product",
"numpy.int",
"numpy.asarray",
"numpy.prod",
"numpy.ravel_multi_index",
"numpy.squeeze",
"numpy.expand_dims"
]
]
|
luanagbmartins/cavia | [
"91f093af9d6f463ee651db533f6c2acc637c7e9f"
]
| [
"rl/envs/mujoco/ant.py"
]
| [
"import numpy as np\r\nfrom gym.envs.mujoco import AntEnv as AntEnv_\r\n\r\n\r\nclass AntEnv(AntEnv_):\r\n @property\r\n def action_scaling(self):\r\n if (not hasattr(self, 'action_space')) or (self.action_space is None):\r\n return 1.0\r\n if self._action_scaling is None:\r\n lb, ub = self.action_space.low, self.action_space.high\r\n self._action_scaling = 0.5 * (ub - lb)\r\n return self._action_scaling\r\n\r\n def _get_obs(self):\r\n return np.concatenate([\r\n self.sim.data.qpos.flat,\r\n self.sim.data.qvel.flat,\r\n np.clip(self.sim.data.cfrc_ext, -1, 1).flat,\r\n self.sim.data.get_body_xmat(\"torso\").flat,\r\n self.get_body_com(\"torso\").flat,\r\n ]).astype(np.float32).flatten()\r\n\r\n def viewer_setup(self):\r\n camera_id = self.model.camera_name2id('track')\r\n self.viewer.cam.type = 2\r\n self.viewer.cam.fixedcamid = camera_id\r\n self.viewer.cam.distance = self.model.stat.extent * 0.35\r\n # Hide the overlay\r\n self.viewer._hide_overlay = True\r\n\r\n def render(self, mode='human'):\r\n if mode == 'rgb_array':\r\n self._get_viewer().render()\r\n # window size used for old mujoco-py:\r\n width, height = 500, 500\r\n data = self._get_viewer().read_pixels(width, height, depth=False)\r\n return data\r\n elif mode == 'human':\r\n self._get_viewer().render()\r\n\r\n\r\nclass AntVelEnv(AntEnv):\r\n \"\"\"Ant environment with target velocity, as described in [1]. The \r\n code is adapted from\r\n https://github.com/cbfinn/maml_rl/blob/9c8e2ebd741cb0c7b8bf2d040c4caeeb8e06cc95/rllab/envs/mujoco/ant_env_rand.py\r\n\r\n The ant follows the dynamics from MuJoCo [2], and receives at each \r\n time step a reward composed of a control cost, a contact cost, a survival \r\n reward, and a penalty equal to the difference between its current velocity \r\n and the target velocity. The tasks are generated by sampling the target \r\n velocities from the uniform distribution on [0, 3].\r\n\r\n [1] Chelsea Finn, Pieter Abbeel, Sergey Levine, \"Model-Agnostic \r\n Meta-Learning for Fast Adaptation of Deep Networks\", 2017 \r\n (https://arxiv.org/abs/1703.03400)\r\n [2] Emanuel Todorov, Tom Erez, Yuval Tassa, \"MuJoCo: A physics engine for \r\n model-based control\", 2012 \r\n (https://homes.cs.washington.edu/~todorov/papers/TodorovIROS12.pdf)\r\n \"\"\"\r\n\r\n def __init__(self, task={}):\r\n self._task = task\r\n self._goal_vel = task.get('velocity', 0.0)\r\n self._action_scaling = None\r\n super(AntVelEnv, self).__init__()\r\n\r\n def step(self, action):\r\n xposbefore = self.get_body_com(\"torso\")[0]\r\n self.do_simulation(action, self.frame_skip)\r\n xposafter = self.get_body_com(\"torso\")[0]\r\n\r\n forward_vel = (xposafter - xposbefore) / self.dt\r\n forward_reward = -1.0 * np.abs(forward_vel - self._goal_vel) + 1.0\r\n survive_reward = 0.05\r\n\r\n ctrl_cost = 0.5 * 1e-2 * np.sum(np.square(action / self.action_scaling))\r\n contact_cost = 0.5 * 1e-3 * np.sum(\r\n np.square(np.clip(self.sim.data.cfrc_ext, -1, 1)))\r\n\r\n observation = self._get_obs()\r\n reward = forward_reward - ctrl_cost - contact_cost + survive_reward\r\n state = self.state_vector()\r\n notdone = np.isfinite(state).all() \\\r\n and state[2] >= 0.2 and state[2] <= 1.0\r\n done = not notdone\r\n infos = dict(reward_forward=forward_reward, reward_ctrl=-ctrl_cost,\r\n reward_contact=-contact_cost, reward_survive=survive_reward,\r\n task=self._task)\r\n return (observation, reward, done, infos)\r\n\r\n def sample_tasks(self, num_tasks):\r\n velocities = self.np_random.uniform(0.0, 3.0, size=(num_tasks,))\r\n tasks = [{'velocity': velocity} for velocity in velocities]\r\n return tasks\r\n\r\n def reset_task(self, task):\r\n self._task = task\r\n self._goal_vel = task['velocity']\r\n\r\n\r\nclass AntDirEnv(AntEnv):\r\n \"\"\"Ant environment with target direction, as described in [1]. The \r\n code is adapted from\r\n https://github.com/cbfinn/maml_rl/blob/9c8e2ebd741cb0c7b8bf2d040c4caeeb8e06cc95/rllab/envs/mujoco/ant_env_rand_direc.py\r\n\r\n The ant follows the dynamics from MuJoCo [2], and receives at each \r\n time step a reward composed of a control cost, a contact cost, a survival \r\n reward, and a reward equal to its velocity in the target direction. The \r\n tasks are generated by sampling the target directions from a Bernoulli \r\n distribution on {-1, 1} with parameter 0.5 (-1: backward, +1: forward).\r\n\r\n [1] Chelsea Finn, Pieter Abbeel, Sergey Levine, \"Model-Agnostic \r\n Meta-Learning for Fast Adaptation of Deep Networks\", 2017 \r\n (https://arxiv.org/abs/1703.03400)\r\n [2] Emanuel Todorov, Tom Erez, Yuval Tassa, \"MuJoCo: A physics engine for \r\n model-based control\", 2012 \r\n (https://homes.cs.washington.edu/~todorov/papers/TodorovIROS12.pdf)\r\n \"\"\"\r\n\r\n def __init__(self, task={}):\r\n self._task = task\r\n self._goal_dir = task.get('direction', 1)\r\n self._action_scaling = None\r\n super(AntDirEnv, self).__init__()\r\n\r\n def step(self, action):\r\n xposbefore = self.get_body_com(\"torso\")[0]\r\n self.do_simulation(action, self.frame_skip)\r\n xposafter = self.get_body_com(\"torso\")[0]\r\n\r\n forward_vel = (xposafter - xposbefore) / self.dt\r\n forward_reward = self._goal_dir * forward_vel\r\n survive_reward = 0.05\r\n\r\n ctrl_cost = 0.5 * 1e-2 * np.sum(np.square(action / self.action_scaling))\r\n contact_cost = 0.5 * 1e-3 * np.sum(\r\n np.square(np.clip(self.sim.data.cfrc_ext, -1, 1)))\r\n\r\n observation = self._get_obs()\r\n reward = forward_reward - ctrl_cost - contact_cost + survive_reward\r\n state = self.state_vector()\r\n notdone = np.isfinite(state).all() \\\r\n and state[2] >= 0.2 and state[2] <= 1.0\r\n done = not notdone\r\n infos = dict(reward_forward=forward_reward, reward_ctrl=-ctrl_cost,\r\n reward_contact=-contact_cost, reward_survive=survive_reward,\r\n task=self._task)\r\n return (observation, reward, done, infos)\r\n\r\n def sample_tasks(self, num_tasks):\r\n directions = 2 * self.np_random.binomial(1, p=0.5, size=(num_tasks,)) - 1\r\n tasks = [{'direction': direction} for direction in directions]\r\n return tasks\r\n\r\n def reset_task(self, task):\r\n self._task = task\r\n self._goal_dir = task['direction']\r\n\r\n\r\nclass AntPosEnv(AntEnv):\r\n \"\"\"Ant environment with target position. The code is adapted from\r\n https://github.com/cbfinn/maml_rl/blob/9c8e2ebd741cb0c7b8bf2d040c4caeeb8e06cc95/rllab/envs/mujoco/ant_env_rand_goal.py\r\n\r\n The ant follows the dynamics from MuJoCo [1], and receives at each \r\n time step a reward composed of a control cost, a contact cost, a survival \r\n reward, and a penalty equal to its L1 distance to the target position. The \r\n tasks are generated by sampling the target positions from the uniform \r\n distribution on [-3, 3]^2.\r\n\r\n [1] Emanuel Todorov, Tom Erez, Yuval Tassa, \"MuJoCo: A physics engine for \r\n model-based control\", 2012 \r\n (https://homes.cs.washington.edu/~todorov/papers/TodorovIROS12.pdf)\r\n \"\"\"\r\n\r\n def __init__(self, task={}):\r\n self._task = task\r\n self._goal_pos = task.get('position', np.zeros((2,), dtype=np.float32))\r\n self._action_scaling = None\r\n super(AntPosEnv, self).__init__()\r\n\r\n def step(self, action):\r\n self.do_simulation(action, self.frame_skip)\r\n xyposafter = self.get_body_com(\"torso\")[:2]\r\n\r\n goal_reward = -np.sum(np.abs(xyposafter - self._goal_pos)) + 4.0\r\n survive_reward = 0.05\r\n\r\n ctrl_cost = 0.5 * 1e-2 * np.sum(np.square(action / self.action_scaling))\r\n contact_cost = 0.5 * 1e-3 * np.sum(\r\n np.square(np.clip(self.sim.data.cfrc_ext, -1, 1)))\r\n\r\n observation = self._get_obs()\r\n reward = goal_reward - ctrl_cost - contact_cost + survive_reward\r\n state = self.state_vector()\r\n notdone = np.isfinite(state).all() \\\r\n and state[2] >= 0.2 and state[2] <= 1.0\r\n done = not notdone\r\n infos = dict(reward_goal=goal_reward, reward_ctrl=-ctrl_cost,\r\n reward_contact=-contact_cost, reward_survive=survive_reward,\r\n task=self._task)\r\n return (observation, reward, done, infos)\r\n\r\n def sample_tasks(self, num_tasks):\r\n positions = self.np_random.uniform(-3.0, 3.0, size=(num_tasks, 2))\r\n tasks = [{'position': position} for position in positions]\r\n return tasks\r\n\r\n def reset_task(self, task):\r\n self._task = task\r\n self._goal_pos = task['position']\r\n"
]
| [
[
"numpy.square",
"numpy.clip",
"numpy.zeros",
"numpy.abs",
"numpy.isfinite"
]
]
|
leniel/DataMining | [
"f249f636ede67a29de986b8f34c9cbe75b680f47",
"f249f636ede67a29de986b8f34c9cbe75b680f47"
]
| [
"Classification/Work 2/NaiveBayes/naivebayes_crossvalidation.py",
"Classification/Work 2/NeuralNetwork/neuralnet.py"
]
| [
"'''\n\b Created on Sat Nov 05 2016\n\b\n\b Copyright (c) 2016 Leniel Macaferi's Consulting\n'''\n\nimport os\nimport pandas as pd\nfrom sklearn.naive_bayes import GaussianNB\nfrom sklearn.model_selection import cross_val_score\n\npath = os.path.realpath('..')\n\n# Loading the data used to train\ntrainingSet = pd.read_csv(os.path.join(path, '../Data/classification-training.csv'), sep=',', header = None)\n\nclasses = trainingSet[trainingSet.columns[22]] # Last column\nfeatures = trainingSet[trainingSet.columns[1:22]] # Columns between indexes 1 to 22\n\n#pd.set_option('display.max_columns', 23)\n#print(features)\n\nclassifier = GaussianNB()\n\nscores = cross_val_score(classifier, features, classes, cv = 5)\n\nprint(scores)\n\nprint(\"Accuracy: %0.2f (+/- %0.2f)\" % (scores.mean(), scores.std() * 2))",
"'''\n\b Created on Sat Nov 05 2016\n\b\n\b Copyright (c) 2016 Leniel Macaferi's Consulting\n'''\n\nimport os\nimport numpy as np\nimport pandas as pd\nfrom sklearn.neural_network import MLPClassifier\n\npath = os.path.realpath('..')\n\n# Loading the Training set...\ntrainingSet = pd.read_csv(os.path.join(\n path, '../Data/classification-training.csv'), sep=',', header=None)\n\nclasses = trainingSet[trainingSet.columns[22]] # Last column\n# Columns between indexes 1 to 22\nfeatures = trainingSet[trainingSet.columns[1:22]]\n\n#pd.set_option('display.max_columns', 23)\n# print(features)\n\n# Neural Network classifier\nclassifier = MLPClassifier(solver='lbfgs', random_state=1)\n\nclassifier.fit(features, classes)\n\n# Loading the Test set...\ntestSet = pd.read_csv(os.path.join(\n path, '../Data/classification-test.csv'), sep=',', header=None)\n\n# Getting the ids that are used only to output the result\nids = testSet[testSet.columns[0]]\n\n# Using the trained classifier to predict the test data\npredictions = classifier.predict(testSet[testSet.columns[1:22]])\n\n# Write to save predictions to disk\nwriter = csv.writer(open(os.path.join(path, 'nn-predictions.csv'), 'w'))\n\nfor prediction, id in zip(predictions, ids):\n data = [id, prediction]\n\n #print(\"{0} = {1}\\n\".format(id, prediction))\n\n writer.writerow(data)\n"
]
| [
[
"sklearn.naive_bayes.GaussianNB",
"sklearn.model_selection.cross_val_score"
],
[
"sklearn.neural_network.MLPClassifier"
]
]
|
hieuhoang/parSentExtract | [
"9e7aa4c0f0f93934d7f6986d655195bf5bd8e03d"
]
| [
"train.py"
]
| [
"from __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport os\nimport time\n\nfrom six.moves import xrange\n\nos.environ[\"TF_CPP_MIN_LOG_LEVEL\"] = \"1\"\n\nimport numpy as np\nimport tensorflow as tf\n\nimport utils\nfrom model import Config, BiRNN\n\n\ntf.flags.DEFINE_string(\"source_train_path\", \"\",\n \"Path to the file containing the source sentences to \"\n \"train the model.\")\n\ntf.flags.DEFINE_string(\"target_train_path\", \"\",\n \"Path to the file containing the target sentences to \"\n \"train the model.\")\n\ntf.flags.DEFINE_string(\"source_valid_path\", \"\",\n \"Path to the file containing the source sentences to \"\n \"evaluate the model.\")\n\ntf.flags.DEFINE_string(\"target_valid_path\", \"\",\n \"Path to the file containing the target sentences to \"\n \"evaluate the model.\")\n\ntf.flags.DEFINE_string(\"checkpoint_dir\", \"./tflogs\",\n \"Directory to save checkpoints and summaries of the model.\")\n\ntf.flags.DEFINE_integer(\"source_vocab_size\", 100000,\n \"Number of the most frequent words to keep in the source \"\n \"vocabulary.\")\n\ntf.flags.DEFINE_integer(\"target_vocab_size\", 100000,\n \"Number of the most frequent words to keep in target \"\n \"vocabulary.\")\n\ntf.flags.DEFINE_float(\"learning_rate\", 2e-4,\n \"Learning rate.\")\n\ntf.flags.DEFINE_float(\"max_gradient_norm\", 5.0,\n \"Clip gradient to this norm.\")\n\ntf.flags.DEFINE_float(\"decision_threshold\", 0.99,\n \"Decision threshold to predict a positive label.\")\n\ntf.flags.DEFINE_integer(\"embedding_size\", 300,\n \"Size of each word embedding.\")\n\ntf.flags.DEFINE_integer(\"state_size\", 300,\n \"Size of the recurrent state in the BiRNN encoder.\")\n\ntf.flags.DEFINE_integer(\"hidden_size\", 128,\n \"Size of the hidden layer in the feed-forward neural \"\n \"network.\")\n\ntf.flags.DEFINE_integer(\"num_layers\", 1,\n \"Number of layers in the BiRNN encoder.\")\n\ntf.flags.DEFINE_string(\"source_embeddings_path\", None,\n \"Pretrained embeddings to initialize the source embeddings \"\n \"matrix.\")\n\ntf.flags.DEFINE_string(\"target_embeddings_path\", None,\n \"Pretrained embeddings to initialize the target embeddings \"\n \"matrix.\")\n\ntf.flags.DEFINE_boolean(\"fix_pretrained\", False,\n \"If true fix pretrained embeddings.\")\n\ntf.flags.DEFINE_boolean(\"use_lstm\", False,\n \"If true use LSTM cells. Otherwise use GRU cells.\")\n\ntf.flags.DEFINE_boolean(\"use_mean_pooling\", False,\n \"If true use mean pooling for final sentence representation.\")\n\ntf.flags.DEFINE_boolean(\"use_max_pooling\", False,\n \"If true use max pooling for final sentence representation.\")\n\ntf.flags.DEFINE_integer(\"batch_size\", 128,\n \"Batch size to use during training.\")\n\ntf.flags.DEFINE_integer(\"num_epochs\", 15,\n \"Number of epochs to train the model.\")\n\ntf.flags.DEFINE_integer(\"num_negative\", 5,\n \"Number of negative examples to sample per pair of \"\n \"parallel sentences in training dataset.\")\n\ntf.flags.DEFINE_float(\"keep_prob_input\", 0.8,\n \"Keep probability for dropout applied at the embedding layer.\")\n\ntf.flags.DEFINE_float(\"keep_prob_output\", 0.7,\n \"Keep probability for dropout applied at the prediction layer.\")\n\ntf.flags.DEFINE_integer(\"steps_per_checkpoint\", 200,\n \"Number of steps to save a model checkpoint.\")\n\n\nFLAGS = tf.flags.FLAGS\n\n\ndef eval_epoch(sess, model, data_iterator, summary_writer):\n \"\"\"Evaluate model for one epoch.\"\"\"\n sess.run(tf.local_variables_initializer())\n num_iter = int(np.ceil(data_iterator.size / FLAGS.batch_size))\n epoch_loss = 0\n for step in xrange(num_iter):\n source, target, label = data_iterator.next_batch(FLAGS.batch_size)\n source_len = utils.sequence_length(source)\n target_len = utils.sequence_length(target)\n feed_dict = {model.x_source: source,\n model.x_target: target,\n model.labels: label,\n model.source_seq_length: source_len,\n model.target_seq_length: target_len,\n model.decision_threshold: FLAGS.decision_threshold}\n loss_value, epoch_accuracy,\\\n epoch_precision, epoch_recall = sess.run([model.mean_loss,\n model.accuracy[1],\n model.precision[1],\n model.recall[1]],\n feed_dict=feed_dict)\n epoch_loss += loss_value\n if step % FLAGS.steps_per_checkpoint == 0:\n summary = sess.run(model.summaries, feed_dict=feed_dict)\n summary_writer.add_summary(summary, global_step=data_iterator.global_step)\n epoch_loss /= step\n epoch_f1 = utils.f1_score(epoch_precision, epoch_recall)\n print(\" Testing: Loss = {:.6f}, Accuracy = {:.4f}, \"\n \"Precision = {:.4f}, Recall = {:.4f}, F1 = {:.4f}\"\n .format(epoch_loss, epoch_accuracy,\n epoch_precision, epoch_recall, epoch_f1))\n\n\ndef main(_):\n assert FLAGS.source_train_path, (\"--source_train_path is required.\")\n assert FLAGS.target_train_path, (\"--target_train_path is required.\")\n assert FLAGS.source_valid_path, (\"--source_valid_path is required.\")\n assert FLAGS.target_valid_path, (\"--target_valid_path is required.\")\n\n # Create vocabularies.\n source_vocab_path = os.path.join(os.path.dirname(FLAGS.source_train_path),\n \"vocabulary.source\")\n target_vocab_path = os.path.join(os.path.dirname(FLAGS.source_train_path),\n \"vocabulary.target\")\n utils.create_vocabulary(source_vocab_path, FLAGS.source_train_path, FLAGS.source_vocab_size)\n utils.create_vocabulary(target_vocab_path, FLAGS.target_train_path, FLAGS.target_vocab_size)\n\n # Read vocabularies.\n source_vocab, rev_source_vocab = utils.initialize_vocabulary(source_vocab_path)\n #print(\"source_vocab\", source_vocab)\n #print(\"rev_source_vocab\", rev_source_vocab)\n\n target_vocab, rev_target_vocab = utils.initialize_vocabulary(target_vocab_path)\n #print(\"target_vocab\", target_vocab)\n\n # Read parallel sentences.\n parallel_data = utils.read_data(FLAGS.source_train_path, FLAGS.target_train_path,\n source_vocab, target_vocab)\n print(\"parallel_data\", type(parallel_data), len(parallel_data))\n print(\"parallel_data[0]\", type(parallel_data[0]), len(parallel_data[0]), parallel_data[0])\n\n # Read validation data set.\n if FLAGS.source_valid_path and FLAGS.target_valid_path:\n valid_data = utils.read_data(FLAGS.source_valid_path, FLAGS.target_valid_path,\n source_vocab, target_vocab)\n\n # Initialize BiRNN.\n config = Config(len(source_vocab),\n len(target_vocab),\n FLAGS.embedding_size,\n FLAGS.state_size,\n FLAGS.hidden_size,\n FLAGS.num_layers,\n FLAGS.learning_rate,\n FLAGS.max_gradient_norm,\n FLAGS.use_lstm,\n FLAGS.use_mean_pooling,\n FLAGS.use_max_pooling,\n FLAGS.source_embeddings_path,\n FLAGS.target_embeddings_path,\n FLAGS.fix_pretrained)\n\n model = BiRNN(config)\n\n # Build graph.\n model.build_graph()\n\n # Train model.\n with tf.Session() as sess:\n\n sess.run(tf.global_variables_initializer())\n sess.run(tf.local_variables_initializer())\n\n train_iterator = utils.TrainingIterator(parallel_data, FLAGS.num_negative)\n train_summary_writer = tf.summary.FileWriter(os.path.join(FLAGS.checkpoint_dir, \"train\"), sess.graph)\n\n if FLAGS.source_valid_path and FLAGS.target_valid_path:\n valid_iterator = utils.EvalIterator(valid_data)\n valid_summary_writer = tf.summary.FileWriter(os.path.join(FLAGS.checkpoint_dir, \"valid\"), sess.graph)\n\n epoch_loss = 0\n epoch_completed = 0\n batch_completed = 0\n\n num_iter = int(np.ceil(train_iterator.size / FLAGS.batch_size * FLAGS.num_epochs))\n start_time = time.time()\n print(\"Training model on {} sentence pairs per epoch:\".\n format(train_iterator.size, valid_iterator.size))\n\n for step in xrange(num_iter):\n source, target, label = train_iterator.next_batch(FLAGS.batch_size)\n source_len = utils.sequence_length(source)\n target_len = utils.sequence_length(target)\n feed_dict = {model.x_source: source,\n model.x_target: target,\n model.labels: label,\n model.source_seq_length: source_len,\n model.target_seq_length: target_len,\n model.input_dropout: FLAGS.keep_prob_input,\n model.output_dropout: FLAGS.keep_prob_output,\n model.decision_threshold: FLAGS.decision_threshold}\n\n _, loss_value, epoch_accuracy,\\\n epoch_precision, epoch_recall = sess.run([model.train_op,\n model.mean_loss,\n model.accuracy[1],\n model.precision[1],\n model.recall[1]],\n feed_dict=feed_dict)\n epoch_loss += loss_value\n batch_completed += 1\n # Write the model's training summaries.\n if step % FLAGS.steps_per_checkpoint == 0:\n summary = sess.run(model.summaries, feed_dict=feed_dict)\n train_summary_writer.add_summary(summary, global_step=step)\n # End of current epoch.\n if train_iterator.epoch_completed > epoch_completed:\n epoch_time = time.time() - start_time\n epoch_loss /= batch_completed\n epoch_f1 = utils.f1_score(epoch_precision, epoch_recall)\n epoch_completed += 1\n print(\"Epoch {} in {:.0f} sec\\n\"\n \" Training: Loss = {:.6f}, Accuracy = {:.4f}, \"\n \"Precision = {:.4f}, Recall = {:.4f}, F1 = {:.4f}\"\n .format(epoch_completed, epoch_time,\n epoch_loss, epoch_accuracy,\n epoch_precision, epoch_recall, epoch_f1))\n # Save a model checkpoint.\n checkpoint_path = os.path.join(FLAGS.checkpoint_dir, \"model.ckpt\")\n model.saver.save(sess, checkpoint_path, global_step=step)\n # Evaluate model on the validation set.\n if FLAGS.source_valid_path and FLAGS.target_valid_path:\n eval_epoch(sess, model, valid_iterator, valid_summary_writer)\n # Initialize local variables for new epoch.\n batch_completed = 0\n epoch_loss = 0\n sess.run(tf.local_variables_initializer())\n start_time = time.time()\n\n print(\"Training done with {} steps.\".format(num_iter))\n train_summary_writer.close()\n valid_summary_writer.close()\n\n\nif __name__ == \"__main__\":\n tf.app.run()\n"
]
| [
[
"numpy.ceil",
"tensorflow.flags.DEFINE_string",
"tensorflow.flags.DEFINE_boolean",
"tensorflow.Session",
"tensorflow.flags.DEFINE_float",
"tensorflow.flags.DEFINE_integer",
"tensorflow.local_variables_initializer",
"tensorflow.app.run",
"tensorflow.global_variables_initializer"
]
]
|
jamesrosstwo/idr-dif | [
"e900af5f440b943a7a46134a5afe7a81dd888a05"
]
| [
"code/utils/general.py"
]
| [
"import os\nfrom glob import glob\nfrom pathlib import Path\n\nimport torch\n\n\n_root_dir = os.path.dirname(os.path.abspath(__file__))\nROOT_PATH = Path(_root_dir).parent.parent\n\ndef mkdir_ifnotexists(directory):\n if not os.path.exists(directory):\n os.mkdir(directory)\n\ndef get_class(kls):\n parts = kls.split('.')\n module = \".\".join(parts[:-1])\n m = __import__(module)\n for comp in parts[1:]:\n m = getattr(m, comp)\n return m\n\ndef glob_imgs(path):\n imgs = []\n for ext in ['*.png', '*.jpg', '*.JPEG', '*.JPG']:\n imgs.extend(glob(os.path.join(path, ext)))\n return imgs\n\ndef split_input(model_input, total_pixels):\n '''\n Split the input to fit Cuda memory for large resolution.\n Can decrease the value of n_pixels in case of cuda out of memory error.\n '''\n n_pixels = 10000\n split = []\n for i, indx in enumerate(torch.split(torch.arange(total_pixels).cuda(), n_pixels, dim=0)):\n data = model_input.copy()\n data['uv'] = torch.index_select(model_input['uv'], 1, indx)\n data['object_mask'] = torch.index_select(model_input['object_mask'], 1, indx)\n split.append(data)\n return split\n\ndef merge_output(res, total_pixels, batch_size):\n ''' Merge the split output. '''\n\n model_outputs = {}\n for entry in res[0]:\n if res[0][entry] is None:\n continue\n if len(res[0][entry].shape) == 1:\n model_outputs[entry] = torch.cat([r[entry].reshape(batch_size, -1, 1) for r in res],\n 1).reshape(batch_size * total_pixels)\n else:\n model_outputs[entry] = torch.cat([r[entry].reshape(batch_size, -1, r[entry].shape[-1]) for r in res],\n 1).reshape(batch_size * total_pixels, -1)\n\n return model_outputs"
]
| [
[
"torch.index_select",
"torch.arange"
]
]
|
usimarit/selfattention-segan | [
"563a86e825f1e4067ec1fd3bed36e89e11434388"
]
| [
"sasegan/datasets/test_dataset.py"
]
| [
"# Copyright 2020 Huy Le Nguyen (@usimarit)\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport tensorflow as tf\n\nfrom tensorflow_asr.featurizers.speech_featurizers import read_raw_audio\n\nfrom .train_dataset import SeganAugTrainDataset, SeganTrainDataset\nfrom ..featurizers.speech_featurizer import SpeechFeaturizer\n\n\nclass SeganAugTestDataset(SeganAugTrainDataset):\n def __init__(self,\n speech_featurizer: SpeechFeaturizer,\n clean_dir: str,\n noises_config: dict):\n super(SeganAugTestDataset, self).__init__(\n stage=\"test\", speech_featurizer=speech_featurizer, clean_dir=clean_dir, noises_config=noises_config)\n\n def parse(self, clean_wav):\n noisy_wav = self.noises.augment(clean_wav)\n noisy_slices = self.speech_featurizer.extract(noisy_wav)\n clean_slices = self.speech_featurizer.extract(clean_wav)\n return clean_slices, noisy_slices\n\n def create(self):\n def _gen_data():\n for clean_wav_path in self.data_paths:\n clean_wav = read_raw_audio(clean_wav_path, sample_rate=self.speech_featurizer.sample_rate)\n clean_slices, noisy_slices = self.parse(clean_wav)\n yield clean_wav_path, clean_slices, noisy_slices\n\n dataset = tf.data.Dataset.from_generator(\n _gen_data,\n output_types=(tf.string, tf.float32),\n output_shapes=(\n tf.TensorShape([]),\n tf.TensorShape([None, *self.speech_featurizer.shape]),\n tf.TensorShape([None, *self.speech_featurizer.shape])\n )\n )\n # Prefetch to improve speed of input length\n dataset = dataset.prefetch(tf.data.experimental.AUTOTUNE)\n return dataset\n\n\nclass SeganTestDataset(SeganTrainDataset):\n def __init__(self,\n speech_featurizer: SpeechFeaturizer,\n clean_dir: str,\n noisy_dir: str):\n super(SeganTestDataset, self).__init__(\n stage=\"test\", speech_featurizer=speech_featurizer, clean_dir=clean_dir, noisy_dir=noisy_dir)\n\n def parse(self, clean_wav, noisy_wav):\n clean_slices = self.speech_featurizer.extract(clean_wav)\n noisy_slices = self.speech_featurizer.extract(noisy_wav)\n return clean_slices, noisy_slices\n\n def create(self):\n def _gen_data():\n for clean_wav_path in self.data_paths:\n clean_wav = read_raw_audio(clean_wav_path, sample_rate=self.speech_featurizer.sample_rate)\n noisy_wav_path = clean_wav_path.replace(self.clean_dir, self.noisy_dir)\n noisy_wav = read_raw_audio(noisy_wav_path, sample_rate=self.speech_featurizer.sample_rate)\n clean_slices, noisy_slices = self.parse(clean_wav, noisy_wav)\n yield clean_wav_path, clean_slices, noisy_slices\n\n dataset = tf.data.Dataset.from_generator(\n _gen_data,\n output_types=(tf.string, tf.float32),\n output_shapes=(\n tf.TensorShape([]),\n tf.TensorShape([None, *self.speech_featurizer.shape]),\n tf.TensorShape([None, *self.speech_featurizer.shape])\n )\n )\n # Prefetch to improve speed of input length\n dataset = dataset.prefetch(tf.data.experimental.AUTOTUNE)\n return dataset\n"
]
| [
[
"tensorflow.TensorShape"
]
]
|
mwussow/pytorch_geometric | [
"01c68f9b58c94d9efd1f6e39b9c85177aae521bb"
]
| [
"test/nn/conv/test_sg_conv.py"
]
| [
"import torch\nfrom torch_geometric.nn import SGConv\n\n\ndef test_sg_conv():\n in_channels, out_channels = (16, 32)\n edge_index = torch.tensor([[0, 0, 0, 1, 2, 3], [1, 2, 3, 0, 0, 0]])\n num_nodes = edge_index.max().item() + 1\n x = torch.randn((num_nodes, in_channels))\n\n conv = SGConv(in_channels, out_channels, K=10, cached=True)\n assert conv.__repr__() == 'SGConv(16, 32, K=10)'\n assert conv(x, edge_index).size() == (num_nodes, out_channels)\n assert conv(x, edge_index).size() == (num_nodes, out_channels)\n\n conv = SGConv(in_channels, out_channels, K=10, cached=False)\n assert conv.__repr__() == 'SGConv(16, 32, K=10)'\n assert conv(x, edge_index).size() == (num_nodes, out_channels)\n assert conv(x, edge_index).size() == (num_nodes, out_channels)\n"
]
| [
[
"torch.tensor",
"torch.randn"
]
]
|
Hung-Jia-Jun/yolo_keras_camera_realtime | [
"d74ea9a95ed625337765f4fea9e6f8881ee0a9cf"
]
| [
"test_yolo_2.py"
]
| [
"#! /usr/bin/env python\n\"\"\"Run a YOLO_v2 style detection model on test images.\"\"\"\nimport argparse\nimport colorsys\nimport imghdr\nimport os\nimport random\n\nimport numpy as np\nfrom keras import backend as K\nfrom keras.models import load_model\nfrom PIL import Image, ImageDraw, ImageFont\n\nfrom yad2k.models.keras_yolo import yolo_eval, yolo_head\n\n# parser = argparse.ArgumentParser(\n# description='Run a YOLO_v2 style detection model on test images..')\n# parser.add_argument(\n# 'model_path',\n# help='path to h5 model file containing body of a YOLO_v2 model',\n# default = \"model_data\\\\yolo.h5\"\n# )\n# parser.add_argument(\n# '-a',\n# '--anchors_path',\n# help='path to anchors file, defaults to yolo_anchors.txt',\n# default='model_data/yolo_anchors.txt')\n# parser.add_argument(\n# '-c',\n# '--classes_path',\n# help='path to classes file, defaults to coco_classes.txt',\n# default='model_data/coco_classes.txt')\n# parser.add_argument(\n# '-t',\n# '--test_path',\n# help='path to directory of test images, defaults to images/',\n# default='images')\n# parser.add_argument(\n# '-o',\n# '--output_path',\n# help='path to output test images, defaults to images/out',\n# default='images\\\\out')\n# parser.add_argument(\n# '-s',\n# '--score_threshold',\n# type=float,\n# help='threshold for bounding box scores, default .3',\n# default=.3)\n# parser.add_argument(\n# '-iou',\n# '--iou_threshold',\n# type=float,\n# help='threshold for non max suppression IOU, default .5',\n# default=.5)\n\n\ndef _main():\n score_threshold = .3\n iou_threshold = .5\n model_path = \"model_data\\\\yolo.h5\"\n# model_path = os.path.expanduser(args.model_path)\n assert model_path.endswith('.h5'), 'Keras model must be a .h5 file.'\n \n anchors_path = \"model_data/yolo_anchors.txt\"\n# anchors_path = os.path.expanduser(args.anchors_path)\n\n# classes_path = os.path.expanduser(args.classes_path)\n classes_path = 'model_data/coco_classes.txt'\n# test_path = os.path.expanduser(args.test_path)\n test_path = 'images'\n# output_path = os.path.expanduser(args.output_path)\n output_path = \"images\\out\"\n if not os.path.exists(output_path):\n print('Creating output path {}'.format(output_path))\n os.mkdir(output_path)\n\n sess = K.get_session() # TODO: Remove dependence on Tensorflow session.\n\n with open(classes_path) as f:\n class_names = f.readlines()\n class_names = [c.strip() for c in class_names]\n\n with open(anchors_path) as f:\n anchors = f.readline()\n anchors = [float(x) for x in anchors.split(',')]\n anchors = np.array(anchors).reshape(-1, 2)\n\n yolo_model = load_model(model_path)\n\n # Verify model, anchors, and classes are compatible\n num_classes = len(class_names)\n num_anchors = len(anchors)\n # TODO: Assumes dim ordering is channel last\n model_output_channels = yolo_model.layers[-1].output_shape[-1]\n assert model_output_channels == num_anchors * (num_classes + 5), \\\n 'Mismatch between model and given anchor and class sizes. ' \\\n 'Specify matching anchors and classes with --anchors_path and ' \\\n '--classes_path flags.'\n print('{} model, anchors, and classes loaded.'.format(model_path))\n\n # Check if model is fully convolutional, assuming channel last order.\n model_image_size = yolo_model.layers[0].input_shape[1:3]\n is_fixed_size = model_image_size != (None, None)\n\n # Generate colors for drawing bounding boxes.\n hsv_tuples = [(x / len(class_names), 1., 1.)\n for x in range(len(class_names))]\n colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples))\n colors = list(\n map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)),\n colors))\n random.seed(10101) # Fixed seed for consistent colors across runs.\n random.shuffle(colors) # Shuffle colors to decorrelate adjacent classes.\n random.seed(None) # Reset seed to default.\n\n # Generate output tensor targets for filtered bounding boxes.\n # TODO: Wrap these backend operations with Keras layers.\n yolo_outputs = yolo_head(yolo_model.output, anchors, len(class_names))\n input_image_shape = K.placeholder(shape=(2, ))\n boxes, scores, classes = yolo_eval(\n yolo_outputs,\n input_image_shape,\n score_threshold=score_threshold,\n iou_threshold=iou_threshold)\n\n for image_file in os.listdir(test_path):\n # try:\n # image_type = imghdr.what(os.path.join(test_path, image_file))\n # if not image_type:\n # continue\n # except IsADirectoryError:\n # continue\n\n image = Image.open(os.path.join(test_path, image_file))\n if is_fixed_size: # TODO: When resizing we can use minibatch input.\n resized_image = image.resize(\n tuple(reversed(model_image_size)), Image.BICUBIC)\n image_data = np.array(resized_image, dtype='float32')\n else:\n # Due to skip connection + max pooling in YOLO_v2, inputs must have\n # width and height as multiples of 32.\n new_image_size = (image.width - (image.width % 32),\n image.height - (image.height % 32))\n resized_image = image.resize(new_image_size, Image.BICUBIC)\n image_data = np.array(resized_image, dtype='float32')\n print(image_data.shape)\n\n image_data /= 255.\n image_data = np.expand_dims(image_data, 0) # Add batch dimension.\n\n out_boxes, out_scores, out_classes = sess.run(\n [boxes, scores, classes],\n feed_dict={\n yolo_model.input: image_data,\n input_image_shape: [image.size[1], image.size[0]],\n K.learning_phase(): 0\n })\n print('Found {} boxes for {}'.format(len(out_boxes), image_file))\n\n font = ImageFont.truetype(\n font='font/FiraMono-Medium.otf',\n size=np.floor(3e-2 * image.size[1] + 0.5).astype('int32'))\n thickness = (image.size[0] + image.size[1]) // 300\n\n for i, c in reversed(list(enumerate(out_classes))):\n predicted_class = class_names[c]\n box = out_boxes[i]\n score = out_scores[i]\n\n label = '{} {:.2f}'.format(predicted_class, score)\n\n draw = ImageDraw.Draw(image)\n label_size = draw.textsize(label, font)\n\n top, left, bottom, right = box\n top = max(0, np.floor(top + 0.5).astype('int32'))\n left = max(0, np.floor(left + 0.5).astype('int32'))\n bottom = min(image.size[1], np.floor(bottom + 0.5).astype('int32'))\n right = min(image.size[0], np.floor(right + 0.5).astype('int32'))\n print(label, (left, top), (right, bottom))\n\n if top - label_size[1] >= 0:\n text_origin = np.array([left, top - label_size[1]])\n else:\n text_origin = np.array([left, top + 1])\n\n # My kingdom for a good redistributable image drawing library.\n for i in range(thickness):\n draw.rectangle(\n [left + i, top + i, right - i, bottom - i],\n outline=colors[c])\n draw.rectangle(\n [tuple(text_origin), tuple(text_origin + label_size)],\n fill=colors[c])\n draw.text(text_origin, label, fill=(0, 0, 0), font=font)\n del draw\n\n image.save(os.path.join(output_path, image_file), quality=90)\n sess.close()\n\n\nif __name__ == '__main__':\n _main()\n "
]
| [
[
"numpy.array",
"numpy.expand_dims",
"numpy.floor"
]
]
|
leonmkim/gym-kuka-mujoco | [
"ed45ae74d10e69f4e51439de2d1d0c0811623b6b"
]
| [
"gym_kuka_mujoco/controllers/impedance_controller_v2.py"
]
| [
"import os\n\nimport numpy as np\nfrom gym import spaces\nimport mujoco_py\n\nfrom gym_kuka_mujoco.envs.assets import kuka_asset_dir\nfrom gym_kuka_mujoco.utils.quaternion import identity_quat, subQuat, quatAdd, mat2Quat\nfrom gym_kuka_mujoco.utils.kinematics import forwardKinSite, forwardKinJacobianSite\nfrom .base_controller import BaseController\nfrom . import register_controller\nfrom gym_kuka_mujoco.utils.mujoco_utils import get_qpos_indices, get_qvel_indices, get_actuator_indices, get_joint_indices \n\n\nclass ImpedanceControllerV2(BaseController):\n '''\n An inverse dynamics controller that used PD gains to compute a desired acceleration.\n '''\n\n def __init__(self,\n sim,\n pos_scale=1.0,\n rot_scale=0.3,\n pos_limit=1.0,\n rot_limit=1.0,\n model_path='full_kuka_no_collision_no_gravity.xml',\n site_name='ee_site',\n stiffness=None,\n damping='auto',\n null_space_damping=1.0,\n controlled_joints=None,\n in_ee_frame=False):\n super(ImpedanceControllerV2, self).__init__(sim)\n\n # Create a model for control\n print('Controller model imported from: {}'.format(model_path))\n\n model_path = os.path.join(kuka_asset_dir(), model_path)\n self.model = mujoco_py.load_model_from_path(model_path)\n\n self.in_ee_frame = in_ee_frame\n\n # Construct the action space.\n high_pos = pos_limit*np.ones(3)\n low_pos = -high_pos\n\n high_rot = rot_limit*np.ones(3)\n low_rot = -high_rot\n\n high = np.concatenate((high_pos, high_rot))\n low = np.concatenate((low_pos, low_rot))\n self.action_space = spaces.Box(low, high, dtype=np.float32)\n\n # Controller parameters.\n self.scale = np.ones(6)\n self.scale[:3] *= pos_scale\n self.scale[3:6] *= rot_scale\n\n self.site_name = site_name\n self.pos_set = np.zeros(3)\n self.quat_set = identity_quat.copy()\n\n if stiffness is None:\n self.stiffness = np.array([1.0, 1.0, 1.0, 0.3, 0.3, 0.3])\n else:\n self.stiffness = np.ones(6)*stiffness\n\n if damping=='auto':\n self.damping = 2*np.sqrt(self.stiffness)\n else:\n self.damping = np.ones(6)*damping\n\n self.null_space_damping = null_space_damping\n\n # Get the position, velocity, and actuator indices for the model.\n if controlled_joints is not None:\n self.sim_qpos_idx = get_qpos_indices(sim.model, controlled_joints)\n self.sim_qvel_idx = get_qvel_indices(sim.model, controlled_joints)\n self.sim_actuators_idx = get_actuator_indices(sim.model, controlled_joints)\n self.sim_joint_idx = get_joint_indices(sim.model, controlled_joints)\n\n self.self_qpos_idx = get_qpos_indices(self.model, controlled_joints)\n self.self_qvel_idx = get_qvel_indices(self.model, controlled_joints)\n self.self_actuators_idx = get_actuator_indices(self.model, controlled_joints)\n else:\n assert self.model.nv == self.model.nu, \"if the number of degrees of freedom is different than the number of actuators you must specify the controlled_joints\"\n self.sim_qpos_idx = range(self.model.nq)\n self.sim_qvel_idx = range(self.model.nv)\n self.sim_actuators_idx = range(self.model.nu)\n self.sim_joint_idx = range(self.model.nu)\n\n self.self_qpos_idx = range(self.model.nq)\n self.self_qvel_idx = range(self.model.nv)\n self.self_actuators_idx = range(self.model.nu)\n\n def set_action(self, action):\n '''\n Set the setpoint.\n '''\n action = action * self.scale\n\n dx = action[0:3].astype(np.float64)\n dr = action[3:6].astype(np.float64)\n\n # print('dx is: {} and dr is: {}'.format(dx, dr) )\n\n pos, mat = forwardKinSite(self.sim, self.site_name, recompute=False)\n quat = mat2Quat(mat)\n \n if self.in_ee_frame:\n dx = mat.dot(dx)\n\n self.pos_set = pos + dx\n self.quat_set = quatAdd(quat, dr)\n\n # print('pos setpoint updated: {}'.format(self.pos_set))\n\n\n def get_torque(self):\n '''\n Update the impedance control setpoint and compute the torque.\n '''\n # Compute the pose difference.\n pos, mat = forwardKinSite(self.sim, self.site_name, recompute=False)\n quat = mat2Quat(mat)\n dx = self.pos_set - pos\n dr = subQuat(self.quat_set, quat) # Original\n dframe = np.concatenate((dx,dr))\n\n # Compute generalized forces from a virtual external force.\n jpos, jrot = forwardKinJacobianSite(self.sim, self.site_name, recompute=False)\n J = np.vstack((jpos[:,self.sim_qvel_idx], jrot[:,self.sim_qvel_idx]))\n cartesian_acc_des = self.stiffness*dframe - self.damping*J.dot(self.sim.data.qvel[self.sim_qvel_idx])\n impedance_acc_des = J.T.dot(np.linalg.solve(J.dot(J.T) + 1e-6*np.eye(6), cartesian_acc_des))\n\n # Add damping in the null space of the the Jacobian\n projection_matrix = J.T.dot(np.linalg.solve(J.dot(J.T), J))\n projection_matrix = np.eye(projection_matrix.shape[0]) - projection_matrix\n null_space_vel = projection_matrix.dot(self.sim.data.qvel[self.sim_qvel_idx])\n impedance_acc_des += -self.null_space_damping*null_space_vel # null space damping\n\n # Cancel other dynamics and add virtual damping using inverse dynamics.\n acc_des = np.zeros(self.sim.model.nv)\n acc_des[self.sim_qvel_idx] = impedance_acc_des\n self.sim.data.qacc[:] = acc_des\n mujoco_py.functions.mj_inverse(self.model, self.sim.data)\n id_torque = self.sim.data.qfrc_inverse[self.sim_actuators_idx].copy()\n \n return id_torque\n\nregister_controller(ImpedanceControllerV2, \"ImpedanceControllerV2\")"
]
| [
[
"numpy.concatenate",
"numpy.array",
"numpy.zeros",
"numpy.ones",
"numpy.eye",
"numpy.sqrt",
"numpy.vstack"
]
]
|
surisdi/DPC | [
"ce6fe25938c1bebb7f654d0c8f8479bf92ab4054",
"ce6fe25938c1bebb7f654d0c8f8479bf92ab4054"
]
| [
"utils/utils.py",
"utils/pairwise_hyp_cone.py"
]
| [
"import torch\nimport numpy as np\nimport os\nfrom datetime import datetime\nimport glob\nimport matplotlib.pyplot as plt\nplt.switch_backend('agg')\nfrom collections import deque\nfrom torchvision import transforms\n\n\ndef save_checkpoint(state, is_best=0, gap=1, filename='models/checkpoint.pth.tar', keep_all=False):\n torch.save(state, filename)\n last_epoch_path = os.path.join(os.path.dirname(filename),\n 'epoch%s.pth.tar' % str(state['epoch']-gap))\n if not keep_all:\n try: os.remove(last_epoch_path)\n except: pass\n if is_best:\n past_best = glob.glob(os.path.join(os.path.dirname(filename), 'model_best_*.pth.tar'))\n for i in past_best:\n try: os.remove(i)\n except: pass\n path_best = os.path.join(os.path.dirname(filename), 'model_best_epoch%s.pth.tar' % str(state['epoch']))\n torch.save(state, path_best)\n print(f'Updating best model: {path_best}')\n\n\ndef write_log(content, epoch, filename):\n if not os.path.exists(filename):\n log_file = open(filename, 'w')\n else:\n log_file = open(filename, 'a')\n log_file.write('## Epoch %d:\\n' % epoch)\n log_file.write('time: %s\\n' % str(datetime.now()))\n log_file.write(content + '\\n\\n')\n log_file.close()\n\n\ndef calc_topk_accuracy(output, target, topk=(1,)):\n '''\n Modified from: https://gist.github.com/agermanidis/275b23ad7a10ee89adccf021536bb97e\n Given predicted and ground truth labels, \n calculate top-k accuracies.\n '''\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0)\n res.append(correct_k.mul_(1 / batch_size))\n return res\n\n\ndef calc_accuracy(output, target):\n '''output: (B, N); target: (B)'''\n target = target.squeeze()\n _, pred = torch.max(output, 1)\n return torch.mean((pred == target).float())\n\n\ndef calc_accuracy_binary(output, target):\n '''output, target: (B, N), output is logits, before sigmoid '''\n pred = output > 0\n acc = torch.mean((pred == target.byte()).float())\n del pred, output, target\n return acc\n\n\ndef denorm(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]):\n assert len(mean)==len(std)==3\n inv_mean = [-mean[i]/std[i] for i in range(3)]\n inv_std = [1/i for i in std]\n return transforms.Normalize(mean=inv_mean, std=inv_std)\n\n\nclass AverageMeter(object):\n \"\"\"Computes and stores the average and current value\"\"\"\n def __init__(self):\n self.reset()\n\n def reset(self):\n self.val = 0\n self.avg = 0\n self.sum = 0\n self.count = 0\n self.local_history = deque([])\n self.local_avg = 0\n self.history = []\n self.dict = {} # save all data values here\n self.save_dict = {} # save mean and std here, for summary table\n self.avg_expanded = None\n\n def update(self, val, n=1, history=0, step=5):\n is_array = False\n if type(val) == torch.Tensor:\n if len(val.shape) > 0 and val.shape[0] > 1:\n is_array = True\n val = val.view(-1).cpu().data.detach().numpy()\n else:\n val = val.mean().item()\n elif type(val) == np.ndarray:\n if len(val.shape) > 0 and val.shape[0] > 1:\n is_array = True\n val = val.reshape(-1)\n elif type(val) == float:\n pass\n else:\n raise TypeError(f'{type(val)} type not supported in AverageMeter')\n\n if type(n) == torch.Tensor:\n n = n.float().mean().item()\n self.val = np.mean(val)\n self.sum += val * n\n self.count += n\n # self.avg = self.sum / self.count\n if is_array:\n self.avg_expanded = self.sum / self.count\n self.avg = self.avg_expanded.mean()\n else:\n self.avg = self.sum / self.count\n self.avg_expanded = np.array([self.avg])\n if history:\n self.history.append(val.mean())\n if step > 0:\n self.local_history.append(val)\n if len(self.local_history) > step:\n self.local_history.popleft()\n self.local_avg = np.average(self.local_history)\n\n def dict_update(self, val, key):\n if key in self.dict.keys():\n self.dict[key].append(val)\n else:\n self.dict[key] = [val]\n\n def __len__(self):\n return self.count\n\n\nclass AccuracyTable(object):\n '''compute accuracy for each class'''\n def __init__(self):\n self.dict = {}\n\n def update(self, pred, tar):\n pred = torch.squeeze(pred)\n tar = torch.squeeze(tar)\n for i, j in zip(pred, tar):\n i = int(i)\n j = int(j)\n if j not in self.dict.keys():\n self.dict[j] = {'count':0,'correct':0}\n self.dict[j]['count'] += 1\n if i == j:\n self.dict[j]['correct'] += 1\n\n def print_table(self, label):\n for key in self.dict.keys():\n acc = self.dict[key]['correct'] / self.dict[key]['count']\n print('%s: %2d, accuracy: %3d/%3d = %0.6f' \\\n % (label, key, self.dict[key]['correct'], self.dict[key]['count'], acc))\n\n\ndef neq_load_customized(args, model, pretrained_dict,\n parts=['backbone', 'agg', 'network_pred', 'hyperbolic_linear', 'network-class'],\n size_diff=False):\n '''\n load pre-trained model in a not-equal way, when new model has been partially modified\n size_diff: some parameters may have the same name but different size. Cannot load these, but do not throw error, and\n load all the rest\n '''\n model_dict = model.state_dict()\n tmp = {}\n print_r(args, '\\n=======Check Weights Loading======')\n print_r(args, ('loading the following parts:', ', '.join(parts)))\n if parts == 'all':\n if size_diff:\n for k, v in pretrained_dict.items():\n if k in model.state_dict() and model.state_dict()[k].shape == v.shape:\n tmp[k] = v\n else:\n print_r(args, f'{k} not loaded')\n else:\n tmp = pretrained_dict\n else:\n for part in parts:\n print_r(args, ('loading:', part))\n print_r(args, '\\n=======Check Weights Loading======')\n print_r(args, 'Weights not used from pretrained file:')\n for k, v in pretrained_dict.items():\n if part in k:\n if k in model_dict:\n if not (size_diff and model.state_dict()[k].shape != v.shape):\n tmp[k] = v\n else:\n print_r(args, k)\n print_r(args, '---------------------------')\n print_r(args, 'Weights not loaded into new model:')\n for k, v in model_dict.items():\n if part in k:\n if k not in pretrained_dict:\n print_r(args, k)\n print_r(args, '===================================\\n')\n\n del pretrained_dict\n if 'time_index.weight' in tmp and \\\n 'time_index' in [a[0].split('.')[0] for a in list(model.named_parameters())] and \\\n model.time_index.weight.shape[0] < tmp['time_index.weight'].shape[0]:\n tmp['time_index.weight'].data = tmp['time_index.weight'][:model.time_index.weight.shape[0]].data\n model.load_state_dict(tmp, strict=False)\n return model\n\n\ndef print_r(args, text, print_no_verbose=False):\n \"\"\" Print only when the local rank is <=0 (only once)\"\"\"\n if args.local_rank <= 0 and (args.verbose or print_no_verbose):\n if type(text) == tuple:\n print(*text)\n else:\n print(text)\n \n \nclass ConfusionMeter(object):\n '''compute and show confusion matrix'''\n def __init__(self, num_class):\n self.num_class = num_class\n self.mat = np.zeros((num_class, num_class))\n self.precision = []\n self.recall = []\n\n def update(self, pred, tar):\n pred, tar = pred.cpu().numpy(), tar.cpu().numpy()\n pred = np.squeeze(pred)\n tar = np.squeeze(tar)\n for p,t in zip(pred.flat, tar.flat):\n self.mat[p][t] += 1\n\n def print_mat(self):\n print('Confusion Matrix: (target in columns)')\n print(self.mat)\n\n def plot_mat(self, path, dictionary=None, annotate=False):\n plt.figure(dpi=600)\n plt.imshow(self.mat,\n cmap=plt.cm.jet,\n interpolation=None,\n extent=(0.5, np.shape(self.mat)[0]+0.5, np.shape(self.mat)[1]+0.5, 0.5))\n width, height = self.mat.shape\n if annotate:\n for x in range(width):\n for y in range(height):\n plt.annotate(str(int(self.mat[x][y])), xy=(y+1, x+1),\n horizontalalignment='center',\n verticalalignment='center',\n fontsize=8)\n\n if dictionary is not None:\n plt.xticks([i+1 for i in range(width)],\n [dictionary[i] for i in range(width)],\n rotation='vertical')\n plt.yticks([i+1 for i in range(height)],\n [dictionary[i] for i in range(height)])\n plt.xlabel('Ground Truth')\n plt.ylabel('Prediction')\n plt.colorbar()\n plt.tight_layout()\n plt.savefig(path, format='svg')\n plt.clf()\n\n # for i in range(width):\n # if np.sum(self.mat[i,:]) != 0:\n # self.precision.append(self.mat[i,i] / np.sum(self.mat[i,:]))\n # if np.sum(self.mat[:,i]) != 0:\n # self.recall.append(self.mat[i,i] / np.sum(self.mat[:,i]))\n # print('Average Precision: %0.4f' % np.mean(self.precision))\n # print('Average Recall: %0.4f' % np.mean(self.recall))\n\n\n\n\n",
"import torch\nimport numpy as np\n\nclass PairwiseHypConeDist():\n def __init__(self, K=0.1, fp64_hyper=True):\n self.K = K\n self.fp64_hyper = fp64_hyper\n def __call__(self, x, y):\n '''\n scale up embedding if it's smaller than the threshold radius K\n \n Note: this step potentially contains a lot of in-place operation,\n which is not legal for torch.autograd. Need to make clone of\n the variable every step of the way\n '''\n N_pred, D = x.shape\n N_gt, D = y.shape\n \n # scaling up x when it's too small\n x_norm = torch.norm(x, p=2, dim=-1)\n x_small = x.transpose(dim0=-1, dim1=-2)\n scale_factor = ((0.1 + 1e-7) / x_norm)\n x_small = (x_small * scale_factor).clone()\n x = torch.where(x_norm < (0.1 + 1e-7), x_small, x.transpose(dim0=-1, dim1=-2)).transpose(dim0=-1, dim1=-2)\n \n # neccessary components\n x_square = self.square_norm(x).unsqueeze(dim=1).expand(N_pred, N_gt)\n y_square = self.square_norm(y).unsqueeze(dim=0).expand(N_pred, N_gt)\n x_norm = torch.sqrt(x_square)\n xy_square = self.pairwise_distances(x, y)\n xy_norm = torch.sqrt(xy_square)\n xy_prod = self.pairwise_mul(x, y)\n \n # Xi\n num = xy_prod * (1 + x_square) - x_square * (1 + y_square)\n denom = x_norm * xy_norm * torch.sqrt(1 + x_square * y_square - 2.0 * xy_prod)\n Xi = torch.acos(num / denom)\n\n # Phi\n Phi = torch.asin(self.K * (1 - x_square) / x_norm)\n \n return Xi - Phi\n \n def square_norm(self, x):\n \"\"\"\n Helper function returning square of the euclidean norm.\n Also here we clamp it since it really likes to die to zero.\n \"\"\"\n norm = torch.norm(x,dim=-1,p=2)**2\n return torch.clamp(norm, min=0.0)\n\n def pairwise_mul(self, x, y):\n \"\"\"\n Helper function returning pairwise vector product.\n Also here we clamp it since it really likes to die to zero.\n \"\"\"\n y_t = torch.transpose(y, 0, 1)\n prod = torch.mm(x, y_t)\n return prod\n\n def pairwise_distances(self, x, y=None):\n '''\n Input: x is a Nxd matrix\n y is an optional Mxd matirx\n Output: dist is a NxM matrix where dist[i,j] is the square norm between x[i,:] and y[j,:]\n if y is not given then use 'y=x'.\n i.e. dist[i,j] = ||x[i,:]-y[j,:]||^2\n '''\n x_norm = (x**2).sum(1).view(-1, 1)\n if y is not None:\n y_t = torch.transpose(y, 0, 1)\n y_norm = (y**2).sum(1).view(1, -1)\n else:\n y_t = torch.transpose(x, 0, 1)\n y_norm = x_norm.view(1, -1)\n\n dist = x_norm + y_norm - 2.0 * torch.mm(x, y_t)\n # Ensure diagonal is zero if x=y\n # if y is None:\n # dist = dist - torch.diag(dist.diag)\n return torch.clamp(dist, 0.0, np.inf)"
]
| [
[
"matplotlib.pyplot.switch_backend",
"matplotlib.pyplot.colorbar",
"numpy.array",
"numpy.zeros",
"torch.max",
"matplotlib.pyplot.xlabel",
"torch.save",
"matplotlib.pyplot.savefig",
"numpy.mean",
"matplotlib.pyplot.figure",
"numpy.shape",
"torch.squeeze",
"matplotlib.pyplot.tight_layout",
"matplotlib.pyplot.ylabel",
"numpy.average",
"matplotlib.pyplot.clf",
"numpy.squeeze"
],
[
"torch.acos",
"torch.sqrt",
"torch.norm",
"torch.clamp",
"torch.mm",
"torch.transpose",
"torch.asin"
]
]
|
JunweiPan3013/featuretools | [
"b0c8478f9bf8f46217726e3a32de51e083d98351"
]
| [
"featuretools/computational_backends/pandas_backend.py"
]
| [
"import cProfile\nimport logging\nimport os\nimport pstats\nimport sys\nimport warnings\nfrom datetime import datetime\n\nimport numpy as np\nimport pandas as pd\nimport pandas.api.types as pdtypes\nfrom future import standard_library\n\nfrom .base_backend import ComputationalBackend\nfrom .feature_tree import FeatureTree\n\nfrom featuretools import variable_types\nfrom featuretools.entityset.relationship import Relationship\nfrom featuretools.exceptions import UnknownFeature\nfrom featuretools.primitives import (\n AggregationPrimitive,\n DirectFeature,\n IdentityFeature,\n TransformPrimitive\n)\nfrom featuretools.utils.gen_utils import make_tqdm_iterator\n\nstandard_library.install_aliases()\nwarnings.simplefilter('ignore', np.RankWarning)\nwarnings.simplefilter(\"ignore\", category=RuntimeWarning)\nlogger = logging.getLogger('featuretools.computational_backend')\nROOT_DIR = os.path.expanduser(\"~\")\n\n\nclass PandasBackend(ComputationalBackend):\n\n def __init__(self, entityset, features):\n assert len(set(f.entity.id for f in features)) == 1, \\\n \"Features must all be defined on the same entity\"\n\n self.entityset = entityset\n self.target_eid = features[0].entity.id\n self.features = features\n self.feature_tree = FeatureTree(entityset, features)\n\n def __sizeof__(self):\n return self.entityset.__sizeof__()\n\n def calculate_all_features(self, instance_ids, time_last,\n training_window=None, profile=False,\n precalculated_features=None, ignored=None,\n verbose=False):\n \"\"\"\n Given a list of instance ids and features with a shared time window,\n generate and return a mapping of instance -> feature values.\n\n Args:\n instance_ids (list): List of instance id for which to build features.\n\n time_last (pd.Timestamp): Last allowed time. Data from exactly this\n time not allowed.\n\n training_window (Timedelta, optional): Data older than\n time_last by more than this will be ignored.\n\n profile (bool): Enable profiler if True.\n\n verbose (bool): Print output progress if True.\n\n Returns:\n pd.DataFrame : Pandas DataFrame of calculated feature values.\n Indexed by instance_ids. Columns in same order as features\n passed in.\n\n \"\"\"\n assert len(instance_ids) > 0, \"0 instance ids provided\"\n self.instance_ids = instance_ids\n\n self.time_last = time_last\n if self.time_last is None:\n self.time_last = datetime.now()\n\n # For debugging\n if profile:\n pr = cProfile.Profile()\n pr.enable()\n\n if precalculated_features is None:\n precalculated_features = {}\n # Access the index to get the filtered data we need\n target_entity = self.entityset[self.target_eid]\n if ignored:\n # TODO: Just want to remove entities if don't have any (sub)features defined\n # on them anymore, rather than recreating\n ordered_entities = FeatureTree(self.entityset, self.features, ignored=ignored).ordered_entities\n else:\n ordered_entities = self.feature_tree.ordered_entities\n\n necessary_columns = self.feature_tree.necessary_columns\n eframes_by_filter = \\\n self.entityset.get_pandas_data_slice(filter_entity_ids=ordered_entities,\n index_eid=self.target_eid,\n instances=instance_ids,\n entity_columns=necessary_columns,\n time_last=time_last,\n training_window=training_window,\n verbose=verbose)\n large_eframes_by_filter = None\n if any([f.uses_full_entity for f in self.feature_tree.all_features]):\n large_necessary_columns = self.feature_tree.necessary_columns_for_all_values_features\n large_eframes_by_filter = \\\n self.entityset.get_pandas_data_slice(filter_entity_ids=ordered_entities,\n index_eid=self.target_eid,\n instances=None,\n entity_columns=large_necessary_columns,\n time_last=time_last,\n training_window=training_window,\n verbose=verbose)\n\n # Handle an empty time slice by returning a dataframe with defaults\n if eframes_by_filter is None:\n return self.generate_default_df(instance_ids=instance_ids)\n\n finished_entity_ids = []\n # Populate entity_frames with precalculated features\n if len(precalculated_features) > 0:\n for entity_id, precalc_feature_values in precalculated_features.items():\n if entity_id in eframes_by_filter:\n frame = eframes_by_filter[entity_id][entity_id]\n eframes_by_filter[entity_id][entity_id] = pd.merge(frame,\n precalc_feature_values,\n left_index=True,\n right_index=True)\n else:\n # Only features we're taking from this entity\n # are precomputed\n # Make sure the id variable is a column as well as an index\n entity_id_var = self.entityset[entity_id].index\n precalc_feature_values[entity_id_var] = precalc_feature_values.index.values\n eframes_by_filter[entity_id] = {entity_id: precalc_feature_values}\n finished_entity_ids.append(entity_id)\n\n # Iterate over the top-level entities (filter entities) in sorted order\n # and calculate all relevant features under each one.\n if verbose:\n total_groups_to_compute = sum(len(group)\n for group in self.feature_tree.ordered_feature_groups.values())\n\n pbar = make_tqdm_iterator(total=total_groups_to_compute,\n desc=\"Computing features\",\n unit=\"feature group\")\n if verbose:\n pbar.update(0)\n\n for filter_eid in ordered_entities:\n entity_frames = eframes_by_filter[filter_eid]\n large_entity_frames = None\n if large_eframes_by_filter is not None:\n large_entity_frames = large_eframes_by_filter[filter_eid]\n\n # update the current set of entity frames with the computed features\n # from previously finished entities\n for eid in finished_entity_ids:\n # only include this frame if it's not from a descendent entity:\n # descendent entity frames will have to be re-calculated.\n # TODO: this check might not be necessary, depending on our\n # constraints\n if not self.entityset.find_backward_path(start_entity_id=filter_eid,\n goal_entity_id=eid):\n entity_frames[eid] = eframes_by_filter[eid][eid]\n # TODO: look this over again\n # precalculated features will only be placed in entity_frames,\n # and it's possible that that they are the only features computed\n # for an entity. In this case, the entity won't be present in\n # large_eframes_by_filter. The relevant lines that this case passes\n # through are 136-143\n if (large_eframes_by_filter is not None and\n eid in large_eframes_by_filter and eid in large_eframes_by_filter[eid]):\n large_entity_frames[eid] = large_eframes_by_filter[eid][eid]\n\n if filter_eid in self.feature_tree.ordered_feature_groups:\n for group in self.feature_tree.ordered_feature_groups[filter_eid]:\n if verbose:\n pbar.set_postfix({'running': 0})\n\n test_feature = group[0]\n entity_id = test_feature.entity.id\n\n input_frames_type = self.feature_tree.input_frames_type(test_feature)\n\n input_frames = large_entity_frames\n if input_frames_type == \"subset_entity_frames\":\n input_frames = entity_frames\n\n handler = self._feature_type_handler(test_feature)\n result_frame = handler(group, input_frames)\n\n output_frames_type = self.feature_tree.output_frames_type(test_feature)\n if output_frames_type in ['full_and_subset_entity_frames', 'subset_entity_frames']:\n index = entity_frames[entity_id].index\n # If result_frame came from a uses_full_entity feature,\n # and the input was large_entity_frames,\n # then it's possible it doesn't contain some of the features\n # in the output entity_frames\n # We thus need to concatenate the existing frame with the result frame,\n # making sure not to duplicate any columns\n _result_frame = result_frame.reindex(index)\n cols_to_keep = [c for c in _result_frame.columns\n if c not in entity_frames[entity_id].columns]\n entity_frames[entity_id] = pd.concat([entity_frames[entity_id],\n _result_frame[cols_to_keep]],\n axis=1)\n\n if output_frames_type in ['full_and_subset_entity_frames', 'full_entity_frames']:\n index = large_entity_frames[entity_id].index\n _result_frame = result_frame.reindex(index)\n cols_to_keep = [c for c in _result_frame.columns\n if c not in large_entity_frames[entity_id].columns]\n large_entity_frames[entity_id] = pd.concat([large_entity_frames[entity_id],\n _result_frame[cols_to_keep]],\n axis=1)\n\n if verbose:\n pbar.update(1)\n\n finished_entity_ids.append(filter_eid)\n\n if verbose:\n pbar.set_postfix({'running': 0})\n pbar.refresh()\n sys.stdout.flush()\n pbar.close()\n\n # debugging\n if profile:\n pr.disable()\n prof_folder_path = os.path.join(ROOT_DIR, 'prof')\n if not os.path.exists(prof_folder_path):\n os.mkdir(prof_folder_path)\n with open(os.path.join(prof_folder_path, 'inst-%s.log' %\n list(instance_ids)[0]), 'w') as f:\n pstats.Stats(pr, stream=f).strip_dirs().sort_stats(\"cumulative\", \"tottime\").print_stats()\n\n df = eframes_by_filter[self.target_eid][self.target_eid]\n\n # fill in empty rows with default values\n missing_ids = [i for i in instance_ids if i not in\n df[target_entity.index]]\n if missing_ids:\n default_df = self.generate_default_df(instance_ids=missing_ids,\n extra_columns=df.columns)\n df = df.append(default_df, sort=True)\n\n df.index.name = self.entityset[self.target_eid].index\n return df[[feat.get_name() for feat in self.features]]\n\n def generate_default_df(self, instance_ids, extra_columns=None):\n index_name = self.features[0].entity.index\n default_row = [f.default_value for f in self.features]\n default_cols = [f.get_name() for f in self.features]\n default_matrix = [default_row] * len(instance_ids)\n default_df = pd.DataFrame(default_matrix,\n columns=default_cols,\n index=instance_ids)\n default_df.index.name = index_name\n if extra_columns is not None:\n for c in extra_columns:\n if c not in default_df.columns:\n default_df[c] = [np.nan] * len(instance_ids)\n return default_df\n\n def _feature_type_handler(self, f):\n if isinstance(f, TransformPrimitive):\n return self._calculate_transform_features\n elif isinstance(f, DirectFeature):\n return self._calculate_direct_features\n elif isinstance(f, AggregationPrimitive):\n return self._calculate_agg_features\n elif isinstance(f, IdentityFeature):\n return self._calculate_identity_features\n else:\n raise UnknownFeature(u\"{} feature unknown\".format(f.__class__))\n\n def _calculate_identity_features(self, features, entity_frames):\n entity_id = features[0].entity.id\n assert (entity_id in entity_frames and\n features[0].get_name() in entity_frames[entity_id].columns)\n return entity_frames[entity_id]\n\n def _calculate_transform_features(self, features, entity_frames):\n entity_id = features[0].entity.id\n assert len(set([f.entity.id for f in features])) == 1, \\\n \"features must share base entity\"\n assert entity_id in entity_frames\n\n frame = entity_frames[entity_id]\n for f in features:\n # handle when no data\n if frame.shape[0] == 0:\n set_default_column(frame, f)\n continue\n\n # collect only the variables we need for this transformation\n variable_data = [frame[bf.get_name()].values\n for bf in f.base_features]\n\n feature_func = f.get_function()\n # apply the function to the relevant dataframe slice and add the\n # feature row to the results dataframe.\n if f.uses_calc_time:\n values = feature_func(*variable_data, time=self.time_last)\n else:\n values = feature_func(*variable_data)\n\n if isinstance(values, pd.Series):\n values = values.values\n frame[f.get_name()] = list(values)\n return frame\n\n def _calculate_direct_features(self, features, entity_frames):\n entity_id = features[0].entity.id\n parent_entity_id = features[0].parent_entity.id\n\n assert entity_id in entity_frames and parent_entity_id in entity_frames\n\n path = self.entityset.find_forward_path(entity_id, parent_entity_id)\n assert len(path) == 1, \\\n \"Error calculating DirectFeatures, len(path) > 1\"\n\n parent_df = entity_frames[parent_entity_id]\n child_df = entity_frames[entity_id]\n merge_var = path[0].child_variable.id\n\n # generate a mapping of old column names (in the parent entity) to\n # new column names (in the child entity) for the merge\n col_map = {path[0].parent_variable.id: merge_var}\n index_as_feature = None\n for f in features:\n if f.base_features[0].get_name() == path[0].parent_variable.id:\n index_as_feature = f\n # Sometimes entityset._add_multigenerational_links adds link variables\n # that would ordinarily get calculated as direct features,\n # so we make sure not to attempt to calculate again\n if f.get_name() in child_df.columns:\n continue\n col_map[f.base_features[0].get_name()] = f.get_name()\n\n # merge the identity feature from the parent entity into the child\n merge_df = parent_df[list(col_map.keys())].rename(columns=col_map)\n if index_as_feature is not None:\n merge_df.set_index(index_as_feature.get_name(), inplace=True,\n drop=False)\n else:\n merge_df.set_index(merge_var, inplace=True)\n\n new_df = pd.merge(left=child_df, right=merge_df,\n left_on=merge_var, right_index=True,\n how='left')\n\n return new_df\n\n def _calculate_agg_features(self, features, entity_frames):\n test_feature = features[0]\n entity = test_feature.entity\n child_entity = test_feature.base_features[0].entity\n\n assert entity.id in entity_frames and child_entity.id in entity_frames\n\n frame = entity_frames[entity.id]\n base_frame = entity_frames[child_entity.id]\n # Sometimes approximate features get computed in a previous filter frame\n # and put in the current one dynamically,\n # so there may be existing features here\n features = [f for f in features if f.get_name()\n not in frame.columns]\n if not len(features):\n return frame\n\n # handle where\n where = test_feature.where\n if where is not None and not base_frame.empty:\n base_frame = base_frame.loc[base_frame[where.get_name()]]\n\n # when no child data, just add all the features to frame with nan\n if base_frame.empty:\n for f in features:\n frame[f.get_name()] = np.nan\n else:\n relationship_path = self.entityset.find_backward_path(entity.id,\n child_entity.id)\n\n groupby_var = Relationship._get_link_variable_name(relationship_path)\n\n # if the use_previous property exists on this feature, include only the\n # instances from the child entity included in that Timedelta\n use_previous = test_feature.use_previous\n if use_previous and not base_frame.empty:\n # Filter by use_previous values\n time_last = self.time_last\n if use_previous.is_absolute():\n time_first = time_last - use_previous\n ti = child_entity.time_index\n if ti is not None:\n base_frame = base_frame[base_frame[ti] >= time_first]\n else:\n n = use_previous.value\n\n def last_n(df):\n return df.iloc[-n:]\n\n base_frame = base_frame.groupby(groupby_var, observed=True, sort=False).apply(last_n)\n\n to_agg = {}\n agg_rename = {}\n to_apply = set()\n # apply multivariable and time-dependent features as we find them, and\n # save aggregable features for later\n for f in features:\n if _can_agg(f):\n variable_id = f.base_features[0].get_name()\n\n if variable_id not in to_agg:\n to_agg[variable_id] = []\n\n func = f.get_function()\n funcname = func\n if callable(func):\n funcname = func.__name__\n\n to_agg[variable_id].append(func)\n # this is used below to rename columns that pandas names for us\n agg_rename[u\"{}-{}\".format(variable_id, funcname)] = f.get_name()\n continue\n\n to_apply.add(f)\n\n # Apply the non-aggregable functions generate a new dataframe, and merge\n # it with the existing one\n if len(to_apply):\n wrap = agg_wrapper(to_apply, self.time_last)\n # groupby_var can be both the name of the index and a column,\n # to silence pandas warning about ambiguity we explicitly pass\n # the column (in actuality grouping by both index and group would\n # work)\n to_merge = base_frame.groupby(base_frame[groupby_var], observed=True, sort=False).apply(wrap)\n frame = pd.merge(left=frame, right=to_merge,\n left_index=True,\n right_index=True, how='left')\n\n # Apply the aggregate functions to generate a new dataframe, and merge\n # it with the existing one\n if len(to_agg):\n # groupby_var can be both the name of the index and a column,\n # to silence pandas warning about ambiguity we explicitly pass\n # the column (in actuality grouping by both index and group would\n # work)\n to_merge = base_frame.groupby(base_frame[groupby_var],\n observed=True, sort=False).agg(to_agg)\n # rename columns to the correct feature names\n to_merge.columns = [agg_rename[\"-\".join(x)] for x in to_merge.columns.ravel()]\n to_merge = to_merge[list(agg_rename.values())]\n\n # workaround for pandas bug where categories are in the wrong order\n # see: https://github.com/pandas-dev/pandas/issues/22501\n if pdtypes.is_categorical_dtype(frame.index):\n categories = pdtypes.CategoricalDtype(categories=frame.index.categories)\n to_merge.index = to_merge.index.astype(object).astype(categories)\n\n frame = pd.merge(left=frame, right=to_merge,\n left_index=True, right_index=True, how='left')\n\n # Handle default values\n # 1. handle non scalar default values\n iterfeats = [f for f in features\n if hasattr(f.default_value, '__iter__')]\n for f in iterfeats:\n nulls = pd.isnull(frame[f.get_name()])\n for ni in nulls[nulls].index:\n frame.at[ni, f.get_name()] = f.default_value\n\n # 2. handle scalars default values\n fillna_dict = {f.get_name(): f.default_value for f in features\n if f not in iterfeats}\n frame.fillna(fillna_dict, inplace=True)\n\n # convert boolean dtypes to floats as appropriate\n # pandas behavior: https://github.com/pydata/pandas/issues/3752\n for f in features:\n if (not f.expanding and\n f.variable_type == variable_types.Numeric and\n frame[f.get_name()].dtype.name in ['object', 'bool']):\n frame[f.get_name()] = frame[f.get_name()].astype(float)\n\n return frame\n\n\ndef _can_agg(feature):\n assert isinstance(feature, AggregationPrimitive)\n base_features = feature.base_features\n if feature.where is not None:\n base_features = [bf.get_name() for bf in base_features\n if bf.get_name() != feature.where.get_name()]\n\n if feature.uses_calc_time:\n return False\n\n return len(base_features) == 1 and not feature.expanding\n\n\ndef agg_wrapper(feats, time_last):\n def wrap(df):\n d = {}\n for f in feats:\n func = f.get_function()\n variable_ids = [bf.get_name() for bf in f.base_features]\n args = [df[v] for v in variable_ids]\n\n if f.uses_calc_time:\n d[f.get_name()] = func(*args, time=time_last)\n else:\n d[f.get_name()] = func(*args)\n\n return pd.Series(d)\n return wrap\n\n\ndef set_default_column(frame, f):\n default = f.default_value\n if hasattr(default, '__iter__'):\n length = frame.shape[0]\n default = [f.default_value] * length\n frame[f.get_name()] = default\n"
]
| [
[
"pandas.merge",
"pandas.concat",
"pandas.DataFrame",
"pandas.api.types.CategoricalDtype",
"pandas.Series",
"pandas.api.types.is_categorical_dtype"
]
]
|
wdzhong/ASTGCN-PyTorch | [
"4f76d2302b6fd4227c4846e06ff11560d8a8237b"
]
| [
"lib/utils.py"
]
| [
"# -*- coding:utf-8 -*-\n# pylint: disable=no-member\n\nimport csv\nimport numpy as np\nfrom scipy.sparse.linalg import eigs\n\nfrom .metrics import mean_absolute_error, mean_squared_error, masked_mape_np\n\n\ndef search_data(sequence_length, num_of_batches, label_start_idx,\n num_for_predict, units, points_per_hour):\n '''\n Parameters\n ----------\n sequence_length: int, length of all history data\n\n num_of_batches: int, the number of batches will be used for training\n\n label_start_idx: int, the first index of predicting target\n\n num_for_predict: int,\n the number of points will be predicted for each sample\n\n units: int, week: 7 * 24, day: 24, recent(hour): 1\n\n points_per_hour: int, number of points per hour, depends on data\n\n Returns\n ----------\n list[(start_idx, end_idx)]\n '''\n\n if points_per_hour < 0:\n raise ValueError(\"points_per_hour should be greater than 0!\")\n\n if label_start_idx + num_for_predict > sequence_length:\n return None\n\n x_idx = []\n for i in range(1, num_of_batches + 1):\n start_idx = label_start_idx - points_per_hour * units * i\n end_idx = start_idx + num_for_predict # wd: this could overlap with 'label_start_index', e.g. when num_for_predict is larger than 12 (one hour)\n if start_idx >= 0:\n x_idx.append((start_idx, end_idx))\n else:\n return None\n\n if len(x_idx) != num_of_batches:\n return None\n\n return x_idx[::-1]\n\n\ndef get_sample_indices(data_sequence, num_of_weeks, num_of_days, num_of_hours,\n label_start_idx, num_for_predict, points_per_hour=12):\n \"\"\"\n Parameters\n ----------\n data_sequence: np.ndarray\n shape is (sequence_length, num_of_vertices, num_of_features)\n\n num_of_weeks, num_of_days, num_of_hours: int\n\n label_start_idx: int, the first index of predicting target\n\n num_for_predict: int,\n the number of points will be predicted for each sample\n\n points_per_hour: int, default 12, number of points per hour\n\n Returns\n ----------\n week_sample: np.ndarray\n shape is (num_of_weeks * points_per_hour, # wd: points_per_hour should be num_for_predict??\n num_of_vertices, num_of_features)\n\n day_sample: np.ndarray\n shape is (num_of_days * points_per_hour,\n num_of_vertices, num_of_features)\n\n hour_sample: np.ndarray\n shape is (num_of_hours * points_per_hour,\n num_of_vertices, num_of_features)\n\n target: np.ndarray\n shape is (num_for_predict, num_of_vertices, num_of_features)\n \"\"\"\n week_indices = search_data(data_sequence.shape[0], num_of_weeks,\n label_start_idx, num_for_predict,\n 7 * 24, points_per_hour)\n if not week_indices:\n return None\n\n day_indices = search_data(data_sequence.shape[0], num_of_days,\n label_start_idx, num_for_predict,\n 24, points_per_hour)\n if not day_indices:\n return None\n\n hour_indices = search_data(data_sequence.shape[0], num_of_hours,\n label_start_idx, num_for_predict,\n 1, points_per_hour)\n if not hour_indices:\n return None\n\n week_sample = np.concatenate([data_sequence[i: j]\n for i, j in week_indices], axis=0)\n day_sample = np.concatenate([data_sequence[i: j]\n for i, j in day_indices], axis=0)\n hour_sample = np.concatenate([data_sequence[i: j]\n for i, j in hour_indices], axis=0)\n target = data_sequence[label_start_idx: label_start_idx + num_for_predict]\n\n return week_sample, day_sample, hour_sample, target\n\n\ndef get_adjacency_matrix(distance_df_filename, num_of_vertices):\n '''\n Parameters\n ----------\n distance_df_filename: str, path of the csv file contains edges information\n\n num_of_vertices: int, the number of vertices\n\n Returns\n ----------\n A: np.ndarray, adjacency matrix\n\n '''\n\n with open(distance_df_filename, 'r') as f:\n reader = csv.reader(f)\n header = f.__next__()\n edges = [(int(i[0]), int(i[1])) for i in reader]\n\n A = np.zeros((int(num_of_vertices), int(num_of_vertices)),\n dtype=np.float32)\n\n for i, j in edges:\n A[i, j] = 1\n\n return A\n\n\ndef scaled_Laplacian(W):\n '''\n compute \\tilde{L}\n\n Parameters\n ----------\n W: np.ndarray, shape is (N, N), N is the num of vertices\n\n Returns\n ----------\n scaled_Laplacian: np.ndarray, shape (N, N)\n\n '''\n\n assert W.shape[0] == W.shape[1]\n\n D = np.diag(np.sum(W, axis=1))\n\n L = D - W\n\n lambda_max = eigs(L, k=1, which='LR')[0].real\n\n return (2 * L) / lambda_max - np.identity(W.shape[0])\n\n\ndef cheb_polynomial(L_tilde, K):\n '''\n compute a list of chebyshev polynomials from T_0 to T_{K-1}\n\n Parameters\n ----------\n L_tilde: scaled Laplacian, np.ndarray, shape (N, N)\n\n K: the maximum order of chebyshev polynomials\n\n Returns\n ----------\n cheb_polynomials: list[np.ndarray], length: K, from T_0 to T_{K-1}\n\n '''\n\n N = L_tilde.shape[0]\n\n cheb_polynomials = [np.identity(N), L_tilde.copy()]\n\n for i in range(2, K):\n cheb_polynomials.append(\n 2 * L_tilde * cheb_polynomials[i - 1] - cheb_polynomials[i - 2])\n\n return cheb_polynomials\n\n\ndef compute_val_loss(net, val_loader, loss_function, sw, epoch, device):\n \"\"\"\n compute mean loss on validation set\n\n Parameters\n ----------\n net: model\n\n val_loader: DataLoader\n\n loss_function: func\n\n sw: SummaryWriter. TODO: to be implemented\n\n epoch: int, current epoch\n\n \"\"\"\n val_loader_length = len(val_loader)\n tmp = []\n for index, (val_w, val_d, val_r, val_t) in enumerate(val_loader):\n val_w = val_w.to(device)\n val_d = val_d.to(device)\n val_r = val_r.to(device)\n val_t = val_t.to(device)\n output = net([val_w, val_d, val_r])\n l = loss_function(output, val_t) # l is a tensor, with single value\n tmp.append(l.item())\n print('validation batch %s / %s, loss: %.2f' % (\n index + 1, val_loader_length, l.item()))\n\n validation_loss = sum(tmp) / len(tmp)\n\n if sw:\n sw.add_scalar(tag='validation_loss',\n value=validation_loss,\n global_step=epoch)\n\n print('epoch: %s, validation loss: %.2f' % (epoch, validation_loss))\n\n\ndef predict(net, test_loader, device):\n \"\"\"\n predict\n\n Parameters\n ----------\n net: model\n\n test_loader: DataLoader\n\n Returns\n ----------\n prediction: np.ndarray,\n shape is (num_of_samples, num_of_vertices, num_for_predict)\n\n \"\"\"\n\n test_loader_length = len(test_loader)\n prediction = []\n for index, (test_w, test_d, test_r, _) in enumerate(test_loader):\n test_w = test_w.to(device)\n test_d = test_d.to(device)\n test_r = test_r.to(device)\n prediction.append(net([test_w, test_d, test_r]).cpu().numpy())\n print('predicting testing set batch %s / %s' % (index + 1, test_loader_length))\n prediction = np.concatenate(prediction, 0)\n return prediction\n\n\ndef evaluate(net, test_loader, true_value, num_of_vertices, sw, epoch, device):\n \"\"\"\n compute MAE, RMSE, MAPE scores of the prediction\n for 3, 6, 12 points on testing set\n\n Parameters\n ----------\n net: model\n\n test_loader: DataLoader\n\n true_value: np.ndarray, all ground truth of testing set\n shape is (num_of_samples, num_for_predict, num_of_vertices)\n\n num_of_vertices: int, number of vertices\n\n sw: SummaryWriter. TODO: to be implemented.\n\n epoch: int, current epoch\n\n \"\"\"\n prediction = predict(net, test_loader, device)\n prediction = (prediction.transpose((0, 2, 1))\n .reshape(prediction.shape[0], -1))\n for i in [3, 6, 12]:\n print('current epoch: %s, predict %s points' % (epoch, i))\n\n mae = mean_absolute_error(true_value[:, : i * num_of_vertices],\n prediction[:, : i * num_of_vertices])\n rmse = mean_squared_error(true_value[:, : i * num_of_vertices],\n prediction[:, : i * num_of_vertices]) ** 0.5\n mape = masked_mape_np(true_value[:, : i * num_of_vertices],\n prediction[:, : i * num_of_vertices], 0)\n\n print('MAE: %.2f' % (mae))\n print('RMSE: %.2f' % (rmse))\n print('MAPE: %.2f' % (mape))\n print()\n if sw:\n sw.add_scalar(tag='MAE_%s_points' % (i),\n value=mae,\n global_step=epoch)\n sw.add_scalar(tag='RMSE_%s_points' % (i),\n value=rmse,\n global_step=epoch)\n sw.add_scalar(tag='MAPE_%s_points' % (i),\n value=mape,\n global_step=epoch)\n"
]
| [
[
"numpy.concatenate",
"numpy.sum",
"scipy.sparse.linalg.eigs",
"numpy.identity"
]
]
|
JacopoBugini/SpotMask | [
"0be6c35283b89d5bbddcdb2b65a67a59fac4d264"
]
| [
"utils/utils.py"
]
| [
"import numpy as np\nimport cv2\nimport tensorflow.keras as keras\nfrom tensorflow.keras.preprocessing import image\nimport numpy as np\n\n# -------------------------------------------------------------------\n# Load models\n# -------------------------------------------------------------------\n\n# Load the trained model\nmask_net = keras.models.load_model('models/facemask-correctness/mask_correctness_model.h5')\nprint(\"Model Check Mask imported correctly\")\n\ndetect_net = keras.models.load_model('models/mask-detection/mask_detection_model.h5')\nprint(\"Model Detect Mask imported correctly\")\nprint(\"*********************************************\")\n\nsuggest_net = keras.models.load_model('models/suggestions-detection/suggestions_model.h5')\nprint(\"Model Detect Mask imported correctly\")\nprint(\"*********************************************\")\n\n# -------------------------------------------------------------------\n# Parameters\n# -------------------------------------------------------------------\n\nCONF_THRESHOLD = 0.5\nNMS_THRESHOLD = 0.4\nIMG_WIDTH = 416\nIMG_HEIGHT = 416\n\n\n# -------------------------------------------------------------------\n# Help functions\n# -------------------------------------------------------------------\n\n# Get the names of the output layers\ndef get_outputs_names(net):\n # Get the names of all the layers in the network\n layers_names = net.getLayerNames()\n\n # Get the names of the output layers, i.e. the layers with unconnected\n return [layers_names[i[0] - 1] for i in net.getUnconnectedOutLayers()]\n\ndef process_frame(frame, outs, conf_threshold, nms_threshold, mode):\n frame_height = frame.shape[0]\n frame_width = frame.shape[1]\n\n # Scan through all the bounding boxes output from the network and keep only the ones with high confidence scores.\n confidences = []\n boxes = []\n final_boxes = []\n for out in outs:\n for detection in out:\n scores = detection[5:]\n class_id = np.argmax(scores)\n confidence = scores[class_id]\n if confidence > conf_threshold:\n center_x = int(detection[0] * frame_width)\n center_y = int(detection[1] * frame_height)\n width = int(detection[2] * frame_width)\n height = int(detection[3] * frame_height)\n left = int(center_x - width / 2)\n top = int(center_y - height / 2)\n confidences.append(float(confidence))\n boxes.append([left, top, width, height])\n\n # Perform non maximum suppression to eliminate redundant overlapping boxes with lower confidences.\n indices = cv2.dnn.NMSBoxes(boxes, confidences, conf_threshold,\n nms_threshold)\n\n for i in indices:\n i = i[0]\n box = boxes[i]\n left = box[0]\n top = box[1]\n width = box[2]\n height = box[3]\n final_boxes.append(box)\n \n colour_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\n face_img_crop = colour_frame[top-30:top+height+30, left-30:left+width+30]\n\n img_array = prepare_frame(face_img_crop)\n\n output_mask, colour, mask_result = detect_mask_usage(img_array, mode)\n\n cv2.rectangle(frame, (left, top), (left+width, top+height), colour, 3)\n cv2.putText(frame, output_mask, (left, top-10), cv2.FONT_HERSHEY_SIMPLEX, 0.6, colour, 2)\n\n return final_boxes\n\ndef prepare_frame(img, size=[150,150]):\n\n img_reshaped = cv2.resize(img, (size[0],size[1]))\n img_array = image.img_to_array(img_reshaped)\n img_array = img_array.astype('float32')\n img_array /= 255.0\n img_array = img_array.reshape((1,) + img_array.shape)\n\n return img_array\n\ndef detect_mask_usage(img_array, mode):\n\n # predict mask presence: Detect Mask\n mask_result = detect_net.predict_on_batch(img_array)\n\n # Predict Mask Correctness: Mask Correctness\n mask_is_proper = mask_net.predict_on_batch(img_array)\n\n # Predict Mask Suggestions: Mask Suggestions\n suggestions = suggest_net.predict_on_batch(img_array)\n \n # Elaborate scores based on prediction values\n # get mask presence results\n score=np.amax(mask_result[0], axis=0)\n list_scores = list(mask_result[0])\n mask_detection_result_index = list_scores.index(score)\n \n # get mask correctness results\n score_2=np.amax(mask_is_proper[0], axis=0)\n list_scores_2 = list(mask_is_proper[0])\n correctness_result_index = list_scores_2.index(score_2)\n\n # get mask suggestions results\n score_3=np.amax(suggestions[0], axis=0)\n list_scores_3 = list(suggestions[0])\n suggestions_result_index = list_scores_3.index(score_3)\n\n \n if mask_detection_result_index == 1:\n output_mask = 'Wear a Mask!' \n colour = (0,0,255)\n\n else: \n\n if mode == 'simple':\n\n if correctness_result_index == 1:\n output_mask = 'Good!'\n colour = (0,255,0)\n else:\n output_mask = 'Wear it correctly!'\n colour = (0,152,232)\n \n elif mode == 'suggestions':\n\n if suggestions_result_index == 0:\n output_mask = 'Adjust on Chin!'\n colour = (0,152,232)\n elif suggestions_result_index == 1:\n output_mask = 'Cover your Nose!'\n colour = (0,152,232)\n elif suggestions_result_index == 2:\n output_mask = 'Cover Mouth and Nose!'\n colour = (0,152,232)\n elif suggestions_result_index == 3:\n output_mask = 'Good!'\n colour = (0,255,0)\n\n else:\n print('Mode not recongized. Please consider giving --mode \"suggestions\" or --mode \"simple\"')\n \n return output_mask, colour, mask_result\n"
]
| [
[
"tensorflow.keras.models.load_model",
"tensorflow.keras.preprocessing.image.img_to_array",
"numpy.amax",
"numpy.argmax"
]
]
|
visatish/ray | [
"dc76e51a60652b3210c93f81df6dafcf461d4431",
"dc76e51a60652b3210c93f81df6dafcf461d4431"
]
| [
"python/ray/tune/logger.py",
"python/ray/rllib/utils/tf_run_builder.py"
]
| [
"from __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport csv\nimport json\nimport logging\nimport numpy as np\nimport os\nimport yaml\n\nfrom ray.tune.log_sync import get_syncer\nfrom ray.tune.result import NODE_IP, TRAINING_ITERATION, TIME_TOTAL_S, \\\n TIMESTEPS_TOTAL\n\nlogger = logging.getLogger(__name__)\n\ntry:\n import tensorflow as tf\nexcept ImportError:\n tf = None\n logger.warning(\"Couldn't import TensorFlow - \"\n \"disabling TensorBoard logging.\")\n\n\nclass Logger(object):\n \"\"\"Logging interface for ray.tune; specialized implementations follow.\n\n By default, the UnifiedLogger implementation is used which logs results in\n multiple formats (TensorBoard, rllab/viskit, plain json) at once.\n \"\"\"\n\n def __init__(self, config, logdir, upload_uri=None):\n self.config = config\n self.logdir = logdir\n self.uri = upload_uri\n self._init()\n\n def _init(self):\n pass\n\n def on_result(self, result):\n \"\"\"Given a result, appends it to the existing log.\"\"\"\n\n raise NotImplementedError\n\n def close(self):\n \"\"\"Releases all resources used by this logger.\"\"\"\n\n pass\n\n def flush(self):\n \"\"\"Flushes all disk writes to storage.\"\"\"\n\n pass\n\n\nclass UnifiedLogger(Logger):\n \"\"\"Unified result logger for TensorBoard, rllab/viskit, plain json.\n\n This class also periodically syncs output to the given upload uri.\"\"\"\n\n def _init(self):\n self._loggers = []\n for cls in [_JsonLogger, _TFLogger, _VisKitLogger]:\n if cls is _TFLogger and tf is None:\n logger.info(\"TF not installed - \"\n \"cannot log with {}...\".format(cls))\n continue\n self._loggers.append(cls(self.config, self.logdir, self.uri))\n self._log_syncer = get_syncer(self.logdir, self.uri)\n\n def on_result(self, result):\n for logger in self._loggers:\n logger.on_result(result)\n self._log_syncer.set_worker_ip(result.get(NODE_IP))\n self._log_syncer.sync_if_needed()\n\n def close(self):\n for logger in self._loggers:\n logger.close()\n self._log_syncer.sync_now(force=True)\n\n def flush(self):\n for logger in self._loggers:\n logger.flush()\n self._log_syncer.sync_now(force=True)\n self._log_syncer.wait()\n\n\nclass NoopLogger(Logger):\n def on_result(self, result):\n pass\n\n\nclass _JsonLogger(Logger):\n def _init(self):\n config_out = os.path.join(self.logdir, \"params.json\")\n with open(config_out, \"w\") as f:\n json.dump(self.config, f, sort_keys=True, cls=_SafeFallbackEncoder)\n local_file = os.path.join(self.logdir, \"result.json\")\n self.local_out = open(local_file, \"w\")\n\n def on_result(self, result):\n json.dump(result, self, cls=_SafeFallbackEncoder)\n self.write(\"\\n\")\n\n def write(self, b):\n self.local_out.write(b)\n self.local_out.flush()\n\n def close(self):\n self.local_out.close()\n\n\ndef to_tf_values(result, path):\n values = []\n for attr, value in result.items():\n if value is not None:\n if type(value) in [int, float, np.float32, np.float64, np.int32]:\n values.append(\n tf.Summary.Value(\n tag=\"/\".join(path + [attr]), simple_value=value))\n elif type(value) is dict:\n values.extend(to_tf_values(value, path + [attr]))\n return values\n\n\nclass _TFLogger(Logger):\n def _init(self):\n self._file_writer = tf.summary.FileWriter(self.logdir)\n\n def on_result(self, result):\n tmp = result.copy()\n for k in [\n \"config\", \"pid\", \"timestamp\", TIME_TOTAL_S, TRAINING_ITERATION\n ]:\n del tmp[k] # not useful to tf log these\n values = to_tf_values(tmp, [\"ray\", \"tune\"])\n train_stats = tf.Summary(value=values)\n t = result.get(TIMESTEPS_TOTAL) or result[TRAINING_ITERATION]\n self._file_writer.add_summary(train_stats, t)\n iteration_value = to_tf_values({\n \"training_iteration\": result[TRAINING_ITERATION]\n }, [\"ray\", \"tune\"])\n iteration_stats = tf.Summary(value=iteration_value)\n self._file_writer.add_summary(iteration_stats, t)\n self._file_writer.flush()\n\n def flush(self):\n self._file_writer.flush()\n\n def close(self):\n self._file_writer.close()\n\n\nclass _VisKitLogger(Logger):\n def _init(self):\n \"\"\"CSV outputted with Headers as first set of results.\"\"\"\n # Note that we assume params.json was already created by JsonLogger\n self._file = open(os.path.join(self.logdir, \"progress.csv\"), \"w\")\n self._csv_out = None\n\n def on_result(self, result):\n if self._csv_out is None:\n self._csv_out = csv.DictWriter(self._file, result.keys())\n self._csv_out.writeheader()\n self._csv_out.writerow(result.copy())\n\n def close(self):\n self._file.close()\n\n\nclass _SafeFallbackEncoder(json.JSONEncoder):\n def __init__(self, nan_str=\"null\", **kwargs):\n super(_SafeFallbackEncoder, self).__init__(**kwargs)\n self.nan_str = nan_str\n\n def default(self, value):\n try:\n if np.isnan(value):\n return None\n if np.issubdtype(value, float):\n return float(value)\n if np.issubdtype(value, int):\n return int(value)\n except Exception:\n return str(value) # give up, just stringify it (ok for logs)\n\n\ndef pretty_print(result):\n result = result.copy()\n result.update(config=None) # drop config from pretty print\n out = {}\n for k, v in result.items():\n if v is not None:\n out[k] = v\n\n cleaned = json.dumps(out, cls=_SafeFallbackEncoder)\n return yaml.safe_dump(json.loads(cleaned), default_flow_style=False)\n",
"from __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport os\nimport time\n\nimport tensorflow as tf\nfrom tensorflow.python.client import timeline\n\n\nclass TFRunBuilder(object):\n \"\"\"Used to incrementally build up a TensorFlow run.\n\n This is particularly useful for batching ops from multiple different\n policies in the multi-agent setting.\n \"\"\"\n\n def __init__(self, session, debug_name):\n self.session = session\n self.debug_name = debug_name\n self.feed_dict = {}\n self.fetches = []\n self._executed = None\n\n def add_feed_dict(self, feed_dict):\n assert not self._executed\n for k in feed_dict:\n assert k not in self.feed_dict\n self.feed_dict.update(feed_dict)\n\n def add_fetches(self, fetches):\n assert not self._executed\n base_index = len(self.fetches)\n self.fetches.extend(fetches)\n return list(range(base_index, len(self.fetches)))\n\n def get(self, to_fetch):\n if self._executed is None:\n try:\n self._executed = run_timeline(\n self.session, self.fetches, self.debug_name,\n self.feed_dict, os.environ.get(\"TF_TIMELINE_DIR\"))\n except Exception as e:\n print(\"Error fetching: {}, feed_dict={}\".format(\n self.fetches, self.feed_dict))\n raise e\n if isinstance(to_fetch, int):\n return self._executed[to_fetch]\n elif isinstance(to_fetch, list):\n return [self.get(x) for x in to_fetch]\n elif isinstance(to_fetch, tuple):\n return tuple(self.get(x) for x in to_fetch)\n else:\n raise ValueError(\"Unsupported fetch type: {}\".format(to_fetch))\n\n\n_count = 0\n\n\ndef run_timeline(sess, ops, debug_name, feed_dict={}, timeline_dir=None):\n if timeline_dir:\n run_options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)\n run_metadata = tf.RunMetadata()\n start = time.time()\n fetches = sess.run(\n ops,\n options=run_options,\n run_metadata=run_metadata,\n feed_dict=feed_dict)\n trace = timeline.Timeline(step_stats=run_metadata.step_stats)\n global _count\n outf = os.path.join(\n timeline_dir, \"timeline-{}-{}-{}.json\".format(\n debug_name, os.getpid(), _count))\n _count += 1\n trace_file = open(outf, \"w\")\n print(\"Wrote tf timeline ({} s) to {}\".format(time.time() - start,\n os.path.abspath(outf)))\n trace_file.write(trace.generate_chrome_trace_format())\n else:\n fetches = sess.run(ops, feed_dict=feed_dict)\n return fetches\n"
]
| [
[
"tensorflow.Summary",
"tensorflow.summary.FileWriter",
"numpy.issubdtype",
"numpy.isnan"
],
[
"tensorflow.RunMetadata",
"tensorflow.RunOptions",
"tensorflow.python.client.timeline.Timeline"
]
]
|
h-mayorquin/time_series_basic | [
"654fb67ef6258b3f200c15a2b8068ab9300401d7"
]
| [
"hdf5_loading_three_bumps.py"
]
| [
"import h5py\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport matplotlib.gridspec as gridspec\n\nfrom signals.aux_functions import gaussian_bump\nimport nexa.loading as load\nfrom visualization.sensors import visualize_SLM_hdf5\nfrom visualization.sensors import visualize_STDM_hdf5\nfrom visualization.sensor_clustering import visualize_cluster_matrix_hdf5\n\n# Load the database\nlocation = './results_database/three_bumps_distance.hdf5'\ndatabase = h5py.File(location, 'r')\n\n# Time \nTmax = 1000\ndt = 1.0\ntime = np.arange(0, Tmax, dt)\n\n# Parameters that the bumpbs share\nmax_rate = 100\nbase = 10\nvalue = 50\nattenuation = 2\n\n# Define three arangments for the values of the gaussian bumpbs\ncenter1 = 100\ncenter2 = 500\ncenter3 = 700\n\n# Now create the guassian bumps\ngb1 = gaussian_bump(time, center1, max_rate, base, value, attenuation)\ngb2 = gaussian_bump(time, center2, max_rate, base, value * 2, attenuation)\ngb3 = gaussian_bump(time, center3, max_rate, base, value * 0.5, attenuation)\n\n# Database extraction\nrun_name = str(center1) + '-'\nrun_name += str(center2) + '-'\nrun_name += str(center3)\n\nnexa_arrangement = '3-4-3'\nr = database[run_name]\n\n# Load everything\nSLM = load.get_SLM_hdf5(database, run_name)\nSTDM = load.get_STDM_hdf5(database, run_name, nexa_arrangement)\ncluster_to_index = load.get_cluster_to_index_hdf5(database, run_name, nexa_arrangement)\nindex_to_cluster = load.get_index_to_cluster_hdf5(database, run_name, nexa_arrangement)\ncluster_to_time_centers = load.get_cluster_to_time_centers_hdf5(database, run_name, nexa_arrangement)\n\n# Now visualize the signals and the SLM\nif False:\n fig = plt.figure()\n gs = gridspec.GridSpec(3, 2)\n\n ax1 = fig.add_subplot(gs[0, 0])\n ax1.plot(time, gb1)\n ax2 = fig.add_subplot(gs[1, 0])\n ax2.plot(time,gb2)\n ax3 = fig.add_subplot(gs[2, 0])\n ax3.plot(time, gb3)\n\n ax4 = fig.add_subplot(gs[:, 1])\n visualize_SLM_hdf5(database, run_name, ax=ax4)\n\n plt.show()\n\n# Now the signals and the STDM\nif False:\n fig = plt.figure()\n gs = gridspec.GridSpec(3, 2)\n\n ax1 = fig.add_subplot(gs[0, 0])\n ax1.plot(time, gb1)\n ax2 = fig.add_subplot(gs[1, 0])\n ax2.plot(time,gb2)\n ax3 = fig.add_subplot(gs[2, 0])\n ax3.plot(time, gb3)\n\n ax4 = fig.add_subplot(gs[:, 1])\n visualize_STDM_hdf5(database, run_name, nexa_arrangement, ax= ax4)\n\n plt.show()\n\n \n# Now visualize the SLM and STDM\nif False:\n fig = plt.figure()\n gs = gridspec.GridSpec(2, 2)\n ax1 = fig.add_subplot(gs[:, 0])\n visualize_SLM_hdf5(database, run_name, ax=ax1)\n ax2 = fig.add_subplot(gs[:, 1])\n visualize_STDM_hdf5(database, run_name, nexa_arrangement, ax= ax2)\n fig.show()\n plt.close(fig)\n\n# Now visualize the signals and the cluster matrix \nif True:\n fig = plt.figure()\n gs = gridspec.GridSpec(3, 2)\n\n ax1 = fig.add_subplot(gs[0, 0])\n ax1.plot(time, gb1)\n ax2 = fig.add_subplot(gs[1, 0])\n ax2.plot(time, gb2)\n ax3 = fig.add_subplot(gs[2, 0])\n ax3.plot(time, gb3)\n\n ax4 = fig.add_subplot(gs[:, 1])\n visualize_cluster_matrix_hdf5(database, run_name, nexa_arrangement, ax=ax4)\n\n plt.show()\n\n"
]
| [
[
"matplotlib.pyplot.close",
"matplotlib.pyplot.figure",
"numpy.arange",
"matplotlib.pyplot.show",
"matplotlib.gridspec.GridSpec"
]
]
|
sun-yitao/GrabAIChallenge | [
"05946339e5a478216d7a9234e29e9bd7af5b3492"
]
| [
"ws-dan/utils.py"
]
| [
"import numpy as np\n\n\ndef accuracy(output, target, topk=(1,)):\n \"\"\"Computes the accuracy@k for the specified values of k\"\"\"\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0)\n res.append(correct_k.mul_(100. / batch_size))\n\n return np.array(res, dtype='float')\n"
]
| [
[
"numpy.array"
]
]
|
cinmoy98/neural-network-visualizer | [
"bbb8a5237fe60ee552e3f343ab03707d381895dc"
]
| [
"app.py"
]
| [
"\nimport streamlit as st\nimport json\nimport requests\nimport matplotlib.pyplot as plt\nimport numpy as np\n\nURI = 'http://neural-net-viz-flask.herokuapp.com'\n\nst.title('Nural Network Visualizer')\nst.sidebar.markdown('## Input Image')\n\nif st.button('Get Random Prediction'):\n response = requests.post(URI, data={})\n response = json.loads(response.text)\n preds = response.get('prediction')\n image = response.get('image')\n image = np.reshape(image, (28, 28))\n \n st.sidebar.image(image, width=150)\n \n for layer, p in enumerate(preds):\n numbers = np.squeeze(np.array(p))\n \n plt.figure(figsize=(32, 4))\n \n if layer == 2:\n row = 1\n col = 10\n else:\n row = 2\n col = 16\n \n for i, number in enumerate(numbers):\n plt.subplot(row, col, i+1)\n plt.imshow(number * np.ones((8, 8, 3)).astype('float32'))\n plt.xticks([])\n plt.yticks([])\n \n if layer == 2:\n plt.xlabel(str(i), fontsize=40)\n plt.subplots_adjust(wspace=0.05, hspace=0.05)\n plt.tight_layout()\n st.text('Layer {}'.format(layer + 1))\n st.pyplot()\n \n"
]
| [
[
"numpy.array",
"numpy.reshape",
"numpy.ones",
"matplotlib.pyplot.yticks",
"matplotlib.pyplot.figure",
"matplotlib.pyplot.tight_layout",
"matplotlib.pyplot.subplots_adjust",
"matplotlib.pyplot.xticks",
"matplotlib.pyplot.subplot"
]
]
|
stanford-oval/word-language-model | [
"3be3f65a198b518b66e22a910f28f83324db3825"
]
| [
"data.py"
]
| [
"import os\nimport torch\n\nclass Dictionary(object):\n \"\"\"Build word2idx and idx2word from Corpus(train/val/test)\"\"\"\n def __init__(self):\n self.word2idx = {} # word: index\n self.idx2word = [] # position(index): word\n\n def add_word(self, word):\n \"\"\"Create/Update word2idx and idx2word\"\"\"\n if word not in self.word2idx:\n self.idx2word.append(word)\n self.word2idx[word] = len(self.idx2word) - 1\n return self.word2idx[word]\n\n def __len__(self):\n return len(self.idx2word)\n\n\nclass Corpus(object):\n \"\"\"Corpus Tokenizer\"\"\"\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') as f:\n tokens = 0\n for line in f:\n # line to list of token + eos\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') 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"
]
| [
[
"torch.LongTensor"
]
]
|
KexianShen/acados | [
"2981d29dc6ecdaabdb39cd6c0d784724704afe4a"
]
| [
"interfaces/acados_template/acados_template/acados_sim.py"
]
| [
"# -*- coding: future_fstrings -*-\n#\n# Copyright 2019 Gianluca Frison, Dimitris Kouzoupis, Robin Verschueren,\n# Andrea Zanelli, Niels van Duijkeren, Jonathan Frey, Tommaso Sartor,\n# Branimir Novoselnik, Rien Quirynen, Rezart Qelibari, Dang Doan,\n# Jonas Koenemann, Yutao Chen, Tobias Schöls, Jonas Schlagenhauf, Moritz Diehl\n#\n# This file is part of acados.\n#\n# The 2-Clause BSD License\n#\n# Redistribution and use in source and binary forms, with or without\n# modification, are permitted provided that the following conditions are met:\n#\n# 1. Redistributions of source code must retain the above copyright notice,\n# this list of conditions and the following disclaimer.\n#\n# 2. Redistributions in binary form must reproduce the above copyright notice,\n# this list of conditions and the following disclaimer in the documentation\n# and/or other materials provided with the distribution.\n#\n# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n# POSSIBILITY OF SUCH DAMAGE.;\n#\n\nimport numpy as np\nimport casadi as ca\nimport os\nfrom .acados_model import AcadosModel\nfrom .utils import get_acados_path, get_lib_ext\n\nclass AcadosSimDims:\n \"\"\"\n Class containing the dimensions of the model to be simulated.\n \"\"\"\n def __init__(self):\n self.__nx = None\n self.__nu = None\n self.__nz = 0\n self.__np = 0\n\n @property\n def nx(self):\n \"\"\":math:`n_x` - number of states. Type: int > 0\"\"\"\n return self.__nx\n\n @property\n def nz(self):\n \"\"\":math:`n_z` - number of algebraic variables. Type: int >= 0\"\"\"\n return self.__nz\n\n @property\n def nu(self):\n \"\"\":math:`n_u` - number of inputs. Type: int >= 0\"\"\"\n return self.__nu\n\n @property\n def np(self):\n \"\"\":math:`n_p` - number of parameters. Type: int >= 0\"\"\"\n return self.__np\n\n @nx.setter\n def nx(self, nx):\n if isinstance(nx, int) and nx > 0:\n self.__nx = nx\n else:\n raise Exception('Invalid nx value, expected positive integer.')\n\n @nz.setter\n def nz(self, nz):\n if isinstance(nz, int) and nz > -1:\n self.__nz = nz\n else:\n raise Exception('Invalid nz value, expected nonnegative integer.')\n\n @nu.setter\n def nu(self, nu):\n if isinstance(nu, int) and nu > -1:\n self.__nu = nu\n else:\n raise Exception('Invalid nu value, expected nonnegative integer.')\n\n @np.setter\n def np(self, np):\n if isinstance(np, int) and np > -1:\n self.__np = np\n else:\n raise Exception('Invalid np value, expected nonnegative integer.')\n\n def set(self, attr, value):\n setattr(self, attr, value)\n\n\nclass AcadosSimOpts:\n \"\"\"\n class containing the solver options\n \"\"\"\n def __init__(self):\n self.__integrator_type = 'ERK'\n self.__collocation_type = 'GAUSS_LEGENDRE'\n self.__Tsim = None\n # ints\n self.__sim_method_num_stages = 1\n self.__sim_method_num_steps = 1\n self.__sim_method_newton_iter = 3\n # bools\n self.__sens_forw = True\n self.__sens_adj = False\n self.__sens_algebraic = False\n self.__sens_hess = False\n self.__output_z = False\n self.__sim_method_jac_reuse = 0\n\n @property\n def integrator_type(self):\n \"\"\"Integrator type. Default: 'ERK'.\"\"\"\n return self.__integrator_type\n\n @property\n def num_stages(self):\n \"\"\"Number of stages in the integrator. Default: 1\"\"\"\n return self.__sim_method_num_stages\n\n @property\n def num_steps(self):\n \"\"\"Number of steps in the integrator. Default: 1\"\"\"\n return self.__sim_method_num_steps\n\n @property\n def newton_iter(self):\n \"\"\"Number of Newton iterations in simulation method. Default: 3\"\"\"\n return self.__sim_method_newton_iter\n\n @property\n def sens_forw(self):\n \"\"\"Boolean determining if forward sensitivities are computed. Default: True\"\"\"\n return self.__sens_forw\n\n @property\n def sens_adj(self):\n \"\"\"Boolean determining if adjoint sensitivities are computed. Default: False\"\"\"\n return self.__sens_adj\n\n @property\n def sens_algebraic(self):\n \"\"\"Boolean determining if sensitivities wrt algebraic variables are computed. Default: False\"\"\"\n return self.__sens_algebraic\n\n @property\n def sens_hess(self):\n \"\"\"Boolean determining if hessians are computed. Default: False\"\"\"\n return self.__sens_hess\n\n @property\n def output_z(self):\n \"\"\"Boolean determining if values for algebraic variables (corresponding to start of simulation interval) are computed. Default: False\"\"\"\n return self.__output_z\n\n @property\n def sim_method_jac_reuse(self):\n \"\"\"Integer determining if jacobians are reused (0 or 1). Default: 0\"\"\"\n return self.__sim_method_jac_reuse\n\n @property\n def T(self):\n \"\"\"Time horizon\"\"\"\n return self.__Tsim\n\n @property\n def collocation_type(self):\n \"\"\"Collocation type: relevant for implicit integrators\n -- string in {GAUSS_RADAU_IIA, GAUSS_LEGENDRE}\n\n Default: GAUSS_LEGENDRE\n \"\"\"\n return self.__collocation_type\n\n @integrator_type.setter\n def integrator_type(self, integrator_type):\n integrator_types = ('ERK', 'IRK', 'GNSF')\n if integrator_type in integrator_types:\n self.__integrator_type = integrator_type\n else:\n raise Exception('Invalid integrator_type value. Possible values are:\\n\\n' \\\n + ',\\n'.join(integrator_types) + '.\\n\\nYou have: ' + integrator_type + '.\\n\\n')\n\n @collocation_type.setter\n def collocation_type(self, collocation_type):\n collocation_types = ('GAUSS_RADAU_IIA', 'GAUSS_LEGENDRE')\n if collocation_type in collocation_types:\n self.__collocation_type = collocation_type\n else:\n raise Exception('Invalid collocation_type value. Possible values are:\\n\\n' \\\n + ',\\n'.join(collocation_types) + '.\\n\\nYou have: ' + collocation_type + '.\\n\\n')\n\n @T.setter\n def T(self, T):\n self.__Tsim = T\n\n @num_stages.setter\n def num_stages(self, num_stages):\n if isinstance(num_stages, int):\n self.__sim_method_num_stages = num_stages\n else:\n raise Exception('Invalid num_stages value. num_stages must be an integer.')\n\n @num_steps.setter\n def num_steps(self, num_steps):\n if isinstance(num_steps, int):\n self.__sim_method_num_steps = num_steps\n else:\n raise Exception('Invalid num_steps value. num_steps must be an integer.')\n\n @newton_iter.setter\n def newton_iter(self, newton_iter):\n if isinstance(newton_iter, int):\n self.__sim_method_newton_iter = newton_iter\n else:\n raise Exception('Invalid newton_iter value. newton_iter must be an integer.')\n\n @sens_forw.setter\n def sens_forw(self, sens_forw):\n if sens_forw in (True, False):\n self.__sens_forw = sens_forw\n else:\n raise Exception('Invalid sens_forw value. sens_forw must be a Boolean.')\n\n @sens_adj.setter\n def sens_adj(self, sens_adj):\n if sens_adj in (True, False):\n self.__sens_adj = sens_adj\n else:\n raise Exception('Invalid sens_adj value. sens_adj must be a Boolean.')\n\n @sens_hess.setter\n def sens_hess(self, sens_hess):\n if sens_hess in (True, False):\n self.__sens_hess = sens_hess\n else:\n raise Exception('Invalid sens_hess value. sens_hess must be a Boolean.')\n\n @sens_algebraic.setter\n def sens_algebraic(self, sens_algebraic):\n if sens_algebraic in (True, False):\n self.__sens_algebraic = sens_algebraic\n else:\n raise Exception('Invalid sens_algebraic value. sens_algebraic must be a Boolean.')\n\n @output_z.setter\n def output_z(self, output_z):\n if output_z in (True, False):\n self.__output_z = output_z\n else:\n raise Exception('Invalid output_z value. output_z must be a Boolean.')\n\n @sim_method_jac_reuse.setter\n def sim_method_jac_reuse(self, sim_method_jac_reuse):\n if sim_method_jac_reuse in (0, 1):\n self.__sim_method_jac_reuse = sim_method_jac_reuse\n else:\n raise Exception('Invalid sim_method_jac_reuse value. sim_method_jac_reuse must be 0 or 1.')\n\nclass AcadosSim:\n \"\"\"\n The class has the following properties that can be modified to formulate a specific simulation problem, see below:\n\n :param acados_path: string with the path to acados. It is used to generate the include and lib paths.\n\n - :py:attr:`dims` of type :py:class:`acados_template.acados_ocp.AcadosSimDims` - are automatically detected from model\n - :py:attr:`model` of type :py:class:`acados_template.acados_model.AcadosModel`\n - :py:attr:`solver_options` of type :py:class:`acados_template.acados_sim.AcadosSimOpts`\n\n - :py:attr:`acados_include_path` (set automatically)\n - :py:attr:`shared_lib_ext` (set automatically)\n - :py:attr:`acados_lib_path` (set automatically)\n - :py:attr:`parameter_values` - used to initialize the parameters (can be changed)\n\n \"\"\"\n def __init__(self, acados_path=''):\n if acados_path == '':\n acados_path = get_acados_path()\n self.dims = AcadosSimDims()\n \"\"\"Dimension definitions, automatically detected from :py:attr:`model`. Type :py:class:`acados_template.acados_sim.AcadosSimDims`\"\"\"\n self.model = AcadosModel()\n \"\"\"Model definitions, type :py:class:`acados_template.acados_model.AcadosModel`\"\"\"\n self.solver_options = AcadosSimOpts()\n \"\"\"Solver Options, type :py:class:`acados_template.acados_sim.AcadosSimOpts`\"\"\"\n\n self.acados_include_path = os.path.join(acados_path, 'include').replace(os.sep, '/') # the replace part is important on Windows for CMake\n \"\"\"Path to acados include directory (set automatically), type: `string`\"\"\"\n self.acados_lib_path = os.path.join(acados_path, 'lib').replace(os.sep, '/') # the replace part is important on Windows for CMake\n \"\"\"Path to where acados library is located (set automatically), type: `string`\"\"\"\n\n self.code_export_directory = 'c_generated_code'\n \"\"\"Path to where code will be exported. Default: `c_generated_code`.\"\"\"\n self.shared_lib_ext = get_lib_ext()\n\n self.cython_include_dirs = ''\n self.__parameter_values = np.array([])\n\n @property\n def parameter_values(self):\n \"\"\":math:`p` - initial values for parameter - can be updated\"\"\"\n return self.__parameter_values\n\n @parameter_values.setter\n def parameter_values(self, parameter_values):\n if isinstance(parameter_values, np.ndarray):\n self.__parameter_values = parameter_values\n else:\n raise Exception('Invalid parameter_values value. ' +\n f'Expected numpy array, got {type(parameter_values)}.')\n\n def set(self, attr, value):\n # tokenize string\n tokens = attr.split('_', 1)\n if len(tokens) > 1:\n setter_to_call = getattr(getattr(self, tokens[0]), 'set')\n else:\n setter_to_call = getattr(self, 'set')\n\n setter_to_call(tokens[1], value)\n\n return\n"
]
| [
[
"numpy.array"
]
]
|
dmytrov/gaussianprocess | [
"7044bd2d66f44e10656fee17e94fdee0c24c70bb"
]
| [
"code/utils/numerical/ssyrk.py"
]
| [
"import os\nimport sys\nimport time\nimport numpy\nfrom numpy import zeros\nfrom numpy.random import randn\nfrom scipy.linalg import blas\n\n\ndef run_ssyrk(N, l):\n\n A = randn(N, N).astype('float32', order='F')\n C = zeros((N, N), dtype='float32', order='F')\n\n start = time.time()\n for i in range(0, l):\n blas.ssyrk(1.0, A, c=C, overwrite_c=True)\n end = time.time()\n\n timediff = (end - start)\n mflops = (N * N * N) * l / timediff\n mflops *= 1e-6\n\n size = \"%dx%d\" % (N, N)\n print(\"%14s :\\t%20f MFlops\\t%20f sec\" % (size, mflops, timediff))\n\n\nif __name__ == \"__main__\":\n N = 128\n NMAX = 2048\n NINC = 128\n LOOPS = 1\n\n z = 0\n for arg in sys.argv:\n if z == 1:\n N = int(arg)\n elif z == 2:\n NMAX = int(arg)\n elif z == 3:\n NINC = int(arg)\n elif z == 4:\n LOOPS = int(arg)\n\n z = z + 1\n\n if 'OPENBLAS_LOOPS' in os.environ:\n p = os.environ['OPENBLAS_LOOPS']\n if p:\n LOOPS = int(p)\n\n print(\"From: %d To: %d Step=%d Loops=%d\" % (N, NMAX, NINC, LOOPS))\n print(\"\\tSIZE\\t\\t\\tFlops\\t\\t\\t\\t\\tTime\")\n\n for i in range(N, NMAX + NINC, NINC):\n run_ssyrk(i, LOOPS)\n\n "
]
| [
[
"scipy.linalg.blas.ssyrk",
"numpy.random.randn",
"numpy.zeros"
]
]
|
nadaved1/hailo_model_zoo | [
"42b716f337dde4ec602022a34d6a07a1bbd45539"
]
| [
"hailo_model_zoo/utils/data.py"
]
| [
"from builtins import object\nimport os\nimport cv2\nimport numpy as np\nimport tensorflow as tf\n\nfrom hailo_model_zoo.core.datasets import dataset_factory\nfrom hailo_model_zoo.utils.video_utils import VideoCapture\n\n\ndef _open_image_file(img_path):\n image = tf.io.read_file(img_path)\n image = tf.cast(tf.image.decode_jpeg(image, channels=3), tf.uint8)\n image_name = tf.compat.v1.string_split([img_path], os.path.sep).values[-1]\n return image, {\n 'img_orig': image,\n 'image_name': image_name,\n }\n\n\ndef _read_npz(item):\n img_name = item.decode()\n data = np.load(img_name, allow_pickle=True)\n base_name = os.path.basename(img_name).replace('.npz', '')\n data = {key: data[key].item() for key in data}\n image_info = data[base_name]['image_info']\n rpn_boxes = image_info['rpn_proposals']\n num_rpn_boxes = image_info['num_rpn_proposals']\n return data[base_name]['logits'], rpn_boxes, num_rpn_boxes, image_info['image_name'], \\\n image_info['image_id']\n\n\ndef _open_featuremap(img_path):\n featuremap, rpn_boxes, num_rpn_boxes, \\\n image_name, image_id = tf.compat.v1.py_func(_read_npz, [img_path], [tf.float32, tf.float32,\n tf.int64, tf.string, tf.int32])\n return featuremap, {\"rpn_proposals\": rpn_boxes,\n \"num_rpn_boxes\": num_rpn_boxes,\n \"image_name\": image_name,\n \"image_id\": image_id}\n\n\ndef _parse_video_frame(image, name):\n image = tf.cast(image, tf.uint8)\n return image, {'label_index': tf.cast(0, tf.float32),\n 'img_orig': image,\n 'image_name': name,\n 'is_same': tf.cast(0, tf.float32),\n 'mask': tf.image.rgb_to_grayscale(image)}\n\n\ndef _video_generator(video_path):\n def _video_generator_implementation():\n filename = os.path.basename(video_path)\n base, _ = os.path.splitext(filename)\n with VideoCapture(video_path) as cap:\n total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))\n required_digits = len(str(total_frames))\n number_format = '{{:0{}d}}'.format(required_digits)\n name_format = '{}_frame_' + number_format + '.png'\n frame_count = 0\n success = True\n while success:\n success, image = cap.read()\n if success:\n image_name = name_format.format(base, frame_count)\n image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n yield image, image_name\n frame_count += 1\n return _video_generator_implementation\n\n\nclass DataFeed(object):\n \"\"\"DataFeed class. Use this class to handle input data\"\"\"\n\n def __init__(self, preprocessing_callback, batch_size=8):\n self._preproc_callback = preprocessing_callback\n self._batch_size = batch_size\n\n @property\n def iterator(self):\n return tf.compat.v1.data.make_initializable_iterator(self._dataset)\n\n\nclass TFRecordFeed(DataFeed):\n def __init__(self, preprocessing_callback, batch_size, tfrecord_file, dataset_name):\n super().__init__(preprocessing_callback, batch_size=batch_size)\n parse_func = dataset_factory.get_dataset_parse_func(dataset_name)\n dataset = tf.data.TFRecordDataset([str(tfrecord_file)]).map(parse_func)\n if self._preproc_callback:\n dataset = dataset.map(self._preproc_callback)\n self._dataset = dataset.batch(self._batch_size)\n\n\ndef _dataset_from_folder(folder_path):\n all_files = []\n for root, dirs, files in os.walk(folder_path, topdown=False):\n for name in files:\n if os.path.splitext(name)[-1].lower() in ['.jpg', '.jpeg', '.png', '.npz']:\n all_files.append(os.path.join(root, name))\n all_files.sort()\n all_files = tf.convert_to_tensor(all_files, dtype=tf.string)\n dataset = tf.data.Dataset.from_tensor_slices(all_files)\n return dataset\n\n\nclass ImageFeed(DataFeed):\n def __init__(self, preprocessing_callback, batch_size, folder_path):\n super().__init__(preprocessing_callback, batch_size)\n\n dataset = _dataset_from_folder(folder_path).map(_open_image_file)\n if self._preproc_callback:\n dataset = dataset.map(self._preproc_callback)\n self._dataset = dataset.batch(self._batch_size)\n\n\nclass RegionProposalFeed(DataFeed):\n def __init__(self, preprocessing_callback, batch_size, folder_path):\n super().__init__(preprocessing_callback, batch_size)\n\n dataset = _dataset_from_folder(folder_path).map(_open_featuremap)\n if self._preproc_callback:\n dataset = dataset.map(self._preproc_callback)\n dataset = dataset.apply(tf.data.experimental.unbatch())\n self._dataset = dataset.batch(self._batch_size)\n\n\nclass VideoFeed(DataFeed):\n def __init__(self, preprocessing_callback, batch_size, file_path):\n super().__init__(preprocessing_callback, batch_size=batch_size)\n\n dataset = tf.data.Dataset.from_generator(_video_generator(file_path), (tf.float32, tf.string))\n dataset = dataset.map(_parse_video_frame)\n if self._preproc_callback:\n dataset = dataset.map(self._preproc_callback)\n self._dataset = dataset.batch(self._batch_size)\n"
]
| [
[
"tensorflow.convert_to_tensor",
"tensorflow.compat.v1.string_split",
"tensorflow.data.Dataset.from_tensor_slices",
"tensorflow.io.read_file",
"numpy.load",
"tensorflow.compat.v1.py_func",
"tensorflow.data.experimental.unbatch",
"tensorflow.compat.v1.data.make_initializable_iterator",
"tensorflow.image.rgb_to_grayscale",
"tensorflow.image.decode_jpeg",
"tensorflow.cast"
]
]
|
xenron/coco | [
"e318d534127b769612716c05d40e3d5b090eb5a3"
]
| [
"package/ml/regression/logistic.py"
]
| [
"from sklearn import linear_model\nfrom ml.regression.base import Regression\n\n\nclass LogisticRegression(Regression):\n\n def __init__(self):\n Regression.__init__(self)\n self._name = \"Logistic\"\n self._model = linear_model.LogisticRegression(C=1e5)\n\n def predict_proba(self, data):\n return self._model.predict_proba(data)\n"
]
| [
[
"sklearn.linear_model.LogisticRegression"
]
]
|
POSTECH-CVLab/Geometric-Primitives | [
"e4b16d8930f4a9d1c906d06255988d02f54a6deb"
]
| [
"geometric_primitives/rules/rules_mixed_22_12.py"
]
| [
"import numpy as np\n\n\nPROBS_CONTACTS = np.array([4.0, 2.0, 4.0, 2.0])\nPROBS_CONTACTS /= np.sum(PROBS_CONTACTS)\n\nRULE_CONTACTS = [\n # [0.5, 1.0] -> 4\n {\n 'num_contacts': 1,\n 'translations': [[0.5, 1.0], [-0.5, 1.0], [0.5, -1.0], [-0.5, -1.0]],\n 'direction': 0\n },\n # [0.5, 0.0] -> 2\n {\n 'num_contacts': 2,\n 'translations': [[0.5, 0.0], [-0.5, 0.0]],\n 'direction': 0\n },\n # [1.0, 0.5] -> 4\n {\n 'num_contacts': 1,\n 'translations': [[1.0, 0.5], [-1.0, 0.5], [1.0, -0.5], [-1.0, -0.5]],\n 'direction': 1\n },\n # [0.0, 0.5] -> 2\n {\n 'num_contacts': 2,\n 'translations': [[0.0, 0.5], [0.0, -0.5]],\n 'direction': 1\n },\n]\n\nLIST_RULES = []\nind = 1\nfor rule in RULE_CONTACTS:\n cur_direction = rule['direction']\n cur_num_contacts = rule['num_contacts']\n\n for translation in rule['translations']:\n cur_rule = [ind, [cur_direction, translation, cur_num_contacts]]\n LIST_RULES.append(cur_rule)\n\n ind += 1\n"
]
| [
[
"numpy.sum",
"numpy.array"
]
]
|
wakky927/Computational-Engineering-B | [
"3720d96668a32dc73f38ed0bc8afe4705452de9e"
]
| [
"src/lecture9/solver.py"
]
| [
"import numpy as np\n\nimport condition\n\n\ndef solve_matrix(p, Ap, Ae, Aw, An, As, bb, m, n):\n md = 101\n nd = 101\n\n p_old = np.zeros((md, nd))\n\n ''' SOR algorithm '''\n iter_max = 300 # SOR max iteration steps\n relax_factor = 1.8 # SOR relaxation factor\n\n for iter_i in range(1, iter_max):\n error = 0.0\n\n for i in range(1, m + 1):\n for j in range(1, n + 1):\n p_old[i][j] = p[i][j]\n\n for i in range(1, m + 1):\n for j in range(1, n + 1):\n p[i][j] = (bb[i][j] - Ae[i][j] * p_old[i + 1][j] - Aw[i][j]\n * p[i - 1][j] - An[i][j] * p_old[i][j + 1]\n - As[i][j] * p[i][j - 1]) / Ap[i][j]\\\n * relax_factor + p_old[i][j] * (1 - relax_factor)\n a = np.abs(p[i][j] - p_old[i][j])\n e = max(error, a)\n error = e\n\n # print(f\"iteration no. {iter_i} -- error = {error}\")\n\n return\n\n\ndef solve_p(p, u, v, u_old, v_old, nue, density, dx, dy, dt, m, n):\n md = 101\n nd = 101\n\n Ap = np.zeros((md, nd))\n Ae = np.zeros((md, nd))\n Aw = np.zeros((md, nd))\n An = np.zeros((md, nd))\n As = np.zeros((md, nd))\n bb = np.zeros((md, nd))\n\n u_stg = 0.0\n v_stg = 0.0\n\n for i in range(1, m + 1):\n for j in range(1, n + 1):\n ''' velocity u '''\n # convection_x (1st upwind scheme)\n u[i][j] = u_old[i][j]\\\n - dt * max(u_old[i][j], 0.0)\\\n * (u_old[i][j] - u_old[i - 1][j]) / dx\\\n - dt * min(u_old[i][j], 0.0)\\\n * (u_old[i + 1][j] - u_old[i][j]) / dx\n\n # convection_y\n # v_stg = 0.25 * (v_old[i][j] + v_old[i + 1][j] + v_old[i][j - 1]\n # + v_old[i + 1][j - 1]) # Staggered grid\n u[i][j] = u[i][j]\\\n - dt * max(v_old[i][j], 0.0)\\\n * (u_old[i][j] - u_old[i][j - 1]) / dy\\\n - dt * min(v_old[i][j], 0.0)\\\n * (u_old[i][j + 1] - u_old[i][j]) / dy\n\n # diffusion_x\n u[i][j] = u[i][j]\\\n + dt * nue * (u_old[i + 1][j] - 2 * u_old[i][j]\n + u_old[i - 1][j]) / dx**2\n\n # diffusion_y\n u[i][j] = u[i][j] \\\n + dt * nue * (u_old[i][j + 1] - 2 * u_old[i][j]\n + u_old[i][j - 1]) / dy**2\n\n ''' velocity v '''\n # convection_x (1st upwind scheme)\n # u_stg = 0.25 * (u_old[i][j] + u_old[i - 1][j] + u_old[i][j + 1]\n # + u_old[i - 1][j + 1]) # Staggered grid\n v[i][j] = v_old[i][j] \\\n - dt * max(u_old[i][j], 0.0) \\\n * (v_old[i][j] - v_old[i - 1][j]) / dx \\\n - dt * min(u_old[i][j], 0.0) \\\n * (v_old[i + 1][j] - v_old[i][j]) / dx\n\n # convection_y\n v[i][j] = v[i][j] \\\n - dt * max(v_old[i][j], 0.0) \\\n * (v_old[i][j] - v_old[i][j - 1]) / dy \\\n - dt * min(v_old[i][j], 0.0) \\\n * (v_old[i][j + 1] - v_old[i][j]) / dy\n\n # diffusion_x\n v[i][j] = v[i][j] \\\n + dt * nue * (v_old[i + 1][j] - 2 * v_old[i][j]\n + v_old[i - 1][j]) / dx**2\n\n # diffusion_y\n v[i][j] = v[i][j] \\\n + dt * nue * (v_old[i][j + 1] - 2 * v_old[i][j]\n + v_old[i][j - 1]) / dy**2\n\n ''' matrix solution '''\n for i in range(1, m + 1):\n for j in range(1, n + 1):\n Ae[i][j] = dt / density / dx**2\n Aw[i][j] = dt / density / dx**2\n An[i][j] = dt / density / dy**2\n As[i][j] = dt / density / dy**2\n Ap[i][j] = - Ae[i][j] - Aw[i][j] - An[i][j] - As[i][j]\n\n # bb[i][j] = (u[i][j] - u[i - 1][j]) / dx\\\n # + (v[i][j] - v[i][j - 1]) / dy\n bb[i][j] = (u[i + 1][j] - u[i - 1][j]) / dx / 2 \\\n + (v[i][j + 1] - v[i][j - 1]) / dy / 2\n\n condition.matrix_c(p, Ap, Ae, Aw, An, As, bb, m, n)\n solve_matrix(p, Ap, Ae, Aw, An, As, bb, m, n)\n\n return\n\n\ndef solve_u(p, u, density, dx, dt, m, n):\n for i in range(1, m + 1):\n for j in range(1, n + 1):\n # convection_x (1st upwind scheme) -> already calculated in solve_p\n # convection_y -> already calculated in solve_p\n # diffusion_x -> already calculated in solve_p\n # diffusion_y -> already calculated in solve_p\n # pressure\n # u[i][j] = u[i][j]\\\n # - dt / density * (p[i + 1][j] - p[i][j]) / dx\n u[i][j] = u[i][j] \\\n - dt / density * (p[i + 1][j] - p[i - 1][j]) / dx / 2\n\n\ndef solve_v(p, v, density, dy, dt, m, n):\n for i in range(1, m + 1):\n for j in range(1, n + 1):\n # convection_x (1st upwind scheme) -> already calculated in solve_p\n # convection_y -> already calculated in solve_p\n # diffusion_x -> already calculated in solve_p\n # diffusion_y -> already calculated in solve_p\n # pressure\n # v[i][j] = v[i][j] \\\n # - dt / density * (p[i][j + 1] - p[i][j]) / dy\n v[i][j] = v[i][j] \\\n - dt / density * (p[i][j + 1] - p[i][j - 1]) / dy / 2\n"
]
| [
[
"numpy.abs",
"numpy.zeros"
]
]
|
tigerwlin/vel | [
"00e4fbb7b612e888e2cbb5d8455146664638cd0b",
"00e4fbb7b612e888e2cbb5d8455146664638cd0b",
"00e4fbb7b612e888e2cbb5d8455146664638cd0b"
]
| [
"vel/openai/baselines/common/vec_env/dummy_vec_env.py",
"vel/rl/models/backbone/nature_cnn_two_tower.py",
"vel/models/rnn/multilayer_sequence_classification_gru.py"
]
| [
"import numpy as np\n# from gym import spaces\nfrom bc_gym_planning_env.envs.base import spaces\nfrom collections import OrderedDict\nfrom . import VecEnv\n\nclass DummyVecEnv(VecEnv):\n def __init__(self, env_fns):\n self.envs = [fn() for fn in env_fns]\n env = self.envs[0]\n VecEnv.__init__(self, len(env_fns), env.observation_space, env.action_space)\n shapes, dtypes = {}, {}\n self.keys = []\n obs_space = env.observation_space\n\n if isinstance(obs_space, spaces.Dict):\n assert isinstance(obs_space.spaces, OrderedDict)\n subspaces = obs_space.spaces\n else:\n subspaces = {None: obs_space}\n\n for key, box in subspaces.items():\n shapes[key] = box.shape\n dtypes[key] = box.dtype\n self.keys.append(key)\n\n self.buf_obs = { k: np.zeros((self.num_envs,) + tuple(shapes[k]), dtype=dtypes[k]) for k in self.keys }\n self.buf_dones = np.zeros((self.num_envs,), dtype=np.bool)\n self.buf_rews = np.zeros((self.num_envs,), dtype=np.float32)\n self.buf_infos = [{} for _ in range(self.num_envs)]\n self.actions = None\n\n def step_async(self, actions):\n self.actions = actions\n\n def step_wait(self):\n for e in range(self.num_envs):\n obs, self.buf_rews[e], self.buf_dones[e], self.buf_infos[e] = self.envs[e].step(self.actions)\n if self.buf_dones[e]:\n obs = self.envs[e].reset()\n self._save_obs(e, obs)\n return (self._obs_from_buf(), np.copy(self.buf_rews), np.copy(self.buf_dones),\n self.buf_infos.copy())\n\n def reset(self):\n for e in range(self.num_envs):\n obs = self.envs[e].reset()\n self._save_obs(e, obs)\n return self._obs_from_buf()\n\n def close(self):\n return\n\n def render(self, mode='human'):\n return [e.render(mode=mode) for e in self.envs]\n\n def _save_obs(self, e, obs):\n for k in self.keys:\n if k is None:\n self.buf_obs[k][e] = obs\n else:\n self.buf_obs[k][e] = obs[k]\n\n def _obs_from_buf(self):\n if self.keys==[None]:\n return self.buf_obs[None]\n else:\n return self.buf_obs\n",
"\"\"\"\nCode based loosely on implementation:\nhttps://github.com/openai/baselines/blob/master/baselines/ppo2/policies.py\n\nUnder MIT license.\n\"\"\"\nimport numpy as np\n\nimport torch\nimport torch.nn as nn\nimport torch.nn.init as init\nimport torch.nn.functional as F\n\nimport vel.util.network as net_util\nfrom vel.rl.models.backbone.CoordConv import CoordConv\n\nfrom vel.api.base import LinearBackboneModel, ModelFactory\n\n\nclass NatureCnnTwoTower(LinearBackboneModel):\n \"\"\" Neural network as defined in the paper 'Human-level control through deep reinforcement learning' \"\"\"\n def __init__(self, input_width, input_height, input_channels, output_dim=512):\n super().__init__()\n\n self._output_dim = output_dim\n\n # self.conv1 = nn.Conv2d(\n # in_channels=input_channels,\n # out_channels=32,\n # kernel_size=(8, 8),\n # stride=2\n # )\n self.conv1 = CoordConv(x_dim=133, y_dim=133, with_r=False,\n in_channels=input_channels+2,\n out_channels=32,\n kernel_size=(8, 8),\n stride=2\n )\n\n self.conv2 = nn.Conv2d(\n in_channels=32,\n out_channels=64,\n kernel_size=(4, 4),\n stride=2\n )\n\n self.conv3 = nn.Conv2d(\n in_channels=64,\n out_channels=64,\n kernel_size=(3, 3),\n stride=1\n )\n\n self.linear1 = nn.Linear(5, 1024)\n self.linear2 = nn.Linear(1024, 512)\n\n\n self.final_width = net_util.convolutional_layer_series(input_width, [\n (8, 0, 2),\n (4, 0, 2),\n (3, 0, 1)\n ])\n\n self.final_height = net_util.convolutional_layer_series(input_height, [\n (8, 0, 2),\n (4, 0, 2),\n (3, 0, 1)\n ])\n\n self.linear_layer1 = nn.Linear(\n self.final_width * self.final_height * 64*1 + 512, # 64 is the number of channels of the last conv layer\n 1024\n )\n self.linear_layer2 = nn.Linear(1024, self.output_dim)\n\n @property\n def output_dim(self) -> int:\n \"\"\" Final dimension of model output \"\"\"\n return self._output_dim\n\n def reset_weights(self):\n \"\"\" Call proper initializers for the weights \"\"\"\n for m in self.modules():\n if isinstance(m, nn.Conv2d):\n # init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')\n init.orthogonal_(m.weight, gain=np.sqrt(2))\n init.constant_(m.bias, 0.0)\n elif isinstance(m, nn.Linear):\n # init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')\n init.orthogonal_(m.weight, gain=np.sqrt(2))\n init.constant_(m.bias, 0.0)\n\n def forward(self, image):\n input1 = image['environment']\n input2 = image['goal'].float()\n result1 = input1.permute(0, 3, 1, 2).contiguous().type(torch.float) / 255.0\n result1 = F.relu(self.conv1(result1))\n result1 = F.relu(self.conv2(result1))\n result1 = F.relu(self.conv3(result1))\n\n result2 = input2.view(input2.size(0), -1)\n result2 = F.leaky_relu(self.linear1(result2))\n result2 = F.leaky_relu(self.linear2(result2))\n\n flattened1 = result1.view(result1.size(0), -1)\n flattened2 = result2.view(result2.size(0), -1)\n flattened = torch.cat((flattened1, flattened2), 1)\n\n result = F.leaky_relu(self.linear_layer1(flattened))\n result = F.leaky_relu(self.linear_layer2(result))\n return result\n\n\ndef create(input_width, input_height, input_channels=1, output_dim=512):\n def instantiate(**_):\n return NatureCnnTwoTower(\n input_width=input_width, input_height=input_height, input_channels=input_channels,\n output_dim=output_dim\n )\n\n return ModelFactory.generic(instantiate)\n\n\n# Add this to make nicer scripting interface\nNatureCnnTwoTowerFactory = create\n\n",
"import typing\n\nimport torch\nimport torch.nn.functional as F\nimport torch.nn as nn\n\nfrom vel.api.base import SupervisedModel, ModelFactory, LinearBackboneModel\nfrom vel.metrics.accuracy import Accuracy\nfrom vel.metrics.loss_metric import Loss\n\n\nclass MultilayerSequenceClassificationGRU(SupervisedModel):\n \"\"\" Multilayer GRU network for sequence modeling (n:1) \"\"\"\n\n def __init__(self, input_block: LinearBackboneModel, output_dim: int,\n rnn_layers: typing.List[int], rnn_dropout: float=0.0, bidirectional: bool=False,\n linear_layers: typing.List[int]=None, linear_dropout: float=0.0):\n super().__init__()\n\n self.output_dim = output_dim\n\n self.rnn_layers_sizes = rnn_layers\n self.rnn_dropout = rnn_dropout\n self.linear_layers_sizes = linear_layers\n self.linear_dropout = linear_dropout\n\n self.bidirectional = bidirectional\n self.input_block = input_block\n\n current_dim = self.input_block.output_dim\n\n self.rnn_layers = []\n self.rnn_dropout_layers = []\n\n bidirectional_multiplier = 1\n\n for idx, current_layer in enumerate(rnn_layers, 1):\n gru = nn.GRU(\n input_size=current_dim * bidirectional_multiplier,\n hidden_size=current_layer,\n bidirectional=bidirectional,\n batch_first=True,\n )\n\n self.add_module('gru{:02}'.format(idx), gru)\n self.rnn_layers.append(gru)\n\n if self.rnn_dropout > 0.0:\n dropout_layer = nn.Dropout(p=self.rnn_dropout)\n\n self.add_module('rnn_dropout{:02}'.format(idx), dropout_layer)\n self.rnn_dropout_layers.append(dropout_layer)\n\n current_dim = current_layer\n\n if self.bidirectional:\n bidirectional_multiplier = 2\n else:\n bidirectional_multiplier = 1\n\n self.linear_layers = []\n self.linear_dropout_layers = []\n\n for idx, current_layer in enumerate(linear_layers, 1):\n linear_layer = nn.Linear(current_dim * bidirectional_multiplier, current_layer)\n\n self.add_module('linear{:02}'.format(idx), linear_layer)\n self.linear_layers.append(linear_layer)\n\n if self.linear_dropout > 0.0:\n dropout_layer = nn.Dropout(p=self.linear_dropout)\n\n self.add_module('linear_dropout{:02}'.format(idx), dropout_layer)\n self.linear_dropout_layers.append(dropout_layer)\n\n bidirectional_multiplier = 1\n current_dim = current_layer\n\n if self.bidirectional:\n self.output_layer = nn.Linear(bidirectional_multiplier * current_dim, output_dim)\n else:\n self.output_layer = nn.Linear(current_dim, output_dim)\n\n self.output_activation = nn.LogSoftmax(dim=1)\n\n def reset_weights(self):\n self.input_block.reset_weights()\n\n for layer in self.linear_layers:\n nn.init.kaiming_normal_(layer.weight, nonlinearity='relu')\n nn.init.zeros_(layer.bias)\n\n nn.init.kaiming_normal_(self.output_layer.weight, nonlinearity='relu')\n nn.init.zeros_(self.output_layer.bias)\n\n def forward(self, sequence):\n \"\"\" Forward propagate batch of sequences through the network, without accounting for the state \"\"\"\n data = self.input_block(sequence)\n\n for idx in range(len(self.rnn_layers)):\n data, _ = self.rnn_layers[idx](data)\n\n if self.rnn_dropout_layers:\n data = self.rnn_dropout_layers[idx](data)\n\n # We are interested only in the last element of the sequence\n if self.bidirectional:\n last_hidden_size = self.rnn_layers_sizes[-1]\n data = torch.cat([data[:, -1, :last_hidden_size], data[:, 0, last_hidden_size:]], dim=1)\n else:\n data = data[:, -1]\n\n for idx in range(len(self.linear_layers_sizes)):\n data = F.relu(self.linear_layers[idx](data))\n\n if self.linear_dropout_layers:\n data = self.linear_dropout_layers[idx](data)\n\n data = self.output_layer(data)\n\n return self.output_activation(data)\n\n # def forward_state(self, sequence, state=None):\n # \"\"\" Forward propagate a sequence through the network accounting for the state \"\"\"\n # if state is None:\n # state = self.initial_state(sequence.size(0))\n #\n # data = self.input_layer(sequence)\n #\n # state_outputs = []\n #\n # # for layer_length, layer in zip(self.hidden_layers, self.gru_layers):\n # for idx in range(len(self.gru_layers)):\n # layer_length = self.hidden_layers[idx]\n #\n # # Partition hidden state, for each layer we have layer_length of h state and layer_length of c state\n # current_state = state[:, :, :layer_length]\n # state = state[:, :, layer_length:]\n #\n # # Propagate through the GRU state\n # data, new_h = self.gru_layers[idx](data, current_state)\n #\n # if self.dropout_layers:\n # data = self.dropout_layers[idx](data)\n #\n # state_outputs.append(new_h)\n #\n # output_data = self.output_activation(self.output_layer(data))\n #\n # concatenated_hidden_output = torch.cat(state_outputs, dim=2)\n #\n # return output_data, concatenated_hidden_output\n\n def get_layer_groups(self):\n return [\n self.input_block,\n self.rnn_layers,\n self.linear_layers,\n self.output_layer\n ]\n\n def initial_state(self, batch_size):\n \"\"\" Initial state of the network \"\"\"\n return torch.zeros(batch_size, 1, sum(self.rnn_layers_sizes))\n\n def loss_value(self, x_data, y_true, y_pred):\n \"\"\" Calculate a value of loss function \"\"\"\n return F.nll_loss(y_pred, y_true)\n\n def metrics(self) -> list:\n \"\"\" Set of metrics for this model \"\"\"\n return [Loss(), Accuracy()]\n\n\ndef create(input_block: LinearBackboneModel, output_dim: int,\n rnn_layers: typing.List[int], rnn_dropout: float=0.0, bidirectional: bool=False,\n linear_layers: typing.List[int]=None, linear_dropout: float=0.0):\n \"\"\" Vel creation function \"\"\"\n if linear_layers is None:\n linear_layers = []\n\n def instantiate(**_):\n return MultilayerSequenceClassificationGRU(\n input_block=input_block, output_dim=output_dim,\n rnn_layers=rnn_layers, rnn_dropout=rnn_dropout, bidirectional=bidirectional,\n linear_layers=linear_layers, linear_dropout=linear_dropout\n )\n\n return ModelFactory.generic(instantiate)\n"
]
| [
[
"numpy.copy",
"numpy.zeros"
],
[
"torch.nn.Linear",
"torch.cat",
"torch.nn.init.constant_",
"torch.nn.Conv2d",
"numpy.sqrt"
],
[
"torch.nn.LogSoftmax",
"torch.nn.Linear",
"torch.cat",
"torch.nn.Dropout",
"torch.nn.GRU",
"torch.nn.init.kaiming_normal_",
"torch.nn.functional.nll_loss",
"torch.nn.init.zeros_"
]
]
|
Smithsonian/Mass-Georeferencing | [
"bb7d81cd82684900003d3049764cd2d243325248"
]
| [
"old/shiny/match_localities/match_SI_GBIF.py"
]
| [
"#!/usr/bin/env python3\n#\n# Match SI GBIF records without coordinates to other GBIF records for the species/genus\n#\nimport psycopg2, os, logging, sys, locale, psycopg2.extras\nimport pandas as pd\nfrom time import localtime, strftime\nfrom fuzzywuzzy import fuzz\nimport pycountry\n\n\n#Import settings\nimport settings\n\n#Set locale for number format\nlocale.setlocale(locale.LC_ALL, 'en_US.UTF-8')\n\n\n\n#Get current time\ncurrent_time = strftime(\"%Y%m%d_%H%M%S\", localtime())\n\n# Set Logging\nif not os.path.exists('logs'):\n os.makedirs('logs')\n\nlogfile_name = 'logs/{}.log'.format(current_time)\n# from http://stackoverflow.com/a/9321890\nlogging.basicConfig(level=logging.DEBUG,\n format='%(asctime)s %(name)-12s %(levelname)-8s %(message)s',\n datefmt='%m-%d %H:%M:%S',\n filename=logfile_name,\n filemode='a')\nconsole = logging.StreamHandler()\nconsole.setLevel(logging.INFO)\nformatter = logging.Formatter('%(name)-12s: %(levelname)-8s %(message)s')\nconsole.setFormatter(formatter)\nlogging.getLogger('').addHandler(console)\nlogger1 = logging.getLogger(\"si_georef\")\n\n\n#search_fuzzy(record['locality'], record['stateprovince'], candidates, method = 'set', threshold = 80)\ndef search_fuzzy(locality, stateprovince, data, filter_stateprovince = True, method = 'partial', threshold = 80):\n \"\"\"Search localities in the databases for matches using fuzzywuzzy.\"\"\"\n try:\n int(threshold)\n except:\n print('invalid threshold value')\n sys.exit(1)\n #Check results\n if method == 'partial':\n data['score1'] = data.apply(lambda row : fuzz.partial_ratio(locality, row['name']), axis = 1)\n if filter_stateprovince == True:\n data['score2'] = data.apply(lambda row : fuzz.partial_ratio(stateprovince, row['stateprovince']), axis = 1)\n data['score'] = (data['score1'] + data['score2'])/2\n results = data.drop(columns = ['score1', 'score2'])\n else:\n data['score'] = data['score1']\n results = data.drop(columns = ['score1']) \n elif method == 'set':\n data['score1'] = data.apply(lambda row : fuzz.token_set_ratio(locality, row['name']), axis = 1)\n if filter_stateprovince == True:\n data['score2'] = data.apply(lambda row : fuzz.token_set_ratio(stateprovince, row['stateprovince']), axis = 1)\n data['score'] = (data['score1'] + data['score2'])/2\n results = data.drop(columns = ['score1', 'score2'])\n else:\n data['score'] = data['score1']\n results = data.drop(columns = ['score1']) \n results = results[results.score > threshold]\n #print(results)\n return results\n\n\n\n#Connect to the dpogis database\ntry:\n logger1.info(\"Connecting to the database.\")\n conn = psycopg2.connect(host = settings.pg_host, database = settings.pg_db, user = settings.pg_user, connect_timeout = 60)\nexcept:\n print(\" ERROR: Could not connect to server.\")\n sys.exit(1)\n\nconn.autocommit = True\ncur = conn.cursor(cursor_factory = psycopg2.extras.RealDictCursor)\n\n\nif len(sys.argv) > 1:\n arg = sys.argv[1]\n if arg == \"plants\":\n sel_species = \"SELECT species, kingdom, phylum, class, _order, family, genus FROM gbif_si WHERE species != '' AND decimallatitude is null and decimallongitude is null AND locality != '' AND phylum = 'Tracheophyta' GROUP BY species, kingdom, phylum, class, _order, family, genus\"\n #sel_species = \"SELECT DISTINCT species FROM gbif_si WHERE species != '' AND ((decimallatitude is null and decimallongitude is null) OR (georeferenceprotocol LIKE '%%unknown%%') OR (locality != '')) AND phylum = 'Tracheophyta'\"\n elif arg == \"birds\":\n sel_species = \"SELECT species, kingdom, phylum, class, _order, family, genus FROM gbif_si WHERE species != '' AND decimallatitude is null and decimallongitude is null AND locality != '' AND class = 'Aves' GROUP BY species, kingdom, phylum, class, _order, family, genus\"\n elif arg == \"mammals\":\n sel_species = \"SELECT species, kingdom, phylum, class, _order, family, genus FROM gbif_si WHERE species != '' AND decimallatitude is null and decimallongitude is null AND locality != '' AND class = 'Mammalia' GROUP BY species, kingdom, phylum, class, _order, family, genus\"\n elif arg == \"reptiles\":\n sel_species = \"SELECT species, kingdom, phylum, class, _order, family, genus FROM gbif_si WHERE species != '' AND decimallatitude is null and decimallongitude is null AND locality != '' AND class = 'Reptilia' GROUP BY species, kingdom, phylum, class, _order, family, genus\"\n elif arg == \"amphibians\":\n sel_species = \"SELECT species, kingdom, phylum, class, _order, family, genus FROM gbif_si WHERE species != '' AND decimallatitude is null and decimallongitude is null AND locality != '' AND class = 'Amphibia' GROUP BY species, kingdom, phylum, class, _order, family, genus\"\n elif arg == \"bivalves\":\n sel_species = \"SELECT species, kingdom, phylum, class, _order, family, genus FROM gbif_si WHERE species != '' AND decimallatitude is null and decimallongitude is null AND locality != '' AND basisofrecord = 'FOSSIL_SPECIMEN' AND class = 'Bivalvia' GROUP BY species, kingdom, phylum, class, _order, family, genus\"\n elif arg == \"gastropods\":\n sel_species = \"SELECT species, kingdom, phylum, class, _order, family, genus FROM gbif_si WHERE species != '' AND decimallatitude is null and decimallongitude is null AND locality != '' AND basisofrecord = 'FOSSIL_SPECIMEN' AND class = 'Gastropoda' GROUP BY species, kingdom, phylum, class, _order, family, genus\"\n elif arg == \"crabs\":\n sel_species = \"SELECT species, kingdom, phylum, class, _order, family, genus FROM gbif_si WHERE species != '' AND decimallatitude is null and decimallongitude is null AND locality != '' AND basisofrecord = 'FOSSIL_SPECIMEN' AND class = 'Malacostraca' GROUP BY species, kingdom, phylum, class, _order, family, genus\"\n elif arg == \"echinoids\":\n sel_species = \"SELECT species, kingdom, phylum, class, _order, family, genus FROM gbif_si WHERE species != '' AND decimallatitude is null and decimallongitude is null AND locality != '' AND basisofrecord = 'FOSSIL_SPECIMEN' AND class = 'Echinoidea' GROUP BY species, kingdom, phylum, class, _order, family, genus\"\n elif arg == \"iz\":\n sel_species = \"SELECT species, kingdom, phylum, class, _order, family, genus FROM gbif_si WHERE species != '' AND decimallatitude is null and decimallongitude is null AND locality != '' AND family = 'Unionidae' GROUP BY species, kingdom, phylum, class, _order, family, genus\"\n else:\n print(\"Invalid argument\")\n sys.exit(1)\n\n\n\n#Select species\ncur.execute(sel_species)\nlogger1.debug(cur.query)\nscinames = cur.fetchall()\n\n\n\nfor sciname in scinames:\n cur.execute(\"DELETE FROM gbif_si_matches WHERE species = %s\", (sciname['species'],))\n logger1.debug(cur.query)\n cur.execute(\"DELETE FROM gbif_si_summary WHERE species = %(species)s AND kingdom = %(kingdom)s AND phylum = %(phylum)s AND class = %(class)s AND _order = %(_order)s AND family = %(family)s AND genus = %(genus)s\", {'species': sciname['species'], 'kingdom': sciname['kingdom'], 'phylum': sciname['phylum'], 'class': sciname['class'], '_order': sciname['_order'], 'family': sciname['family'], 'genus': sciname['genus']})\n logger1.debug(cur.query)\n\n\n\n#search_fuzzy(locality, scientificname, countrycode, db, cur, rank = 'species', method = 'partial', threshold = 80):\n#Loop the species\nfor sciname in scinames:\n logger1.info(\"sciname: {}\".format(sciname['species']))\n \n #Get countries\n cur.execute(\"SELECT countrycode FROM gbif_si WHERE species = %s AND decimallatitude is null and decimallongitude is null AND lower(locality) != 'unknown' AND locality != '' GROUP BY countrycode\", (sciname['species'],))\n logger1.debug(cur.query)\n countries = cur.fetchall()\n for country in countries:\n #Get records for the country\n cur.execute(\"SELECT MAX(gbifid::bigint)::text as gbifid, countrycode, stateprovince, locality, kingdom, phylum, class, _order, family, genus FROM gbif_si WHERE species = %(species)s AND countrycode = %(countrycode)s AND decimallatitude is null and decimallongitude is null AND lower(locality) != 'unknown' AND locality != '' GROUP BY countrycode, stateprovince, locality, kingdom, phylum, class, _order, family, genus\", {'species': sciname['species'], 'countrycode': country['countrycode']})\n logger1.debug(cur.query)\n records = pd.DataFrame(cur.fetchall())\n ################\n #Get candidates\n ################\n #GBIF - species\n logger1.info(\"GBIF: {}\".format(country['countrycode']))\n query_template = \"SELECT MAX(gbifid::bigint)::text as uid, locality as name, count(*) as no_records, countrycode, trim(leading ', ' from replace(municipality || ', ' || county || ', ' || stateprovince || ', ' || countrycode, ', , ', '')) as located_at, stateprovince, recordedBy FROM gbif WHERE {rank} = '{scientificname}' AND lower(locality) != 'unknown' AND countrycode = '{countrycode}' GROUP BY countrycode, locality, municipality, county, stateprovince, recordedBy\"\n cur.execute(query_template.format(rank = 'species', scientificname = sciname['species'], countrycode = country['countrycode']))\n logger1.debug(cur.query)\n candidates = pd.DataFrame(cur.fetchall())\n logger1.info(\"No. of GBIF candidates: {}\".format(len(candidates)))\n if len(candidates) > 0:\n #Iterate each record\n for index, record in records.iterrows():\n logger1.info(\"record gbifid: {}\".format(record['gbifid']))\n logger1.info(\"locality: {}, {}, {}\".format(record['locality'], record['stateprovince'], record['countrycode']))\n if record['stateprovince'] == '':\n data = search_fuzzy(record['locality'], record['stateprovince'], candidates, filter_stateprovince = False, method = 'set', threshold = 80)\n else:\n data = search_fuzzy(record['locality'], record['stateprovince'], candidates, filter_stateprovince = True, method = 'set', threshold = 80)\n logger1.info(\"No. of possible matches: {}\".format(len(data)))\n if len(data) > 0:\n for index, row in data.iterrows():\n cur.execute(\"\"\"INSERT INTO gbif_si_matches (gbifid, source, no_records, species, match, score, located_at, timestamp) VALUES \n (%(gbifid)s, %(source)s, %(no_records)s, %(species)s, %(match)s, %(score)s, %(located_at)s, NOW())\"\"\", {'gbifid': record['gbifid'], 'source': 'gbif.species', 'no_records': str(row['no_records']), 'species': sciname['species'], 'match': str(row['uid']), 'score': row['score'], 'located_at': row['located_at']})\n logger1.debug(cur.query)\n #GBIF - genus\n logger1.info(\"GBIF genus: {}\".format(country['countrycode']))\n query_template = \"SELECT MAX(gbifid::bigint)::text as uid, locality as name, count(*) as no_records, countrycode, trim(leading ', ' from replace(municipality || ', ' || county || ', ' || stateprovince || ', ' || countrycode, ', , ', '')) as located_at, stateprovince, recordedBy FROM gbif WHERE {rank} = '{genus}' AND species != '{scientificname}' AND lower(locality) != 'unknown' AND countrycode = '{countrycode}' GROUP BY countrycode, locality, municipality, county, stateprovince, recordedBy\"\n cur.execute(query_template.format(rank = 'genus', genus = sciname['genus'], scientificname = sciname['species'], countrycode = country['countrycode']))\n logger1.debug(cur.query)\n candidates = pd.DataFrame(cur.fetchall())\n logger1.info(\"No. of GBIF candidates: {}\".format(len(candidates)))\n if len(candidates) > 0:\n #Iterate each record\n for index, record in records.iterrows():\n logger1.info(\"record gbifid: {}\".format(record['gbifid']))\n logger1.info(\"locality: {}, {}, {}\".format(record['locality'], record['stateprovince'], record['countrycode']))\n if record['stateprovince'] == '':\n data = search_fuzzy(record['locality'], record['stateprovince'], candidates, filter_stateprovince = False, method = 'set', threshold = 80)\n else:\n data = search_fuzzy(record['locality'], record['stateprovince'], candidates, filter_stateprovince = True, method = 'set', threshold = 80)\n logger1.info(\"No. of possible matches: {}\".format(len(data)))\n if len(data) > 0:\n for index, row in data.iterrows():\n cur.execute(\"\"\"INSERT INTO gbif_si_matches (gbifid, source, no_records, species, match, score, located_at, timestamp) VALUES \n (%(gbifid)s, %(source)s, %(no_records)s, %(species)s, %(match)s, %(score)s, %(located_at)s, NOW())\"\"\", {'gbifid': record['gbifid'], 'source': 'gbif.genus', 'no_records': str(row['no_records']), 'species': sciname['species'], 'match': str(row['uid']), 'score': row['score'], 'located_at': row['located_at']})\n logger1.debug(cur.query)\n ######################\n #WDPA\n logger1.info(\"WDPA: {}\".format(country['countrycode']))\n if pycountry.countries.get(alpha_2 = record['countrycode']) != None:\n iso = pycountry.countries.get(alpha_2 = record['countrycode']).alpha_3\n query_template = \"\"\"\n SELECT uid, name, gadm2 as stateprovince, 'wdpa_polygons' as source FROM wdpa_polygons WHERE parent_iso = '{iso}' AND lower(name) != 'unknown'\n UNION \n SELECT uid, orig_name AS name, gadm2 as stateprovince, 'wdpa_polygons' as source FROM wdpa_polygons WHERE parent_iso = '{iso}' AND lower(name) != 'unknown'\n UNION \n SELECT uid, name, gadm2 as stateprovince, 'wdpa_points' as source FROM wdpa_points WHERE parent_iso = '{iso}' AND lower(name) != 'unknown'\n UNION \n SELECT uid, orig_name AS name, gadm2 as stateprovince, 'wdpa_points' as source FROM wdpa_points WHERE parent_iso = '{iso}' AND lower(name) != 'unknown'\n \"\"\"\n cur.execute(query_template.format(iso = iso))\n logger1.debug(cur.query)\n candidates = pd.DataFrame(cur.fetchall())\n logger1.info(\"No. of WDPA candidates: {}\".format(len(candidates)))\n if len(candidates) > 0:\n #Iterate each record\n for index, record in records.iterrows():\n logger1.info(\"record gbifid: {}\".format(record['gbifid']))\n logger1.info(\"locality: {}, {}, {}\".format(record['locality'], record['stateprovince'], record['countrycode']))\n data = search_fuzzy(record['locality'], record['stateprovince'], candidates, method = 'set', threshold = 80)\n logger1.info(\"No. of possible matches: {}\".format(len(data)))\n if len(data) > 0:\n for index, row in data.iterrows():\n cur.execute(\"\"\"INSERT INTO gbif_si_matches (gbifid, source, species, match, score, located_at, timestamp) VALUES \n (%(gbifid)s, %(source)s, %(species)s, %(match)s, %(score)s, %(stateprovince)s, NOW())\"\"\", {'gbifid': record['gbifid'], 'source': row['source'], 'species': sciname['species'], 'match': str(row['uid']), 'score': row['score'], 'stateprovince': row['stateprovince']})\n logger1.debug(cur.query)\n ######################\n #GADM\n logger1.info(\"GADM: {}\".format(country['countrycode']))\n if pycountry.countries.get(alpha_2 = record['countrycode']) != None:\n country = pycountry.countries.get(alpha_2 = record['countrycode']).name\n #GADM1\n query_template = \"SELECT uid, name_1 as name, name_0 as stateprovince, 'gadm1' as source FROM gadm1 WHERE name_0 = '{country}' UNION SELECT uid, varname_1 as name, name_0 as stateprovince, 'gadm1' as source FROM gadm1 WHERE name_0 = '{country}' AND varname_1 IS NOT NULL\"\n cur.execute(query_template.format(country = country.replace(\"'\", \"''\")))\n data = pd.DataFrame(cur.fetchall())\n #GADM2\n query_template = \"SELECT uid, name_2 as name, name_1 || ', ' || name_0 as stateprovince, 'gadm2' as source FROM gadm2 WHERE name_0 = '{country}' UNION SELECT uid, varname_2 as name, name_1 || ', ' || name_0 as stateprovince, 'gadm2' as source FROM gadm2 WHERE name_0 = '{country}' AND varname_2 IS NOT NULL\"\n cur.execute(query_template.format(country = country.replace(\"'\", \"''\")))\n data1 = pd.DataFrame(cur.fetchall())\n data = pd.concat([data, data1], ignore_index=True)\n #GADM3\n query_template = \"SELECT uid, name_3 as name, name_2 || ', ' || name_1 || ', ' || name_0 as stateprovince, 'gadm3' as source FROM gadm3 WHERE name_0 = '{country}' UNION SELECT uid, varname_3 as name, name_2 || ', ' || name_1 || ', ' || name_0 as stateprovince, 'gadm3' as source FROM gadm3 WHERE name_0 = '{country}' AND varname_3 IS NOT NULL\"\n cur.execute(query_template.format(country = country.replace(\"'\", \"''\")))\n data1 = pd.DataFrame(cur.fetchall())\n data = pd.concat([data, data1], ignore_index=True)\n #GADM4\n query_template = \"SELECT uid, name_4 as name, name_3 || ', ' || name_2 || ', ' || name_1 || ', ' || name_0 as stateprovince, 'gadm4' as source FROM gadm4 WHERE name_0 = '{country}' UNION SELECT uid, varname_4 as name, name_3 || ', ' || name_2 || ', ' || name_1 || ', ' || name_0 as stateprovince, 'gadm4' as source FROM gadm4 WHERE name_0 = '{country}' AND varname_4 IS NOT NULL\"\n cur.execute(query_template.format(country = country.replace(\"'\", \"''\")))\n data1 = pd.DataFrame(cur.fetchall())\n data = pd.concat([data, data1], ignore_index=True)\n #GADM5\n query_template = \"SELECT uid, name_5 as name, name_4 || ', ' || name_3 || ', ' || name_2 || ', ' || name_1 || ', ' || name_0 as stateprovince, 'gadm5' as source FROM gadm5 WHERE name_0 = '{country}'\"\n cur.execute(query_template.format(country = country.replace(\"'\", \"''\")))\n data1 = pd.DataFrame(cur.fetchall())\n candidates = pd.concat([data, data1], ignore_index=True)\n logger1.info(\"No. of GADM candidates: {}\".format(len(candidates)))\n if len(candidates) > 0:\n #Iterate each record\n for index, record in records.iterrows():\n logger1.info(\"record gbifid: {}\".format(record['gbifid']))\n logger1.info(\"locality: {}, {}, {}\".format(record['locality'], record['stateprovince'], record['countrycode']))\n data = search_fuzzy(record['locality'], record['stateprovince'], candidates, method = 'set', threshold = 80)\n logger1.info(\"No. of possible matches: {}\".format(len(data)))\n if len(data) > 0:\n for index, row in data.iterrows():\n cur.execute(\"\"\"INSERT INTO gbif_si_matches (gbifid, source, species, match, score, located_at, timestamp) VALUES \n (%(gbifid)s, %(source)s, %(species)s, %(match)s, %(score)s, %(stateprovince)s, NOW())\"\"\", {'gbifid': record['gbifid'], 'source': row['source'], 'species': sciname['species'], 'match': str(row['uid']), 'score': row['score'], 'stateprovince': row['stateprovince']})\n logger1.debug(cur.query)\n ######################\n #Geonames\n # if record['countrycode'] != None:\n # query_template = \"\"\"\n # SELECT uid, name, gadm2 as stateprovince, 'geonames' as source FROM geonames WHERE country_code = '{countrycode}'\n # UNION\n # SELECT uid, unnest(string_to_array(alternatenames, ',')) as name, gadm2 as stateprovince, 'geonames' as source FROM geonames WHERE country_code = '{countrycode}'\n # \"\"\"\n # cur.execute(query_template.format(countrycode = record['countrycode']))\n # logger1.debug(cur.query)\n # candidates = pd.DataFrame(cur.fetchall())\n # logger1.info(\"No. of candidates: {}\".format(len(candidates)))\n # if len(candidates) > 0:\n # #Iterate each record\n # for index, record in records.iterrows():\n # logger1.info(\"locality: {}, {}, {}\".format(record['locality'], record['stateprovince'], record['countrycode']))\n # data = search_fuzzy(record['locality'], record['stateprovince'], candidates, method = 'set', threshold = 80)\n # for index, row in data.iterrows():\n # cur.execute(\"\"\"INSERT INTO gbif_si_matches (gbifid, source, species, match, score, located_at, timestamp) VALUES \n # (%(gbifid)s, %(source)s, %(species)s, %(match)s, %(score)s, %(stateprovince)s, NOW())\"\"\", {'gbifid': record['gbifid'], 'source': row['source'], 'species': sciname['species'], 'match': str(row['uid']), 'score': row['score'], 'stateprovince': row['stateprovince']})\n # logger1.debug(cur.query)\n ######################\n #GNIS\n if record['countrycode'] == 'US':\n logger1.info(\"GNIS: {}, US\".format(record['stateprovince']))\n query_template = \"SELECT uid, feature_name as name, gadm2 as stateprovince, 'gnis' as source FROM gnis WHERE state_alpha ILIKE '%{stateprovince}%'\"\n cur.execute(query_template.format(stateprovince = record['stateprovince']))\n logger1.debug(cur.query)\n candidates = pd.DataFrame(cur.fetchall())\n logger1.info(\"No. of GNIS candidates: {}\".format(len(candidates)))\n if len(candidates) > 0:\n #Iterate each record\n for index, record in records.iterrows():\n logger1.info(\"record gbifid: {}\".format(record['gbifid']))\n logger1.info(\"locality: {}, {}, {}\".format(record['locality'], record['stateprovince'], record['countrycode']))\n data = search_fuzzy(record['locality'], record['stateprovince'], candidates, method = 'set', threshold = 80)\n logger1.info(\"No. of possible matches: {}\".format(len(data)))\n if len(data) > 0:\n for index, row in data.iterrows():\n cur.execute(\"\"\"INSERT INTO gbif_si_matches (gbifid, source, species, match, score, located_at, timestamp) VALUES \n (%(gbifid)s, %(source)s, %(species)s, %(match)s, %(score)s, %(stateprovince)s, NOW())\"\"\", {'gbifid': record['gbifid'], 'source': row['source'], 'species': sciname['species'], 'match': str(row['uid']), 'score': row['score'], 'stateprovince': row['stateprovince']})\n logger1.debug(cur.query)\n #############\n #Lakes\n if pycountry.countries.get(alpha_2 = record['countrycode']) != None:\n country = pycountry.countries.get(alpha_2 = record['countrycode']).name\n logger1.info(\"Lakes: {}\".format(country.replace(\"'\", \"''\")))\n query_template = \"SELECT uid, lake_name as name, gadm2 as stateprovince, 'global_lakes' as source FROM global_lakes WHERE country ILIKE '%{country}%'\"\n cur.execute(query_template.format(country = country.replace(\"'\", \"''\")))\n logger1.debug(cur.query)\n else:\n query_template = \"SELECT uid, lake_name as name, gadm2 as stateprovince, 'global_lakes' as source FROM global_lakes\"\n cur.execute(query_template)\n candidates = pd.DataFrame(cur.fetchall())\n logger1.info(\"No. of global_lakes candidates: {}\".format(len(candidates)))\n if len(candidates) > 0:\n #Iterate each record\n for index, record in records.iterrows():\n logger1.info(\"record gbifid: {}\".format(record['gbifid']))\n logger1.info(\"locality: {}, {}, {}\".format(record['locality'], record['stateprovince'], record['countrycode']))\n data = search_fuzzy(record['locality'], record['stateprovince'], candidates, method = 'set', threshold = 80)\n logger1.info(\"No. of possible matches: {}\".format(len(data)))\n if len(data) > 0:\n for index, row in data.iterrows():\n cur.execute(\"\"\"INSERT INTO gbif_si_matches (gbifid, source, species, match, score, located_at, timestamp) VALUES \n (%(gbifid)s, %(source)s, %(species)s, %(match)s, %(score)s, %(stateprovince)s, NOW())\"\"\", {'gbifid': record['gbifid'], 'source': row['source'], 'species': sciname['species'], 'match': str(row['uid']), 'score': row['score'], 'stateprovince': row['stateprovince']})\n logger1.debug(cur.query)\n #Save summary of results\n cur.execute(\"SELECT count(*) as no_records FROM gbif_si_matches WHERE species = %s\", (sciname['species'],))\n logger1.debug(cur.query)\n no_records = cur.fetchone()\n if no_records['no_records'] > 0:\n cur.execute(\"\"\"INSERT INTO gbif_si_summary (species, kingdom, phylum, class, _order, family, genus, no_records) \n (SELECT %(species)s, %(kingdom)s, %(phylum)s, %(class)s, %(_order)s, %(family)s, %(genus)s, count(*) FROM gbif_si_matches where species = %(species)s);\"\"\", {'species': sciname['species'], 'kingdom': sciname['kingdom'], 'phylum': sciname['phylum'], 'class': sciname['class'], '_order': sciname['_order'], 'family': sciname['family'], 'genus': sciname['genus']})\n logger1.debug(cur.query)\n cur.execute(\"DELETE FROM gbif_si_summary WHERE no_records = 0\")\n \n\n\n\nsys.exit(0)"
]
| [
[
"pandas.concat"
]
]
|
OliviaNabbosa89/Disaster_Responses | [
"1e66d77c303cec685dfc2ca94f4fca4cc9400570",
"1e66d77c303cec685dfc2ca94f4fca4cc9400570",
"1e66d77c303cec685dfc2ca94f4fca4cc9400570",
"1e66d77c303cec685dfc2ca94f4fca4cc9400570",
"1e66d77c303cec685dfc2ca94f4fca4cc9400570",
"1e66d77c303cec685dfc2ca94f4fca4cc9400570",
"1e66d77c303cec685dfc2ca94f4fca4cc9400570",
"1e66d77c303cec685dfc2ca94f4fca4cc9400570",
"1e66d77c303cec685dfc2ca94f4fca4cc9400570",
"1e66d77c303cec685dfc2ca94f4fca4cc9400570",
"1e66d77c303cec685dfc2ca94f4fca4cc9400570",
"1e66d77c303cec685dfc2ca94f4fca4cc9400570",
"1e66d77c303cec685dfc2ca94f4fca4cc9400570",
"1e66d77c303cec685dfc2ca94f4fca4cc9400570",
"1e66d77c303cec685dfc2ca94f4fca4cc9400570",
"1e66d77c303cec685dfc2ca94f4fca4cc9400570"
]
| [
"venv/Lib/site-packages/pandas/tests/series/test_analytics.py",
"venv/Lib/site-packages/sklearn/decomposition/_nmf.py",
"venv/Lib/site-packages/sklearn/utils/tests/test_testing.py",
"venv/Lib/site-packages/pandas/tests/base/test_factorize.py",
"venv/Lib/site-packages/sklearn/utils/metaestimators.py",
"venv/Lib/site-packages/pandas/tests/io/formats/test_eng_formatting.py",
"venv/Lib/site-packages/pandas/tests/series/apply/test_series_apply.py",
"venv/Lib/site-packages/pandas/tests/indexes/timedeltas/test_setops.py",
"venv/Lib/site-packages/pandas/tests/tslibs/test_parsing.py",
"venv/Lib/site-packages/pandas/tests/scalar/interval/test_ops.py",
"venv/Lib/site-packages/sklearn/model_selection/_validation.py",
"venv/Lib/site-packages/pandas/tests/series/methods/test_fillna.py",
"venv/Lib/site-packages/pandas/core/arrays/sparse/dtype.py",
"venv/Lib/site-packages/pandas/tests/series/methods/test_searchsorted.py",
"venv/Lib/site-packages/pandas/tests/indexes/ranges/test_range.py",
"venv/Lib/site-packages/sklearn/ensemble/tests/test_iforest.py"
]
| [
"import operator\r\n\r\nimport numpy as np\r\nimport pytest\r\n\r\nimport pandas.util._test_decorators as td\r\n\r\nimport pandas as pd\r\nfrom pandas import DataFrame, Series\r\nimport pandas._testing as tm\r\n\r\n\r\nclass TestSeriesAnalytics:\r\n def test_prod_numpy16_bug(self):\r\n s = Series([1.0, 1.0, 1.0], index=range(3))\r\n result = s.prod()\r\n\r\n assert not isinstance(result, Series)\r\n\r\n def test_matmul(self):\r\n # matmul test is for GH #10259\r\n a = Series(np.random.randn(4), index=[\"p\", \"q\", \"r\", \"s\"])\r\n b = DataFrame(\r\n np.random.randn(3, 4), index=[\"1\", \"2\", \"3\"], columns=[\"p\", \"q\", \"r\", \"s\"]\r\n ).T\r\n\r\n # Series @ DataFrame -> Series\r\n result = operator.matmul(a, b)\r\n expected = Series(np.dot(a.values, b.values), index=[\"1\", \"2\", \"3\"])\r\n tm.assert_series_equal(result, expected)\r\n\r\n # DataFrame @ Series -> Series\r\n result = operator.matmul(b.T, a)\r\n expected = Series(np.dot(b.T.values, a.T.values), index=[\"1\", \"2\", \"3\"])\r\n tm.assert_series_equal(result, expected)\r\n\r\n # Series @ Series -> scalar\r\n result = operator.matmul(a, a)\r\n expected = np.dot(a.values, a.values)\r\n tm.assert_almost_equal(result, expected)\r\n\r\n # GH 21530\r\n # vector (1D np.array) @ Series (__rmatmul__)\r\n result = operator.matmul(a.values, a)\r\n expected = np.dot(a.values, a.values)\r\n tm.assert_almost_equal(result, expected)\r\n\r\n # GH 21530\r\n # vector (1D list) @ Series (__rmatmul__)\r\n result = operator.matmul(a.values.tolist(), a)\r\n expected = np.dot(a.values, a.values)\r\n tm.assert_almost_equal(result, expected)\r\n\r\n # GH 21530\r\n # matrix (2D np.array) @ Series (__rmatmul__)\r\n result = operator.matmul(b.T.values, a)\r\n expected = np.dot(b.T.values, a.values)\r\n tm.assert_almost_equal(result, expected)\r\n\r\n # GH 21530\r\n # matrix (2D nested lists) @ Series (__rmatmul__)\r\n result = operator.matmul(b.T.values.tolist(), a)\r\n expected = np.dot(b.T.values, a.values)\r\n tm.assert_almost_equal(result, expected)\r\n\r\n # mixed dtype DataFrame @ Series\r\n a[\"p\"] = int(a.p)\r\n result = operator.matmul(b.T, a)\r\n expected = Series(np.dot(b.T.values, a.T.values), index=[\"1\", \"2\", \"3\"])\r\n tm.assert_series_equal(result, expected)\r\n\r\n # different dtypes DataFrame @ Series\r\n a = a.astype(int)\r\n result = operator.matmul(b.T, a)\r\n expected = Series(np.dot(b.T.values, a.T.values), index=[\"1\", \"2\", \"3\"])\r\n tm.assert_series_equal(result, expected)\r\n\r\n msg = r\"Dot product shape mismatch, \\(4,\\) vs \\(3,\\)\"\r\n # exception raised is of type Exception\r\n with pytest.raises(Exception, match=msg):\r\n a.dot(a.values[:3])\r\n msg = \"matrices are not aligned\"\r\n with pytest.raises(ValueError, match=msg):\r\n a.dot(b.T)\r\n\r\n def test_ptp(self):\r\n # GH21614\r\n N = 1000\r\n arr = np.random.randn(N)\r\n ser = Series(arr)\r\n assert np.ptp(ser) == np.ptp(arr)\r\n\r\n def test_repeat(self):\r\n s = Series(np.random.randn(3), index=[\"a\", \"b\", \"c\"])\r\n\r\n reps = s.repeat(5)\r\n exp = Series(s.values.repeat(5), index=s.index.values.repeat(5))\r\n tm.assert_series_equal(reps, exp)\r\n\r\n to_rep = [2, 3, 4]\r\n reps = s.repeat(to_rep)\r\n exp = Series(s.values.repeat(to_rep), index=s.index.values.repeat(to_rep))\r\n tm.assert_series_equal(reps, exp)\r\n\r\n def test_numpy_repeat(self):\r\n s = Series(np.arange(3), name=\"x\")\r\n expected = Series(s.values.repeat(2), name=\"x\", index=s.index.values.repeat(2))\r\n tm.assert_series_equal(np.repeat(s, 2), expected)\r\n\r\n msg = \"the 'axis' parameter is not supported\"\r\n with pytest.raises(ValueError, match=msg):\r\n np.repeat(s, 2, axis=0)\r\n\r\n def test_is_monotonic(self):\r\n\r\n s = Series(np.random.randint(0, 10, size=1000))\r\n assert not s.is_monotonic\r\n s = Series(np.arange(1000))\r\n assert s.is_monotonic is True\r\n assert s.is_monotonic_increasing is True\r\n s = Series(np.arange(1000, 0, -1))\r\n assert s.is_monotonic_decreasing is True\r\n\r\n s = Series(pd.date_range(\"20130101\", periods=10))\r\n assert s.is_monotonic is True\r\n assert s.is_monotonic_increasing is True\r\n s = Series(list(reversed(s.tolist())))\r\n assert s.is_monotonic is False\r\n assert s.is_monotonic_decreasing is True\r\n\r\n @pytest.mark.parametrize(\"func\", [np.any, np.all])\r\n @pytest.mark.parametrize(\"kwargs\", [dict(keepdims=True), dict(out=object())])\r\n @td.skip_if_np_lt(\"1.15\")\r\n def test_validate_any_all_out_keepdims_raises(self, kwargs, func):\r\n s = pd.Series([1, 2])\r\n param = list(kwargs)[0]\r\n name = func.__name__\r\n\r\n msg = (\r\n f\"the '{param}' parameter is not \"\r\n \"supported in the pandas \"\r\n fr\"implementation of {name}\\(\\)\"\r\n )\r\n with pytest.raises(ValueError, match=msg):\r\n func(s, **kwargs)\r\n\r\n @td.skip_if_np_lt(\"1.15\")\r\n def test_validate_sum_initial(self):\r\n s = pd.Series([1, 2])\r\n msg = (\r\n r\"the 'initial' parameter is not \"\r\n r\"supported in the pandas \"\r\n r\"implementation of sum\\(\\)\"\r\n )\r\n with pytest.raises(ValueError, match=msg):\r\n np.sum(s, initial=10)\r\n\r\n def test_validate_median_initial(self):\r\n s = pd.Series([1, 2])\r\n msg = (\r\n r\"the 'overwrite_input' parameter is not \"\r\n r\"supported in the pandas \"\r\n r\"implementation of median\\(\\)\"\r\n )\r\n with pytest.raises(ValueError, match=msg):\r\n # It seems like np.median doesn't dispatch, so we use the\r\n # method instead of the ufunc.\r\n s.median(overwrite_input=True)\r\n\r\n @td.skip_if_np_lt(\"1.15\")\r\n def test_validate_stat_keepdims(self):\r\n s = pd.Series([1, 2])\r\n msg = (\r\n r\"the 'keepdims' parameter is not \"\r\n r\"supported in the pandas \"\r\n r\"implementation of sum\\(\\)\"\r\n )\r\n with pytest.raises(ValueError, match=msg):\r\n np.sum(s, keepdims=True)\r\n\r\n def test_td64_summation_overflow(self):\r\n # GH 9442\r\n s = pd.Series(pd.date_range(\"20130101\", periods=100000, freq=\"H\"))\r\n s[0] += pd.Timedelta(\"1s 1ms\")\r\n\r\n # mean\r\n result = (s - s.min()).mean()\r\n expected = pd.Timedelta((pd.TimedeltaIndex((s - s.min())).asi8 / len(s)).sum())\r\n\r\n # the computation is converted to float so\r\n # might be some loss of precision\r\n assert np.allclose(result.value / 1000, expected.value / 1000)\r\n\r\n # sum\r\n msg = \"overflow in timedelta operation\"\r\n with pytest.raises(ValueError, match=msg):\r\n (s - s.min()).sum()\r\n\r\n s1 = s[0:10000]\r\n with pytest.raises(ValueError, match=msg):\r\n (s1 - s1.min()).sum()\r\n s2 = s[0:1000]\r\n (s2 - s2.min()).sum()\r\n",
"\"\"\" Non-negative matrix factorization.\r\n\"\"\"\r\n# Author: Vlad Niculae\r\n# Lars Buitinck\r\n# Mathieu Blondel <[email protected]>\r\n# Tom Dupre la Tour\r\n# License: BSD 3 clause\r\n\r\nimport numbers\r\nimport numpy as np\r\nimport scipy.sparse as sp\r\nimport time\r\nimport warnings\r\nfrom math import sqrt\r\n\r\nfrom ._cdnmf_fast import _update_cdnmf_fast\r\nfrom .._config import config_context\r\nfrom ..base import BaseEstimator, TransformerMixin\r\nfrom ..exceptions import ConvergenceWarning\r\nfrom ..utils import check_random_state, check_array\r\nfrom ..utils.extmath import randomized_svd, safe_sparse_dot, squared_norm\r\nfrom ..utils.validation import check_is_fitted, check_non_negative\r\nfrom ..utils.validation import _deprecate_positional_args\r\n\r\nEPSILON = np.finfo(np.float32).eps\r\n\r\n\r\ndef norm(x):\r\n \"\"\"Dot product-based Euclidean norm implementation.\r\n\r\n See: http://fseoane.net/blog/2011/computing-the-vector-norm/\r\n\r\n Parameters\r\n ----------\r\n x : array-like\r\n Vector for which to compute the norm.\r\n \"\"\"\r\n return sqrt(squared_norm(x))\r\n\r\n\r\ndef trace_dot(X, Y):\r\n \"\"\"Trace of np.dot(X, Y.T).\r\n\r\n Parameters\r\n ----------\r\n X : array-like\r\n First matrix.\r\n Y : array-like\r\n Second matrix.\r\n \"\"\"\r\n return np.dot(X.ravel(), Y.ravel())\r\n\r\n\r\ndef _check_init(A, shape, whom):\r\n A = check_array(A)\r\n if np.shape(A) != shape:\r\n raise ValueError('Array with wrong shape passed to %s. Expected %s, '\r\n 'but got %s ' % (whom, shape, np.shape(A)))\r\n check_non_negative(A, whom)\r\n if np.max(A) == 0:\r\n raise ValueError('Array passed to %s is full of zeros.' % whom)\r\n\r\n\r\ndef _beta_divergence(X, W, H, beta, square_root=False):\r\n \"\"\"Compute the beta-divergence of X and dot(W, H).\r\n\r\n Parameters\r\n ----------\r\n X : float or array-like of shape (n_samples, n_features)\r\n\r\n W : float or array-like of shape (n_samples, n_components)\r\n\r\n H : float or array-like of shape (n_components, n_features)\r\n\r\n beta : float or {'frobenius', 'kullback-leibler', 'itakura-saito'}\r\n Parameter of the beta-divergence.\r\n If beta == 2, this is half the Frobenius *squared* norm.\r\n If beta == 1, this is the generalized Kullback-Leibler divergence.\r\n If beta == 0, this is the Itakura-Saito divergence.\r\n Else, this is the general beta-divergence.\r\n\r\n square_root : bool, default=False\r\n If True, return np.sqrt(2 * res)\r\n For beta == 2, it corresponds to the Frobenius norm.\r\n\r\n Returns\r\n -------\r\n res : float\r\n Beta divergence of X and np.dot(X, H).\r\n \"\"\"\r\n beta = _beta_loss_to_float(beta)\r\n\r\n # The method can be called with scalars\r\n if not sp.issparse(X):\r\n X = np.atleast_2d(X)\r\n W = np.atleast_2d(W)\r\n H = np.atleast_2d(H)\r\n\r\n # Frobenius norm\r\n if beta == 2:\r\n # Avoid the creation of the dense np.dot(W, H) if X is sparse.\r\n if sp.issparse(X):\r\n norm_X = np.dot(X.data, X.data)\r\n norm_WH = trace_dot(np.linalg.multi_dot([W.T, W, H]), H)\r\n cross_prod = trace_dot((X * H.T), W)\r\n res = (norm_X + norm_WH - 2. * cross_prod) / 2.\r\n else:\r\n res = squared_norm(X - np.dot(W, H)) / 2.\r\n\r\n if square_root:\r\n return np.sqrt(res * 2)\r\n else:\r\n return res\r\n\r\n if sp.issparse(X):\r\n # compute np.dot(W, H) only where X is nonzero\r\n WH_data = _special_sparse_dot(W, H, X).data\r\n X_data = X.data\r\n else:\r\n WH = np.dot(W, H)\r\n WH_data = WH.ravel()\r\n X_data = X.ravel()\r\n\r\n # do not affect the zeros: here 0 ** (-1) = 0 and not infinity\r\n indices = X_data > EPSILON\r\n WH_data = WH_data[indices]\r\n X_data = X_data[indices]\r\n\r\n # used to avoid division by zero\r\n WH_data[WH_data == 0] = EPSILON\r\n\r\n # generalized Kullback-Leibler divergence\r\n if beta == 1:\r\n # fast and memory efficient computation of np.sum(np.dot(W, H))\r\n sum_WH = np.dot(np.sum(W, axis=0), np.sum(H, axis=1))\r\n # computes np.sum(X * log(X / WH)) only where X is nonzero\r\n div = X_data / WH_data\r\n res = np.dot(X_data, np.log(div))\r\n # add full np.sum(np.dot(W, H)) - np.sum(X)\r\n res += sum_WH - X_data.sum()\r\n\r\n # Itakura-Saito divergence\r\n elif beta == 0:\r\n div = X_data / WH_data\r\n res = np.sum(div) - np.product(X.shape) - np.sum(np.log(div))\r\n\r\n # beta-divergence, beta not in (0, 1, 2)\r\n else:\r\n if sp.issparse(X):\r\n # slow loop, but memory efficient computation of :\r\n # np.sum(np.dot(W, H) ** beta)\r\n sum_WH_beta = 0\r\n for i in range(X.shape[1]):\r\n sum_WH_beta += np.sum(np.dot(W, H[:, i]) ** beta)\r\n\r\n else:\r\n sum_WH_beta = np.sum(WH ** beta)\r\n\r\n sum_X_WH = np.dot(X_data, WH_data ** (beta - 1))\r\n res = (X_data ** beta).sum() - beta * sum_X_WH\r\n res += sum_WH_beta * (beta - 1)\r\n res /= beta * (beta - 1)\r\n\r\n if square_root:\r\n return np.sqrt(2 * res)\r\n else:\r\n return res\r\n\r\n\r\ndef _special_sparse_dot(W, H, X):\r\n \"\"\"Computes np.dot(W, H), only where X is non zero.\"\"\"\r\n if sp.issparse(X):\r\n ii, jj = X.nonzero()\r\n n_vals = ii.shape[0]\r\n dot_vals = np.empty(n_vals)\r\n n_components = W.shape[1]\r\n\r\n batch_size = max(n_components, n_vals // n_components)\r\n for start in range(0, n_vals, batch_size):\r\n batch = slice(start, start + batch_size)\r\n dot_vals[batch] = np.multiply(W[ii[batch], :],\r\n H.T[jj[batch], :]).sum(axis=1)\r\n\r\n WH = sp.coo_matrix((dot_vals, (ii, jj)), shape=X.shape)\r\n return WH.tocsr()\r\n else:\r\n return np.dot(W, H)\r\n\r\n\r\ndef _compute_regularization(alpha, l1_ratio, regularization):\r\n \"\"\"Compute L1 and L2 regularization coefficients for W and H.\"\"\"\r\n alpha_H = 0.\r\n alpha_W = 0.\r\n if regularization in ('both', 'components'):\r\n alpha_H = float(alpha)\r\n if regularization in ('both', 'transformation'):\r\n alpha_W = float(alpha)\r\n\r\n l1_reg_W = alpha_W * l1_ratio\r\n l1_reg_H = alpha_H * l1_ratio\r\n l2_reg_W = alpha_W * (1. - l1_ratio)\r\n l2_reg_H = alpha_H * (1. - l1_ratio)\r\n return l1_reg_W, l1_reg_H, l2_reg_W, l2_reg_H\r\n\r\n\r\ndef _check_string_param(solver, regularization, beta_loss, init):\r\n allowed_solver = ('cd', 'mu')\r\n if solver not in allowed_solver:\r\n raise ValueError(\r\n 'Invalid solver parameter: got %r instead of one of %r' %\r\n (solver, allowed_solver))\r\n\r\n allowed_regularization = ('both', 'components', 'transformation', None)\r\n if regularization not in allowed_regularization:\r\n raise ValueError(\r\n 'Invalid regularization parameter: got %r instead of one of %r' %\r\n (regularization, allowed_regularization))\r\n\r\n # 'mu' is the only solver that handles other beta losses than 'frobenius'\r\n if solver != 'mu' and beta_loss not in (2, 'frobenius'):\r\n raise ValueError(\r\n 'Invalid beta_loss parameter: solver %r does not handle beta_loss'\r\n ' = %r' % (solver, beta_loss))\r\n\r\n if solver == 'mu' and init == 'nndsvd':\r\n warnings.warn(\"The multiplicative update ('mu') solver cannot update \"\r\n \"zeros present in the initialization, and so leads to \"\r\n \"poorer results when used jointly with init='nndsvd'. \"\r\n \"You may try init='nndsvda' or init='nndsvdar' instead.\",\r\n UserWarning)\r\n\r\n beta_loss = _beta_loss_to_float(beta_loss)\r\n return beta_loss\r\n\r\n\r\ndef _beta_loss_to_float(beta_loss):\r\n \"\"\"Convert string beta_loss to float.\"\"\"\r\n allowed_beta_loss = {'frobenius': 2,\r\n 'kullback-leibler': 1,\r\n 'itakura-saito': 0}\r\n if isinstance(beta_loss, str) and beta_loss in allowed_beta_loss:\r\n beta_loss = allowed_beta_loss[beta_loss]\r\n\r\n if not isinstance(beta_loss, numbers.Number):\r\n raise ValueError('Invalid beta_loss parameter: got %r instead '\r\n 'of one of %r, or a float.' %\r\n (beta_loss, allowed_beta_loss.keys()))\r\n return beta_loss\r\n\r\n\r\ndef _initialize_nmf(X, n_components, init='warn', eps=1e-6,\r\n random_state=None):\r\n \"\"\"Algorithms for NMF initialization.\r\n\r\n Computes an initial guess for the non-negative\r\n rank k matrix approximation for X: X = WH.\r\n\r\n Parameters\r\n ----------\r\n X : array-like of shape (n_samples, n_features)\r\n The data matrix to be decomposed.\r\n\r\n n_components : int\r\n The number of components desired in the approximation.\r\n\r\n init : {'random', 'nndsvd', 'nndsvda', 'nndsvdar'}, default=None\r\n Method used to initialize the procedure.\r\n Default: None.\r\n Valid options:\r\n\r\n - None: 'nndsvd' if n_components <= min(n_samples, n_features),\r\n otherwise 'random'.\r\n\r\n - 'random': non-negative random matrices, scaled with:\r\n sqrt(X.mean() / n_components)\r\n\r\n - 'nndsvd': Nonnegative Double Singular Value Decomposition (NNDSVD)\r\n initialization (better for sparseness)\r\n\r\n - 'nndsvda': NNDSVD with zeros filled with the average of X\r\n (better when sparsity is not desired)\r\n\r\n - 'nndsvdar': NNDSVD with zeros filled with small random values\r\n (generally faster, less accurate alternative to NNDSVDa\r\n for when sparsity is not desired)\r\n\r\n - 'custom': use custom matrices W and H\r\n\r\n eps : float, default=1e-6\r\n Truncate all values less then this in output to zero.\r\n\r\n random_state : int, RandomState instance or None, default=None\r\n Used when ``init`` == 'nndsvdar' or 'random'. Pass an int for\r\n reproducible results across multiple function calls.\r\n See :term:`Glossary <random_state>`.\r\n\r\n Returns\r\n -------\r\n W : array-like of shape (n_samples, n_components)\r\n Initial guesses for solving X ~= WH.\r\n\r\n H : array-like of shape (n_components, n_features)\r\n Initial guesses for solving X ~= WH.\r\n\r\n References\r\n ----------\r\n C. Boutsidis, E. Gallopoulos: SVD based initialization: A head start for\r\n nonnegative matrix factorization - Pattern Recognition, 2008\r\n http://tinyurl.com/nndsvd\r\n \"\"\"\r\n if init == 'warn':\r\n warnings.warn((\"The 'init' value, when 'init=None' and \"\r\n \"n_components is less than n_samples and \"\r\n \"n_features, will be changed from 'nndsvd' to \"\r\n \"'nndsvda' in 1.1 (renaming of 0.26).\"), FutureWarning)\r\n init = None\r\n\r\n check_non_negative(X, \"NMF initialization\")\r\n n_samples, n_features = X.shape\r\n\r\n if (init is not None and init != 'random'\r\n and n_components > min(n_samples, n_features)):\r\n raise ValueError(\"init = '{}' can only be used when \"\r\n \"n_components <= min(n_samples, n_features)\"\r\n .format(init))\r\n\r\n if init is None:\r\n if n_components <= min(n_samples, n_features):\r\n init = 'nndsvd'\r\n else:\r\n init = 'random'\r\n\r\n # Random initialization\r\n if init == 'random':\r\n avg = np.sqrt(X.mean() / n_components)\r\n rng = check_random_state(random_state)\r\n H = avg * rng.randn(n_components, n_features).astype(X.dtype,\r\n copy=False)\r\n W = avg * rng.randn(n_samples, n_components).astype(X.dtype,\r\n copy=False)\r\n np.abs(H, out=H)\r\n np.abs(W, out=W)\r\n return W, H\r\n\r\n # NNDSVD initialization\r\n U, S, V = randomized_svd(X, n_components, random_state=random_state)\r\n W = np.zeros_like(U)\r\n H = np.zeros_like(V)\r\n\r\n # The leading singular triplet is non-negative\r\n # so it can be used as is for initialization.\r\n W[:, 0] = np.sqrt(S[0]) * np.abs(U[:, 0])\r\n H[0, :] = np.sqrt(S[0]) * np.abs(V[0, :])\r\n\r\n for j in range(1, n_components):\r\n x, y = U[:, j], V[j, :]\r\n\r\n # extract positive and negative parts of column vectors\r\n x_p, y_p = np.maximum(x, 0), np.maximum(y, 0)\r\n x_n, y_n = np.abs(np.minimum(x, 0)), np.abs(np.minimum(y, 0))\r\n\r\n # and their norms\r\n x_p_nrm, y_p_nrm = norm(x_p), norm(y_p)\r\n x_n_nrm, y_n_nrm = norm(x_n), norm(y_n)\r\n\r\n m_p, m_n = x_p_nrm * y_p_nrm, x_n_nrm * y_n_nrm\r\n\r\n # choose update\r\n if m_p > m_n:\r\n u = x_p / x_p_nrm\r\n v = y_p / y_p_nrm\r\n sigma = m_p\r\n else:\r\n u = x_n / x_n_nrm\r\n v = y_n / y_n_nrm\r\n sigma = m_n\r\n\r\n lbd = np.sqrt(S[j] * sigma)\r\n W[:, j] = lbd * u\r\n H[j, :] = lbd * v\r\n\r\n W[W < eps] = 0\r\n H[H < eps] = 0\r\n\r\n if init == \"nndsvd\":\r\n pass\r\n elif init == \"nndsvda\":\r\n avg = X.mean()\r\n W[W == 0] = avg\r\n H[H == 0] = avg\r\n elif init == \"nndsvdar\":\r\n rng = check_random_state(random_state)\r\n avg = X.mean()\r\n W[W == 0] = abs(avg * rng.randn(len(W[W == 0])) / 100)\r\n H[H == 0] = abs(avg * rng.randn(len(H[H == 0])) / 100)\r\n else:\r\n raise ValueError(\r\n 'Invalid init parameter: got %r instead of one of %r' %\r\n (init, (None, 'random', 'nndsvd', 'nndsvda', 'nndsvdar')))\r\n\r\n return W, H\r\n\r\n\r\ndef _update_coordinate_descent(X, W, Ht, l1_reg, l2_reg, shuffle,\r\n random_state):\r\n \"\"\"Helper function for _fit_coordinate_descent.\r\n\r\n Update W to minimize the objective function, iterating once over all\r\n coordinates. By symmetry, to update H, one can call\r\n _update_coordinate_descent(X.T, Ht, W, ...).\r\n\r\n \"\"\"\r\n n_components = Ht.shape[1]\r\n\r\n HHt = np.dot(Ht.T, Ht)\r\n XHt = safe_sparse_dot(X, Ht)\r\n\r\n # L2 regularization corresponds to increase of the diagonal of HHt\r\n if l2_reg != 0.:\r\n # adds l2_reg only on the diagonal\r\n HHt.flat[::n_components + 1] += l2_reg\r\n # L1 regularization corresponds to decrease of each element of XHt\r\n if l1_reg != 0.:\r\n XHt -= l1_reg\r\n\r\n if shuffle:\r\n permutation = random_state.permutation(n_components)\r\n else:\r\n permutation = np.arange(n_components)\r\n # The following seems to be required on 64-bit Windows w/ Python 3.5.\r\n permutation = np.asarray(permutation, dtype=np.intp)\r\n return _update_cdnmf_fast(W, HHt, XHt, permutation)\r\n\r\n\r\ndef _fit_coordinate_descent(X, W, H, tol=1e-4, max_iter=200, l1_reg_W=0,\r\n l1_reg_H=0, l2_reg_W=0, l2_reg_H=0, update_H=True,\r\n verbose=0, shuffle=False, random_state=None):\r\n \"\"\"Compute Non-negative Matrix Factorization (NMF) with Coordinate Descent\r\n\r\n The objective function is minimized with an alternating minimization of W\r\n and H. Each minimization is done with a cyclic (up to a permutation of the\r\n features) Coordinate Descent.\r\n\r\n Parameters\r\n ----------\r\n X : array-like of shape (n_samples, n_features)\r\n Constant matrix.\r\n\r\n W : array-like of shape (n_samples, n_components)\r\n Initial guess for the solution.\r\n\r\n H : array-like of shape (n_components, n_features)\r\n Initial guess for the solution.\r\n\r\n tol : float, default=1e-4\r\n Tolerance of the stopping condition.\r\n\r\n max_iter : int, default=200\r\n Maximum number of iterations before timing out.\r\n\r\n l1_reg_W : float, default=0.\r\n L1 regularization parameter for W.\r\n\r\n l1_reg_H : float, default=0.\r\n L1 regularization parameter for H.\r\n\r\n l2_reg_W : float, default=0.\r\n L2 regularization parameter for W.\r\n\r\n l2_reg_H : float, default=0.\r\n L2 regularization parameter for H.\r\n\r\n update_H : bool, default=True\r\n Set to True, both W and H will be estimated from initial guesses.\r\n Set to False, only W will be estimated.\r\n\r\n verbose : int, default=0\r\n The verbosity level.\r\n\r\n shuffle : bool, default=False\r\n If true, randomize the order of coordinates in the CD solver.\r\n\r\n random_state : int, RandomState instance or None, default=None\r\n Used to randomize the coordinates in the CD solver, when\r\n ``shuffle`` is set to ``True``. Pass an int for reproducible\r\n results across multiple function calls.\r\n See :term:`Glossary <random_state>`.\r\n\r\n Returns\r\n -------\r\n W : ndarray of shape (n_samples, n_components)\r\n Solution to the non-negative least squares problem.\r\n\r\n H : ndarray of shape (n_components, n_features)\r\n Solution to the non-negative least squares problem.\r\n\r\n n_iter : int\r\n The number of iterations done by the algorithm.\r\n\r\n References\r\n ----------\r\n Cichocki, Andrzej, and Phan, Anh-Huy. \"Fast local algorithms for\r\n large scale nonnegative matrix and tensor factorizations.\"\r\n IEICE transactions on fundamentals of electronics, communications and\r\n computer sciences 92.3: 708-721, 2009.\r\n \"\"\"\r\n # so W and Ht are both in C order in memory\r\n Ht = check_array(H.T, order='C')\r\n X = check_array(X, accept_sparse='csr')\r\n\r\n rng = check_random_state(random_state)\r\n\r\n for n_iter in range(1, max_iter + 1):\r\n violation = 0.\r\n\r\n # Update W\r\n violation += _update_coordinate_descent(X, W, Ht, l1_reg_W,\r\n l2_reg_W, shuffle, rng)\r\n # Update H\r\n if update_H:\r\n violation += _update_coordinate_descent(X.T, Ht, W, l1_reg_H,\r\n l2_reg_H, shuffle, rng)\r\n\r\n if n_iter == 1:\r\n violation_init = violation\r\n\r\n if violation_init == 0:\r\n break\r\n\r\n if verbose:\r\n print(\"violation:\", violation / violation_init)\r\n\r\n if violation / violation_init <= tol:\r\n if verbose:\r\n print(\"Converged at iteration\", n_iter + 1)\r\n break\r\n\r\n return W, Ht.T, n_iter\r\n\r\n\r\ndef _multiplicative_update_w(X, W, H, beta_loss, l1_reg_W, l2_reg_W, gamma,\r\n H_sum=None, HHt=None, XHt=None, update_H=True):\r\n \"\"\"Update W in Multiplicative Update NMF.\"\"\"\r\n if beta_loss == 2:\r\n # Numerator\r\n if XHt is None:\r\n XHt = safe_sparse_dot(X, H.T)\r\n if update_H:\r\n # avoid a copy of XHt, which will be re-computed (update_H=True)\r\n numerator = XHt\r\n else:\r\n # preserve the XHt, which is not re-computed (update_H=False)\r\n numerator = XHt.copy()\r\n\r\n # Denominator\r\n if HHt is None:\r\n HHt = np.dot(H, H.T)\r\n denominator = np.dot(W, HHt)\r\n\r\n else:\r\n # Numerator\r\n # if X is sparse, compute WH only where X is non zero\r\n WH_safe_X = _special_sparse_dot(W, H, X)\r\n if sp.issparse(X):\r\n WH_safe_X_data = WH_safe_X.data\r\n X_data = X.data\r\n else:\r\n WH_safe_X_data = WH_safe_X\r\n X_data = X\r\n # copy used in the Denominator\r\n WH = WH_safe_X.copy()\r\n if beta_loss - 1. < 0:\r\n WH[WH == 0] = EPSILON\r\n\r\n # to avoid taking a negative power of zero\r\n if beta_loss - 2. < 0:\r\n WH_safe_X_data[WH_safe_X_data == 0] = EPSILON\r\n\r\n if beta_loss == 1:\r\n np.divide(X_data, WH_safe_X_data, out=WH_safe_X_data)\r\n elif beta_loss == 0:\r\n # speeds up computation time\r\n # refer to /numpy/numpy/issues/9363\r\n WH_safe_X_data **= -1\r\n WH_safe_X_data **= 2\r\n # element-wise multiplication\r\n WH_safe_X_data *= X_data\r\n else:\r\n WH_safe_X_data **= beta_loss - 2\r\n # element-wise multiplication\r\n WH_safe_X_data *= X_data\r\n\r\n # here numerator = dot(X * (dot(W, H) ** (beta_loss - 2)), H.T)\r\n numerator = safe_sparse_dot(WH_safe_X, H.T)\r\n\r\n # Denominator\r\n if beta_loss == 1:\r\n if H_sum is None:\r\n H_sum = np.sum(H, axis=1) # shape(n_components, )\r\n denominator = H_sum[np.newaxis, :]\r\n\r\n else:\r\n # computation of WHHt = dot(dot(W, H) ** beta_loss - 1, H.T)\r\n if sp.issparse(X):\r\n # memory efficient computation\r\n # (compute row by row, avoiding the dense matrix WH)\r\n WHHt = np.empty(W.shape)\r\n for i in range(X.shape[0]):\r\n WHi = np.dot(W[i, :], H)\r\n if beta_loss - 1 < 0:\r\n WHi[WHi == 0] = EPSILON\r\n WHi **= beta_loss - 1\r\n WHHt[i, :] = np.dot(WHi, H.T)\r\n else:\r\n WH **= beta_loss - 1\r\n WHHt = np.dot(WH, H.T)\r\n denominator = WHHt\r\n\r\n # Add L1 and L2 regularization\r\n if l1_reg_W > 0:\r\n denominator += l1_reg_W\r\n if l2_reg_W > 0:\r\n denominator = denominator + l2_reg_W * W\r\n denominator[denominator == 0] = EPSILON\r\n\r\n numerator /= denominator\r\n delta_W = numerator\r\n\r\n # gamma is in ]0, 1]\r\n if gamma != 1:\r\n delta_W **= gamma\r\n\r\n return delta_W, H_sum, HHt, XHt\r\n\r\n\r\ndef _multiplicative_update_h(X, W, H, beta_loss, l1_reg_H, l2_reg_H, gamma):\r\n \"\"\"Update H in Multiplicative Update NMF.\"\"\"\r\n if beta_loss == 2:\r\n numerator = safe_sparse_dot(W.T, X)\r\n denominator = np.linalg.multi_dot([W.T, W, H])\r\n\r\n else:\r\n # Numerator\r\n WH_safe_X = _special_sparse_dot(W, H, X)\r\n if sp.issparse(X):\r\n WH_safe_X_data = WH_safe_X.data\r\n X_data = X.data\r\n else:\r\n WH_safe_X_data = WH_safe_X\r\n X_data = X\r\n # copy used in the Denominator\r\n WH = WH_safe_X.copy()\r\n if beta_loss - 1. < 0:\r\n WH[WH == 0] = EPSILON\r\n\r\n # to avoid division by zero\r\n if beta_loss - 2. < 0:\r\n WH_safe_X_data[WH_safe_X_data == 0] = EPSILON\r\n\r\n if beta_loss == 1:\r\n np.divide(X_data, WH_safe_X_data, out=WH_safe_X_data)\r\n elif beta_loss == 0:\r\n # speeds up computation time\r\n # refer to /numpy/numpy/issues/9363\r\n WH_safe_X_data **= -1\r\n WH_safe_X_data **= 2\r\n # element-wise multiplication\r\n WH_safe_X_data *= X_data\r\n else:\r\n WH_safe_X_data **= beta_loss - 2\r\n # element-wise multiplication\r\n WH_safe_X_data *= X_data\r\n\r\n # here numerator = dot(W.T, (dot(W, H) ** (beta_loss - 2)) * X)\r\n numerator = safe_sparse_dot(W.T, WH_safe_X)\r\n\r\n # Denominator\r\n if beta_loss == 1:\r\n W_sum = np.sum(W, axis=0) # shape(n_components, )\r\n W_sum[W_sum == 0] = 1.\r\n denominator = W_sum[:, np.newaxis]\r\n\r\n # beta_loss not in (1, 2)\r\n else:\r\n # computation of WtWH = dot(W.T, dot(W, H) ** beta_loss - 1)\r\n if sp.issparse(X):\r\n # memory efficient computation\r\n # (compute column by column, avoiding the dense matrix WH)\r\n WtWH = np.empty(H.shape)\r\n for i in range(X.shape[1]):\r\n WHi = np.dot(W, H[:, i])\r\n if beta_loss - 1 < 0:\r\n WHi[WHi == 0] = EPSILON\r\n WHi **= beta_loss - 1\r\n WtWH[:, i] = np.dot(W.T, WHi)\r\n else:\r\n WH **= beta_loss - 1\r\n WtWH = np.dot(W.T, WH)\r\n denominator = WtWH\r\n\r\n # Add L1 and L2 regularization\r\n if l1_reg_H > 0:\r\n denominator += l1_reg_H\r\n if l2_reg_H > 0:\r\n denominator = denominator + l2_reg_H * H\r\n denominator[denominator == 0] = EPSILON\r\n\r\n numerator /= denominator\r\n delta_H = numerator\r\n\r\n # gamma is in ]0, 1]\r\n if gamma != 1:\r\n delta_H **= gamma\r\n\r\n return delta_H\r\n\r\n\r\ndef _fit_multiplicative_update(X, W, H, beta_loss='frobenius',\r\n max_iter=200, tol=1e-4,\r\n l1_reg_W=0, l1_reg_H=0, l2_reg_W=0, l2_reg_H=0,\r\n update_H=True, verbose=0):\r\n \"\"\"Compute Non-negative Matrix Factorization with Multiplicative Update.\r\n\r\n The objective function is _beta_divergence(X, WH) and is minimized with an\r\n alternating minimization of W and H. Each minimization is done with a\r\n Multiplicative Update.\r\n\r\n Parameters\r\n ----------\r\n X : array-like of shape (n_samples, n_features)\r\n Constant input matrix.\r\n\r\n W : array-like of shape (n_samples, n_components)\r\n Initial guess for the solution.\r\n\r\n H : array-like of shape (n_components, n_features)\r\n Initial guess for the solution.\r\n\r\n beta_loss : float or {'frobenius', 'kullback-leibler', \\\r\n 'itakura-saito'}, default='frobenius'\r\n String must be in {'frobenius', 'kullback-leibler', 'itakura-saito'}.\r\n Beta divergence to be minimized, measuring the distance between X\r\n and the dot product WH. Note that values different from 'frobenius'\r\n (or 2) and 'kullback-leibler' (or 1) lead to significantly slower\r\n fits. Note that for beta_loss <= 0 (or 'itakura-saito'), the input\r\n matrix X cannot contain zeros.\r\n\r\n max_iter : int, default=200\r\n Number of iterations.\r\n\r\n tol : float, default=1e-4\r\n Tolerance of the stopping condition.\r\n\r\n l1_reg_W : float, default=0.\r\n L1 regularization parameter for W.\r\n\r\n l1_reg_H : float, default=0.\r\n L1 regularization parameter for H.\r\n\r\n l2_reg_W : float, default=0.\r\n L2 regularization parameter for W.\r\n\r\n l2_reg_H : float, default=0.\r\n L2 regularization parameter for H.\r\n\r\n update_H : bool, default=True\r\n Set to True, both W and H will be estimated from initial guesses.\r\n Set to False, only W will be estimated.\r\n\r\n verbose : int, default=0\r\n The verbosity level.\r\n\r\n Returns\r\n -------\r\n W : ndarray of shape (n_samples, n_components)\r\n Solution to the non-negative least squares problem.\r\n\r\n H : ndarray of shape (n_components, n_features)\r\n Solution to the non-negative least squares problem.\r\n\r\n n_iter : int\r\n The number of iterations done by the algorithm.\r\n\r\n References\r\n ----------\r\n Fevotte, C., & Idier, J. (2011). Algorithms for nonnegative matrix\r\n factorization with the beta-divergence. Neural Computation, 23(9).\r\n \"\"\"\r\n start_time = time.time()\r\n\r\n beta_loss = _beta_loss_to_float(beta_loss)\r\n\r\n # gamma for Maximization-Minimization (MM) algorithm [Fevotte 2011]\r\n if beta_loss < 1:\r\n gamma = 1. / (2. - beta_loss)\r\n elif beta_loss > 2:\r\n gamma = 1. / (beta_loss - 1.)\r\n else:\r\n gamma = 1.\r\n\r\n # used for the convergence criterion\r\n error_at_init = _beta_divergence(X, W, H, beta_loss, square_root=True)\r\n previous_error = error_at_init\r\n\r\n H_sum, HHt, XHt = None, None, None\r\n for n_iter in range(1, max_iter + 1):\r\n # update W\r\n # H_sum, HHt and XHt are saved and reused if not update_H\r\n delta_W, H_sum, HHt, XHt = _multiplicative_update_w(\r\n X, W, H, beta_loss, l1_reg_W, l2_reg_W, gamma,\r\n H_sum, HHt, XHt, update_H)\r\n W *= delta_W\r\n\r\n # necessary for stability with beta_loss < 1\r\n if beta_loss < 1:\r\n W[W < np.finfo(np.float64).eps] = 0.\r\n\r\n # update H\r\n if update_H:\r\n delta_H = _multiplicative_update_h(X, W, H, beta_loss, l1_reg_H,\r\n l2_reg_H, gamma)\r\n H *= delta_H\r\n\r\n # These values will be recomputed since H changed\r\n H_sum, HHt, XHt = None, None, None\r\n\r\n # necessary for stability with beta_loss < 1\r\n if beta_loss <= 1:\r\n H[H < np.finfo(np.float64).eps] = 0.\r\n\r\n # test convergence criterion every 10 iterations\r\n if tol > 0 and n_iter % 10 == 0:\r\n error = _beta_divergence(X, W, H, beta_loss, square_root=True)\r\n\r\n if verbose:\r\n iter_time = time.time()\r\n print(\"Epoch %02d reached after %.3f seconds, error: %f\" %\r\n (n_iter, iter_time - start_time, error))\r\n\r\n if (previous_error - error) / error_at_init < tol:\r\n break\r\n previous_error = error\r\n\r\n # do not print if we have already printed in the convergence test\r\n if verbose and (tol == 0 or n_iter % 10 != 0):\r\n end_time = time.time()\r\n print(\"Epoch %02d reached after %.3f seconds.\" %\r\n (n_iter, end_time - start_time))\r\n\r\n return W, H, n_iter\r\n\r\n\r\n@_deprecate_positional_args\r\ndef non_negative_factorization(X, W=None, H=None, n_components=None, *,\r\n init='warn', update_H=True, solver='cd',\r\n beta_loss='frobenius', tol=1e-4,\r\n max_iter=200, alpha=0., l1_ratio=0.,\r\n regularization=None, random_state=None,\r\n verbose=0, shuffle=False):\r\n \"\"\"Compute Non-negative Matrix Factorization (NMF).\r\n\r\n Find two non-negative matrices (W, H) whose product approximates the non-\r\n negative matrix X. This factorization can be used for example for\r\n dimensionality reduction, source separation or topic extraction.\r\n\r\n The objective function is:\r\n\r\n .. math::\r\n\r\n 0.5 * ||X - WH||_{Fro}^2 + alpha * l1_{ratio} * ||vec(W)||_1\r\n\r\n + alpha * l1_{ratio} * ||vec(H)||_1\r\n\r\n + 0.5 * alpha * (1 - l1_{ratio}) * ||W||_{Fro}^2\r\n\r\n + 0.5 * alpha * (1 - l1_{ratio}) * ||H||_{Fro}^2\r\n\r\n Where:\r\n\r\n :math:`||A||_{Fro}^2 = \\\\sum_{i,j} A_{ij}^2` (Frobenius norm)\r\n\r\n :math:`||vec(A)||_1 = \\\\sum_{i,j} abs(A_{ij})` (Elementwise L1 norm)\r\n\r\n For multiplicative-update ('mu') solver, the Frobenius norm\r\n :math:`(0.5 * ||X - WH||_{Fro}^2)` can be changed into another\r\n beta-divergence loss, by changing the beta_loss parameter.\r\n\r\n The objective function is minimized with an alternating minimization of W\r\n and H. If H is given and update_H=False, it solves for W only.\r\n\r\n Parameters\r\n ----------\r\n X : array-like of shape (n_samples, n_features)\r\n Constant matrix.\r\n\r\n W : array-like of shape (n_samples, n_components), default=None\r\n If init='custom', it is used as initial guess for the solution.\r\n\r\n H : array-like of shape (n_components, n_features), default=None\r\n If init='custom', it is used as initial guess for the solution.\r\n If update_H=False, it is used as a constant, to solve for W only.\r\n\r\n n_components : int, default=None\r\n Number of components, if n_components is not set all features\r\n are kept.\r\n\r\n init : {'random', 'nndsvd', 'nndsvda', 'nndsvdar', 'custom'}, default=None\r\n Method used to initialize the procedure.\r\n\r\n Valid options:\r\n\r\n - None: 'nndsvd' if n_components < n_features, otherwise 'random'.\r\n\r\n - 'random': non-negative random matrices, scaled with:\r\n sqrt(X.mean() / n_components)\r\n\r\n - 'nndsvd': Nonnegative Double Singular Value Decomposition (NNDSVD)\r\n initialization (better for sparseness)\r\n\r\n - 'nndsvda': NNDSVD with zeros filled with the average of X\r\n (better when sparsity is not desired)\r\n\r\n - 'nndsvdar': NNDSVD with zeros filled with small random values\r\n (generally faster, less accurate alternative to NNDSVDa\r\n for when sparsity is not desired)\r\n\r\n - 'custom': use custom matrices W and H if `update_H=True`. If\r\n `update_H=False`, then only custom matrix H is used.\r\n\r\n .. versionchanged:: 0.23\r\n The default value of `init` changed from 'random' to None in 0.23.\r\n\r\n update_H : bool, default=True\r\n Set to True, both W and H will be estimated from initial guesses.\r\n Set to False, only W will be estimated.\r\n\r\n solver : {'cd', 'mu'}, default='cd'\r\n Numerical solver to use:\r\n\r\n - 'cd' is a Coordinate Descent solver that uses Fast Hierarchical\r\n Alternating Least Squares (Fast HALS).\r\n\r\n - 'mu' is a Multiplicative Update solver.\r\n\r\n .. versionadded:: 0.17\r\n Coordinate Descent solver.\r\n\r\n .. versionadded:: 0.19\r\n Multiplicative Update solver.\r\n\r\n beta_loss : float or {'frobenius', 'kullback-leibler', \\\r\n 'itakura-saito'}, default='frobenius'\r\n Beta divergence to be minimized, measuring the distance between X\r\n and the dot product WH. Note that values different from 'frobenius'\r\n (or 2) and 'kullback-leibler' (or 1) lead to significantly slower\r\n fits. Note that for beta_loss <= 0 (or 'itakura-saito'), the input\r\n matrix X cannot contain zeros. Used only in 'mu' solver.\r\n\r\n .. versionadded:: 0.19\r\n\r\n tol : float, default=1e-4\r\n Tolerance of the stopping condition.\r\n\r\n max_iter : int, default=200\r\n Maximum number of iterations before timing out.\r\n\r\n alpha : float, default=0.\r\n Constant that multiplies the regularization terms.\r\n\r\n l1_ratio : float, default=0.\r\n The regularization mixing parameter, with 0 <= l1_ratio <= 1.\r\n For l1_ratio = 0 the penalty is an elementwise L2 penalty\r\n (aka Frobenius Norm).\r\n For l1_ratio = 1 it is an elementwise L1 penalty.\r\n For 0 < l1_ratio < 1, the penalty is a combination of L1 and L2.\r\n\r\n regularization : {'both', 'components', 'transformation'}, default=None\r\n Select whether the regularization affects the components (H), the\r\n transformation (W), both or none of them.\r\n\r\n random_state : int, RandomState instance or None, default=None\r\n Used for NMF initialisation (when ``init`` == 'nndsvdar' or\r\n 'random'), and in Coordinate Descent. Pass an int for reproducible\r\n results across multiple function calls.\r\n See :term:`Glossary <random_state>`.\r\n\r\n verbose : int, default=0\r\n The verbosity level.\r\n\r\n shuffle : bool, default=False\r\n If true, randomize the order of coordinates in the CD solver.\r\n\r\n Returns\r\n -------\r\n W : ndarray of shape (n_samples, n_components)\r\n Solution to the non-negative least squares problem.\r\n\r\n H : ndarray of shape (n_components, n_features)\r\n Solution to the non-negative least squares problem.\r\n\r\n n_iter : int\r\n Actual number of iterations.\r\n\r\n Examples\r\n --------\r\n >>> import numpy as np\r\n >>> X = np.array([[1,1], [2, 1], [3, 1.2], [4, 1], [5, 0.8], [6, 1]])\r\n >>> from sklearn.decomposition import non_negative_factorization\r\n >>> W, H, n_iter = non_negative_factorization(X, n_components=2,\r\n ... init='random', random_state=0)\r\n\r\n References\r\n ----------\r\n Cichocki, Andrzej, and P. H. A. N. Anh-Huy. \"Fast local algorithms for\r\n large scale nonnegative matrix and tensor factorizations.\"\r\n IEICE transactions on fundamentals of electronics, communications and\r\n computer sciences 92.3: 708-721, 2009.\r\n\r\n Fevotte, C., & Idier, J. (2011). Algorithms for nonnegative matrix\r\n factorization with the beta-divergence. Neural Computation, 23(9).\r\n \"\"\"\r\n X = check_array(X, accept_sparse=('csr', 'csc'),\r\n dtype=[np.float64, np.float32])\r\n check_non_negative(X, \"NMF (input X)\")\r\n beta_loss = _check_string_param(solver, regularization, beta_loss, init)\r\n\r\n if X.min() == 0 and beta_loss <= 0:\r\n raise ValueError(\"When beta_loss <= 0 and X contains zeros, \"\r\n \"the solver may diverge. Please add small values to \"\r\n \"X, or use a positive beta_loss.\")\r\n\r\n n_samples, n_features = X.shape\r\n if n_components is None:\r\n n_components = n_features\r\n\r\n if not isinstance(n_components, numbers.Integral) or n_components <= 0:\r\n raise ValueError(\"Number of components must be a positive integer;\"\r\n \" got (n_components=%r)\" % n_components)\r\n if not isinstance(max_iter, numbers.Integral) or max_iter < 0:\r\n raise ValueError(\"Maximum number of iterations must be a positive \"\r\n \"integer; got (max_iter=%r)\" % max_iter)\r\n if not isinstance(tol, numbers.Number) or tol < 0:\r\n raise ValueError(\"Tolerance for stopping criteria must be \"\r\n \"positive; got (tol=%r)\" % tol)\r\n\r\n # check W and H, or initialize them\r\n if init == 'custom' and update_H:\r\n _check_init(H, (n_components, n_features), \"NMF (input H)\")\r\n _check_init(W, (n_samples, n_components), \"NMF (input W)\")\r\n if H.dtype != X.dtype or W.dtype != X.dtype:\r\n raise TypeError(\"H and W should have the same dtype as X. Got \"\r\n \"H.dtype = {} and W.dtype = {}.\"\r\n .format(H.dtype, W.dtype))\r\n elif not update_H:\r\n _check_init(H, (n_components, n_features), \"NMF (input H)\")\r\n if H.dtype != X.dtype:\r\n raise TypeError(\"H should have the same dtype as X. Got H.dtype = \"\r\n \"{}.\".format(H.dtype))\r\n # 'mu' solver should not be initialized by zeros\r\n if solver == 'mu':\r\n avg = np.sqrt(X.mean() / n_components)\r\n W = np.full((n_samples, n_components), avg, dtype=X.dtype)\r\n else:\r\n W = np.zeros((n_samples, n_components), dtype=X.dtype)\r\n else:\r\n W, H = _initialize_nmf(X, n_components, init=init,\r\n random_state=random_state)\r\n\r\n l1_reg_W, l1_reg_H, l2_reg_W, l2_reg_H = _compute_regularization(\r\n alpha, l1_ratio, regularization)\r\n\r\n if solver == 'cd':\r\n W, H, n_iter = _fit_coordinate_descent(X, W, H, tol, max_iter,\r\n l1_reg_W, l1_reg_H,\r\n l2_reg_W, l2_reg_H,\r\n update_H=update_H,\r\n verbose=verbose,\r\n shuffle=shuffle,\r\n random_state=random_state)\r\n elif solver == 'mu':\r\n W, H, n_iter = _fit_multiplicative_update(X, W, H, beta_loss, max_iter,\r\n tol, l1_reg_W, l1_reg_H,\r\n l2_reg_W, l2_reg_H, update_H,\r\n verbose)\r\n\r\n else:\r\n raise ValueError(\"Invalid solver parameter '%s'.\" % solver)\r\n\r\n if n_iter == max_iter and tol > 0:\r\n warnings.warn(\"Maximum number of iterations %d reached. Increase it to\"\r\n \" improve convergence.\" % max_iter, ConvergenceWarning)\r\n\r\n return W, H, n_iter\r\n\r\n\r\nclass NMF(TransformerMixin, BaseEstimator):\r\n \"\"\"Non-Negative Matrix Factorization (NMF).\r\n\r\n Find two non-negative matrices (W, H) whose product approximates the non-\r\n negative matrix X. This factorization can be used for example for\r\n dimensionality reduction, source separation or topic extraction.\r\n\r\n The objective function is:\r\n\r\n .. math::\r\n\r\n 0.5 * ||X - WH||_{Fro}^2 + alpha * l1_{ratio} * ||vec(W)||_1\r\n\r\n + alpha * l1_{ratio} * ||vec(H)||_1\r\n\r\n + 0.5 * alpha * (1 - l1_{ratio}) * ||W||_{Fro}^2\r\n\r\n + 0.5 * alpha * (1 - l1_{ratio}) * ||H||_{Fro}^2\r\n\r\n Where:\r\n\r\n :math:`||A||_{Fro}^2 = \\\\sum_{i,j} A_{ij}^2` (Frobenius norm)\r\n\r\n :math:`||vec(A)||_1 = \\\\sum_{i,j} abs(A_{ij})` (Elementwise L1 norm)\r\n\r\n For multiplicative-update ('mu') solver, the Frobenius norm\r\n (:math:`0.5 * ||X - WH||_{Fro}^2`) can be changed into another\r\n beta-divergence loss, by changing the beta_loss parameter.\r\n\r\n The objective function is minimized with an alternating minimization of W\r\n and H.\r\n\r\n Read more in the :ref:`User Guide <NMF>`.\r\n\r\n Parameters\r\n ----------\r\n n_components : int, default=None\r\n Number of components, if n_components is not set all features\r\n are kept.\r\n\r\n init : {'random', 'nndsvd', 'nndsvda', 'nndsvdar', 'custom'}, default=None\r\n Method used to initialize the procedure.\r\n Default: None.\r\n Valid options:\r\n\r\n - `None`: 'nndsvd' if n_components <= min(n_samples, n_features),\r\n otherwise random.\r\n\r\n - `'random'`: non-negative random matrices, scaled with:\r\n sqrt(X.mean() / n_components)\r\n\r\n - `'nndsvd'`: Nonnegative Double Singular Value Decomposition (NNDSVD)\r\n initialization (better for sparseness)\r\n\r\n - `'nndsvda'`: NNDSVD with zeros filled with the average of X\r\n (better when sparsity is not desired)\r\n\r\n - `'nndsvdar'` NNDSVD with zeros filled with small random values\r\n (generally faster, less accurate alternative to NNDSVDa\r\n for when sparsity is not desired)\r\n\r\n - `'custom'`: use custom matrices W and H\r\n\r\n solver : {'cd', 'mu'}, default='cd'\r\n Numerical solver to use:\r\n 'cd' is a Coordinate Descent solver.\r\n 'mu' is a Multiplicative Update solver.\r\n\r\n .. versionadded:: 0.17\r\n Coordinate Descent solver.\r\n\r\n .. versionadded:: 0.19\r\n Multiplicative Update solver.\r\n\r\n beta_loss : float or {'frobenius', 'kullback-leibler', \\\r\n 'itakura-saito'}, default='frobenius'\r\n Beta divergence to be minimized, measuring the distance between X\r\n and the dot product WH. Note that values different from 'frobenius'\r\n (or 2) and 'kullback-leibler' (or 1) lead to significantly slower\r\n fits. Note that for beta_loss <= 0 (or 'itakura-saito'), the input\r\n matrix X cannot contain zeros. Used only in 'mu' solver.\r\n\r\n .. versionadded:: 0.19\r\n\r\n tol : float, default=1e-4\r\n Tolerance of the stopping condition.\r\n\r\n max_iter : int, default=200\r\n Maximum number of iterations before timing out.\r\n\r\n random_state : int, RandomState instance or None, default=None\r\n Used for initialisation (when ``init`` == 'nndsvdar' or\r\n 'random'), and in Coordinate Descent. Pass an int for reproducible\r\n results across multiple function calls.\r\n See :term:`Glossary <random_state>`.\r\n\r\n alpha : float, default=0.\r\n Constant that multiplies the regularization terms. Set it to zero to\r\n have no regularization.\r\n\r\n .. versionadded:: 0.17\r\n *alpha* used in the Coordinate Descent solver.\r\n\r\n l1_ratio : float, default=0.\r\n The regularization mixing parameter, with 0 <= l1_ratio <= 1.\r\n For l1_ratio = 0 the penalty is an elementwise L2 penalty\r\n (aka Frobenius Norm).\r\n For l1_ratio = 1 it is an elementwise L1 penalty.\r\n For 0 < l1_ratio < 1, the penalty is a combination of L1 and L2.\r\n\r\n .. versionadded:: 0.17\r\n Regularization parameter *l1_ratio* used in the Coordinate Descent\r\n solver.\r\n\r\n verbose : int, default=0\r\n Whether to be verbose.\r\n\r\n shuffle : bool, default=False\r\n If true, randomize the order of coordinates in the CD solver.\r\n\r\n .. versionadded:: 0.17\r\n *shuffle* parameter used in the Coordinate Descent solver.\r\n\r\n regularization : {'both', 'components', 'transformation', None}, \\\r\n default='both'\r\n Select whether the regularization affects the components (H), the\r\n transformation (W), both or none of them.\r\n\r\n .. versionadded:: 0.24\r\n\r\n Attributes\r\n ----------\r\n components_ : ndarray of shape (n_components, n_features)\r\n Factorization matrix, sometimes called 'dictionary'.\r\n\r\n n_components_ : int\r\n The number of components. It is same as the `n_components` parameter\r\n if it was given. Otherwise, it will be same as the number of\r\n features.\r\n\r\n reconstruction_err_ : float\r\n Frobenius norm of the matrix difference, or beta-divergence, between\r\n the training data ``X`` and the reconstructed data ``WH`` from\r\n the fitted model.\r\n\r\n n_iter_ : int\r\n Actual number of iterations.\r\n\r\n Examples\r\n --------\r\n >>> import numpy as np\r\n >>> X = np.array([[1, 1], [2, 1], [3, 1.2], [4, 1], [5, 0.8], [6, 1]])\r\n >>> from sklearn.decomposition import NMF\r\n >>> model = NMF(n_components=2, init='random', random_state=0)\r\n >>> W = model.fit_transform(X)\r\n >>> H = model.components_\r\n\r\n References\r\n ----------\r\n Cichocki, Andrzej, and P. H. A. N. Anh-Huy. \"Fast local algorithms for\r\n large scale nonnegative matrix and tensor factorizations.\"\r\n IEICE transactions on fundamentals of electronics, communications and\r\n computer sciences 92.3: 708-721, 2009.\r\n\r\n Fevotte, C., & Idier, J. (2011). Algorithms for nonnegative matrix\r\n factorization with the beta-divergence. Neural Computation, 23(9).\r\n \"\"\"\r\n @_deprecate_positional_args\r\n def __init__(self, n_components=None, *, init='warn', solver='cd',\r\n beta_loss='frobenius', tol=1e-4, max_iter=200,\r\n random_state=None, alpha=0., l1_ratio=0., verbose=0,\r\n shuffle=False, regularization='both'):\r\n self.n_components = n_components\r\n self.init = init\r\n self.solver = solver\r\n self.beta_loss = beta_loss\r\n self.tol = tol\r\n self.max_iter = max_iter\r\n self.random_state = random_state\r\n self.alpha = alpha\r\n self.l1_ratio = l1_ratio\r\n self.verbose = verbose\r\n self.shuffle = shuffle\r\n self.regularization = regularization\r\n\r\n def _more_tags(self):\r\n return {'requires_positive_X': True}\r\n\r\n def fit_transform(self, X, y=None, W=None, H=None):\r\n \"\"\"Learn a NMF model for the data X and returns the transformed data.\r\n\r\n This is more efficient than calling fit followed by transform.\r\n\r\n Parameters\r\n ----------\r\n X : {array-like, sparse matrix} of shape (n_samples, n_features)\r\n Data matrix to be decomposed\r\n\r\n y : Ignored\r\n\r\n W : array-like of shape (n_samples, n_components)\r\n If init='custom', it is used as initial guess for the solution.\r\n\r\n H : array-like of shape (n_components, n_features)\r\n If init='custom', it is used as initial guess for the solution.\r\n\r\n Returns\r\n -------\r\n W : ndarray of shape (n_samples, n_components)\r\n Transformed data.\r\n \"\"\"\r\n X = self._validate_data(X, accept_sparse=('csr', 'csc'),\r\n dtype=[np.float64, np.float32])\r\n\r\n with config_context(assume_finite=True):\r\n W, H, n_iter_ = non_negative_factorization(\r\n X=X, W=W, H=H, n_components=self.n_components, init=self.init,\r\n update_H=True, solver=self.solver, beta_loss=self.beta_loss,\r\n tol=self.tol, max_iter=self.max_iter, alpha=self.alpha,\r\n l1_ratio=self.l1_ratio, regularization=self.regularization,\r\n random_state=self.random_state, verbose=self.verbose,\r\n shuffle=self.shuffle)\r\n\r\n self.reconstruction_err_ = _beta_divergence(X, W, H, self.beta_loss,\r\n square_root=True)\r\n\r\n self.n_components_ = H.shape[0]\r\n self.components_ = H\r\n self.n_iter_ = n_iter_\r\n\r\n return W\r\n\r\n def fit(self, X, y=None, **params):\r\n \"\"\"Learn a NMF model for the data X.\r\n\r\n Parameters\r\n ----------\r\n X : {array-like, sparse matrix} of shape (n_samples, n_features)\r\n Data matrix to be decomposed\r\n\r\n y : Ignored\r\n\r\n Returns\r\n -------\r\n self\r\n \"\"\"\r\n self.fit_transform(X, **params)\r\n return self\r\n\r\n def transform(self, X):\r\n \"\"\"Transform the data X according to the fitted NMF model.\r\n\r\n Parameters\r\n ----------\r\n X : {array-like, sparse matrix} of shape (n_samples, n_features)\r\n Data matrix to be transformed by the model.\r\n\r\n Returns\r\n -------\r\n W : ndarray of shape (n_samples, n_components)\r\n Transformed data.\r\n \"\"\"\r\n check_is_fitted(self)\r\n X = self._validate_data(X, accept_sparse=('csr', 'csc'),\r\n dtype=[np.float64, np.float32],\r\n reset=False)\r\n\r\n with config_context(assume_finite=True):\r\n W, _, n_iter_ = non_negative_factorization(\r\n X=X, W=None, H=self.components_,\r\n n_components=self.n_components_,\r\n init=self.init, update_H=False, solver=self.solver,\r\n beta_loss=self.beta_loss, tol=self.tol, max_iter=self.max_iter,\r\n alpha=self.alpha, l1_ratio=self.l1_ratio,\r\n regularization=self.regularization,\r\n random_state=self.random_state,\r\n verbose=self.verbose, shuffle=self.shuffle)\r\n\r\n return W\r\n\r\n def inverse_transform(self, W):\r\n \"\"\"Transform data back to its original space.\r\n\r\n Parameters\r\n ----------\r\n W : {ndarray, sparse matrix} of shape (n_samples, n_components)\r\n Transformed data matrix.\r\n\r\n Returns\r\n -------\r\n X : {ndarray, sparse matrix} of shape (n_samples, n_features)\r\n Data matrix of original shape.\r\n\r\n .. versionadded:: 0.18\r\n \"\"\"\r\n check_is_fitted(self)\r\n return np.dot(W, self.components_)\r\n",
"import warnings\r\nimport unittest\r\nimport sys\r\nimport os\r\nimport atexit\r\n\r\nimport numpy as np\r\n\r\nfrom scipy import sparse\r\n\r\nimport pytest\r\n\r\nfrom sklearn.utils.deprecation import deprecated\r\nfrom sklearn.utils.metaestimators import if_delegate_has_method\r\nfrom sklearn.utils._testing import (\r\n assert_raises,\r\n assert_warns,\r\n assert_no_warnings,\r\n set_random_state,\r\n assert_raise_message,\r\n ignore_warnings,\r\n check_docstring_parameters,\r\n assert_allclose_dense_sparse,\r\n assert_raises_regex,\r\n TempMemmap,\r\n create_memmap_backed_data,\r\n _delete_folder,\r\n _convert_container,\r\n raises,\r\n)\r\n\r\nfrom sklearn.tree import DecisionTreeClassifier\r\nfrom sklearn.discriminant_analysis import LinearDiscriminantAnalysis\r\n\r\n\r\ndef test_set_random_state():\r\n lda = LinearDiscriminantAnalysis()\r\n tree = DecisionTreeClassifier()\r\n # Linear Discriminant Analysis doesn't have random state: smoke test\r\n set_random_state(lda, 3)\r\n set_random_state(tree, 3)\r\n assert tree.random_state == 3\r\n\r\n\r\ndef test_assert_allclose_dense_sparse():\r\n x = np.arange(9).reshape(3, 3)\r\n msg = \"Not equal to tolerance \"\r\n y = sparse.csc_matrix(x)\r\n for X in [x, y]:\r\n # basic compare\r\n with pytest.raises(AssertionError, match=msg):\r\n assert_allclose_dense_sparse(X, X*2)\r\n assert_allclose_dense_sparse(X, X)\r\n\r\n with pytest.raises(ValueError, match=\"Can only compare two sparse\"):\r\n assert_allclose_dense_sparse(x, y)\r\n\r\n A = sparse.diags(np.ones(5), offsets=0).tocsr()\r\n B = sparse.csr_matrix(np.ones((1, 5)))\r\n with pytest.raises(AssertionError, match=\"Arrays are not equal\"):\r\n assert_allclose_dense_sparse(B, A)\r\n\r\n\r\ndef test_assert_raises_msg():\r\n with assert_raises_regex(AssertionError, 'Hello world'):\r\n with assert_raises(ValueError, msg='Hello world'):\r\n pass\r\n\r\n\r\ndef test_assert_raise_message():\r\n def _raise_ValueError(message):\r\n raise ValueError(message)\r\n\r\n def _no_raise():\r\n pass\r\n\r\n assert_raise_message(ValueError, \"test\",\r\n _raise_ValueError, \"test\")\r\n\r\n assert_raises(AssertionError,\r\n assert_raise_message, ValueError, \"something else\",\r\n _raise_ValueError, \"test\")\r\n\r\n assert_raises(ValueError,\r\n assert_raise_message, TypeError, \"something else\",\r\n _raise_ValueError, \"test\")\r\n\r\n assert_raises(AssertionError,\r\n assert_raise_message, ValueError, \"test\",\r\n _no_raise)\r\n\r\n # multiple exceptions in a tuple\r\n assert_raises(AssertionError,\r\n assert_raise_message, (ValueError, AttributeError),\r\n \"test\", _no_raise)\r\n\r\n\r\ndef test_ignore_warning():\r\n # This check that ignore_warning decorateur and context manager are working\r\n # as expected\r\n def _warning_function():\r\n warnings.warn(\"deprecation warning\", DeprecationWarning)\r\n\r\n def _multiple_warning_function():\r\n warnings.warn(\"deprecation warning\", DeprecationWarning)\r\n warnings.warn(\"deprecation warning\")\r\n\r\n # Check the function directly\r\n assert_no_warnings(ignore_warnings(_warning_function))\r\n assert_no_warnings(ignore_warnings(_warning_function,\r\n category=DeprecationWarning))\r\n assert_warns(DeprecationWarning, ignore_warnings(_warning_function,\r\n category=UserWarning))\r\n assert_warns(UserWarning,\r\n ignore_warnings(_multiple_warning_function,\r\n category=FutureWarning))\r\n assert_warns(DeprecationWarning,\r\n ignore_warnings(_multiple_warning_function,\r\n category=UserWarning))\r\n assert_no_warnings(ignore_warnings(_warning_function,\r\n category=(DeprecationWarning,\r\n UserWarning)))\r\n\r\n # Check the decorator\r\n @ignore_warnings\r\n def decorator_no_warning():\r\n _warning_function()\r\n _multiple_warning_function()\r\n\r\n @ignore_warnings(category=(DeprecationWarning, UserWarning))\r\n def decorator_no_warning_multiple():\r\n _multiple_warning_function()\r\n\r\n @ignore_warnings(category=DeprecationWarning)\r\n def decorator_no_deprecation_warning():\r\n _warning_function()\r\n\r\n @ignore_warnings(category=UserWarning)\r\n def decorator_no_user_warning():\r\n _warning_function()\r\n\r\n @ignore_warnings(category=DeprecationWarning)\r\n def decorator_no_deprecation_multiple_warning():\r\n _multiple_warning_function()\r\n\r\n @ignore_warnings(category=UserWarning)\r\n def decorator_no_user_multiple_warning():\r\n _multiple_warning_function()\r\n\r\n assert_no_warnings(decorator_no_warning)\r\n assert_no_warnings(decorator_no_warning_multiple)\r\n assert_no_warnings(decorator_no_deprecation_warning)\r\n assert_warns(DeprecationWarning, decorator_no_user_warning)\r\n assert_warns(UserWarning, decorator_no_deprecation_multiple_warning)\r\n assert_warns(DeprecationWarning, decorator_no_user_multiple_warning)\r\n\r\n # Check the context manager\r\n def context_manager_no_warning():\r\n with ignore_warnings():\r\n _warning_function()\r\n\r\n def context_manager_no_warning_multiple():\r\n with ignore_warnings(category=(DeprecationWarning, UserWarning)):\r\n _multiple_warning_function()\r\n\r\n def context_manager_no_deprecation_warning():\r\n with ignore_warnings(category=DeprecationWarning):\r\n _warning_function()\r\n\r\n def context_manager_no_user_warning():\r\n with ignore_warnings(category=UserWarning):\r\n _warning_function()\r\n\r\n def context_manager_no_deprecation_multiple_warning():\r\n with ignore_warnings(category=DeprecationWarning):\r\n _multiple_warning_function()\r\n\r\n def context_manager_no_user_multiple_warning():\r\n with ignore_warnings(category=UserWarning):\r\n _multiple_warning_function()\r\n\r\n assert_no_warnings(context_manager_no_warning)\r\n assert_no_warnings(context_manager_no_warning_multiple)\r\n assert_no_warnings(context_manager_no_deprecation_warning)\r\n assert_warns(DeprecationWarning, context_manager_no_user_warning)\r\n assert_warns(UserWarning, context_manager_no_deprecation_multiple_warning)\r\n assert_warns(DeprecationWarning, context_manager_no_user_multiple_warning)\r\n\r\n # Check that passing warning class as first positional argument\r\n warning_class = UserWarning\r\n match = \"'obj' should be a callable.+you should use 'category=UserWarning'\"\r\n\r\n with pytest.raises(ValueError, match=match):\r\n silence_warnings_func = ignore_warnings(warning_class)(\r\n _warning_function)\r\n silence_warnings_func()\r\n\r\n with pytest.raises(ValueError, match=match):\r\n @ignore_warnings(warning_class)\r\n def test():\r\n pass\r\n\r\n\r\nclass TestWarns(unittest.TestCase):\r\n def test_warn(self):\r\n def f():\r\n warnings.warn(\"yo\")\r\n return 3\r\n\r\n with warnings.catch_warnings():\r\n warnings.simplefilter(\"ignore\", UserWarning)\r\n filters_orig = warnings.filters[:]\r\n assert assert_warns(UserWarning, f) == 3\r\n # test that assert_warns doesn't have side effects on warnings\r\n # filters\r\n assert warnings.filters == filters_orig\r\n with pytest.raises(AssertionError):\r\n assert_no_warnings(f)\r\n assert assert_no_warnings(lambda x: x, 1) == 1\r\n\r\n def test_warn_wrong_warning(self):\r\n def f():\r\n warnings.warn(\"yo\", FutureWarning)\r\n\r\n failed = False\r\n filters = sys.modules['warnings'].filters[:]\r\n try:\r\n try:\r\n # Should raise an AssertionError\r\n\r\n # assert_warns has a special handling of \"FutureWarning\" that\r\n # pytest.warns does not have\r\n assert_warns(UserWarning, f)\r\n failed = True\r\n except AssertionError:\r\n pass\r\n finally:\r\n sys.modules['warnings'].filters = filters\r\n\r\n if failed:\r\n raise AssertionError(\"wrong warning caught by assert_warn\")\r\n\r\n\r\n# Tests for docstrings:\r\n\r\ndef f_ok(a, b):\r\n \"\"\"Function f\r\n\r\n Parameters\r\n ----------\r\n a : int\r\n Parameter a\r\n b : float\r\n Parameter b\r\n\r\n Returns\r\n -------\r\n c : list\r\n Parameter c\r\n \"\"\"\r\n c = a + b\r\n return c\r\n\r\n\r\ndef f_bad_sections(a, b):\r\n \"\"\"Function f\r\n\r\n Parameters\r\n ----------\r\n a : int\r\n Parameter a\r\n b : float\r\n Parameter b\r\n\r\n Results\r\n -------\r\n c : list\r\n Parameter c\r\n \"\"\"\r\n c = a + b\r\n return c\r\n\r\n\r\ndef f_bad_order(b, a):\r\n \"\"\"Function f\r\n\r\n Parameters\r\n ----------\r\n a : int\r\n Parameter a\r\n b : float\r\n Parameter b\r\n\r\n Returns\r\n -------\r\n c : list\r\n Parameter c\r\n \"\"\"\r\n c = a + b\r\n return c\r\n\r\n\r\ndef f_too_many_param_docstring(a, b):\r\n \"\"\"Function f\r\n\r\n Parameters\r\n ----------\r\n a : int\r\n Parameter a\r\n b : int\r\n Parameter b\r\n c : int\r\n Parameter c\r\n\r\n Returns\r\n -------\r\n d : list\r\n Parameter c\r\n \"\"\"\r\n d = a + b\r\n return d\r\n\r\n\r\ndef f_missing(a, b):\r\n \"\"\"Function f\r\n\r\n Parameters\r\n ----------\r\n a : int\r\n Parameter a\r\n\r\n Returns\r\n -------\r\n c : list\r\n Parameter c\r\n \"\"\"\r\n c = a + b\r\n return c\r\n\r\n\r\ndef f_check_param_definition(a, b, c, d, e):\r\n \"\"\"Function f\r\n\r\n Parameters\r\n ----------\r\n a: int\r\n Parameter a\r\n b:\r\n Parameter b\r\n c :\r\n Parameter c\r\n d:int\r\n Parameter d\r\n e\r\n No typespec is allowed without colon\r\n \"\"\"\r\n return a + b + c + d\r\n\r\n\r\nclass Klass:\r\n def f_missing(self, X, y):\r\n pass\r\n\r\n def f_bad_sections(self, X, y):\r\n \"\"\"Function f\r\n\r\n Parameter\r\n ----------\r\n a : int\r\n Parameter a\r\n b : float\r\n Parameter b\r\n\r\n Results\r\n -------\r\n c : list\r\n Parameter c\r\n \"\"\"\r\n pass\r\n\r\n\r\nclass MockEst:\r\n def __init__(self):\r\n \"\"\"MockEstimator\"\"\"\r\n def fit(self, X, y):\r\n return X\r\n\r\n def predict(self, X):\r\n return X\r\n\r\n def predict_proba(self, X):\r\n return X\r\n\r\n def score(self, X):\r\n return 1.\r\n\r\n\r\nclass MockMetaEstimator:\r\n def __init__(self, delegate):\r\n \"\"\"MetaEstimator to check if doctest on delegated methods work.\r\n\r\n Parameters\r\n ---------\r\n delegate : estimator\r\n Delegated estimator.\r\n \"\"\"\r\n self.delegate = delegate\r\n\r\n @if_delegate_has_method(delegate=('delegate'))\r\n def predict(self, X):\r\n \"\"\"This is available only if delegate has predict.\r\n\r\n Parameters\r\n ----------\r\n y : ndarray\r\n Parameter y\r\n \"\"\"\r\n return self.delegate.predict(X)\r\n\r\n @if_delegate_has_method(delegate=('delegate'))\r\n @deprecated(\"Testing a deprecated delegated method\")\r\n def score(self, X):\r\n \"\"\"This is available only if delegate has score.\r\n\r\n Parameters\r\n ---------\r\n y : ndarray\r\n Parameter y\r\n \"\"\"\r\n\r\n @if_delegate_has_method(delegate=('delegate'))\r\n def predict_proba(self, X):\r\n \"\"\"This is available only if delegate has predict_proba.\r\n\r\n Parameters\r\n ---------\r\n X : ndarray\r\n Parameter X\r\n \"\"\"\r\n return X\r\n\r\n @deprecated('Testing deprecated function with wrong params')\r\n def fit(self, X, y):\r\n \"\"\"Incorrect docstring but should not be tested\"\"\"\r\n\r\n\r\ndef test_check_docstring_parameters():\r\n pytest.importorskip('numpydoc',\r\n reason=\"numpydoc is required to test the docstrings\")\r\n\r\n incorrect = check_docstring_parameters(f_ok)\r\n assert incorrect == []\r\n incorrect = check_docstring_parameters(f_ok, ignore=['b'])\r\n assert incorrect == []\r\n incorrect = check_docstring_parameters(f_missing, ignore=['b'])\r\n assert incorrect == []\r\n with pytest.raises(RuntimeError, match=\"Unknown section Results\"):\r\n check_docstring_parameters(f_bad_sections)\r\n with pytest.raises(RuntimeError, match=\"Unknown section Parameter\"):\r\n check_docstring_parameters(Klass.f_bad_sections)\r\n\r\n incorrect = check_docstring_parameters(f_check_param_definition)\r\n assert (\r\n incorrect == [\r\n \"sklearn.utils.tests.test_testing.f_check_param_definition There \"\r\n \"was no space between the param name and colon ('a: int')\",\r\n\r\n \"sklearn.utils.tests.test_testing.f_check_param_definition There \"\r\n \"was no space between the param name and colon ('b:')\",\r\n\r\n \"sklearn.utils.tests.test_testing.f_check_param_definition \"\r\n \"Parameter 'c :' has an empty type spec. Remove the colon\",\r\n\r\n \"sklearn.utils.tests.test_testing.f_check_param_definition There \"\r\n \"was no space between the param name and colon ('d:int')\",\r\n ])\r\n\r\n messages = [\r\n [\"In function: sklearn.utils.tests.test_testing.f_bad_order\",\r\n \"There's a parameter name mismatch in function docstring w.r.t.\"\r\n \" function signature, at index 0 diff: 'b' != 'a'\",\r\n \"Full diff:\",\r\n \"- ['b', 'a']\",\r\n \"+ ['a', 'b']\"],\r\n\r\n [\"In function: \" +\r\n \"sklearn.utils.tests.test_testing.f_too_many_param_docstring\",\r\n \"Parameters in function docstring have more items w.r.t. function\"\r\n \" signature, first extra item: c\",\r\n \"Full diff:\",\r\n \"- ['a', 'b']\",\r\n \"+ ['a', 'b', 'c']\",\r\n \"? +++++\"],\r\n\r\n [\"In function: sklearn.utils.tests.test_testing.f_missing\",\r\n \"Parameters in function docstring have less items w.r.t. function\"\r\n \" signature, first missing item: b\",\r\n \"Full diff:\",\r\n \"- ['a', 'b']\",\r\n \"+ ['a']\"],\r\n\r\n [\"In function: sklearn.utils.tests.test_testing.Klass.f_missing\",\r\n \"Parameters in function docstring have less items w.r.t. function\"\r\n \" signature, first missing item: X\",\r\n \"Full diff:\",\r\n \"- ['X', 'y']\",\r\n \"+ []\"],\r\n\r\n [\"In function: \" +\r\n \"sklearn.utils.tests.test_testing.MockMetaEstimator.predict\",\r\n \"There's a parameter name mismatch in function docstring w.r.t.\"\r\n \" function signature, at index 0 diff: 'X' != 'y'\",\r\n \"Full diff:\",\r\n \"- ['X']\",\r\n \"? ^\",\r\n \"+ ['y']\",\r\n \"? ^\"],\r\n\r\n [\"In function: \" +\r\n \"sklearn.utils.tests.test_testing.MockMetaEstimator.\"\r\n + \"predict_proba\",\r\n \"Parameters in function docstring have less items w.r.t. function\"\r\n \" signature, first missing item: X\",\r\n \"Full diff:\",\r\n \"- ['X']\",\r\n \"+ []\"],\r\n\r\n [\"In function: \" +\r\n \"sklearn.utils.tests.test_testing.MockMetaEstimator.score\",\r\n \"Parameters in function docstring have less items w.r.t. function\"\r\n \" signature, first missing item: X\",\r\n \"Full diff:\",\r\n \"- ['X']\",\r\n \"+ []\"],\r\n\r\n [\"In function: \" +\r\n \"sklearn.utils.tests.test_testing.MockMetaEstimator.fit\",\r\n \"Parameters in function docstring have less items w.r.t. function\"\r\n \" signature, first missing item: X\",\r\n \"Full diff:\",\r\n \"- ['X', 'y']\",\r\n \"+ []\"],\r\n\r\n ]\r\n\r\n mock_meta = MockMetaEstimator(delegate=MockEst())\r\n\r\n for msg, f in zip(messages,\r\n [f_bad_order,\r\n f_too_many_param_docstring,\r\n f_missing,\r\n Klass.f_missing,\r\n mock_meta.predict,\r\n mock_meta.predict_proba,\r\n mock_meta.score,\r\n mock_meta.fit]):\r\n incorrect = check_docstring_parameters(f)\r\n assert msg == incorrect, ('\\n\"%s\"\\n not in \\n\"%s\"' % (msg, incorrect))\r\n\r\n\r\nclass RegistrationCounter:\r\n def __init__(self):\r\n self.nb_calls = 0\r\n\r\n def __call__(self, to_register_func):\r\n self.nb_calls += 1\r\n assert to_register_func.func is _delete_folder\r\n\r\n\r\ndef check_memmap(input_array, mmap_data, mmap_mode='r'):\r\n assert isinstance(mmap_data, np.memmap)\r\n writeable = mmap_mode != 'r'\r\n assert mmap_data.flags.writeable is writeable\r\n np.testing.assert_array_equal(input_array, mmap_data)\r\n\r\n\r\ndef test_tempmemmap(monkeypatch):\r\n registration_counter = RegistrationCounter()\r\n monkeypatch.setattr(atexit, 'register', registration_counter)\r\n\r\n input_array = np.ones(3)\r\n with TempMemmap(input_array) as data:\r\n check_memmap(input_array, data)\r\n temp_folder = os.path.dirname(data.filename)\r\n if os.name != 'nt':\r\n assert not os.path.exists(temp_folder)\r\n assert registration_counter.nb_calls == 1\r\n\r\n mmap_mode = 'r+'\r\n with TempMemmap(input_array, mmap_mode=mmap_mode) as data:\r\n check_memmap(input_array, data, mmap_mode=mmap_mode)\r\n temp_folder = os.path.dirname(data.filename)\r\n if os.name != 'nt':\r\n assert not os.path.exists(temp_folder)\r\n assert registration_counter.nb_calls == 2\r\n\r\n\r\ndef test_create_memmap_backed_data(monkeypatch):\r\n registration_counter = RegistrationCounter()\r\n monkeypatch.setattr(atexit, 'register', registration_counter)\r\n\r\n input_array = np.ones(3)\r\n data = create_memmap_backed_data(input_array)\r\n check_memmap(input_array, data)\r\n assert registration_counter.nb_calls == 1\r\n\r\n data, folder = create_memmap_backed_data(input_array,\r\n return_folder=True)\r\n check_memmap(input_array, data)\r\n assert folder == os.path.dirname(data.filename)\r\n assert registration_counter.nb_calls == 2\r\n\r\n mmap_mode = 'r+'\r\n data = create_memmap_backed_data(input_array, mmap_mode=mmap_mode)\r\n check_memmap(input_array, data, mmap_mode)\r\n assert registration_counter.nb_calls == 3\r\n\r\n input_list = [input_array, input_array + 1, input_array + 2]\r\n mmap_data_list = create_memmap_backed_data(input_list)\r\n for input_array, data in zip(input_list, mmap_data_list):\r\n check_memmap(input_array, data)\r\n assert registration_counter.nb_calls == 4\r\n\r\n\r\[email protected](\r\n \"constructor_name, container_type\",\r\n [('list', list),\r\n ('tuple', tuple),\r\n ('array', np.ndarray),\r\n ('sparse', sparse.csr_matrix),\r\n ('dataframe', pytest.importorskip('pandas').DataFrame),\r\n ('series', pytest.importorskip('pandas').Series),\r\n ('index', pytest.importorskip('pandas').Index),\r\n ('slice', slice)]\r\n)\r\ndef test_convert_container(constructor_name, container_type):\r\n container = [0, 1]\r\n assert isinstance(_convert_container(container, constructor_name),\r\n container_type)\r\n\r\n\r\ndef test_raises():\r\n # Tests for the raises context manager\r\n\r\n # Proper type, no match\r\n with raises(TypeError):\r\n raise TypeError()\r\n\r\n # Proper type, proper match\r\n with raises(TypeError, match=\"how are you\") as cm:\r\n raise TypeError(\"hello how are you\")\r\n assert cm.raised_and_matched\r\n\r\n # Proper type, proper match with multiple patterns\r\n with raises(TypeError, match=[\"not this one\", \"how are you\"]) as cm:\r\n raise TypeError(\"hello how are you\")\r\n assert cm.raised_and_matched\r\n\r\n # bad type, no match\r\n with pytest.raises(ValueError, match=\"this will be raised\"):\r\n with raises(TypeError) as cm:\r\n raise ValueError(\"this will be raised\")\r\n assert not cm.raised_and_matched\r\n\r\n # Bad type, no match, with a err_msg\r\n with pytest.raises(AssertionError, match=\"the failure message\"):\r\n with raises(TypeError, err_msg=\"the failure message\") as cm:\r\n raise ValueError()\r\n assert not cm.raised_and_matched\r\n\r\n # bad type, with match (is ignored anyway)\r\n with pytest.raises(ValueError, match=\"this will be raised\"):\r\n with raises(TypeError, match=\"this is ignored\") as cm:\r\n raise ValueError(\"this will be raised\")\r\n assert not cm.raised_and_matched\r\n\r\n # proper type but bad match\r\n with pytest.raises(\r\n AssertionError, match=\"should contain one of the following patterns\"\r\n ):\r\n with raises(TypeError, match=\"hello\") as cm:\r\n raise TypeError(\"Bad message\")\r\n assert not cm.raised_and_matched\r\n\r\n # proper type but bad match, with err_msg\r\n with pytest.raises(AssertionError, match=\"the failure message\"):\r\n with raises(\r\n TypeError, match=\"hello\", err_msg=\"the failure message\"\r\n ) as cm:\r\n raise TypeError(\"Bad message\")\r\n assert not cm.raised_and_matched\r\n\r\n # no raise with default may_pass=False\r\n with pytest.raises(AssertionError, match=\"Did not raise\"):\r\n with raises(TypeError) as cm:\r\n pass\r\n assert not cm.raised_and_matched\r\n\r\n # no raise with may_pass=True\r\n with raises(TypeError, match=\"hello\", may_pass=True) as cm:\r\n pass # still OK\r\n assert not cm.raised_and_matched\r\n\r\n # Multiple exception types:\r\n with raises((TypeError, ValueError)):\r\n raise TypeError()\r\n with raises((TypeError, ValueError)):\r\n raise ValueError()\r\n with pytest.raises(AssertionError):\r\n with raises((TypeError, ValueError)):\r\n pass\r\n",
"import numpy as np\r\nimport pytest\r\n\r\nimport pandas as pd\r\nimport pandas._testing as tm\r\n\r\n\r\[email protected](\"sort\", [True, False])\r\ndef test_factorize(index_or_series_obj, sort):\r\n obj = index_or_series_obj\r\n result_codes, result_uniques = obj.factorize(sort=sort)\r\n\r\n constructor = pd.Index\r\n if isinstance(obj, pd.MultiIndex):\r\n constructor = pd.MultiIndex.from_tuples\r\n expected_uniques = constructor(obj.unique())\r\n\r\n if sort:\r\n expected_uniques = expected_uniques.sort_values()\r\n\r\n # construct an integer ndarray so that\r\n # `expected_uniques.take(expected_codes)` is equal to `obj`\r\n expected_uniques_list = list(expected_uniques)\r\n expected_codes = [expected_uniques_list.index(val) for val in obj]\r\n expected_codes = np.asarray(expected_codes, dtype=np.intp)\r\n\r\n tm.assert_numpy_array_equal(result_codes, expected_codes)\r\n tm.assert_index_equal(result_uniques, expected_uniques)\r\n\r\n\r\ndef test_series_factorize_na_sentinel_none():\r\n # GH35667\r\n values = np.array([1, 2, 1, np.nan])\r\n ser = pd.Series(values)\r\n codes, uniques = ser.factorize(na_sentinel=None)\r\n\r\n expected_codes = np.array([0, 1, 0, 2], dtype=np.intp)\r\n expected_uniques = pd.Index([1.0, 2.0, np.nan])\r\n\r\n tm.assert_numpy_array_equal(codes, expected_codes)\r\n tm.assert_index_equal(uniques, expected_uniques)\r\n",
"\"\"\"Utilities for meta-estimators\"\"\"\r\n# Author: Joel Nothman\r\n# Andreas Mueller\r\n# License: BSD\r\nfrom typing import List, Any\r\n\r\nfrom abc import ABCMeta, abstractmethod\r\nfrom operator import attrgetter\r\nfrom functools import update_wrapper\r\nimport numpy as np\r\n\r\nfrom ..utils import _safe_indexing\r\nfrom ..base import BaseEstimator\r\nfrom ..base import _is_pairwise\r\n\r\n__all__ = ['if_delegate_has_method']\r\n\r\n\r\nclass _BaseComposition(BaseEstimator, metaclass=ABCMeta):\r\n \"\"\"Handles parameter management for classifiers composed of named estimators.\r\n \"\"\"\r\n steps: List[Any]\r\n\r\n @abstractmethod\r\n def __init__(self):\r\n pass\r\n\r\n def _get_params(self, attr, deep=True):\r\n out = super().get_params(deep=deep)\r\n if not deep:\r\n return out\r\n estimators = getattr(self, attr)\r\n out.update(estimators)\r\n for name, estimator in estimators:\r\n if hasattr(estimator, 'get_params'):\r\n for key, value in estimator.get_params(deep=True).items():\r\n out['%s__%s' % (name, key)] = value\r\n return out\r\n\r\n def _set_params(self, attr, **params):\r\n # Ensure strict ordering of parameter setting:\r\n # 1. All steps\r\n if attr in params:\r\n setattr(self, attr, params.pop(attr))\r\n # 2. Step replacement\r\n items = getattr(self, attr)\r\n names = []\r\n if items:\r\n names, _ = zip(*items)\r\n for name in list(params.keys()):\r\n if '__' not in name and name in names:\r\n self._replace_estimator(attr, name, params.pop(name))\r\n # 3. Step parameters and other initialisation arguments\r\n super().set_params(**params)\r\n return self\r\n\r\n def _replace_estimator(self, attr, name, new_val):\r\n # assumes `name` is a valid estimator name\r\n new_estimators = list(getattr(self, attr))\r\n for i, (estimator_name, _) in enumerate(new_estimators):\r\n if estimator_name == name:\r\n new_estimators[i] = (name, new_val)\r\n break\r\n setattr(self, attr, new_estimators)\r\n\r\n def _validate_names(self, names):\r\n if len(set(names)) != len(names):\r\n raise ValueError('Names provided are not unique: '\r\n '{0!r}'.format(list(names)))\r\n invalid_names = set(names).intersection(self.get_params(deep=False))\r\n if invalid_names:\r\n raise ValueError('Estimator names conflict with constructor '\r\n 'arguments: {0!r}'.format(sorted(invalid_names)))\r\n invalid_names = [name for name in names if '__' in name]\r\n if invalid_names:\r\n raise ValueError('Estimator names must not contain __: got '\r\n '{0!r}'.format(invalid_names))\r\n\r\n\r\nclass _IffHasAttrDescriptor:\r\n \"\"\"Implements a conditional property using the descriptor protocol.\r\n\r\n Using this class to create a decorator will raise an ``AttributeError``\r\n if none of the delegates (specified in ``delegate_names``) is an attribute\r\n of the base object or the first found delegate does not have an attribute\r\n ``attribute_name``.\r\n\r\n This allows ducktyping of the decorated method based on\r\n ``delegate.attribute_name``. Here ``delegate`` is the first item in\r\n ``delegate_names`` for which ``hasattr(object, delegate) is True``.\r\n\r\n See https://docs.python.org/3/howto/descriptor.html for an explanation of\r\n descriptors.\r\n \"\"\"\r\n def __init__(self, fn, delegate_names, attribute_name):\r\n self.fn = fn\r\n self.delegate_names = delegate_names\r\n self.attribute_name = attribute_name\r\n\r\n # update the docstring of the descriptor\r\n update_wrapper(self, fn)\r\n\r\n def __get__(self, obj, type=None):\r\n # raise an AttributeError if the attribute is not present on the object\r\n if obj is not None:\r\n # delegate only on instances, not the classes.\r\n # this is to allow access to the docstrings.\r\n for delegate_name in self.delegate_names:\r\n try:\r\n delegate = attrgetter(delegate_name)(obj)\r\n except AttributeError:\r\n continue\r\n else:\r\n getattr(delegate, self.attribute_name)\r\n break\r\n else:\r\n attrgetter(self.delegate_names[-1])(obj)\r\n\r\n # lambda, but not partial, allows help() to work with update_wrapper\r\n out = lambda *args, **kwargs: self.fn(obj, *args, **kwargs)\r\n # update the docstring of the returned function\r\n update_wrapper(out, self.fn)\r\n return out\r\n\r\n\r\ndef if_delegate_has_method(delegate):\r\n \"\"\"Create a decorator for methods that are delegated to a sub-estimator\r\n\r\n This enables ducktyping by hasattr returning True according to the\r\n sub-estimator.\r\n\r\n Parameters\r\n ----------\r\n delegate : string, list of strings or tuple of strings\r\n Name of the sub-estimator that can be accessed as an attribute of the\r\n base object. If a list or a tuple of names are provided, the first\r\n sub-estimator that is an attribute of the base object will be used.\r\n\r\n \"\"\"\r\n if isinstance(delegate, list):\r\n delegate = tuple(delegate)\r\n if not isinstance(delegate, tuple):\r\n delegate = (delegate,)\r\n\r\n return lambda fn: _IffHasAttrDescriptor(fn, delegate,\r\n attribute_name=fn.__name__)\r\n\r\n\r\ndef _safe_split(estimator, X, y, indices, train_indices=None):\r\n \"\"\"Create subset of dataset and properly handle kernels.\r\n\r\n Slice X, y according to indices for cross-validation, but take care of\r\n precomputed kernel-matrices or pairwise affinities / distances.\r\n\r\n If ``estimator._pairwise is True``, X needs to be square and\r\n we slice rows and columns. If ``train_indices`` is not None,\r\n we slice rows using ``indices`` (assumed the test set) and columns\r\n using ``train_indices``, indicating the training set.\r\n\r\n .. deprecated:: 0.24\r\n\r\n The _pairwise attribute is deprecated in 0.24. From 1.1\r\n (renaming of 0.26) and onward, this function will check for the\r\n pairwise estimator tag.\r\n\r\n Labels y will always be indexed only along the first axis.\r\n\r\n Parameters\r\n ----------\r\n estimator : object\r\n Estimator to determine whether we should slice only rows or rows and\r\n columns.\r\n\r\n X : array-like, sparse matrix or iterable\r\n Data to be indexed. If ``estimator._pairwise is True``,\r\n this needs to be a square array-like or sparse matrix.\r\n\r\n y : array-like, sparse matrix or iterable\r\n Targets to be indexed.\r\n\r\n indices : array of int\r\n Rows to select from X and y.\r\n If ``estimator._pairwise is True`` and ``train_indices is None``\r\n then ``indices`` will also be used to slice columns.\r\n\r\n train_indices : array of int or None, default=None\r\n If ``estimator._pairwise is True`` and ``train_indices is not None``,\r\n then ``train_indices`` will be use to slice the columns of X.\r\n\r\n Returns\r\n -------\r\n X_subset : array-like, sparse matrix or list\r\n Indexed data.\r\n\r\n y_subset : array-like, sparse matrix or list\r\n Indexed targets.\r\n\r\n \"\"\"\r\n if _is_pairwise(estimator):\r\n if not hasattr(X, \"shape\"):\r\n raise ValueError(\"Precomputed kernels or affinity matrices have \"\r\n \"to be passed as arrays or sparse matrices.\")\r\n # X is a precomputed square kernel matrix\r\n if X.shape[0] != X.shape[1]:\r\n raise ValueError(\"X should be a square kernel matrix\")\r\n if train_indices is None:\r\n X_subset = X[np.ix_(indices, indices)]\r\n else:\r\n X_subset = X[np.ix_(indices, train_indices)]\r\n else:\r\n X_subset = _safe_indexing(X, indices)\r\n\r\n if y is not None:\r\n y_subset = _safe_indexing(y, indices)\r\n else:\r\n y_subset = None\r\n\r\n return X_subset, y_subset\r\n",
"import numpy as np\r\n\r\nimport pandas as pd\r\nfrom pandas import DataFrame\r\nimport pandas._testing as tm\r\n\r\nimport pandas.io.formats.format as fmt\r\n\r\n\r\nclass TestEngFormatter:\r\n def test_eng_float_formatter(self):\r\n df = DataFrame({\"A\": [1.41, 141.0, 14100, 1410000.0]})\r\n\r\n fmt.set_eng_float_format()\r\n result = df.to_string()\r\n expected = (\r\n \" A\\n\"\r\n \"0 1.410E+00\\n\"\r\n \"1 141.000E+00\\n\"\r\n \"2 14.100E+03\\n\"\r\n \"3 1.410E+06\"\r\n )\r\n assert result == expected\r\n\r\n fmt.set_eng_float_format(use_eng_prefix=True)\r\n result = df.to_string()\r\n expected = \" A\\n0 1.410\\n1 141.000\\n2 14.100k\\n3 1.410M\"\r\n assert result == expected\r\n\r\n fmt.set_eng_float_format(accuracy=0)\r\n result = df.to_string()\r\n expected = \" A\\n0 1E+00\\n1 141E+00\\n2 14E+03\\n3 1E+06\"\r\n assert result == expected\r\n\r\n tm.reset_display_options()\r\n\r\n def compare(self, formatter, input, output):\r\n formatted_input = formatter(input)\r\n assert formatted_input == output\r\n\r\n def compare_all(self, formatter, in_out):\r\n \"\"\"\r\n Parameters:\r\n -----------\r\n formatter: EngFormatter under test\r\n in_out: list of tuples. Each tuple = (number, expected_formatting)\r\n\r\n It is tested if 'formatter(number) == expected_formatting'.\r\n *number* should be >= 0 because formatter(-number) == fmt is also\r\n tested. *fmt* is derived from *expected_formatting*\r\n \"\"\"\r\n for input, output in in_out:\r\n self.compare(formatter, input, output)\r\n self.compare(formatter, -input, \"-\" + output[1:])\r\n\r\n def test_exponents_with_eng_prefix(self):\r\n formatter = fmt.EngFormatter(accuracy=3, use_eng_prefix=True)\r\n f = np.sqrt(2)\r\n in_out = [\r\n (f * 10 ** -24, \" 1.414y\"),\r\n (f * 10 ** -23, \" 14.142y\"),\r\n (f * 10 ** -22, \" 141.421y\"),\r\n (f * 10 ** -21, \" 1.414z\"),\r\n (f * 10 ** -20, \" 14.142z\"),\r\n (f * 10 ** -19, \" 141.421z\"),\r\n (f * 10 ** -18, \" 1.414a\"),\r\n (f * 10 ** -17, \" 14.142a\"),\r\n (f * 10 ** -16, \" 141.421a\"),\r\n (f * 10 ** -15, \" 1.414f\"),\r\n (f * 10 ** -14, \" 14.142f\"),\r\n (f * 10 ** -13, \" 141.421f\"),\r\n (f * 10 ** -12, \" 1.414p\"),\r\n (f * 10 ** -11, \" 14.142p\"),\r\n (f * 10 ** -10, \" 141.421p\"),\r\n (f * 10 ** -9, \" 1.414n\"),\r\n (f * 10 ** -8, \" 14.142n\"),\r\n (f * 10 ** -7, \" 141.421n\"),\r\n (f * 10 ** -6, \" 1.414u\"),\r\n (f * 10 ** -5, \" 14.142u\"),\r\n (f * 10 ** -4, \" 141.421u\"),\r\n (f * 10 ** -3, \" 1.414m\"),\r\n (f * 10 ** -2, \" 14.142m\"),\r\n (f * 10 ** -1, \" 141.421m\"),\r\n (f * 10 ** 0, \" 1.414\"),\r\n (f * 10 ** 1, \" 14.142\"),\r\n (f * 10 ** 2, \" 141.421\"),\r\n (f * 10 ** 3, \" 1.414k\"),\r\n (f * 10 ** 4, \" 14.142k\"),\r\n (f * 10 ** 5, \" 141.421k\"),\r\n (f * 10 ** 6, \" 1.414M\"),\r\n (f * 10 ** 7, \" 14.142M\"),\r\n (f * 10 ** 8, \" 141.421M\"),\r\n (f * 10 ** 9, \" 1.414G\"),\r\n (f * 10 ** 10, \" 14.142G\"),\r\n (f * 10 ** 11, \" 141.421G\"),\r\n (f * 10 ** 12, \" 1.414T\"),\r\n (f * 10 ** 13, \" 14.142T\"),\r\n (f * 10 ** 14, \" 141.421T\"),\r\n (f * 10 ** 15, \" 1.414P\"),\r\n (f * 10 ** 16, \" 14.142P\"),\r\n (f * 10 ** 17, \" 141.421P\"),\r\n (f * 10 ** 18, \" 1.414E\"),\r\n (f * 10 ** 19, \" 14.142E\"),\r\n (f * 10 ** 20, \" 141.421E\"),\r\n (f * 10 ** 21, \" 1.414Z\"),\r\n (f * 10 ** 22, \" 14.142Z\"),\r\n (f * 10 ** 23, \" 141.421Z\"),\r\n (f * 10 ** 24, \" 1.414Y\"),\r\n (f * 10 ** 25, \" 14.142Y\"),\r\n (f * 10 ** 26, \" 141.421Y\"),\r\n ]\r\n self.compare_all(formatter, in_out)\r\n\r\n def test_exponents_without_eng_prefix(self):\r\n formatter = fmt.EngFormatter(accuracy=4, use_eng_prefix=False)\r\n f = np.pi\r\n in_out = [\r\n (f * 10 ** -24, \" 3.1416E-24\"),\r\n (f * 10 ** -23, \" 31.4159E-24\"),\r\n (f * 10 ** -22, \" 314.1593E-24\"),\r\n (f * 10 ** -21, \" 3.1416E-21\"),\r\n (f * 10 ** -20, \" 31.4159E-21\"),\r\n (f * 10 ** -19, \" 314.1593E-21\"),\r\n (f * 10 ** -18, \" 3.1416E-18\"),\r\n (f * 10 ** -17, \" 31.4159E-18\"),\r\n (f * 10 ** -16, \" 314.1593E-18\"),\r\n (f * 10 ** -15, \" 3.1416E-15\"),\r\n (f * 10 ** -14, \" 31.4159E-15\"),\r\n (f * 10 ** -13, \" 314.1593E-15\"),\r\n (f * 10 ** -12, \" 3.1416E-12\"),\r\n (f * 10 ** -11, \" 31.4159E-12\"),\r\n (f * 10 ** -10, \" 314.1593E-12\"),\r\n (f * 10 ** -9, \" 3.1416E-09\"),\r\n (f * 10 ** -8, \" 31.4159E-09\"),\r\n (f * 10 ** -7, \" 314.1593E-09\"),\r\n (f * 10 ** -6, \" 3.1416E-06\"),\r\n (f * 10 ** -5, \" 31.4159E-06\"),\r\n (f * 10 ** -4, \" 314.1593E-06\"),\r\n (f * 10 ** -3, \" 3.1416E-03\"),\r\n (f * 10 ** -2, \" 31.4159E-03\"),\r\n (f * 10 ** -1, \" 314.1593E-03\"),\r\n (f * 10 ** 0, \" 3.1416E+00\"),\r\n (f * 10 ** 1, \" 31.4159E+00\"),\r\n (f * 10 ** 2, \" 314.1593E+00\"),\r\n (f * 10 ** 3, \" 3.1416E+03\"),\r\n (f * 10 ** 4, \" 31.4159E+03\"),\r\n (f * 10 ** 5, \" 314.1593E+03\"),\r\n (f * 10 ** 6, \" 3.1416E+06\"),\r\n (f * 10 ** 7, \" 31.4159E+06\"),\r\n (f * 10 ** 8, \" 314.1593E+06\"),\r\n (f * 10 ** 9, \" 3.1416E+09\"),\r\n (f * 10 ** 10, \" 31.4159E+09\"),\r\n (f * 10 ** 11, \" 314.1593E+09\"),\r\n (f * 10 ** 12, \" 3.1416E+12\"),\r\n (f * 10 ** 13, \" 31.4159E+12\"),\r\n (f * 10 ** 14, \" 314.1593E+12\"),\r\n (f * 10 ** 15, \" 3.1416E+15\"),\r\n (f * 10 ** 16, \" 31.4159E+15\"),\r\n (f * 10 ** 17, \" 314.1593E+15\"),\r\n (f * 10 ** 18, \" 3.1416E+18\"),\r\n (f * 10 ** 19, \" 31.4159E+18\"),\r\n (f * 10 ** 20, \" 314.1593E+18\"),\r\n (f * 10 ** 21, \" 3.1416E+21\"),\r\n (f * 10 ** 22, \" 31.4159E+21\"),\r\n (f * 10 ** 23, \" 314.1593E+21\"),\r\n (f * 10 ** 24, \" 3.1416E+24\"),\r\n (f * 10 ** 25, \" 31.4159E+24\"),\r\n (f * 10 ** 26, \" 314.1593E+24\"),\r\n ]\r\n self.compare_all(formatter, in_out)\r\n\r\n def test_rounding(self):\r\n formatter = fmt.EngFormatter(accuracy=3, use_eng_prefix=True)\r\n in_out = [\r\n (5.55555, \" 5.556\"),\r\n (55.5555, \" 55.556\"),\r\n (555.555, \" 555.555\"),\r\n (5555.55, \" 5.556k\"),\r\n (55555.5, \" 55.556k\"),\r\n (555555, \" 555.555k\"),\r\n ]\r\n self.compare_all(formatter, in_out)\r\n\r\n formatter = fmt.EngFormatter(accuracy=1, use_eng_prefix=True)\r\n in_out = [\r\n (5.55555, \" 5.6\"),\r\n (55.5555, \" 55.6\"),\r\n (555.555, \" 555.6\"),\r\n (5555.55, \" 5.6k\"),\r\n (55555.5, \" 55.6k\"),\r\n (555555, \" 555.6k\"),\r\n ]\r\n self.compare_all(formatter, in_out)\r\n\r\n formatter = fmt.EngFormatter(accuracy=0, use_eng_prefix=True)\r\n in_out = [\r\n (5.55555, \" 6\"),\r\n (55.5555, \" 56\"),\r\n (555.555, \" 556\"),\r\n (5555.55, \" 6k\"),\r\n (55555.5, \" 56k\"),\r\n (555555, \" 556k\"),\r\n ]\r\n self.compare_all(formatter, in_out)\r\n\r\n formatter = fmt.EngFormatter(accuracy=3, use_eng_prefix=True)\r\n result = formatter(0)\r\n assert result == \" 0.000\"\r\n\r\n def test_nan(self):\r\n # Issue #11981\r\n\r\n formatter = fmt.EngFormatter(accuracy=1, use_eng_prefix=True)\r\n result = formatter(np.nan)\r\n assert result == \"NaN\"\r\n\r\n df = pd.DataFrame(\r\n {\r\n \"a\": [1.5, 10.3, 20.5],\r\n \"b\": [50.3, 60.67, 70.12],\r\n \"c\": [100.2, 101.33, 120.33],\r\n }\r\n )\r\n pt = df.pivot_table(values=\"a\", index=\"b\", columns=\"c\")\r\n fmt.set_eng_float_format(accuracy=1)\r\n result = pt.to_string()\r\n assert \"NaN\" in result\r\n tm.reset_display_options()\r\n\r\n def test_inf(self):\r\n # Issue #11981\r\n\r\n formatter = fmt.EngFormatter(accuracy=1, use_eng_prefix=True)\r\n result = formatter(np.inf)\r\n assert result == \"inf\"\r\n",
"from collections import Counter, defaultdict\r\nfrom itertools import chain\r\n\r\nimport numpy as np\r\nimport pytest\r\n\r\nimport pandas as pd\r\nfrom pandas import DataFrame, Index, MultiIndex, Series, isna\r\nimport pandas._testing as tm\r\nfrom pandas.core.base import SpecificationError\r\n\r\n\r\nclass TestSeriesApply:\r\n def test_apply(self, datetime_series):\r\n with np.errstate(all=\"ignore\"):\r\n tm.assert_series_equal(\r\n datetime_series.apply(np.sqrt), np.sqrt(datetime_series)\r\n )\r\n\r\n # element-wise apply\r\n import math\r\n\r\n tm.assert_series_equal(\r\n datetime_series.apply(math.exp), np.exp(datetime_series)\r\n )\r\n\r\n # empty series\r\n s = Series(dtype=object, name=\"foo\", index=pd.Index([], name=\"bar\"))\r\n rs = s.apply(lambda x: x)\r\n tm.assert_series_equal(s, rs)\r\n\r\n # check all metadata (GH 9322)\r\n assert s is not rs\r\n assert s.index is rs.index\r\n assert s.dtype == rs.dtype\r\n assert s.name == rs.name\r\n\r\n # index but no data\r\n s = Series(index=[1, 2, 3], dtype=np.float64)\r\n rs = s.apply(lambda x: x)\r\n tm.assert_series_equal(s, rs)\r\n\r\n def test_apply_same_length_inference_bug(self):\r\n s = Series([1, 2])\r\n\r\n def f(x):\r\n return (x, x + 1)\r\n\r\n result = s.apply(f)\r\n expected = s.map(f)\r\n tm.assert_series_equal(result, expected)\r\n\r\n s = Series([1, 2, 3])\r\n result = s.apply(f)\r\n expected = s.map(f)\r\n tm.assert_series_equal(result, expected)\r\n\r\n def test_apply_dont_convert_dtype(self):\r\n s = Series(np.random.randn(10))\r\n\r\n def f(x):\r\n return x if x > 0 else np.nan\r\n\r\n result = s.apply(f, convert_dtype=False)\r\n assert result.dtype == object\r\n\r\n def test_with_string_args(self, datetime_series):\r\n\r\n for arg in [\"sum\", \"mean\", \"min\", \"max\", \"std\"]:\r\n result = datetime_series.apply(arg)\r\n expected = getattr(datetime_series, arg)()\r\n assert result == expected\r\n\r\n def test_apply_args(self):\r\n s = Series([\"foo,bar\"])\r\n\r\n result = s.apply(str.split, args=(\",\",))\r\n assert result[0] == [\"foo\", \"bar\"]\r\n assert isinstance(result[0], list)\r\n\r\n def test_series_map_box_timestamps(self):\r\n # GH#2689, GH#2627\r\n ser = Series(pd.date_range(\"1/1/2000\", periods=10))\r\n\r\n def func(x):\r\n return (x.hour, x.day, x.month)\r\n\r\n # it works!\r\n ser.map(func)\r\n ser.apply(func)\r\n\r\n def test_apply_box(self):\r\n # ufunc will not be boxed. Same test cases as the test_map_box\r\n vals = [pd.Timestamp(\"2011-01-01\"), pd.Timestamp(\"2011-01-02\")]\r\n s = pd.Series(vals)\r\n assert s.dtype == \"datetime64[ns]\"\r\n # boxed value must be Timestamp instance\r\n res = s.apply(lambda x: f\"{type(x).__name__}_{x.day}_{x.tz}\")\r\n exp = pd.Series([\"Timestamp_1_None\", \"Timestamp_2_None\"])\r\n tm.assert_series_equal(res, exp)\r\n\r\n vals = [\r\n pd.Timestamp(\"2011-01-01\", tz=\"US/Eastern\"),\r\n pd.Timestamp(\"2011-01-02\", tz=\"US/Eastern\"),\r\n ]\r\n s = pd.Series(vals)\r\n assert s.dtype == \"datetime64[ns, US/Eastern]\"\r\n res = s.apply(lambda x: f\"{type(x).__name__}_{x.day}_{x.tz}\")\r\n exp = pd.Series([\"Timestamp_1_US/Eastern\", \"Timestamp_2_US/Eastern\"])\r\n tm.assert_series_equal(res, exp)\r\n\r\n # timedelta\r\n vals = [pd.Timedelta(\"1 days\"), pd.Timedelta(\"2 days\")]\r\n s = pd.Series(vals)\r\n assert s.dtype == \"timedelta64[ns]\"\r\n res = s.apply(lambda x: f\"{type(x).__name__}_{x.days}\")\r\n exp = pd.Series([\"Timedelta_1\", \"Timedelta_2\"])\r\n tm.assert_series_equal(res, exp)\r\n\r\n # period\r\n vals = [pd.Period(\"2011-01-01\", freq=\"M\"), pd.Period(\"2011-01-02\", freq=\"M\")]\r\n s = pd.Series(vals)\r\n assert s.dtype == \"Period[M]\"\r\n res = s.apply(lambda x: f\"{type(x).__name__}_{x.freqstr}\")\r\n exp = pd.Series([\"Period_M\", \"Period_M\"])\r\n tm.assert_series_equal(res, exp)\r\n\r\n def test_apply_datetimetz(self):\r\n values = pd.date_range(\"2011-01-01\", \"2011-01-02\", freq=\"H\").tz_localize(\r\n \"Asia/Tokyo\"\r\n )\r\n s = pd.Series(values, name=\"XX\")\r\n\r\n result = s.apply(lambda x: x + pd.offsets.Day())\r\n exp_values = pd.date_range(\"2011-01-02\", \"2011-01-03\", freq=\"H\").tz_localize(\r\n \"Asia/Tokyo\"\r\n )\r\n exp = pd.Series(exp_values, name=\"XX\")\r\n tm.assert_series_equal(result, exp)\r\n\r\n # change dtype\r\n # GH 14506 : Returned dtype changed from int32 to int64\r\n result = s.apply(lambda x: x.hour)\r\n exp = pd.Series(list(range(24)) + [0], name=\"XX\", dtype=np.int64)\r\n tm.assert_series_equal(result, exp)\r\n\r\n # not vectorized\r\n def f(x):\r\n if not isinstance(x, pd.Timestamp):\r\n raise ValueError\r\n return str(x.tz)\r\n\r\n result = s.map(f)\r\n exp = pd.Series([\"Asia/Tokyo\"] * 25, name=\"XX\")\r\n tm.assert_series_equal(result, exp)\r\n\r\n def test_apply_dict_depr(self):\r\n\r\n tsdf = pd.DataFrame(\r\n np.random.randn(10, 3),\r\n columns=[\"A\", \"B\", \"C\"],\r\n index=pd.date_range(\"1/1/2000\", periods=10),\r\n )\r\n msg = \"nested renamer is not supported\"\r\n with pytest.raises(SpecificationError, match=msg):\r\n tsdf.A.agg({\"foo\": [\"sum\", \"mean\"]})\r\n\r\n def test_apply_categorical(self):\r\n values = pd.Categorical(list(\"ABBABCD\"), categories=list(\"DCBA\"), ordered=True)\r\n ser = pd.Series(values, name=\"XX\", index=list(\"abcdefg\"))\r\n result = ser.apply(lambda x: x.lower())\r\n\r\n # should be categorical dtype when the number of categories are\r\n # the same\r\n values = pd.Categorical(list(\"abbabcd\"), categories=list(\"dcba\"), ordered=True)\r\n exp = pd.Series(values, name=\"XX\", index=list(\"abcdefg\"))\r\n tm.assert_series_equal(result, exp)\r\n tm.assert_categorical_equal(result.values, exp.values)\r\n\r\n result = ser.apply(lambda x: \"A\")\r\n exp = pd.Series([\"A\"] * 7, name=\"XX\", index=list(\"abcdefg\"))\r\n tm.assert_series_equal(result, exp)\r\n assert result.dtype == object\r\n\r\n @pytest.mark.parametrize(\"series\", [[\"1-1\", \"1-1\", np.NaN], [\"1-1\", \"1-2\", np.NaN]])\r\n def test_apply_categorical_with_nan_values(self, series):\r\n # GH 20714 bug fixed in: GH 24275\r\n s = pd.Series(series, dtype=\"category\")\r\n result = s.apply(lambda x: x.split(\"-\")[0])\r\n result = result.astype(object)\r\n expected = pd.Series([\"1\", \"1\", np.NaN], dtype=\"category\")\r\n expected = expected.astype(object)\r\n tm.assert_series_equal(result, expected)\r\n\r\n def test_apply_empty_integer_series_with_datetime_index(self):\r\n # GH 21245\r\n s = pd.Series([], index=pd.date_range(start=\"2018-01-01\", periods=0), dtype=int)\r\n result = s.apply(lambda x: x)\r\n tm.assert_series_equal(result, s)\r\n\r\n\r\nclass TestSeriesAggregate:\r\n def test_transform(self, string_series):\r\n # transforming functions\r\n\r\n with np.errstate(all=\"ignore\"):\r\n\r\n f_sqrt = np.sqrt(string_series)\r\n f_abs = np.abs(string_series)\r\n\r\n # ufunc\r\n result = string_series.transform(np.sqrt)\r\n expected = f_sqrt.copy()\r\n tm.assert_series_equal(result, expected)\r\n\r\n result = string_series.apply(np.sqrt)\r\n tm.assert_series_equal(result, expected)\r\n\r\n # list-like\r\n result = string_series.transform([np.sqrt])\r\n expected = f_sqrt.to_frame().copy()\r\n expected.columns = [\"sqrt\"]\r\n tm.assert_frame_equal(result, expected)\r\n\r\n result = string_series.transform([np.sqrt])\r\n tm.assert_frame_equal(result, expected)\r\n\r\n result = string_series.transform([\"sqrt\"])\r\n tm.assert_frame_equal(result, expected)\r\n\r\n # multiple items in list\r\n # these are in the order as if we are applying both functions per\r\n # series and then concatting\r\n expected = pd.concat([f_sqrt, f_abs], axis=1)\r\n expected.columns = [\"sqrt\", \"absolute\"]\r\n result = string_series.apply([np.sqrt, np.abs])\r\n tm.assert_frame_equal(result, expected)\r\n\r\n result = string_series.transform([\"sqrt\", \"abs\"])\r\n expected.columns = [\"sqrt\", \"abs\"]\r\n tm.assert_frame_equal(result, expected)\r\n\r\n # dict, provide renaming\r\n expected = pd.concat([f_sqrt, f_abs], axis=1)\r\n expected.columns = [\"foo\", \"bar\"]\r\n expected = expected.unstack().rename(\"series\")\r\n\r\n result = string_series.apply({\"foo\": np.sqrt, \"bar\": np.abs})\r\n tm.assert_series_equal(result.reindex_like(expected), expected)\r\n\r\n def test_transform_and_agg_error(self, string_series):\r\n # we are trying to transform with an aggregator\r\n msg = \"transforms cannot produce aggregated results\"\r\n with pytest.raises(ValueError, match=msg):\r\n string_series.transform([\"min\", \"max\"])\r\n\r\n msg = \"cannot combine transform and aggregation\"\r\n with pytest.raises(ValueError, match=msg):\r\n with np.errstate(all=\"ignore\"):\r\n string_series.agg([\"sqrt\", \"max\"])\r\n\r\n with pytest.raises(ValueError, match=msg):\r\n with np.errstate(all=\"ignore\"):\r\n string_series.transform([\"sqrt\", \"max\"])\r\n\r\n msg = \"cannot perform both aggregation and transformation\"\r\n with pytest.raises(ValueError, match=msg):\r\n with np.errstate(all=\"ignore\"):\r\n string_series.agg({\"foo\": np.sqrt, \"bar\": \"sum\"})\r\n\r\n def test_demo(self):\r\n # demonstration tests\r\n s = Series(range(6), dtype=\"int64\", name=\"series\")\r\n\r\n result = s.agg([\"min\", \"max\"])\r\n expected = Series([0, 5], index=[\"min\", \"max\"], name=\"series\")\r\n tm.assert_series_equal(result, expected)\r\n\r\n result = s.agg({\"foo\": \"min\"})\r\n expected = Series([0], index=[\"foo\"], name=\"series\")\r\n tm.assert_series_equal(result, expected)\r\n\r\n # nested renaming\r\n msg = \"nested renamer is not supported\"\r\n with pytest.raises(SpecificationError, match=msg):\r\n s.agg({\"foo\": [\"min\", \"max\"]})\r\n\r\n def test_multiple_aggregators_with_dict_api(self):\r\n\r\n s = Series(range(6), dtype=\"int64\", name=\"series\")\r\n # nested renaming\r\n msg = \"nested renamer is not supported\"\r\n with pytest.raises(SpecificationError, match=msg):\r\n s.agg({\"foo\": [\"min\", \"max\"], \"bar\": [\"sum\", \"mean\"]})\r\n\r\n def test_agg_apply_evaluate_lambdas_the_same(self, string_series):\r\n # test that we are evaluating row-by-row first\r\n # before vectorized evaluation\r\n result = string_series.apply(lambda x: str(x))\r\n expected = string_series.agg(lambda x: str(x))\r\n tm.assert_series_equal(result, expected)\r\n\r\n result = string_series.apply(str)\r\n expected = string_series.agg(str)\r\n tm.assert_series_equal(result, expected)\r\n\r\n def test_with_nested_series(self, datetime_series):\r\n # GH 2316\r\n # .agg with a reducer and a transform, what to do\r\n result = datetime_series.apply(\r\n lambda x: Series([x, x ** 2], index=[\"x\", \"x^2\"])\r\n )\r\n expected = DataFrame({\"x\": datetime_series, \"x^2\": datetime_series ** 2})\r\n tm.assert_frame_equal(result, expected)\r\n\r\n result = datetime_series.agg(lambda x: Series([x, x ** 2], index=[\"x\", \"x^2\"]))\r\n tm.assert_frame_equal(result, expected)\r\n\r\n def test_replicate_describe(self, string_series):\r\n # this also tests a result set that is all scalars\r\n expected = string_series.describe()\r\n result = string_series.apply(\r\n {\r\n \"count\": \"count\",\r\n \"mean\": \"mean\",\r\n \"std\": \"std\",\r\n \"min\": \"min\",\r\n \"25%\": lambda x: x.quantile(0.25),\r\n \"50%\": \"median\",\r\n \"75%\": lambda x: x.quantile(0.75),\r\n \"max\": \"max\",\r\n }\r\n )\r\n tm.assert_series_equal(result, expected)\r\n\r\n def test_reduce(self, string_series):\r\n # reductions with named functions\r\n result = string_series.agg([\"sum\", \"mean\"])\r\n expected = Series(\r\n [string_series.sum(), string_series.mean()],\r\n [\"sum\", \"mean\"],\r\n name=string_series.name,\r\n )\r\n tm.assert_series_equal(result, expected)\r\n\r\n def test_non_callable_aggregates(self):\r\n # test agg using non-callable series attributes\r\n s = Series([1, 2, None])\r\n\r\n # Calling agg w/ just a string arg same as calling s.arg\r\n result = s.agg(\"size\")\r\n expected = s.size\r\n assert result == expected\r\n\r\n # test when mixed w/ callable reducers\r\n result = s.agg([\"size\", \"count\", \"mean\"])\r\n expected = Series({\"size\": 3.0, \"count\": 2.0, \"mean\": 1.5})\r\n tm.assert_series_equal(result[expected.index], expected)\r\n\r\n @pytest.mark.parametrize(\r\n \"series, func, expected\",\r\n chain(\r\n tm.get_cython_table_params(\r\n Series(dtype=np.float64),\r\n [\r\n (\"sum\", 0),\r\n (\"max\", np.nan),\r\n (\"min\", np.nan),\r\n (\"all\", True),\r\n (\"any\", False),\r\n (\"mean\", np.nan),\r\n (\"prod\", 1),\r\n (\"std\", np.nan),\r\n (\"var\", np.nan),\r\n (\"median\", np.nan),\r\n ],\r\n ),\r\n tm.get_cython_table_params(\r\n Series([np.nan, 1, 2, 3]),\r\n [\r\n (\"sum\", 6),\r\n (\"max\", 3),\r\n (\"min\", 1),\r\n (\"all\", True),\r\n (\"any\", True),\r\n (\"mean\", 2),\r\n (\"prod\", 6),\r\n (\"std\", 1),\r\n (\"var\", 1),\r\n (\"median\", 2),\r\n ],\r\n ),\r\n tm.get_cython_table_params(\r\n Series(\"a b c\".split()),\r\n [\r\n (\"sum\", \"abc\"),\r\n (\"max\", \"c\"),\r\n (\"min\", \"a\"),\r\n (\"all\", \"c\"), # see GH12863\r\n (\"any\", \"a\"),\r\n ],\r\n ),\r\n ),\r\n )\r\n def test_agg_cython_table(self, series, func, expected):\r\n # GH21224\r\n # test reducing functions in\r\n # pandas.core.base.SelectionMixin._cython_table\r\n result = series.agg(func)\r\n if tm.is_number(expected):\r\n assert np.isclose(result, expected, equal_nan=True)\r\n else:\r\n assert result == expected\r\n\r\n @pytest.mark.parametrize(\r\n \"series, func, expected\",\r\n chain(\r\n tm.get_cython_table_params(\r\n Series(dtype=np.float64),\r\n [\r\n (\"cumprod\", Series([], Index([]), dtype=np.float64)),\r\n (\"cumsum\", Series([], Index([]), dtype=np.float64)),\r\n ],\r\n ),\r\n tm.get_cython_table_params(\r\n Series([np.nan, 1, 2, 3]),\r\n [\r\n (\"cumprod\", Series([np.nan, 1, 2, 6])),\r\n (\"cumsum\", Series([np.nan, 1, 3, 6])),\r\n ],\r\n ),\r\n tm.get_cython_table_params(\r\n Series(\"a b c\".split()), [(\"cumsum\", Series([\"a\", \"ab\", \"abc\"]))]\r\n ),\r\n ),\r\n )\r\n def test_agg_cython_table_transform(self, series, func, expected):\r\n # GH21224\r\n # test transforming functions in\r\n # pandas.core.base.SelectionMixin._cython_table (cumprod, cumsum)\r\n result = series.agg(func)\r\n tm.assert_series_equal(result, expected)\r\n\r\n @pytest.mark.parametrize(\r\n \"series, func, expected\",\r\n chain(\r\n tm.get_cython_table_params(\r\n Series(\"a b c\".split()),\r\n [\r\n (\"mean\", TypeError), # mean raises TypeError\r\n (\"prod\", TypeError),\r\n (\"std\", TypeError),\r\n (\"var\", TypeError),\r\n (\"median\", TypeError),\r\n (\"cumprod\", TypeError),\r\n ],\r\n )\r\n ),\r\n )\r\n def test_agg_cython_table_raises(self, series, func, expected):\r\n # GH21224\r\n with pytest.raises(expected):\r\n # e.g. Series('a b'.split()).cumprod() will raise\r\n series.agg(func)\r\n\r\n def test_transform_none_to_type(self):\r\n # GH34377\r\n df = pd.DataFrame({\"a\": [None]})\r\n\r\n msg = \"DataFrame constructor called with incompatible data and dtype\"\r\n with pytest.raises(TypeError, match=msg):\r\n df.transform({\"a\": int})\r\n\r\n def test_series_apply_no_suffix_index(self):\r\n # GH36189\r\n s = pd.Series([4] * 3)\r\n result = s.apply([\"sum\", lambda x: x.sum(), lambda x: x.sum()])\r\n expected = pd.Series([12, 12, 12], index=[\"sum\", \"<lambda>\", \"<lambda>\"])\r\n\r\n tm.assert_series_equal(result, expected)\r\n\r\n\r\nclass TestSeriesMap:\r\n def test_map(self, datetime_series):\r\n index, data = tm.getMixedTypeDict()\r\n\r\n source = Series(data[\"B\"], index=data[\"C\"])\r\n target = Series(data[\"C\"][:4], index=data[\"D\"][:4])\r\n\r\n merged = target.map(source)\r\n\r\n for k, v in merged.items():\r\n assert v == source[target[k]]\r\n\r\n # input could be a dict\r\n merged = target.map(source.to_dict())\r\n\r\n for k, v in merged.items():\r\n assert v == source[target[k]]\r\n\r\n # function\r\n result = datetime_series.map(lambda x: x * 2)\r\n tm.assert_series_equal(result, datetime_series * 2)\r\n\r\n # GH 10324\r\n a = Series([1, 2, 3, 4])\r\n b = Series([\"even\", \"odd\", \"even\", \"odd\"], dtype=\"category\")\r\n c = Series([\"even\", \"odd\", \"even\", \"odd\"])\r\n\r\n exp = Series([\"odd\", \"even\", \"odd\", np.nan], dtype=\"category\")\r\n tm.assert_series_equal(a.map(b), exp)\r\n exp = Series([\"odd\", \"even\", \"odd\", np.nan])\r\n tm.assert_series_equal(a.map(c), exp)\r\n\r\n a = Series([\"a\", \"b\", \"c\", \"d\"])\r\n b = Series([1, 2, 3, 4], index=pd.CategoricalIndex([\"b\", \"c\", \"d\", \"e\"]))\r\n c = Series([1, 2, 3, 4], index=Index([\"b\", \"c\", \"d\", \"e\"]))\r\n\r\n exp = Series([np.nan, 1, 2, 3])\r\n tm.assert_series_equal(a.map(b), exp)\r\n exp = Series([np.nan, 1, 2, 3])\r\n tm.assert_series_equal(a.map(c), exp)\r\n\r\n a = Series([\"a\", \"b\", \"c\", \"d\"])\r\n b = Series(\r\n [\"B\", \"C\", \"D\", \"E\"],\r\n dtype=\"category\",\r\n index=pd.CategoricalIndex([\"b\", \"c\", \"d\", \"e\"]),\r\n )\r\n c = Series([\"B\", \"C\", \"D\", \"E\"], index=Index([\"b\", \"c\", \"d\", \"e\"]))\r\n\r\n exp = Series(\r\n pd.Categorical([np.nan, \"B\", \"C\", \"D\"], categories=[\"B\", \"C\", \"D\", \"E\"])\r\n )\r\n tm.assert_series_equal(a.map(b), exp)\r\n exp = Series([np.nan, \"B\", \"C\", \"D\"])\r\n tm.assert_series_equal(a.map(c), exp)\r\n\r\n def test_map_empty(self, index):\r\n if isinstance(index, MultiIndex):\r\n pytest.skip(\"Initializing a Series from a MultiIndex is not supported\")\r\n\r\n s = Series(index)\r\n result = s.map({})\r\n\r\n expected = pd.Series(np.nan, index=s.index)\r\n tm.assert_series_equal(result, expected)\r\n\r\n def test_map_compat(self):\r\n # related GH 8024\r\n s = Series([True, True, False], index=[1, 2, 3])\r\n result = s.map({True: \"foo\", False: \"bar\"})\r\n expected = Series([\"foo\", \"foo\", \"bar\"], index=[1, 2, 3])\r\n tm.assert_series_equal(result, expected)\r\n\r\n def test_map_int(self):\r\n left = Series({\"a\": 1.0, \"b\": 2.0, \"c\": 3.0, \"d\": 4})\r\n right = Series({1: 11, 2: 22, 3: 33})\r\n\r\n assert left.dtype == np.float_\r\n assert issubclass(right.dtype.type, np.integer)\r\n\r\n merged = left.map(right)\r\n assert merged.dtype == np.float_\r\n assert isna(merged[\"d\"])\r\n assert not isna(merged[\"c\"])\r\n\r\n def test_map_type_inference(self):\r\n s = Series(range(3))\r\n s2 = s.map(lambda x: np.where(x == 0, 0, 1))\r\n assert issubclass(s2.dtype.type, np.integer)\r\n\r\n def test_map_decimal(self, string_series):\r\n from decimal import Decimal\r\n\r\n result = string_series.map(lambda x: Decimal(str(x)))\r\n assert result.dtype == np.object_\r\n assert isinstance(result[0], Decimal)\r\n\r\n def test_map_na_exclusion(self):\r\n s = Series([1.5, np.nan, 3, np.nan, 5])\r\n\r\n result = s.map(lambda x: x * 2, na_action=\"ignore\")\r\n exp = s * 2\r\n tm.assert_series_equal(result, exp)\r\n\r\n def test_map_dict_with_tuple_keys(self):\r\n \"\"\"\r\n Due to new MultiIndex-ing behaviour in v0.14.0,\r\n dicts with tuple keys passed to map were being\r\n converted to a multi-index, preventing tuple values\r\n from being mapped properly.\r\n \"\"\"\r\n # GH 18496\r\n df = pd.DataFrame({\"a\": [(1,), (2,), (3, 4), (5, 6)]})\r\n label_mappings = {(1,): \"A\", (2,): \"B\", (3, 4): \"A\", (5, 6): \"B\"}\r\n\r\n df[\"labels\"] = df[\"a\"].map(label_mappings)\r\n df[\"expected_labels\"] = pd.Series([\"A\", \"B\", \"A\", \"B\"], index=df.index)\r\n # All labels should be filled now\r\n tm.assert_series_equal(df[\"labels\"], df[\"expected_labels\"], check_names=False)\r\n\r\n def test_map_counter(self):\r\n s = Series([\"a\", \"b\", \"c\"], index=[1, 2, 3])\r\n counter = Counter()\r\n counter[\"b\"] = 5\r\n counter[\"c\"] += 1\r\n result = s.map(counter)\r\n expected = Series([0, 5, 1], index=[1, 2, 3])\r\n tm.assert_series_equal(result, expected)\r\n\r\n def test_map_defaultdict(self):\r\n s = Series([1, 2, 3], index=[\"a\", \"b\", \"c\"])\r\n default_dict = defaultdict(lambda: \"blank\")\r\n default_dict[1] = \"stuff\"\r\n result = s.map(default_dict)\r\n expected = Series([\"stuff\", \"blank\", \"blank\"], index=[\"a\", \"b\", \"c\"])\r\n tm.assert_series_equal(result, expected)\r\n\r\n def test_map_dict_na_key(self):\r\n # https://github.com/pandas-dev/pandas/issues/17648\r\n # Checks that np.nan key is appropriately mapped\r\n s = Series([1, 2, np.nan])\r\n expected = Series([\"a\", \"b\", \"c\"])\r\n result = s.map({1: \"a\", 2: \"b\", np.nan: \"c\"})\r\n tm.assert_series_equal(result, expected)\r\n\r\n def test_map_dict_subclass_with_missing(self):\r\n \"\"\"\r\n Test Series.map with a dictionary subclass that defines __missing__,\r\n i.e. sets a default value (GH #15999).\r\n \"\"\"\r\n\r\n class DictWithMissing(dict):\r\n def __missing__(self, key):\r\n return \"missing\"\r\n\r\n s = Series([1, 2, 3])\r\n dictionary = DictWithMissing({3: \"three\"})\r\n result = s.map(dictionary)\r\n expected = Series([\"missing\", \"missing\", \"three\"])\r\n tm.assert_series_equal(result, expected)\r\n\r\n def test_map_dict_subclass_without_missing(self):\r\n class DictWithoutMissing(dict):\r\n pass\r\n\r\n s = Series([1, 2, 3])\r\n dictionary = DictWithoutMissing({3: \"three\"})\r\n result = s.map(dictionary)\r\n expected = Series([np.nan, np.nan, \"three\"])\r\n tm.assert_series_equal(result, expected)\r\n\r\n def test_map_abc_mapping(self, non_dict_mapping_subclass):\r\n # https://github.com/pandas-dev/pandas/issues/29733\r\n # Check collections.abc.Mapping support as mapper for Series.map\r\n s = Series([1, 2, 3])\r\n not_a_dictionary = non_dict_mapping_subclass({3: \"three\"})\r\n result = s.map(not_a_dictionary)\r\n expected = Series([np.nan, np.nan, \"three\"])\r\n tm.assert_series_equal(result, expected)\r\n\r\n def test_map_abc_mapping_with_missing(self, non_dict_mapping_subclass):\r\n # https://github.com/pandas-dev/pandas/issues/29733\r\n # Check collections.abc.Mapping support as mapper for Series.map\r\n class NonDictMappingWithMissing(non_dict_mapping_subclass):\r\n def __missing__(self, key):\r\n return \"missing\"\r\n\r\n s = Series([1, 2, 3])\r\n not_a_dictionary = NonDictMappingWithMissing({3: \"three\"})\r\n result = s.map(not_a_dictionary)\r\n # __missing__ is a dict concept, not a Mapping concept,\r\n # so it should not change the result!\r\n expected = Series([np.nan, np.nan, \"three\"])\r\n tm.assert_series_equal(result, expected)\r\n\r\n def test_map_box(self):\r\n vals = [pd.Timestamp(\"2011-01-01\"), pd.Timestamp(\"2011-01-02\")]\r\n s = pd.Series(vals)\r\n assert s.dtype == \"datetime64[ns]\"\r\n # boxed value must be Timestamp instance\r\n res = s.apply(lambda x: f\"{type(x).__name__}_{x.day}_{x.tz}\")\r\n exp = pd.Series([\"Timestamp_1_None\", \"Timestamp_2_None\"])\r\n tm.assert_series_equal(res, exp)\r\n\r\n vals = [\r\n pd.Timestamp(\"2011-01-01\", tz=\"US/Eastern\"),\r\n pd.Timestamp(\"2011-01-02\", tz=\"US/Eastern\"),\r\n ]\r\n s = pd.Series(vals)\r\n assert s.dtype == \"datetime64[ns, US/Eastern]\"\r\n res = s.apply(lambda x: f\"{type(x).__name__}_{x.day}_{x.tz}\")\r\n exp = pd.Series([\"Timestamp_1_US/Eastern\", \"Timestamp_2_US/Eastern\"])\r\n tm.assert_series_equal(res, exp)\r\n\r\n # timedelta\r\n vals = [pd.Timedelta(\"1 days\"), pd.Timedelta(\"2 days\")]\r\n s = pd.Series(vals)\r\n assert s.dtype == \"timedelta64[ns]\"\r\n res = s.apply(lambda x: f\"{type(x).__name__}_{x.days}\")\r\n exp = pd.Series([\"Timedelta_1\", \"Timedelta_2\"])\r\n tm.assert_series_equal(res, exp)\r\n\r\n # period\r\n vals = [pd.Period(\"2011-01-01\", freq=\"M\"), pd.Period(\"2011-01-02\", freq=\"M\")]\r\n s = pd.Series(vals)\r\n assert s.dtype == \"Period[M]\"\r\n res = s.apply(lambda x: f\"{type(x).__name__}_{x.freqstr}\")\r\n exp = pd.Series([\"Period_M\", \"Period_M\"])\r\n tm.assert_series_equal(res, exp)\r\n\r\n def test_map_categorical(self):\r\n values = pd.Categorical(list(\"ABBABCD\"), categories=list(\"DCBA\"), ordered=True)\r\n s = pd.Series(values, name=\"XX\", index=list(\"abcdefg\"))\r\n\r\n result = s.map(lambda x: x.lower())\r\n exp_values = pd.Categorical(\r\n list(\"abbabcd\"), categories=list(\"dcba\"), ordered=True\r\n )\r\n exp = pd.Series(exp_values, name=\"XX\", index=list(\"abcdefg\"))\r\n tm.assert_series_equal(result, exp)\r\n tm.assert_categorical_equal(result.values, exp_values)\r\n\r\n result = s.map(lambda x: \"A\")\r\n exp = pd.Series([\"A\"] * 7, name=\"XX\", index=list(\"abcdefg\"))\r\n tm.assert_series_equal(result, exp)\r\n assert result.dtype == object\r\n\r\n with pytest.raises(NotImplementedError):\r\n s.map(lambda x: x, na_action=\"ignore\")\r\n\r\n def test_map_datetimetz(self):\r\n values = pd.date_range(\"2011-01-01\", \"2011-01-02\", freq=\"H\").tz_localize(\r\n \"Asia/Tokyo\"\r\n )\r\n s = pd.Series(values, name=\"XX\")\r\n\r\n # keep tz\r\n result = s.map(lambda x: x + pd.offsets.Day())\r\n exp_values = pd.date_range(\"2011-01-02\", \"2011-01-03\", freq=\"H\").tz_localize(\r\n \"Asia/Tokyo\"\r\n )\r\n exp = pd.Series(exp_values, name=\"XX\")\r\n tm.assert_series_equal(result, exp)\r\n\r\n # change dtype\r\n # GH 14506 : Returned dtype changed from int32 to int64\r\n result = s.map(lambda x: x.hour)\r\n exp = pd.Series(list(range(24)) + [0], name=\"XX\", dtype=np.int64)\r\n tm.assert_series_equal(result, exp)\r\n\r\n with pytest.raises(NotImplementedError):\r\n s.map(lambda x: x, na_action=\"ignore\")\r\n\r\n # not vectorized\r\n def f(x):\r\n if not isinstance(x, pd.Timestamp):\r\n raise ValueError\r\n return str(x.tz)\r\n\r\n result = s.map(f)\r\n exp = pd.Series([\"Asia/Tokyo\"] * 25, name=\"XX\")\r\n tm.assert_series_equal(result, exp)\r\n\r\n @pytest.mark.parametrize(\r\n \"vals,mapping,exp\",\r\n [\r\n (list(\"abc\"), {np.nan: \"not NaN\"}, [np.nan] * 3 + [\"not NaN\"]),\r\n (list(\"abc\"), {\"a\": \"a letter\"}, [\"a letter\"] + [np.nan] * 3),\r\n (list(range(3)), {0: 42}, [42] + [np.nan] * 3),\r\n ],\r\n )\r\n def test_map_missing_mixed(self, vals, mapping, exp):\r\n # GH20495\r\n s = pd.Series(vals + [np.nan])\r\n result = s.map(mapping)\r\n\r\n tm.assert_series_equal(result, pd.Series(exp))\r\n\r\n @pytest.mark.parametrize(\r\n \"dti,exp\",\r\n [\r\n (\r\n Series([1, 2], index=pd.DatetimeIndex([0, 31536000000])),\r\n DataFrame(np.repeat([[1, 2]], 2, axis=0), dtype=\"int64\"),\r\n ),\r\n (\r\n tm.makeTimeSeries(nper=30),\r\n DataFrame(np.repeat([[1, 2]], 30, axis=0), dtype=\"int64\"),\r\n ),\r\n ],\r\n )\r\n def test_apply_series_on_date_time_index_aware_series(self, dti, exp):\r\n # GH 25959\r\n # Calling apply on a localized time series should not cause an error\r\n index = dti.tz_localize(\"UTC\").index\r\n result = pd.Series(index).apply(lambda x: pd.Series([1, 2]))\r\n tm.assert_frame_equal(result, exp)\r\n\r\n def test_apply_scaler_on_date_time_index_aware_series(self):\r\n # GH 25959\r\n # Calling apply on a localized time series should not cause an error\r\n series = tm.makeTimeSeries(nper=30).tz_localize(\"UTC\")\r\n result = pd.Series(series.index).apply(lambda x: 1)\r\n tm.assert_series_equal(result, pd.Series(np.ones(30), dtype=\"int64\"))\r\n\r\n def test_map_float_to_string_precision(self):\r\n # GH 13228\r\n ser = pd.Series(1 / 3)\r\n result = ser.map(lambda val: str(val)).to_dict()\r\n expected = {0: \"0.3333333333333333\"}\r\n assert result == expected\r\n\r\n def test_map_with_invalid_na_action_raises(self):\r\n # https://github.com/pandas-dev/pandas/issues/32815\r\n s = pd.Series([1, 2, 3])\r\n msg = \"na_action must either be 'ignore' or None\"\r\n with pytest.raises(ValueError, match=msg):\r\n s.map(lambda x: x, na_action=\"____\")\r\n\r\n def test_apply_to_timedelta(self):\r\n list_of_valid_strings = [\"00:00:01\", \"00:00:02\"]\r\n a = pd.to_timedelta(list_of_valid_strings)\r\n b = Series(list_of_valid_strings).apply(pd.to_timedelta)\r\n # FIXME: dont leave commented-out\r\n # Can't compare until apply on a Series gives the correct dtype\r\n # assert_series_equal(a, b)\r\n\r\n list_of_strings = [\"00:00:01\", np.nan, pd.NaT, pd.NaT]\r\n\r\n a = pd.to_timedelta(list_of_strings) # noqa\r\n b = Series(list_of_strings).apply(pd.to_timedelta) # noqa\r\n # Can't compare until apply on a Series gives the correct dtype\r\n # assert_series_equal(a, b)\r\n",
"import numpy as np\r\nimport pytest\r\n\r\nimport pandas as pd\r\nfrom pandas import Int64Index, TimedeltaIndex, timedelta_range\r\nimport pandas._testing as tm\r\n\r\nfrom pandas.tseries.offsets import Hour\r\n\r\n\r\nclass TestTimedeltaIndex:\r\n def test_union(self):\r\n\r\n i1 = timedelta_range(\"1day\", periods=5)\r\n i2 = timedelta_range(\"3day\", periods=5)\r\n result = i1.union(i2)\r\n expected = timedelta_range(\"1day\", periods=7)\r\n tm.assert_index_equal(result, expected)\r\n\r\n i1 = Int64Index(np.arange(0, 20, 2))\r\n i2 = timedelta_range(start=\"1 day\", periods=10, freq=\"D\")\r\n i1.union(i2) # Works\r\n i2.union(i1) # Fails with \"AttributeError: can't set attribute\"\r\n\r\n def test_union_sort_false(self):\r\n tdi = timedelta_range(\"1day\", periods=5)\r\n\r\n left = tdi[3:]\r\n right = tdi[:3]\r\n\r\n # Check that we are testing the desired code path\r\n assert left._can_fast_union(right)\r\n\r\n result = left.union(right)\r\n tm.assert_index_equal(result, tdi)\r\n\r\n result = left.union(right, sort=False)\r\n expected = pd.TimedeltaIndex([\"4 Days\", \"5 Days\", \"1 Days\", \"2 Day\", \"3 Days\"])\r\n tm.assert_index_equal(result, expected)\r\n\r\n def test_union_coverage(self):\r\n\r\n idx = TimedeltaIndex([\"3d\", \"1d\", \"2d\"])\r\n ordered = TimedeltaIndex(idx.sort_values(), freq=\"infer\")\r\n result = ordered.union(idx)\r\n tm.assert_index_equal(result, ordered)\r\n\r\n result = ordered[:0].union(ordered)\r\n tm.assert_index_equal(result, ordered)\r\n assert result.freq == ordered.freq\r\n\r\n def test_union_bug_1730(self):\r\n\r\n rng_a = timedelta_range(\"1 day\", periods=4, freq=\"3H\")\r\n rng_b = timedelta_range(\"1 day\", periods=4, freq=\"4H\")\r\n\r\n result = rng_a.union(rng_b)\r\n exp = TimedeltaIndex(sorted(set(rng_a) | set(rng_b)))\r\n tm.assert_index_equal(result, exp)\r\n\r\n def test_union_bug_1745(self):\r\n\r\n left = TimedeltaIndex([\"1 day 15:19:49.695000\"])\r\n right = TimedeltaIndex(\r\n [\"2 day 13:04:21.322000\", \"1 day 15:27:24.873000\", \"1 day 15:31:05.350000\"]\r\n )\r\n\r\n result = left.union(right)\r\n exp = TimedeltaIndex(sorted(set(left) | set(right)))\r\n tm.assert_index_equal(result, exp)\r\n\r\n def test_union_bug_4564(self):\r\n\r\n left = timedelta_range(\"1 day\", \"30d\")\r\n right = left + pd.offsets.Minute(15)\r\n\r\n result = left.union(right)\r\n exp = TimedeltaIndex(sorted(set(left) | set(right)))\r\n tm.assert_index_equal(result, exp)\r\n\r\n def test_union_freq_infer(self):\r\n # When taking the union of two TimedeltaIndexes, we infer\r\n # a freq even if the arguments don't have freq. This matches\r\n # DatetimeIndex behavior.\r\n tdi = pd.timedelta_range(\"1 Day\", periods=5)\r\n left = tdi[[0, 1, 3, 4]]\r\n right = tdi[[2, 3, 1]]\r\n\r\n assert left.freq is None\r\n assert right.freq is None\r\n\r\n result = left.union(right)\r\n tm.assert_index_equal(result, tdi)\r\n assert result.freq == \"D\"\r\n\r\n def test_intersection_bug_1708(self):\r\n index_1 = timedelta_range(\"1 day\", periods=4, freq=\"h\")\r\n index_2 = index_1 + pd.offsets.Hour(5)\r\n\r\n result = index_1 & index_2\r\n assert len(result) == 0\r\n\r\n index_1 = timedelta_range(\"1 day\", periods=4, freq=\"h\")\r\n index_2 = index_1 + pd.offsets.Hour(1)\r\n\r\n result = index_1 & index_2\r\n expected = timedelta_range(\"1 day 01:00:00\", periods=3, freq=\"h\")\r\n tm.assert_index_equal(result, expected)\r\n assert result.freq == expected.freq\r\n\r\n def test_intersection_equal(self, sort):\r\n # GH 24471 Test intersection outcome given the sort keyword\r\n # for equal indicies intersection should return the original index\r\n first = timedelta_range(\"1 day\", periods=4, freq=\"h\")\r\n second = timedelta_range(\"1 day\", periods=4, freq=\"h\")\r\n intersect = first.intersection(second, sort=sort)\r\n if sort is None:\r\n tm.assert_index_equal(intersect, second.sort_values())\r\n assert tm.equalContents(intersect, second)\r\n\r\n # Corner cases\r\n inter = first.intersection(first, sort=sort)\r\n assert inter is first\r\n\r\n @pytest.mark.parametrize(\"period_1, period_2\", [(0, 4), (4, 0)])\r\n def test_intersection_zero_length(self, period_1, period_2, sort):\r\n # GH 24471 test for non overlap the intersection should be zero length\r\n index_1 = timedelta_range(\"1 day\", periods=period_1, freq=\"h\")\r\n index_2 = timedelta_range(\"1 day\", periods=period_2, freq=\"h\")\r\n expected = timedelta_range(\"1 day\", periods=0, freq=\"h\")\r\n result = index_1.intersection(index_2, sort=sort)\r\n tm.assert_index_equal(result, expected)\r\n\r\n def test_zero_length_input_index(self, sort):\r\n # GH 24966 test for 0-len intersections are copied\r\n index_1 = timedelta_range(\"1 day\", periods=0, freq=\"h\")\r\n index_2 = timedelta_range(\"1 day\", periods=3, freq=\"h\")\r\n result = index_1.intersection(index_2, sort=sort)\r\n assert index_1 is not result\r\n assert index_2 is not result\r\n tm.assert_copy(result, index_1)\r\n\r\n @pytest.mark.parametrize(\r\n \"rng, expected\",\r\n # if target has the same name, it is preserved\r\n [\r\n (\r\n timedelta_range(\"1 day\", periods=5, freq=\"h\", name=\"idx\"),\r\n timedelta_range(\"1 day\", periods=4, freq=\"h\", name=\"idx\"),\r\n ),\r\n # if target name is different, it will be reset\r\n (\r\n timedelta_range(\"1 day\", periods=5, freq=\"h\", name=\"other\"),\r\n timedelta_range(\"1 day\", periods=4, freq=\"h\", name=None),\r\n ),\r\n # if no overlap exists return empty index\r\n (\r\n timedelta_range(\"1 day\", periods=10, freq=\"h\", name=\"idx\")[5:],\r\n TimedeltaIndex([], freq=\"h\", name=\"idx\"),\r\n ),\r\n ],\r\n )\r\n def test_intersection(self, rng, expected, sort):\r\n # GH 4690 (with tz)\r\n base = timedelta_range(\"1 day\", periods=4, freq=\"h\", name=\"idx\")\r\n result = base.intersection(rng, sort=sort)\r\n if sort is None:\r\n expected = expected.sort_values()\r\n tm.assert_index_equal(result, expected)\r\n assert result.name == expected.name\r\n assert result.freq == expected.freq\r\n\r\n @pytest.mark.parametrize(\r\n \"rng, expected\",\r\n # part intersection works\r\n [\r\n (\r\n TimedeltaIndex([\"5 hour\", \"2 hour\", \"4 hour\", \"9 hour\"], name=\"idx\"),\r\n TimedeltaIndex([\"2 hour\", \"4 hour\"], name=\"idx\"),\r\n ),\r\n # reordered part intersection\r\n (\r\n TimedeltaIndex([\"2 hour\", \"5 hour\", \"5 hour\", \"1 hour\"], name=\"other\"),\r\n TimedeltaIndex([\"1 hour\", \"2 hour\"], name=None),\r\n ),\r\n # reversed index\r\n (\r\n TimedeltaIndex([\"1 hour\", \"2 hour\", \"4 hour\", \"3 hour\"], name=\"idx\")[\r\n ::-1\r\n ],\r\n TimedeltaIndex([\"1 hour\", \"2 hour\", \"4 hour\", \"3 hour\"], name=\"idx\"),\r\n ),\r\n ],\r\n )\r\n def test_intersection_non_monotonic(self, rng, expected, sort):\r\n # 24471 non-monotonic\r\n base = TimedeltaIndex([\"1 hour\", \"2 hour\", \"4 hour\", \"3 hour\"], name=\"idx\")\r\n result = base.intersection(rng, sort=sort)\r\n if sort is None:\r\n expected = expected.sort_values()\r\n tm.assert_index_equal(result, expected)\r\n assert result.name == expected.name\r\n\r\n # if reversed order, frequency is still the same\r\n if all(base == rng[::-1]) and sort is None:\r\n assert isinstance(result.freq, Hour)\r\n else:\r\n assert result.freq is None\r\n\r\n\r\nclass TestTimedeltaIndexDifference:\r\n def test_difference_freq(self, sort):\r\n # GH14323: Difference of TimedeltaIndex should not preserve frequency\r\n\r\n index = timedelta_range(\"0 days\", \"5 days\", freq=\"D\")\r\n\r\n other = timedelta_range(\"1 days\", \"4 days\", freq=\"D\")\r\n expected = TimedeltaIndex([\"0 days\", \"5 days\"], freq=None)\r\n idx_diff = index.difference(other, sort)\r\n tm.assert_index_equal(idx_diff, expected)\r\n tm.assert_attr_equal(\"freq\", idx_diff, expected)\r\n\r\n other = timedelta_range(\"2 days\", \"5 days\", freq=\"D\")\r\n idx_diff = index.difference(other, sort)\r\n expected = TimedeltaIndex([\"0 days\", \"1 days\"], freq=None)\r\n tm.assert_index_equal(idx_diff, expected)\r\n tm.assert_attr_equal(\"freq\", idx_diff, expected)\r\n\r\n def test_difference_sort(self, sort):\r\n\r\n index = pd.TimedeltaIndex(\r\n [\"5 days\", \"3 days\", \"2 days\", \"4 days\", \"1 days\", \"0 days\"]\r\n )\r\n\r\n other = timedelta_range(\"1 days\", \"4 days\", freq=\"D\")\r\n idx_diff = index.difference(other, sort)\r\n\r\n expected = TimedeltaIndex([\"5 days\", \"0 days\"], freq=None)\r\n\r\n if sort is None:\r\n expected = expected.sort_values()\r\n\r\n tm.assert_index_equal(idx_diff, expected)\r\n tm.assert_attr_equal(\"freq\", idx_diff, expected)\r\n\r\n other = timedelta_range(\"2 days\", \"5 days\", freq=\"D\")\r\n idx_diff = index.difference(other, sort)\r\n expected = TimedeltaIndex([\"1 days\", \"0 days\"], freq=None)\r\n\r\n if sort is None:\r\n expected = expected.sort_values()\r\n\r\n tm.assert_index_equal(idx_diff, expected)\r\n tm.assert_attr_equal(\"freq\", idx_diff, expected)\r\n",
"\"\"\"\r\nTests for Timestamp parsing, aimed at pandas/_libs/tslibs/parsing.pyx\r\n\"\"\"\r\nfrom datetime import datetime\r\nimport re\r\n\r\nfrom dateutil.parser import parse\r\nimport numpy as np\r\nimport pytest\r\n\r\nfrom pandas._libs.tslibs import parsing\r\nfrom pandas._libs.tslibs.parsing import parse_time_string\r\nimport pandas.util._test_decorators as td\r\n\r\nimport pandas._testing as tm\r\n\r\n\r\ndef test_parse_time_string():\r\n (parsed, reso) = parse_time_string(\"4Q1984\")\r\n (parsed_lower, reso_lower) = parse_time_string(\"4q1984\")\r\n\r\n assert reso == reso_lower\r\n assert parsed == parsed_lower\r\n\r\n\r\ndef test_parse_time_string_invalid_type():\r\n # Raise on invalid input, don't just return it\r\n msg = \"Argument 'arg' has incorrect type (expected str, got tuple)\"\r\n with pytest.raises(TypeError, match=re.escape(msg)):\r\n parse_time_string((4, 5))\r\n\r\n\r\[email protected](\r\n \"dashed,normal\", [(\"1988-Q2\", \"1988Q2\"), (\"2Q-1988\", \"2Q1988\")]\r\n)\r\ndef test_parse_time_quarter_with_dash(dashed, normal):\r\n # see gh-9688\r\n (parsed_dash, reso_dash) = parse_time_string(dashed)\r\n (parsed, reso) = parse_time_string(normal)\r\n\r\n assert parsed_dash == parsed\r\n assert reso_dash == reso\r\n\r\n\r\[email protected](\"dashed\", [\"-2Q1992\", \"2-Q1992\", \"4-4Q1992\"])\r\ndef test_parse_time_quarter_with_dash_error(dashed):\r\n msg = f\"Unknown datetime string format, unable to parse: {dashed}\"\r\n\r\n with pytest.raises(parsing.DateParseError, match=msg):\r\n parse_time_string(dashed)\r\n\r\n\r\[email protected](\r\n \"date_string,expected\",\r\n [\r\n (\"123.1234\", False),\r\n (\"-50000\", False),\r\n (\"999\", False),\r\n (\"m\", False),\r\n (\"T\", False),\r\n (\"Mon Sep 16, 2013\", True),\r\n (\"2012-01-01\", True),\r\n (\"01/01/2012\", True),\r\n (\"01012012\", True),\r\n (\"0101\", True),\r\n (\"1-1\", True),\r\n ],\r\n)\r\ndef test_does_not_convert_mixed_integer(date_string, expected):\r\n assert parsing._does_string_look_like_datetime(date_string) is expected\r\n\r\n\r\[email protected](\r\n \"date_str,kwargs,msg\",\r\n [\r\n (\r\n \"2013Q5\",\r\n dict(),\r\n (\r\n \"Incorrect quarterly string is given, \"\r\n \"quarter must be between 1 and 4: 2013Q5\"\r\n ),\r\n ),\r\n # see gh-5418\r\n (\r\n \"2013Q1\",\r\n dict(freq=\"INVLD-L-DEC-SAT\"),\r\n (\r\n \"Unable to retrieve month information \"\r\n \"from given freq: INVLD-L-DEC-SAT\"\r\n ),\r\n ),\r\n ],\r\n)\r\ndef test_parsers_quarterly_with_freq_error(date_str, kwargs, msg):\r\n with pytest.raises(parsing.DateParseError, match=msg):\r\n parsing.parse_time_string(date_str, **kwargs)\r\n\r\n\r\[email protected](\r\n \"date_str,freq,expected\",\r\n [\r\n (\"2013Q2\", None, datetime(2013, 4, 1)),\r\n (\"2013Q2\", \"A-APR\", datetime(2012, 8, 1)),\r\n (\"2013-Q2\", \"A-DEC\", datetime(2013, 4, 1)),\r\n ],\r\n)\r\ndef test_parsers_quarterly_with_freq(date_str, freq, expected):\r\n result, _ = parsing.parse_time_string(date_str, freq=freq)\r\n assert result == expected\r\n\r\n\r\[email protected](\r\n \"date_str\", [\"2Q 2005\", \"2Q-200A\", \"2Q-200\", \"22Q2005\", \"2Q200.\", \"6Q-20\"]\r\n)\r\ndef test_parsers_quarter_invalid(date_str):\r\n if date_str == \"6Q-20\":\r\n msg = (\r\n \"Incorrect quarterly string is given, quarter \"\r\n f\"must be between 1 and 4: {date_str}\"\r\n )\r\n else:\r\n msg = f\"Unknown datetime string format, unable to parse: {date_str}\"\r\n\r\n with pytest.raises(ValueError, match=msg):\r\n parsing.parse_time_string(date_str)\r\n\r\n\r\[email protected](\r\n \"date_str,expected\",\r\n [(\"201101\", datetime(2011, 1, 1, 0, 0)), (\"200005\", datetime(2000, 5, 1, 0, 0))],\r\n)\r\ndef test_parsers_month_freq(date_str, expected):\r\n result, _ = parsing.parse_time_string(date_str, freq=\"M\")\r\n assert result == expected\r\n\r\n\r\[email protected]_if_not_us_locale\r\[email protected](\r\n \"string,fmt\",\r\n [\r\n (\"20111230\", \"%Y%m%d\"),\r\n (\"2011-12-30\", \"%Y-%m-%d\"),\r\n (\"30-12-2011\", \"%d-%m-%Y\"),\r\n (\"2011-12-30 00:00:00\", \"%Y-%m-%d %H:%M:%S\"),\r\n (\"2011-12-30T00:00:00\", \"%Y-%m-%dT%H:%M:%S\"),\r\n (\"2011-12-30 00:00:00.000000\", \"%Y-%m-%d %H:%M:%S.%f\"),\r\n ],\r\n)\r\ndef test_guess_datetime_format_with_parseable_formats(string, fmt):\r\n result = parsing._guess_datetime_format(string)\r\n assert result == fmt\r\n\r\n\r\[email protected](\"dayfirst,expected\", [(True, \"%d/%m/%Y\"), (False, \"%m/%d/%Y\")])\r\ndef test_guess_datetime_format_with_dayfirst(dayfirst, expected):\r\n ambiguous_string = \"01/01/2011\"\r\n result = parsing._guess_datetime_format(ambiguous_string, dayfirst=dayfirst)\r\n assert result == expected\r\n\r\n\r\[email protected]_if_has_locale\r\[email protected](\r\n \"string,fmt\",\r\n [\r\n (\"30/Dec/2011\", \"%d/%b/%Y\"),\r\n (\"30/December/2011\", \"%d/%B/%Y\"),\r\n (\"30/Dec/2011 00:00:00\", \"%d/%b/%Y %H:%M:%S\"),\r\n ],\r\n)\r\ndef test_guess_datetime_format_with_locale_specific_formats(string, fmt):\r\n result = parsing._guess_datetime_format(string)\r\n assert result == fmt\r\n\r\n\r\[email protected](\r\n \"invalid_dt\",\r\n [\r\n \"2013\",\r\n \"01/2013\",\r\n \"12:00:00\",\r\n \"1/1/1/1\",\r\n \"this_is_not_a_datetime\",\r\n \"51a\",\r\n 9,\r\n datetime(2011, 1, 1),\r\n ],\r\n)\r\ndef test_guess_datetime_format_invalid_inputs(invalid_dt):\r\n # A datetime string must include a year, month and a day for it to be\r\n # guessable, in addition to being a string that looks like a datetime.\r\n assert parsing._guess_datetime_format(invalid_dt) is None\r\n\r\n\r\[email protected](\r\n \"string,fmt\",\r\n [\r\n (\"2011-1-1\", \"%Y-%m-%d\"),\r\n (\"1/1/2011\", \"%m/%d/%Y\"),\r\n (\"30-1-2011\", \"%d-%m-%Y\"),\r\n (\"2011-1-1 0:0:0\", \"%Y-%m-%d %H:%M:%S\"),\r\n (\"2011-1-3T00:00:0\", \"%Y-%m-%dT%H:%M:%S\"),\r\n (\"2011-1-1 00:00:00\", \"%Y-%m-%d %H:%M:%S\"),\r\n ],\r\n)\r\ndef test_guess_datetime_format_no_padding(string, fmt):\r\n # see gh-11142\r\n result = parsing._guess_datetime_format(string)\r\n assert result == fmt\r\n\r\n\r\ndef test_try_parse_dates():\r\n arr = np.array([\"5/1/2000\", \"6/1/2000\", \"7/1/2000\"], dtype=object)\r\n result = parsing.try_parse_dates(arr, dayfirst=True)\r\n\r\n expected = np.array([parse(d, dayfirst=True) for d in arr])\r\n tm.assert_numpy_array_equal(result, expected)\r\n\r\n\r\ndef test_parse_time_string_check_instance_type_raise_exception():\r\n # issue 20684\r\n msg = \"Argument 'arg' has incorrect type (expected str, got tuple)\"\r\n with pytest.raises(TypeError, match=re.escape(msg)):\r\n parse_time_string((1, 2, 3))\r\n\r\n result = parse_time_string(\"2019\")\r\n expected = (datetime(2019, 1, 1), \"year\")\r\n assert result == expected\r\n",
"\"\"\"Tests for Interval-Interval operations, such as overlaps, contains, etc.\"\"\"\r\nimport pytest\r\n\r\nfrom pandas import Interval, Timedelta, Timestamp\r\n\r\n\r\[email protected](\r\n params=[\r\n (Timedelta(\"0 days\"), Timedelta(\"1 day\")),\r\n (Timestamp(\"2018-01-01\"), Timedelta(\"1 day\")),\r\n (0, 1),\r\n ],\r\n ids=lambda x: type(x[0]).__name__,\r\n)\r\ndef start_shift(request):\r\n \"\"\"\r\n Fixture for generating intervals of types from a start value and a shift\r\n value that can be added to start to generate an endpoint\r\n \"\"\"\r\n return request.param\r\n\r\n\r\nclass TestOverlaps:\r\n def test_overlaps_self(self, start_shift, closed):\r\n start, shift = start_shift\r\n interval = Interval(start, start + shift, closed)\r\n assert interval.overlaps(interval)\r\n\r\n def test_overlaps_nested(self, start_shift, closed, other_closed):\r\n start, shift = start_shift\r\n interval1 = Interval(start, start + 3 * shift, other_closed)\r\n interval2 = Interval(start + shift, start + 2 * shift, closed)\r\n\r\n # nested intervals should always overlap\r\n assert interval1.overlaps(interval2)\r\n\r\n def test_overlaps_disjoint(self, start_shift, closed, other_closed):\r\n start, shift = start_shift\r\n interval1 = Interval(start, start + shift, other_closed)\r\n interval2 = Interval(start + 2 * shift, start + 3 * shift, closed)\r\n\r\n # disjoint intervals should never overlap\r\n assert not interval1.overlaps(interval2)\r\n\r\n def test_overlaps_endpoint(self, start_shift, closed, other_closed):\r\n start, shift = start_shift\r\n interval1 = Interval(start, start + shift, other_closed)\r\n interval2 = Interval(start + shift, start + 2 * shift, closed)\r\n\r\n # overlap if shared endpoint is closed for both (overlap at a point)\r\n result = interval1.overlaps(interval2)\r\n expected = interval1.closed_right and interval2.closed_left\r\n assert result == expected\r\n\r\n @pytest.mark.parametrize(\r\n \"other\",\r\n [10, True, \"foo\", Timedelta(\"1 day\"), Timestamp(\"2018-01-01\")],\r\n ids=lambda x: type(x).__name__,\r\n )\r\n def test_overlaps_invalid_type(self, other):\r\n interval = Interval(0, 1)\r\n msg = f\"`other` must be an Interval, got {type(other).__name__}\"\r\n with pytest.raises(TypeError, match=msg):\r\n interval.overlaps(other)\r\n",
"\"\"\"\r\nThe :mod:`sklearn.model_selection._validation` module includes classes and\r\nfunctions to validate the model.\r\n\"\"\"\r\n\r\n# Author: Alexandre Gramfort <[email protected]>\r\n# Gael Varoquaux <[email protected]>\r\n# Olivier Grisel <[email protected]>\r\n# Raghav RV <[email protected]>\r\n# License: BSD 3 clause\r\n\r\n\r\nimport warnings\r\nimport numbers\r\nimport time\r\nfrom traceback import format_exc\r\nfrom contextlib import suppress\r\n\r\nimport numpy as np\r\nimport scipy.sparse as sp\r\nfrom joblib import Parallel, logger\r\n\r\nfrom ..base import is_classifier, clone\r\nfrom ..utils import indexable, check_random_state, _safe_indexing\r\nfrom ..utils.validation import _check_fit_params\r\nfrom ..utils.validation import _num_samples\r\nfrom ..utils.validation import _deprecate_positional_args\r\nfrom ..utils.fixes import delayed\r\nfrom ..utils.metaestimators import _safe_split\r\nfrom ..metrics import check_scoring\r\nfrom ..metrics._scorer import _check_multimetric_scoring, _MultimetricScorer\r\nfrom ..exceptions import FitFailedWarning, NotFittedError\r\nfrom ._split import check_cv\r\nfrom ..preprocessing import LabelEncoder\r\n\r\n\r\n__all__ = ['cross_validate', 'cross_val_score', 'cross_val_predict',\r\n 'permutation_test_score', 'learning_curve', 'validation_curve']\r\n\r\n\r\n@_deprecate_positional_args\r\ndef cross_validate(estimator, X, y=None, *, groups=None, scoring=None, cv=None,\r\n n_jobs=None, verbose=0, fit_params=None,\r\n pre_dispatch='2*n_jobs', return_train_score=False,\r\n return_estimator=False, error_score=np.nan):\r\n \"\"\"Evaluate metric(s) by cross-validation and also record fit/score times.\r\n\r\n Read more in the :ref:`User Guide <multimetric_cross_validation>`.\r\n\r\n Parameters\r\n ----------\r\n estimator : estimator object implementing 'fit'\r\n The object to use to fit the data.\r\n\r\n X : array-like of shape (n_samples, n_features)\r\n The data to fit. Can be for example a list, or an array.\r\n\r\n y : array-like of shape (n_samples,) or (n_samples, n_outputs), \\\r\n default=None\r\n The target variable to try to predict in the case of\r\n supervised learning.\r\n\r\n groups : array-like of shape (n_samples,), default=None\r\n Group labels for the samples used while splitting the dataset into\r\n train/test set. Only used in conjunction with a \"Group\" :term:`cv`\r\n instance (e.g., :class:`GroupKFold`).\r\n\r\n scoring : str, callable, list/tuple, or dict, default=None\r\n A single str (see :ref:`scoring_parameter`) or a callable\r\n (see :ref:`scoring`) to evaluate the predictions on the test set.\r\n\r\n For evaluating multiple metrics, either give a list of (unique) strings\r\n or a dict with names as keys and callables as values.\r\n\r\n NOTE that when using custom scorers, each scorer should return a single\r\n value. Metric functions returning a list/array of values can be wrapped\r\n into multiple scorers that return one value each.\r\n\r\n See :ref:`multimetric_grid_search` for an example.\r\n\r\n If None, the estimator's score method is used.\r\n\r\n cv : int, cross-validation generator or an iterable, default=None\r\n Determines the cross-validation splitting strategy.\r\n Possible inputs for cv are:\r\n\r\n - None, to use the default 5-fold cross validation,\r\n - int, to specify the number of folds in a `(Stratified)KFold`,\r\n - :term:`CV splitter`,\r\n - An iterable yielding (train, test) splits as arrays of indices.\r\n\r\n For int/None inputs, if the estimator is a classifier and ``y`` is\r\n either binary or multiclass, :class:`StratifiedKFold` is used. In all\r\n other cases, :class:`KFold` is used.\r\n\r\n Refer :ref:`User Guide <cross_validation>` for the various\r\n cross-validation strategies that can be used here.\r\n\r\n .. versionchanged:: 0.22\r\n ``cv`` default value if None changed from 3-fold to 5-fold.\r\n\r\n n_jobs : int, default=None\r\n Number of jobs to run in parallel. Training the estimator and computing\r\n the score are parallelized over the cross-validation splits.\r\n ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context.\r\n ``-1`` means using all processors. See :term:`Glossary <n_jobs>`\r\n for more details.\r\n\r\n verbose : int, default=0\r\n The verbosity level.\r\n\r\n fit_params : dict, default=None\r\n Parameters to pass to the fit method of the estimator.\r\n\r\n pre_dispatch : int or str, default='2*n_jobs'\r\n Controls the number of jobs that get dispatched during parallel\r\n execution. Reducing this number can be useful to avoid an\r\n explosion of memory consumption when more jobs get dispatched\r\n than CPUs can process. This parameter can be:\r\n\r\n - None, in which case all the jobs are immediately\r\n created and spawned. Use this for lightweight and\r\n fast-running jobs, to avoid delays due to on-demand\r\n spawning of the jobs\r\n\r\n - An int, giving the exact number of total jobs that are\r\n spawned\r\n\r\n - A str, giving an expression as a function of n_jobs,\r\n as in '2*n_jobs'\r\n\r\n return_train_score : bool, default=False\r\n Whether to include train scores.\r\n Computing training scores is used to get insights on how different\r\n parameter settings impact the overfitting/underfitting trade-off.\r\n However computing the scores on the training set can be computationally\r\n expensive and is not strictly required to select the parameters that\r\n yield the best generalization performance.\r\n\r\n .. versionadded:: 0.19\r\n\r\n .. versionchanged:: 0.21\r\n Default value was changed from ``True`` to ``False``\r\n\r\n return_estimator : bool, default=False\r\n Whether to return the estimators fitted on each split.\r\n\r\n .. versionadded:: 0.20\r\n\r\n error_score : 'raise' or numeric, default=np.nan\r\n Value to assign to the score if an error occurs in estimator fitting.\r\n If set to 'raise', the error is raised.\r\n If a numeric value is given, FitFailedWarning is raised.\r\n\r\n .. versionadded:: 0.20\r\n\r\n Returns\r\n -------\r\n scores : dict of float arrays of shape (n_splits,)\r\n Array of scores of the estimator for each run of the cross validation.\r\n\r\n A dict of arrays containing the score/time arrays for each scorer is\r\n returned. The possible keys for this ``dict`` are:\r\n\r\n ``test_score``\r\n The score array for test scores on each cv split.\r\n Suffix ``_score`` in ``test_score`` changes to a specific\r\n metric like ``test_r2`` or ``test_auc`` if there are\r\n multiple scoring metrics in the scoring parameter.\r\n ``train_score``\r\n The score array for train scores on each cv split.\r\n Suffix ``_score`` in ``train_score`` changes to a specific\r\n metric like ``train_r2`` or ``train_auc`` if there are\r\n multiple scoring metrics in the scoring parameter.\r\n This is available only if ``return_train_score`` parameter\r\n is ``True``.\r\n ``fit_time``\r\n The time for fitting the estimator on the train\r\n set for each cv split.\r\n ``score_time``\r\n The time for scoring the estimator on the test set for each\r\n cv split. (Note time for scoring on the train set is not\r\n included even if ``return_train_score`` is set to ``True``\r\n ``estimator``\r\n The estimator objects for each cv split.\r\n This is available only if ``return_estimator`` parameter\r\n is set to ``True``.\r\n\r\n Examples\r\n --------\r\n >>> from sklearn import datasets, linear_model\r\n >>> from sklearn.model_selection import cross_validate\r\n >>> from sklearn.metrics import make_scorer\r\n >>> from sklearn.metrics import confusion_matrix\r\n >>> from sklearn.svm import LinearSVC\r\n >>> diabetes = datasets.load_diabetes()\r\n >>> X = diabetes.data[:150]\r\n >>> y = diabetes.target[:150]\r\n >>> lasso = linear_model.Lasso()\r\n\r\n Single metric evaluation using ``cross_validate``\r\n\r\n >>> cv_results = cross_validate(lasso, X, y, cv=3)\r\n >>> sorted(cv_results.keys())\r\n ['fit_time', 'score_time', 'test_score']\r\n >>> cv_results['test_score']\r\n array([0.33150734, 0.08022311, 0.03531764])\r\n\r\n Multiple metric evaluation using ``cross_validate``\r\n (please refer the ``scoring`` parameter doc for more information)\r\n\r\n >>> scores = cross_validate(lasso, X, y, cv=3,\r\n ... scoring=('r2', 'neg_mean_squared_error'),\r\n ... return_train_score=True)\r\n >>> print(scores['test_neg_mean_squared_error'])\r\n [-3635.5... -3573.3... -6114.7...]\r\n >>> print(scores['train_r2'])\r\n [0.28010158 0.39088426 0.22784852]\r\n\r\n See Also\r\n ---------\r\n cross_val_score : Run cross-validation for single metric evaluation.\r\n\r\n cross_val_predict : Get predictions from each split of cross-validation for\r\n diagnostic purposes.\r\n\r\n sklearn.metrics.make_scorer : Make a scorer from a performance metric or\r\n loss function.\r\n\r\n \"\"\"\r\n X, y, groups = indexable(X, y, groups)\r\n\r\n cv = check_cv(cv, y, classifier=is_classifier(estimator))\r\n\r\n if callable(scoring):\r\n scorers = scoring\r\n elif scoring is None or isinstance(scoring, str):\r\n scorers = check_scoring(estimator, scoring)\r\n else:\r\n scorers = _check_multimetric_scoring(estimator, scoring)\r\n\r\n # We clone the estimator to make sure that all the folds are\r\n # independent, and that it is pickle-able.\r\n parallel = Parallel(n_jobs=n_jobs, verbose=verbose,\r\n pre_dispatch=pre_dispatch)\r\n results = parallel(\r\n delayed(_fit_and_score)(\r\n clone(estimator), X, y, scorers, train, test, verbose, None,\r\n fit_params, return_train_score=return_train_score,\r\n return_times=True, return_estimator=return_estimator,\r\n error_score=error_score)\r\n for train, test in cv.split(X, y, groups))\r\n\r\n # For callabe scoring, the return type is only know after calling. If the\r\n # return type is a dictionary, the error scores can now be inserted with\r\n # the correct key.\r\n if callable(scoring):\r\n _insert_error_scores(results, error_score)\r\n\r\n results = _aggregate_score_dicts(results)\r\n\r\n ret = {}\r\n ret['fit_time'] = results[\"fit_time\"]\r\n ret['score_time'] = results[\"score_time\"]\r\n\r\n if return_estimator:\r\n ret['estimator'] = results[\"estimator\"]\r\n\r\n test_scores_dict = _normalize_score_results(results[\"test_scores\"])\r\n if return_train_score:\r\n train_scores_dict = _normalize_score_results(results[\"train_scores\"])\r\n\r\n for name in test_scores_dict:\r\n ret['test_%s' % name] = test_scores_dict[name]\r\n if return_train_score:\r\n key = 'train_%s' % name\r\n ret[key] = train_scores_dict[name]\r\n\r\n return ret\r\n\r\n\r\ndef _insert_error_scores(results, error_score):\r\n \"\"\"Insert error in `results` by replacing them inplace with `error_score`.\r\n\r\n This only applies to multimetric scores because `_fit_and_score` will\r\n handle the single metric case.\r\n \"\"\"\r\n successful_score = None\r\n failed_indices = []\r\n for i, result in enumerate(results):\r\n if result[\"fit_failed\"]:\r\n failed_indices.append(i)\r\n elif successful_score is None:\r\n successful_score = result[\"test_scores\"]\r\n\r\n if successful_score is None:\r\n raise NotFittedError(\"All estimators failed to fit\")\r\n\r\n if isinstance(successful_score, dict):\r\n formatted_error = {name: error_score for name in successful_score}\r\n for i in failed_indices:\r\n results[i][\"test_scores\"] = formatted_error.copy()\r\n if \"train_scores\" in results[i]:\r\n results[i][\"train_scores\"] = formatted_error.copy()\r\n\r\n\r\ndef _normalize_score_results(scores, scaler_score_key='score'):\r\n \"\"\"Creates a scoring dictionary based on the type of `scores`\"\"\"\r\n if isinstance(scores[0], dict):\r\n # multimetric scoring\r\n return _aggregate_score_dicts(scores)\r\n # scaler\r\n return {scaler_score_key: scores}\r\n\r\n\r\n@_deprecate_positional_args\r\ndef cross_val_score(estimator, X, y=None, *, groups=None, scoring=None,\r\n cv=None, n_jobs=None, verbose=0, fit_params=None,\r\n pre_dispatch='2*n_jobs', error_score=np.nan):\r\n \"\"\"Evaluate a score by cross-validation\r\n\r\n Read more in the :ref:`User Guide <cross_validation>`.\r\n\r\n Parameters\r\n ----------\r\n estimator : estimator object implementing 'fit'\r\n The object to use to fit the data.\r\n\r\n X : array-like of shape (n_samples, n_features)\r\n The data to fit. Can be for example a list, or an array.\r\n\r\n y : array-like of shape (n_samples,) or (n_samples, n_outputs), \\\r\n default=None\r\n The target variable to try to predict in the case of\r\n supervised learning.\r\n\r\n groups : array-like of shape (n_samples,), default=None\r\n Group labels for the samples used while splitting the dataset into\r\n train/test set. Only used in conjunction with a \"Group\" :term:`cv`\r\n instance (e.g., :class:`GroupKFold`).\r\n\r\n scoring : str or callable, default=None\r\n A str (see model evaluation documentation) or\r\n a scorer callable object / function with signature\r\n ``scorer(estimator, X, y)`` which should return only\r\n a single value.\r\n\r\n Similar to :func:`cross_validate`\r\n but only a single metric is permitted.\r\n\r\n If None, the estimator's default scorer (if available) is used.\r\n\r\n cv : int, cross-validation generator or an iterable, default=None\r\n Determines the cross-validation splitting strategy.\r\n Possible inputs for cv are:\r\n\r\n - None, to use the default 5-fold cross validation,\r\n - int, to specify the number of folds in a `(Stratified)KFold`,\r\n - :term:`CV splitter`,\r\n - An iterable yielding (train, test) splits as arrays of indices.\r\n\r\n For int/None inputs, if the estimator is a classifier and ``y`` is\r\n either binary or multiclass, :class:`StratifiedKFold` is used. In all\r\n other cases, :class:`KFold` is used.\r\n\r\n Refer :ref:`User Guide <cross_validation>` for the various\r\n cross-validation strategies that can be used here.\r\n\r\n .. versionchanged:: 0.22\r\n ``cv`` default value if None changed from 3-fold to 5-fold.\r\n\r\n n_jobs : int, default=None\r\n Number of jobs to run in parallel. Training the estimator and computing\r\n the score are parallelized over the cross-validation splits.\r\n ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context.\r\n ``-1`` means using all processors. See :term:`Glossary <n_jobs>`\r\n for more details.\r\n\r\n verbose : int, default=0\r\n The verbosity level.\r\n\r\n fit_params : dict, default=None\r\n Parameters to pass to the fit method of the estimator.\r\n\r\n pre_dispatch : int or str, default='2*n_jobs'\r\n Controls the number of jobs that get dispatched during parallel\r\n execution. Reducing this number can be useful to avoid an\r\n explosion of memory consumption when more jobs get dispatched\r\n than CPUs can process. This parameter can be:\r\n\r\n - None, in which case all the jobs are immediately\r\n created and spawned. Use this for lightweight and\r\n fast-running jobs, to avoid delays due to on-demand\r\n spawning of the jobs\r\n\r\n - An int, giving the exact number of total jobs that are\r\n spawned\r\n\r\n - A str, giving an expression as a function of n_jobs,\r\n as in '2*n_jobs'\r\n\r\n error_score : 'raise' or numeric, default=np.nan\r\n Value to assign to the score if an error occurs in estimator fitting.\r\n If set to 'raise', the error is raised.\r\n If a numeric value is given, FitFailedWarning is raised.\r\n\r\n .. versionadded:: 0.20\r\n\r\n Returns\r\n -------\r\n scores : ndarray of float of shape=(len(list(cv)),)\r\n Array of scores of the estimator for each run of the cross validation.\r\n\r\n Examples\r\n --------\r\n >>> from sklearn import datasets, linear_model\r\n >>> from sklearn.model_selection import cross_val_score\r\n >>> diabetes = datasets.load_diabetes()\r\n >>> X = diabetes.data[:150]\r\n >>> y = diabetes.target[:150]\r\n >>> lasso = linear_model.Lasso()\r\n >>> print(cross_val_score(lasso, X, y, cv=3))\r\n [0.33150734 0.08022311 0.03531764]\r\n\r\n See Also\r\n ---------\r\n cross_validate : To run cross-validation on multiple metrics and also to\r\n return train scores, fit times and score times.\r\n\r\n cross_val_predict : Get predictions from each split of cross-validation for\r\n diagnostic purposes.\r\n\r\n sklearn.metrics.make_scorer : Make a scorer from a performance metric or\r\n loss function.\r\n\r\n \"\"\"\r\n # To ensure multimetric format is not supported\r\n scorer = check_scoring(estimator, scoring=scoring)\r\n\r\n cv_results = cross_validate(estimator=estimator, X=X, y=y, groups=groups,\r\n scoring={'score': scorer}, cv=cv,\r\n n_jobs=n_jobs, verbose=verbose,\r\n fit_params=fit_params,\r\n pre_dispatch=pre_dispatch,\r\n error_score=error_score)\r\n return cv_results['test_score']\r\n\r\n\r\ndef _fit_and_score(estimator, X, y, scorer, train, test, verbose,\r\n parameters, fit_params, return_train_score=False,\r\n return_parameters=False, return_n_test_samples=False,\r\n return_times=False, return_estimator=False,\r\n split_progress=None, candidate_progress=None,\r\n error_score=np.nan):\r\n\r\n \"\"\"Fit estimator and compute scores for a given dataset split.\r\n\r\n Parameters\r\n ----------\r\n estimator : estimator object implementing 'fit'\r\n The object to use to fit the data.\r\n\r\n X : array-like of shape (n_samples, n_features)\r\n The data to fit.\r\n\r\n y : array-like of shape (n_samples,) or (n_samples, n_outputs) or None\r\n The target variable to try to predict in the case of\r\n supervised learning.\r\n\r\n scorer : A single callable or dict mapping scorer name to the callable\r\n If it is a single callable, the return value for ``train_scores`` and\r\n ``test_scores`` is a single float.\r\n\r\n For a dict, it should be one mapping the scorer name to the scorer\r\n callable object / function.\r\n\r\n The callable object / fn should have signature\r\n ``scorer(estimator, X, y)``.\r\n\r\n train : array-like of shape (n_train_samples,)\r\n Indices of training samples.\r\n\r\n test : array-like of shape (n_test_samples,)\r\n Indices of test samples.\r\n\r\n verbose : int\r\n The verbosity level.\r\n\r\n error_score : 'raise' or numeric, default=np.nan\r\n Value to assign to the score if an error occurs in estimator fitting.\r\n If set to 'raise', the error is raised.\r\n If a numeric value is given, FitFailedWarning is raised.\r\n\r\n parameters : dict or None\r\n Parameters to be set on the estimator.\r\n\r\n fit_params : dict or None\r\n Parameters that will be passed to ``estimator.fit``.\r\n\r\n return_train_score : bool, default=False\r\n Compute and return score on training set.\r\n\r\n return_parameters : bool, default=False\r\n Return parameters that has been used for the estimator.\r\n\r\n split_progress : {list, tuple} of int, default=None\r\n A list or tuple of format (<current_split_id>, <total_num_of_splits>).\r\n\r\n candidate_progress : {list, tuple} of int, default=None\r\n A list or tuple of format\r\n (<current_candidate_id>, <total_number_of_candidates>).\r\n\r\n return_n_test_samples : bool, default=False\r\n Whether to return the ``n_test_samples``.\r\n\r\n return_times : bool, default=False\r\n Whether to return the fit/score times.\r\n\r\n return_estimator : bool, default=False\r\n Whether to return the fitted estimator.\r\n\r\n Returns\r\n -------\r\n result : dict with the following attributes\r\n train_scores : dict of scorer name -> float\r\n Score on training set (for all the scorers),\r\n returned only if `return_train_score` is `True`.\r\n test_scores : dict of scorer name -> float\r\n Score on testing set (for all the scorers).\r\n n_test_samples : int\r\n Number of test samples.\r\n fit_time : float\r\n Time spent for fitting in seconds.\r\n score_time : float\r\n Time spent for scoring in seconds.\r\n parameters : dict or None\r\n The parameters that have been evaluated.\r\n estimator : estimator object\r\n The fitted estimator.\r\n fit_failed : bool\r\n The estimator failed to fit.\r\n \"\"\"\r\n if not isinstance(error_score, numbers.Number) and error_score != 'raise':\r\n raise ValueError(\r\n \"error_score must be the string 'raise' or a numeric value. \"\r\n \"(Hint: if using 'raise', please make sure that it has been \"\r\n \"spelled correctly.)\"\r\n )\r\n\r\n progress_msg = \"\"\r\n if verbose > 2:\r\n if split_progress is not None:\r\n progress_msg = f\" {split_progress[0]+1}/{split_progress[1]}\"\r\n if candidate_progress and verbose > 9:\r\n progress_msg += (f\"; {candidate_progress[0]+1}/\"\r\n f\"{candidate_progress[1]}\")\r\n\r\n if verbose > 1:\r\n if parameters is None:\r\n params_msg = ''\r\n else:\r\n sorted_keys = sorted(parameters) # Ensure deterministic o/p\r\n params_msg = (', '.join(f'{k}={parameters[k]}'\r\n for k in sorted_keys))\r\n if verbose > 9:\r\n start_msg = f\"[CV{progress_msg}] START {params_msg}\"\r\n print(f\"{start_msg}{(80 - len(start_msg)) * '.'}\")\r\n\r\n # Adjust length of sample weights\r\n fit_params = fit_params if fit_params is not None else {}\r\n fit_params = _check_fit_params(X, fit_params, train)\r\n\r\n if parameters is not None:\r\n # clone after setting parameters in case any parameters\r\n # are estimators (like pipeline steps)\r\n # because pipeline doesn't clone steps in fit\r\n cloned_parameters = {}\r\n for k, v in parameters.items():\r\n cloned_parameters[k] = clone(v, safe=False)\r\n\r\n estimator = estimator.set_params(**cloned_parameters)\r\n\r\n start_time = time.time()\r\n\r\n X_train, y_train = _safe_split(estimator, X, y, train)\r\n X_test, y_test = _safe_split(estimator, X, y, test, train)\r\n\r\n result = {}\r\n try:\r\n if y_train is None:\r\n estimator.fit(X_train, **fit_params)\r\n else:\r\n estimator.fit(X_train, y_train, **fit_params)\r\n\r\n except Exception as e:\r\n # Note fit time as time until error\r\n fit_time = time.time() - start_time\r\n score_time = 0.0\r\n if error_score == 'raise':\r\n raise\r\n elif isinstance(error_score, numbers.Number):\r\n if isinstance(scorer, dict):\r\n test_scores = {name: error_score for name in scorer}\r\n if return_train_score:\r\n train_scores = test_scores.copy()\r\n else:\r\n test_scores = error_score\r\n if return_train_score:\r\n train_scores = error_score\r\n warnings.warn(\"Estimator fit failed. The score on this train-test\"\r\n \" partition for these parameters will be set to %f. \"\r\n \"Details: \\n%s\" %\r\n (error_score, format_exc()),\r\n FitFailedWarning)\r\n result[\"fit_failed\"] = True\r\n else:\r\n result[\"fit_failed\"] = False\r\n\r\n fit_time = time.time() - start_time\r\n test_scores = _score(estimator, X_test, y_test, scorer, error_score)\r\n score_time = time.time() - start_time - fit_time\r\n if return_train_score:\r\n train_scores = _score(\r\n estimator, X_train, y_train, scorer, error_score\r\n )\r\n\r\n if verbose > 1:\r\n total_time = score_time + fit_time\r\n end_msg = f\"[CV{progress_msg}] END \"\r\n result_msg = params_msg + (\";\" if params_msg else \"\")\r\n if verbose > 2 and isinstance(test_scores, dict):\r\n for scorer_name in sorted(test_scores):\r\n result_msg += f\" {scorer_name}: (\"\r\n if return_train_score:\r\n scorer_scores = train_scores[scorer_name]\r\n result_msg += f\"train={scorer_scores:.3f}, \"\r\n result_msg += f\"test={test_scores[scorer_name]:.3f})\"\r\n result_msg += f\" total time={logger.short_format_time(total_time)}\"\r\n\r\n # Right align the result_msg\r\n end_msg += \".\" * (80 - len(end_msg) - len(result_msg))\r\n end_msg += result_msg\r\n print(end_msg)\r\n\r\n result[\"test_scores\"] = test_scores\r\n if return_train_score:\r\n result[\"train_scores\"] = train_scores\r\n if return_n_test_samples:\r\n result[\"n_test_samples\"] = _num_samples(X_test)\r\n if return_times:\r\n result[\"fit_time\"] = fit_time\r\n result[\"score_time\"] = score_time\r\n if return_parameters:\r\n result[\"parameters\"] = parameters\r\n if return_estimator:\r\n result[\"estimator\"] = estimator\r\n return result\r\n\r\n\r\ndef _score(estimator, X_test, y_test, scorer, error_score=\"raise\"):\r\n \"\"\"Compute the score(s) of an estimator on a given test set.\r\n\r\n Will return a dict of floats if `scorer` is a dict, otherwise a single\r\n float is returned.\r\n \"\"\"\r\n if isinstance(scorer, dict):\r\n # will cache method calls if needed. scorer() returns a dict\r\n scorer = _MultimetricScorer(**scorer)\r\n\r\n try:\r\n if y_test is None:\r\n scores = scorer(estimator, X_test)\r\n else:\r\n scores = scorer(estimator, X_test, y_test)\r\n except Exception:\r\n if error_score == 'raise':\r\n raise\r\n else:\r\n if isinstance(scorer, _MultimetricScorer):\r\n scores = {name: error_score for name in scorer._scorers}\r\n else:\r\n scores = error_score\r\n warnings.warn(\r\n f\"Scoring failed. The score on this train-test partition for \"\r\n f\"these parameters will be set to {error_score}. Details: \\n\"\r\n f\"{format_exc()}\",\r\n UserWarning,\r\n )\r\n\r\n error_msg = (\r\n \"scoring must return a number, got %s (%s) instead. (scorer=%s)\"\r\n )\r\n if isinstance(scores, dict):\r\n for name, score in scores.items():\r\n if hasattr(score, 'item'):\r\n with suppress(ValueError):\r\n # e.g. unwrap memmapped scalars\r\n score = score.item()\r\n if not isinstance(score, numbers.Number):\r\n raise ValueError(error_msg % (score, type(score), name))\r\n scores[name] = score\r\n else: # scalar\r\n if hasattr(scores, 'item'):\r\n with suppress(ValueError):\r\n # e.g. unwrap memmapped scalars\r\n scores = scores.item()\r\n if not isinstance(scores, numbers.Number):\r\n raise ValueError(error_msg % (scores, type(scores), scorer))\r\n return scores\r\n\r\n\r\n@_deprecate_positional_args\r\ndef cross_val_predict(estimator, X, y=None, *, groups=None, cv=None,\r\n n_jobs=None, verbose=0, fit_params=None,\r\n pre_dispatch='2*n_jobs', method='predict'):\r\n \"\"\"Generate cross-validated estimates for each input data point\r\n\r\n The data is split according to the cv parameter. Each sample belongs\r\n to exactly one test set, and its prediction is computed with an\r\n estimator fitted on the corresponding training set.\r\n\r\n Passing these predictions into an evaluation metric may not be a valid\r\n way to measure generalization performance. Results can differ from\r\n :func:`cross_validate` and :func:`cross_val_score` unless all tests sets\r\n have equal size and the metric decomposes over samples.\r\n\r\n Read more in the :ref:`User Guide <cross_validation>`.\r\n\r\n Parameters\r\n ----------\r\n estimator : estimator object implementing 'fit' and 'predict'\r\n The object to use to fit the data.\r\n\r\n X : array-like of shape (n_samples, n_features)\r\n The data to fit. Can be, for example a list, or an array at least 2d.\r\n\r\n y : array-like of shape (n_samples,) or (n_samples, n_outputs), \\\r\n default=None\r\n The target variable to try to predict in the case of\r\n supervised learning.\r\n\r\n groups : array-like of shape (n_samples,), default=None\r\n Group labels for the samples used while splitting the dataset into\r\n train/test set. Only used in conjunction with a \"Group\" :term:`cv`\r\n instance (e.g., :class:`GroupKFold`).\r\n\r\n cv : int, cross-validation generator or an iterable, default=None\r\n Determines the cross-validation splitting strategy.\r\n Possible inputs for cv are:\r\n\r\n - None, to use the default 5-fold cross validation,\r\n - int, to specify the number of folds in a `(Stratified)KFold`,\r\n - :term:`CV splitter`,\r\n - An iterable yielding (train, test) splits as arrays of indices.\r\n\r\n For int/None inputs, if the estimator is a classifier and ``y`` is\r\n either binary or multiclass, :class:`StratifiedKFold` is used. In all\r\n other cases, :class:`KFold` is used.\r\n\r\n Refer :ref:`User Guide <cross_validation>` for the various\r\n cross-validation strategies that can be used here.\r\n\r\n .. versionchanged:: 0.22\r\n ``cv`` default value if None changed from 3-fold to 5-fold.\r\n\r\n n_jobs : int, default=None\r\n Number of jobs to run in parallel. Training the estimator and\r\n predicting are parallelized over the cross-validation splits.\r\n ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context.\r\n ``-1`` means using all processors. See :term:`Glossary <n_jobs>`\r\n for more details.\r\n\r\n verbose : int, default=0\r\n The verbosity level.\r\n\r\n fit_params : dict, defualt=None\r\n Parameters to pass to the fit method of the estimator.\r\n\r\n pre_dispatch : int or str, default='2*n_jobs'\r\n Controls the number of jobs that get dispatched during parallel\r\n execution. Reducing this number can be useful to avoid an\r\n explosion of memory consumption when more jobs get dispatched\r\n than CPUs can process. This parameter can be:\r\n\r\n - None, in which case all the jobs are immediately\r\n created and spawned. Use this for lightweight and\r\n fast-running jobs, to avoid delays due to on-demand\r\n spawning of the jobs\r\n\r\n - An int, giving the exact number of total jobs that are\r\n spawned\r\n\r\n - A str, giving an expression as a function of n_jobs,\r\n as in '2*n_jobs'\r\n\r\n method : {'predict', 'predict_proba', 'predict_log_proba', \\\r\n 'decision_function'}, default='predict'\r\n The method to be invoked by `estimator`.\r\n\r\n Returns\r\n -------\r\n predictions : ndarray\r\n This is the result of calling `method`. Shape:\r\n\r\n - When `method` is 'predict' and in special case where `method` is\r\n 'decision_function' and the target is binary: (n_samples,)\r\n - When `method` is one of {'predict_proba', 'predict_log_proba',\r\n 'decision_function'} (unless special case above):\r\n (n_samples, n_classes)\r\n - If `estimator` is :term:`multioutput`, an extra dimension\r\n 'n_outputs' is added to the end of each shape above.\r\n\r\n See Also\r\n --------\r\n cross_val_score : Calculate score for each CV split.\r\n cross_validate : Calculate one or more scores and timings for each CV\r\n split.\r\n\r\n Notes\r\n -----\r\n In the case that one or more classes are absent in a training portion, a\r\n default score needs to be assigned to all instances for that class if\r\n ``method`` produces columns per class, as in {'decision_function',\r\n 'predict_proba', 'predict_log_proba'}. For ``predict_proba`` this value is\r\n 0. In order to ensure finite output, we approximate negative infinity by\r\n the minimum finite float value for the dtype in other cases.\r\n\r\n Examples\r\n --------\r\n >>> from sklearn import datasets, linear_model\r\n >>> from sklearn.model_selection import cross_val_predict\r\n >>> diabetes = datasets.load_diabetes()\r\n >>> X = diabetes.data[:150]\r\n >>> y = diabetes.target[:150]\r\n >>> lasso = linear_model.Lasso()\r\n >>> y_pred = cross_val_predict(lasso, X, y, cv=3)\r\n \"\"\"\r\n X, y, groups = indexable(X, y, groups)\r\n\r\n cv = check_cv(cv, y, classifier=is_classifier(estimator))\r\n splits = list(cv.split(X, y, groups))\r\n\r\n test_indices = np.concatenate([test for _, test in splits])\r\n if not _check_is_permutation(test_indices, _num_samples(X)):\r\n raise ValueError('cross_val_predict only works for partitions')\r\n\r\n # If classification methods produce multiple columns of output,\r\n # we need to manually encode classes to ensure consistent column ordering.\r\n encode = method in ['decision_function', 'predict_proba',\r\n 'predict_log_proba'] and y is not None\r\n if encode:\r\n y = np.asarray(y)\r\n if y.ndim == 1:\r\n le = LabelEncoder()\r\n y = le.fit_transform(y)\r\n elif y.ndim == 2:\r\n y_enc = np.zeros_like(y, dtype=int)\r\n for i_label in range(y.shape[1]):\r\n y_enc[:, i_label] = LabelEncoder().fit_transform(y[:, i_label])\r\n y = y_enc\r\n\r\n # We clone the estimator to make sure that all the folds are\r\n # independent, and that it is pickle-able.\r\n parallel = Parallel(n_jobs=n_jobs, verbose=verbose,\r\n pre_dispatch=pre_dispatch)\r\n predictions = parallel(delayed(_fit_and_predict)(\r\n clone(estimator), X, y, train, test, verbose, fit_params, method)\r\n for train, test in splits)\r\n\r\n inv_test_indices = np.empty(len(test_indices), dtype=int)\r\n inv_test_indices[test_indices] = np.arange(len(test_indices))\r\n\r\n if sp.issparse(predictions[0]):\r\n predictions = sp.vstack(predictions, format=predictions[0].format)\r\n elif encode and isinstance(predictions[0], list):\r\n # `predictions` is a list of method outputs from each fold.\r\n # If each of those is also a list, then treat this as a\r\n # multioutput-multiclass task. We need to separately concatenate\r\n # the method outputs for each label into an `n_labels` long list.\r\n n_labels = y.shape[1]\r\n concat_pred = []\r\n for i_label in range(n_labels):\r\n label_preds = np.concatenate([p[i_label] for p in predictions])\r\n concat_pred.append(label_preds)\r\n predictions = concat_pred\r\n else:\r\n predictions = np.concatenate(predictions)\r\n\r\n if isinstance(predictions, list):\r\n return [p[inv_test_indices] for p in predictions]\r\n else:\r\n return predictions[inv_test_indices]\r\n\r\n\r\ndef _fit_and_predict(estimator, X, y, train, test, verbose, fit_params,\r\n method):\r\n \"\"\"Fit estimator and predict values for a given dataset split.\r\n\r\n Read more in the :ref:`User Guide <cross_validation>`.\r\n\r\n Parameters\r\n ----------\r\n estimator : estimator object implementing 'fit' and 'predict'\r\n The object to use to fit the data.\r\n\r\n X : array-like of shape (n_samples, n_features)\r\n The data to fit.\r\n\r\n .. versionchanged:: 0.20\r\n X is only required to be an object with finite length or shape now\r\n\r\n y : array-like of shape (n_samples,) or (n_samples, n_outputs) or None\r\n The target variable to try to predict in the case of\r\n supervised learning.\r\n\r\n train : array-like of shape (n_train_samples,)\r\n Indices of training samples.\r\n\r\n test : array-like of shape (n_test_samples,)\r\n Indices of test samples.\r\n\r\n verbose : int\r\n The verbosity level.\r\n\r\n fit_params : dict or None\r\n Parameters that will be passed to ``estimator.fit``.\r\n\r\n method : str\r\n Invokes the passed method name of the passed estimator.\r\n\r\n Returns\r\n -------\r\n predictions : sequence\r\n Result of calling 'estimator.method'\r\n \"\"\"\r\n # Adjust length of sample weights\r\n fit_params = fit_params if fit_params is not None else {}\r\n fit_params = _check_fit_params(X, fit_params, train)\r\n\r\n X_train, y_train = _safe_split(estimator, X, y, train)\r\n X_test, _ = _safe_split(estimator, X, y, test, train)\r\n\r\n if y_train is None:\r\n estimator.fit(X_train, **fit_params)\r\n else:\r\n estimator.fit(X_train, y_train, **fit_params)\r\n func = getattr(estimator, method)\r\n predictions = func(X_test)\r\n\r\n encode = method in ['decision_function', 'predict_proba',\r\n 'predict_log_proba'] and y is not None\r\n\r\n if encode:\r\n if isinstance(predictions, list):\r\n predictions = [_enforce_prediction_order(\r\n estimator.classes_[i_label], predictions[i_label],\r\n n_classes=len(set(y[:, i_label])), method=method)\r\n for i_label in range(len(predictions))]\r\n else:\r\n # A 2D y array should be a binary label indicator matrix\r\n n_classes = len(set(y)) if y.ndim == 1 else y.shape[1]\r\n predictions = _enforce_prediction_order(\r\n estimator.classes_, predictions, n_classes, method)\r\n return predictions\r\n\r\n\r\ndef _enforce_prediction_order(classes, predictions, n_classes, method):\r\n \"\"\"Ensure that prediction arrays have correct column order\r\n\r\n When doing cross-validation, if one or more classes are\r\n not present in the subset of data used for training,\r\n then the output prediction array might not have the same\r\n columns as other folds. Use the list of class names\r\n (assumed to be ints) to enforce the correct column order.\r\n\r\n Note that `classes` is the list of classes in this fold\r\n (a subset of the classes in the full training set)\r\n and `n_classes` is the number of classes in the full training set.\r\n \"\"\"\r\n if n_classes != len(classes):\r\n recommendation = (\r\n 'To fix this, use a cross-validation '\r\n 'technique resulting in properly '\r\n 'stratified folds')\r\n warnings.warn('Number of classes in training fold ({}) does '\r\n 'not match total number of classes ({}). '\r\n 'Results may not be appropriate for your use case. '\r\n '{}'.format(len(classes), n_classes, recommendation),\r\n RuntimeWarning)\r\n if method == 'decision_function':\r\n if (predictions.ndim == 2 and\r\n predictions.shape[1] != len(classes)):\r\n # This handles the case when the shape of predictions\r\n # does not match the number of classes used to train\r\n # it with. This case is found when sklearn.svm.SVC is\r\n # set to `decision_function_shape='ovo'`.\r\n raise ValueError('Output shape {} of {} does not match '\r\n 'number of classes ({}) in fold. '\r\n 'Irregular decision_function outputs '\r\n 'are not currently supported by '\r\n 'cross_val_predict'.format(\r\n predictions.shape, method, len(classes)))\r\n if len(classes) <= 2:\r\n # In this special case, `predictions` contains a 1D array.\r\n raise ValueError('Only {} class/es in training fold, but {} '\r\n 'in overall dataset. This '\r\n 'is not supported for decision_function '\r\n 'with imbalanced folds. {}'.format(\r\n len(classes), n_classes, recommendation))\r\n\r\n float_min = np.finfo(predictions.dtype).min\r\n default_values = {'decision_function': float_min,\r\n 'predict_log_proba': float_min,\r\n 'predict_proba': 0}\r\n predictions_for_all_classes = np.full((_num_samples(predictions),\r\n n_classes),\r\n default_values[method],\r\n dtype=predictions.dtype)\r\n predictions_for_all_classes[:, classes] = predictions\r\n predictions = predictions_for_all_classes\r\n return predictions\r\n\r\n\r\ndef _check_is_permutation(indices, n_samples):\r\n \"\"\"Check whether indices is a reordering of the array np.arange(n_samples)\r\n\r\n Parameters\r\n ----------\r\n indices : ndarray\r\n int array to test\r\n n_samples : int\r\n number of expected elements\r\n\r\n Returns\r\n -------\r\n is_partition : bool\r\n True iff sorted(indices) is np.arange(n)\r\n \"\"\"\r\n if len(indices) != n_samples:\r\n return False\r\n hit = np.zeros(n_samples, dtype=bool)\r\n hit[indices] = True\r\n if not np.all(hit):\r\n return False\r\n return True\r\n\r\n\r\n@_deprecate_positional_args\r\ndef permutation_test_score(estimator, X, y, *, groups=None, cv=None,\r\n n_permutations=100, n_jobs=None, random_state=0,\r\n verbose=0, scoring=None, fit_params=None):\r\n \"\"\"Evaluate the significance of a cross-validated score with permutations\r\n\r\n Permutes targets to generate 'randomized data' and compute the empirical\r\n p-value against the null hypothesis that features and targets are\r\n independent.\r\n\r\n The p-value represents the fraction of randomized data sets where the\r\n estimator performed as well or better than in the original data. A small\r\n p-value suggests that there is a real dependency between features and\r\n targets which has been used by the estimator to give good predictions.\r\n A large p-value may be due to lack of real dependency between features\r\n and targets or the estimator was not able to use the dependency to\r\n give good predictions.\r\n\r\n Read more in the :ref:`User Guide <permutation_test_score>`.\r\n\r\n Parameters\r\n ----------\r\n estimator : estimator object implementing 'fit'\r\n The object to use to fit the data.\r\n\r\n X : array-like of shape at least 2D\r\n The data to fit.\r\n\r\n y : array-like of shape (n_samples,) or (n_samples, n_outputs) or None\r\n The target variable to try to predict in the case of\r\n supervised learning.\r\n\r\n groups : array-like of shape (n_samples,), default=None\r\n Labels to constrain permutation within groups, i.e. ``y`` values\r\n are permuted among samples with the same group identifier.\r\n When not specified, ``y`` values are permuted among all samples.\r\n\r\n When a grouped cross-validator is used, the group labels are\r\n also passed on to the ``split`` method of the cross-validator. The\r\n cross-validator uses them for grouping the samples while splitting\r\n the dataset into train/test set.\r\n\r\n scoring : str or callable, default=None\r\n A single str (see :ref:`scoring_parameter`) or a callable\r\n (see :ref:`scoring`) to evaluate the predictions on the test set.\r\n\r\n If None the estimator's score method is used.\r\n\r\n cv : int, cross-validation generator or an iterable, default=None\r\n Determines the cross-validation splitting strategy.\r\n Possible inputs for cv are:\r\n\r\n - None, to use the default 5-fold cross validation,\r\n - int, to specify the number of folds in a `(Stratified)KFold`,\r\n - :term:`CV splitter`,\r\n - An iterable yielding (train, test) splits as arrays of indices.\r\n\r\n For int/None inputs, if the estimator is a classifier and ``y`` is\r\n either binary or multiclass, :class:`StratifiedKFold` is used. In all\r\n other cases, :class:`KFold` is used.\r\n\r\n Refer :ref:`User Guide <cross_validation>` for the various\r\n cross-validation strategies that can be used here.\r\n\r\n .. versionchanged:: 0.22\r\n ``cv`` default value if None changed from 3-fold to 5-fold.\r\n\r\n n_permutations : int, default=100\r\n Number of times to permute ``y``.\r\n\r\n n_jobs : int, default=None\r\n Number of jobs to run in parallel. Training the estimator and computing\r\n the cross-validated score are parallelized over the permutations.\r\n ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context.\r\n ``-1`` means using all processors. See :term:`Glossary <n_jobs>`\r\n for more details.\r\n\r\n random_state : int, RandomState instance or None, default=0\r\n Pass an int for reproducible output for permutation of\r\n ``y`` values among samples. See :term:`Glossary <random_state>`.\r\n\r\n verbose : int, default=0\r\n The verbosity level.\r\n\r\n fit_params : dict, default=None\r\n Parameters to pass to the fit method of the estimator.\r\n\r\n .. versionadded:: 0.24\r\n\r\n Returns\r\n -------\r\n score : float\r\n The true score without permuting targets.\r\n\r\n permutation_scores : array of shape (n_permutations,)\r\n The scores obtained for each permutations.\r\n\r\n pvalue : float\r\n The p-value, which approximates the probability that the score would\r\n be obtained by chance. This is calculated as:\r\n\r\n `(C + 1) / (n_permutations + 1)`\r\n\r\n Where C is the number of permutations whose score >= the true score.\r\n\r\n The best possible p-value is 1/(n_permutations + 1), the worst is 1.0.\r\n\r\n Notes\r\n -----\r\n This function implements Test 1 in:\r\n\r\n Ojala and Garriga. `Permutation Tests for Studying Classifier\r\n Performance\r\n <http://www.jmlr.org/papers/volume11/ojala10a/ojala10a.pdf>`_. The\r\n Journal of Machine Learning Research (2010) vol. 11\r\n\r\n \"\"\"\r\n X, y, groups = indexable(X, y, groups)\r\n\r\n cv = check_cv(cv, y, classifier=is_classifier(estimator))\r\n scorer = check_scoring(estimator, scoring=scoring)\r\n random_state = check_random_state(random_state)\r\n\r\n # We clone the estimator to make sure that all the folds are\r\n # independent, and that it is pickle-able.\r\n score = _permutation_test_score(clone(estimator), X, y, groups, cv, scorer,\r\n fit_params=fit_params)\r\n permutation_scores = Parallel(n_jobs=n_jobs, verbose=verbose)(\r\n delayed(_permutation_test_score)(\r\n clone(estimator), X, _shuffle(y, groups, random_state),\r\n groups, cv, scorer, fit_params=fit_params)\r\n for _ in range(n_permutations))\r\n permutation_scores = np.array(permutation_scores)\r\n pvalue = (np.sum(permutation_scores >= score) + 1.0) / (n_permutations + 1)\r\n return score, permutation_scores, pvalue\r\n\r\n\r\ndef _permutation_test_score(estimator, X, y, groups, cv, scorer,\r\n fit_params):\r\n \"\"\"Auxiliary function for permutation_test_score\"\"\"\r\n # Adjust length of sample weights\r\n fit_params = fit_params if fit_params is not None else {}\r\n avg_score = []\r\n for train, test in cv.split(X, y, groups):\r\n X_train, y_train = _safe_split(estimator, X, y, train)\r\n X_test, y_test = _safe_split(estimator, X, y, test, train)\r\n fit_params = _check_fit_params(X, fit_params, train)\r\n estimator.fit(X_train, y_train, **fit_params)\r\n avg_score.append(scorer(estimator, X_test, y_test))\r\n return np.mean(avg_score)\r\n\r\n\r\ndef _shuffle(y, groups, random_state):\r\n \"\"\"Return a shuffled copy of y eventually shuffle among same groups.\"\"\"\r\n if groups is None:\r\n indices = random_state.permutation(len(y))\r\n else:\r\n indices = np.arange(len(groups))\r\n for group in np.unique(groups):\r\n this_mask = (groups == group)\r\n indices[this_mask] = random_state.permutation(indices[this_mask])\r\n return _safe_indexing(y, indices)\r\n\r\n\r\n@_deprecate_positional_args\r\ndef learning_curve(estimator, X, y, *, groups=None,\r\n train_sizes=np.linspace(0.1, 1.0, 5), cv=None,\r\n scoring=None, exploit_incremental_learning=False,\r\n n_jobs=None, pre_dispatch=\"all\", verbose=0, shuffle=False,\r\n random_state=None, error_score=np.nan, return_times=False,\r\n fit_params=None):\r\n \"\"\"Learning curve.\r\n\r\n Determines cross-validated training and test scores for different training\r\n set sizes.\r\n\r\n A cross-validation generator splits the whole dataset k times in training\r\n and test data. Subsets of the training set with varying sizes will be used\r\n to train the estimator and a score for each training subset size and the\r\n test set will be computed. Afterwards, the scores will be averaged over\r\n all k runs for each training subset size.\r\n\r\n Read more in the :ref:`User Guide <learning_curve>`.\r\n\r\n Parameters\r\n ----------\r\n estimator : object type that implements the \"fit\" and \"predict\" methods\r\n An object of that type which is cloned for each validation.\r\n\r\n X : array-like of shape (n_samples, n_features)\r\n Training vector, where n_samples is the number of samples and\r\n n_features is the number of features.\r\n\r\n y : array-like of shape (n_samples,) or (n_samples, n_outputs)\r\n Target relative to X for classification or regression;\r\n None for unsupervised learning.\r\n\r\n groups : array-like of shape (n_samples,), default=None\r\n Group labels for the samples used while splitting the dataset into\r\n train/test set. Only used in conjunction with a \"Group\" :term:`cv`\r\n instance (e.g., :class:`GroupKFold`).\r\n\r\n train_sizes : array-like of shape (n_ticks,), \\\r\n default=np.linspace(0.1, 1.0, 5)\r\n Relative or absolute numbers of training examples that will be used to\r\n generate the learning curve. If the dtype is float, it is regarded as a\r\n fraction of the maximum size of the training set (that is determined\r\n by the selected validation method), i.e. it has to be within (0, 1].\r\n Otherwise it is interpreted as absolute sizes of the training sets.\r\n Note that for classification the number of samples usually have to\r\n be big enough to contain at least one sample from each class.\r\n\r\n cv : int, cross-validation generator or an iterable, default=None\r\n Determines the cross-validation splitting strategy.\r\n Possible inputs for cv are:\r\n\r\n - None, to use the default 5-fold cross validation,\r\n - int, to specify the number of folds in a `(Stratified)KFold`,\r\n - :term:`CV splitter`,\r\n - An iterable yielding (train, test) splits as arrays of indices.\r\n\r\n For int/None inputs, if the estimator is a classifier and ``y`` is\r\n either binary or multiclass, :class:`StratifiedKFold` is used. In all\r\n other cases, :class:`KFold` is used.\r\n\r\n Refer :ref:`User Guide <cross_validation>` for the various\r\n cross-validation strategies that can be used here.\r\n\r\n .. versionchanged:: 0.22\r\n ``cv`` default value if None changed from 3-fold to 5-fold.\r\n\r\n scoring : str or callable, default=None\r\n A str (see model evaluation documentation) or\r\n a scorer callable object / function with signature\r\n ``scorer(estimator, X, y)``.\r\n\r\n exploit_incremental_learning : bool, default=False\r\n If the estimator supports incremental learning, this will be\r\n used to speed up fitting for different training set sizes.\r\n\r\n n_jobs : int, default=None\r\n Number of jobs to run in parallel. Training the estimator and computing\r\n the score are parallelized over the different training and test sets.\r\n ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context.\r\n ``-1`` means using all processors. See :term:`Glossary <n_jobs>`\r\n for more details.\r\n\r\n pre_dispatch : int or str, default='all'\r\n Number of predispatched jobs for parallel execution (default is\r\n all). The option can reduce the allocated memory. The str can\r\n be an expression like '2*n_jobs'.\r\n\r\n verbose : int, default=0\r\n Controls the verbosity: the higher, the more messages.\r\n\r\n shuffle : bool, default=False\r\n Whether to shuffle training data before taking prefixes of it\r\n based on``train_sizes``.\r\n\r\n random_state : int, RandomState instance or None, default=None\r\n Used when ``shuffle`` is True. Pass an int for reproducible\r\n output across multiple function calls.\r\n See :term:`Glossary <random_state>`.\r\n\r\n error_score : 'raise' or numeric, default=np.nan\r\n Value to assign to the score if an error occurs in estimator fitting.\r\n If set to 'raise', the error is raised.\r\n If a numeric value is given, FitFailedWarning is raised.\r\n\r\n .. versionadded:: 0.20\r\n\r\n return_times : bool, default=False\r\n Whether to return the fit and score times.\r\n\r\n fit_params : dict, default=None\r\n Parameters to pass to the fit method of the estimator.\r\n\r\n .. versionadded:: 0.24\r\n\r\n Returns\r\n -------\r\n train_sizes_abs : array of shape (n_unique_ticks,)\r\n Numbers of training examples that has been used to generate the\r\n learning curve. Note that the number of ticks might be less\r\n than n_ticks because duplicate entries will be removed.\r\n\r\n train_scores : array of shape (n_ticks, n_cv_folds)\r\n Scores on training sets.\r\n\r\n test_scores : array of shape (n_ticks, n_cv_folds)\r\n Scores on test set.\r\n\r\n fit_times : array of shape (n_ticks, n_cv_folds)\r\n Times spent for fitting in seconds. Only present if ``return_times``\r\n is True.\r\n\r\n score_times : array of shape (n_ticks, n_cv_folds)\r\n Times spent for scoring in seconds. Only present if ``return_times``\r\n is True.\r\n\r\n Notes\r\n -----\r\n See :ref:`examples/model_selection/plot_learning_curve.py\r\n <sphx_glr_auto_examples_model_selection_plot_learning_curve.py>`\r\n \"\"\"\r\n if exploit_incremental_learning and not hasattr(estimator, \"partial_fit\"):\r\n raise ValueError(\"An estimator must support the partial_fit interface \"\r\n \"to exploit incremental learning\")\r\n X, y, groups = indexable(X, y, groups)\r\n\r\n cv = check_cv(cv, y, classifier=is_classifier(estimator))\r\n # Store it as list as we will be iterating over the list multiple times\r\n cv_iter = list(cv.split(X, y, groups))\r\n\r\n scorer = check_scoring(estimator, scoring=scoring)\r\n\r\n n_max_training_samples = len(cv_iter[0][0])\r\n # Because the lengths of folds can be significantly different, it is\r\n # not guaranteed that we use all of the available training data when we\r\n # use the first 'n_max_training_samples' samples.\r\n train_sizes_abs = _translate_train_sizes(train_sizes,\r\n n_max_training_samples)\r\n n_unique_ticks = train_sizes_abs.shape[0]\r\n if verbose > 0:\r\n print(\"[learning_curve] Training set sizes: \" + str(train_sizes_abs))\r\n\r\n parallel = Parallel(n_jobs=n_jobs, pre_dispatch=pre_dispatch,\r\n verbose=verbose)\r\n\r\n if shuffle:\r\n rng = check_random_state(random_state)\r\n cv_iter = ((rng.permutation(train), test) for train, test in cv_iter)\r\n\r\n if exploit_incremental_learning:\r\n classes = np.unique(y) if is_classifier(estimator) else None\r\n out = parallel(delayed(_incremental_fit_estimator)(\r\n clone(estimator), X, y, classes, train, test, train_sizes_abs,\r\n scorer, verbose, return_times, error_score=error_score,\r\n fit_params=fit_params)\r\n for train, test in cv_iter\r\n )\r\n out = np.asarray(out).transpose((2, 1, 0))\r\n else:\r\n train_test_proportions = []\r\n for train, test in cv_iter:\r\n for n_train_samples in train_sizes_abs:\r\n train_test_proportions.append((train[:n_train_samples], test))\r\n\r\n results = parallel(delayed(_fit_and_score)(\r\n clone(estimator), X, y, scorer, train, test, verbose,\r\n parameters=None, fit_params=fit_params, return_train_score=True,\r\n error_score=error_score, return_times=return_times)\r\n for train, test in train_test_proportions\r\n )\r\n results = _aggregate_score_dicts(results)\r\n train_scores = results[\"train_scores\"].reshape(-1, n_unique_ticks).T\r\n test_scores = results[\"test_scores\"].reshape(-1, n_unique_ticks).T\r\n out = [train_scores, test_scores]\r\n\r\n if return_times:\r\n fit_times = results[\"fit_time\"].reshape(-1, n_unique_ticks).T\r\n score_times = results[\"score_time\"].reshape(-1, n_unique_ticks).T\r\n out.extend([fit_times, score_times])\r\n\r\n ret = train_sizes_abs, out[0], out[1]\r\n\r\n if return_times:\r\n ret = ret + (out[2], out[3])\r\n\r\n return ret\r\n\r\n\r\ndef _translate_train_sizes(train_sizes, n_max_training_samples):\r\n \"\"\"Determine absolute sizes of training subsets and validate 'train_sizes'.\r\n\r\n Examples:\r\n _translate_train_sizes([0.5, 1.0], 10) -> [5, 10]\r\n _translate_train_sizes([5, 10], 10) -> [5, 10]\r\n\r\n Parameters\r\n ----------\r\n train_sizes : array-like of shape (n_ticks,)\r\n Numbers of training examples that will be used to generate the\r\n learning curve. If the dtype is float, it is regarded as a\r\n fraction of 'n_max_training_samples', i.e. it has to be within (0, 1].\r\n\r\n n_max_training_samples : int\r\n Maximum number of training samples (upper bound of 'train_sizes').\r\n\r\n Returns\r\n -------\r\n train_sizes_abs : array of shape (n_unique_ticks,)\r\n Numbers of training examples that will be used to generate the\r\n learning curve. Note that the number of ticks might be less\r\n than n_ticks because duplicate entries will be removed.\r\n \"\"\"\r\n train_sizes_abs = np.asarray(train_sizes)\r\n n_ticks = train_sizes_abs.shape[0]\r\n n_min_required_samples = np.min(train_sizes_abs)\r\n n_max_required_samples = np.max(train_sizes_abs)\r\n if np.issubdtype(train_sizes_abs.dtype, np.floating):\r\n if n_min_required_samples <= 0.0 or n_max_required_samples > 1.0:\r\n raise ValueError(\"train_sizes has been interpreted as fractions \"\r\n \"of the maximum number of training samples and \"\r\n \"must be within (0, 1], but is within [%f, %f].\"\r\n % (n_min_required_samples,\r\n n_max_required_samples))\r\n train_sizes_abs = (train_sizes_abs * n_max_training_samples).astype(\r\n dtype=int, copy=False)\r\n train_sizes_abs = np.clip(train_sizes_abs, 1,\r\n n_max_training_samples)\r\n else:\r\n if (n_min_required_samples <= 0 or\r\n n_max_required_samples > n_max_training_samples):\r\n raise ValueError(\"train_sizes has been interpreted as absolute \"\r\n \"numbers of training samples and must be within \"\r\n \"(0, %d], but is within [%d, %d].\"\r\n % (n_max_training_samples,\r\n n_min_required_samples,\r\n n_max_required_samples))\r\n\r\n train_sizes_abs = np.unique(train_sizes_abs)\r\n if n_ticks > train_sizes_abs.shape[0]:\r\n warnings.warn(\"Removed duplicate entries from 'train_sizes'. Number \"\r\n \"of ticks will be less than the size of \"\r\n \"'train_sizes' %d instead of %d).\"\r\n % (train_sizes_abs.shape[0], n_ticks), RuntimeWarning)\r\n\r\n return train_sizes_abs\r\n\r\n\r\ndef _incremental_fit_estimator(estimator, X, y, classes, train, test,\r\n train_sizes, scorer, verbose,\r\n return_times, error_score, fit_params):\r\n \"\"\"Train estimator on training subsets incrementally and compute scores.\"\"\"\r\n train_scores, test_scores, fit_times, score_times = [], [], [], []\r\n partitions = zip(train_sizes, np.split(train, train_sizes)[:-1])\r\n if fit_params is None:\r\n fit_params = {}\r\n for n_train_samples, partial_train in partitions:\r\n train_subset = train[:n_train_samples]\r\n X_train, y_train = _safe_split(estimator, X, y, train_subset)\r\n X_partial_train, y_partial_train = _safe_split(estimator, X, y,\r\n partial_train)\r\n X_test, y_test = _safe_split(estimator, X, y, test, train_subset)\r\n start_fit = time.time()\r\n if y_partial_train is None:\r\n estimator.partial_fit(X_partial_train, classes=classes,\r\n **fit_params)\r\n else:\r\n estimator.partial_fit(X_partial_train, y_partial_train,\r\n classes=classes, **fit_params)\r\n fit_time = time.time() - start_fit\r\n fit_times.append(fit_time)\r\n\r\n start_score = time.time()\r\n\r\n test_scores.append(\r\n _score(estimator, X_test, y_test, scorer, error_score)\r\n )\r\n train_scores.append(\r\n _score(estimator, X_train, y_train, scorer, error_score)\r\n )\r\n\r\n score_time = time.time() - start_score\r\n score_times.append(score_time)\r\n\r\n ret = ((train_scores, test_scores, fit_times, score_times)\r\n if return_times else (train_scores, test_scores))\r\n\r\n return np.array(ret).T\r\n\r\n\r\n@_deprecate_positional_args\r\ndef validation_curve(estimator, X, y, *, param_name, param_range, groups=None,\r\n cv=None, scoring=None, n_jobs=None, pre_dispatch=\"all\",\r\n verbose=0, error_score=np.nan, fit_params=None):\r\n \"\"\"Validation curve.\r\n\r\n Determine training and test scores for varying parameter values.\r\n\r\n Compute scores for an estimator with different values of a specified\r\n parameter. This is similar to grid search with one parameter. However, this\r\n will also compute training scores and is merely a utility for plotting the\r\n results.\r\n\r\n Read more in the :ref:`User Guide <validation_curve>`.\r\n\r\n Parameters\r\n ----------\r\n estimator : object type that implements the \"fit\" and \"predict\" methods\r\n An object of that type which is cloned for each validation.\r\n\r\n X : array-like of shape (n_samples, n_features)\r\n Training vector, where n_samples is the number of samples and\r\n n_features is the number of features.\r\n\r\n y : array-like of shape (n_samples,) or (n_samples, n_outputs) or None\r\n Target relative to X for classification or regression;\r\n None for unsupervised learning.\r\n\r\n param_name : str\r\n Name of the parameter that will be varied.\r\n\r\n param_range : array-like of shape (n_values,)\r\n The values of the parameter that will be evaluated.\r\n\r\n groups : array-like of shape (n_samples,), default=None\r\n Group labels for the samples used while splitting the dataset into\r\n train/test set. Only used in conjunction with a \"Group\" :term:`cv`\r\n instance (e.g., :class:`GroupKFold`).\r\n\r\n cv : int, cross-validation generator or an iterable, default=None\r\n Determines the cross-validation splitting strategy.\r\n Possible inputs for cv are:\r\n\r\n - None, to use the default 5-fold cross validation,\r\n - int, to specify the number of folds in a `(Stratified)KFold`,\r\n - :term:`CV splitter`,\r\n - An iterable yielding (train, test) splits as arrays of indices.\r\n\r\n For int/None inputs, if the estimator is a classifier and ``y`` is\r\n either binary or multiclass, :class:`StratifiedKFold` is used. In all\r\n other cases, :class:`KFold` is used.\r\n\r\n Refer :ref:`User Guide <cross_validation>` for the various\r\n cross-validation strategies that can be used here.\r\n\r\n .. versionchanged:: 0.22\r\n ``cv`` default value if None changed from 3-fold to 5-fold.\r\n\r\n scoring : str or callable, default=None\r\n A str (see model evaluation documentation) or\r\n a scorer callable object / function with signature\r\n ``scorer(estimator, X, y)``.\r\n\r\n n_jobs : int, default=None\r\n Number of jobs to run in parallel. Training the estimator and computing\r\n the score are parallelized over the combinations of each parameter\r\n value and each cross-validation split.\r\n ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context.\r\n ``-1`` means using all processors. See :term:`Glossary <n_jobs>`\r\n for more details.\r\n\r\n pre_dispatch : int or str, default='all'\r\n Number of predispatched jobs for parallel execution (default is\r\n all). The option can reduce the allocated memory. The str can\r\n be an expression like '2*n_jobs'.\r\n\r\n verbose : int, default=0\r\n Controls the verbosity: the higher, the more messages.\r\n\r\n fit_params : dict, default=None\r\n Parameters to pass to the fit method of the estimator.\r\n\r\n .. versionadded:: 0.24\r\n\r\n error_score : 'raise' or numeric, default=np.nan\r\n Value to assign to the score if an error occurs in estimator fitting.\r\n If set to 'raise', the error is raised.\r\n If a numeric value is given, FitFailedWarning is raised.\r\n\r\n .. versionadded:: 0.20\r\n\r\n Returns\r\n -------\r\n train_scores : array of shape (n_ticks, n_cv_folds)\r\n Scores on training sets.\r\n\r\n test_scores : array of shape (n_ticks, n_cv_folds)\r\n Scores on test set.\r\n\r\n Notes\r\n -----\r\n See :ref:`sphx_glr_auto_examples_model_selection_plot_validation_curve.py`\r\n\r\n \"\"\"\r\n X, y, groups = indexable(X, y, groups)\r\n\r\n cv = check_cv(cv, y, classifier=is_classifier(estimator))\r\n scorer = check_scoring(estimator, scoring=scoring)\r\n\r\n parallel = Parallel(n_jobs=n_jobs, pre_dispatch=pre_dispatch,\r\n verbose=verbose)\r\n results = parallel(delayed(_fit_and_score)(\r\n clone(estimator), X, y, scorer, train, test, verbose,\r\n parameters={param_name: v}, fit_params=fit_params,\r\n return_train_score=True, error_score=error_score)\r\n\r\n # NOTE do not change order of iteration to allow one time cv splitters\r\n for train, test in cv.split(X, y, groups) for v in param_range)\r\n n_params = len(param_range)\r\n\r\n results = _aggregate_score_dicts(results)\r\n train_scores = results[\"train_scores\"].reshape(-1, n_params).T\r\n test_scores = results[\"test_scores\"].reshape(-1, n_params).T\r\n\r\n return train_scores, test_scores\r\n\r\n\r\ndef _aggregate_score_dicts(scores):\r\n \"\"\"Aggregate the list of dict to dict of np ndarray\r\n\r\n The aggregated output of _aggregate_score_dicts will be a list of dict\r\n of form [{'prec': 0.1, 'acc':1.0}, {'prec': 0.1, 'acc':1.0}, ...]\r\n Convert it to a dict of array {'prec': np.array([0.1 ...]), ...}\r\n\r\n Parameters\r\n ----------\r\n\r\n scores : list of dict\r\n List of dicts of the scores for all scorers. This is a flat list,\r\n assumed originally to be of row major order.\r\n\r\n Example\r\n -------\r\n\r\n >>> scores = [{'a': 1, 'b':10}, {'a': 2, 'b':2}, {'a': 3, 'b':3},\r\n ... {'a': 10, 'b': 10}] # doctest: +SKIP\r\n >>> _aggregate_score_dicts(scores) # doctest: +SKIP\r\n {'a': array([1, 2, 3, 10]),\r\n 'b': array([10, 2, 3, 10])}\r\n \"\"\"\r\n return {\r\n key: np.asarray([score[key] for score in scores])\r\n if isinstance(scores[0][key], numbers.Number)\r\n else [score[key] for score in scores]\r\n for key in scores[0]\r\n }\r\n",
"from datetime import timedelta\r\n\r\nimport numpy as np\r\nimport pytest\r\n\r\nfrom pandas import Categorical, DataFrame, NaT, Period, Series, Timedelta, Timestamp\r\nimport pandas._testing as tm\r\n\r\n\r\nclass TestSeriesFillNA:\r\n def test_fillna_pytimedelta(self):\r\n # GH#8209\r\n ser = Series([np.nan, Timedelta(\"1 days\")], index=[\"A\", \"B\"])\r\n\r\n result = ser.fillna(timedelta(1))\r\n expected = Series(Timedelta(\"1 days\"), index=[\"A\", \"B\"])\r\n tm.assert_series_equal(result, expected)\r\n\r\n def test_fillna_period(self):\r\n # GH#13737\r\n ser = Series([Period(\"2011-01\", freq=\"M\"), Period(\"NaT\", freq=\"M\")])\r\n\r\n res = ser.fillna(Period(\"2012-01\", freq=\"M\"))\r\n exp = Series([Period(\"2011-01\", freq=\"M\"), Period(\"2012-01\", freq=\"M\")])\r\n tm.assert_series_equal(res, exp)\r\n assert res.dtype == \"Period[M]\"\r\n\r\n def test_fillna_dt64_timestamp(self):\r\n ser = Series(\r\n [\r\n Timestamp(\"20130101\"),\r\n Timestamp(\"20130101\"),\r\n Timestamp(\"20130102\"),\r\n Timestamp(\"20130103 9:01:01\"),\r\n ]\r\n )\r\n ser[2] = np.nan\r\n\r\n # reg fillna\r\n result = ser.fillna(Timestamp(\"20130104\"))\r\n expected = Series(\r\n [\r\n Timestamp(\"20130101\"),\r\n Timestamp(\"20130101\"),\r\n Timestamp(\"20130104\"),\r\n Timestamp(\"20130103 9:01:01\"),\r\n ]\r\n )\r\n tm.assert_series_equal(result, expected)\r\n\r\n result = ser.fillna(NaT)\r\n expected = ser\r\n tm.assert_series_equal(result, expected)\r\n\r\n def test_fillna_dt64_non_nao(self):\r\n # GH#27419\r\n ser = Series([Timestamp(\"2010-01-01\"), NaT, Timestamp(\"2000-01-01\")])\r\n val = np.datetime64(\"1975-04-05\", \"ms\")\r\n\r\n result = ser.fillna(val)\r\n expected = Series(\r\n [Timestamp(\"2010-01-01\"), Timestamp(\"1975-04-05\"), Timestamp(\"2000-01-01\")]\r\n )\r\n tm.assert_series_equal(result, expected)\r\n\r\n def test_fillna_numeric_inplace(self):\r\n x = Series([np.nan, 1.0, np.nan, 3.0, np.nan], [\"z\", \"a\", \"b\", \"c\", \"d\"])\r\n y = x.copy()\r\n\r\n return_value = y.fillna(value=0, inplace=True)\r\n assert return_value is None\r\n\r\n expected = x.fillna(value=0)\r\n tm.assert_series_equal(y, expected)\r\n\r\n # ---------------------------------------------------------------\r\n # CategoricalDtype\r\n\r\n @pytest.mark.parametrize(\r\n \"fill_value, expected_output\",\r\n [\r\n (\"a\", [\"a\", \"a\", \"b\", \"a\", \"a\"]),\r\n ({1: \"a\", 3: \"b\", 4: \"b\"}, [\"a\", \"a\", \"b\", \"b\", \"b\"]),\r\n ({1: \"a\"}, [\"a\", \"a\", \"b\", np.nan, np.nan]),\r\n ({1: \"a\", 3: \"b\"}, [\"a\", \"a\", \"b\", \"b\", np.nan]),\r\n (Series(\"a\"), [\"a\", np.nan, \"b\", np.nan, np.nan]),\r\n (Series(\"a\", index=[1]), [\"a\", \"a\", \"b\", np.nan, np.nan]),\r\n (Series({1: \"a\", 3: \"b\"}), [\"a\", \"a\", \"b\", \"b\", np.nan]),\r\n (Series([\"a\", \"b\"], index=[3, 4]), [\"a\", np.nan, \"b\", \"a\", \"b\"]),\r\n ],\r\n )\r\n def test_fillna_categorical(self, fill_value, expected_output):\r\n # GH#17033\r\n # Test fillna for a Categorical series\r\n data = [\"a\", np.nan, \"b\", np.nan, np.nan]\r\n ser = Series(Categorical(data, categories=[\"a\", \"b\"]))\r\n exp = Series(Categorical(expected_output, categories=[\"a\", \"b\"]))\r\n result = ser.fillna(fill_value)\r\n tm.assert_series_equal(result, exp)\r\n\r\n @pytest.mark.parametrize(\r\n \"fill_value, expected_output\",\r\n [\r\n (Series([\"a\", \"b\", \"c\", \"d\", \"e\"]), [\"a\", \"b\", \"b\", \"d\", \"e\"]),\r\n (Series([\"b\", \"d\", \"a\", \"d\", \"a\"]), [\"a\", \"d\", \"b\", \"d\", \"a\"]),\r\n (\r\n Series(\r\n Categorical(\r\n [\"b\", \"d\", \"a\", \"d\", \"a\"], categories=[\"b\", \"c\", \"d\", \"e\", \"a\"]\r\n )\r\n ),\r\n [\"a\", \"d\", \"b\", \"d\", \"a\"],\r\n ),\r\n ],\r\n )\r\n def test_fillna_categorical_with_new_categories(self, fill_value, expected_output):\r\n # GH#26215\r\n data = [\"a\", np.nan, \"b\", np.nan, np.nan]\r\n ser = Series(Categorical(data, categories=[\"a\", \"b\", \"c\", \"d\", \"e\"]))\r\n exp = Series(Categorical(expected_output, categories=[\"a\", \"b\", \"c\", \"d\", \"e\"]))\r\n result = ser.fillna(fill_value)\r\n tm.assert_series_equal(result, exp)\r\n\r\n def test_fillna_categorical_raises(self):\r\n data = [\"a\", np.nan, \"b\", np.nan, np.nan]\r\n ser = Series(Categorical(data, categories=[\"a\", \"b\"]))\r\n\r\n with pytest.raises(ValueError, match=\"fill value must be in categories\"):\r\n ser.fillna(\"d\")\r\n\r\n with pytest.raises(ValueError, match=\"fill value must be in categories\"):\r\n ser.fillna(Series(\"d\"))\r\n\r\n with pytest.raises(ValueError, match=\"fill value must be in categories\"):\r\n ser.fillna({1: \"d\", 3: \"a\"})\r\n\r\n msg = '\"value\" parameter must be a scalar or dict, but you passed a \"list\"'\r\n with pytest.raises(TypeError, match=msg):\r\n ser.fillna([\"a\", \"b\"])\r\n\r\n msg = '\"value\" parameter must be a scalar or dict, but you passed a \"tuple\"'\r\n with pytest.raises(TypeError, match=msg):\r\n ser.fillna((\"a\", \"b\"))\r\n\r\n msg = (\r\n '\"value\" parameter must be a scalar, dict '\r\n 'or Series, but you passed a \"DataFrame\"'\r\n )\r\n with pytest.raises(TypeError, match=msg):\r\n ser.fillna(DataFrame({1: [\"a\"], 3: [\"b\"]}))\r\n\r\n # ---------------------------------------------------------------\r\n # Invalid Usages\r\n\r\n def test_fillna_listlike_invalid(self):\r\n ser = Series(np.random.randint(-100, 100, 50))\r\n msg = '\"value\" parameter must be a scalar or dict, but you passed a \"list\"'\r\n with pytest.raises(TypeError, match=msg):\r\n ser.fillna([1, 2])\r\n\r\n msg = '\"value\" parameter must be a scalar or dict, but you passed a \"tuple\"'\r\n with pytest.raises(TypeError, match=msg):\r\n ser.fillna((1, 2))\r\n\r\n def test_fillna_method_and_limit_invalid(self):\r\n\r\n # related GH#9217, make sure limit is an int and greater than 0\r\n ser = Series([1, 2, 3, None])\r\n msg = (\r\n r\"Cannot specify both 'value' and 'method'\\.|\"\r\n r\"Limit must be greater than 0|\"\r\n \"Limit must be an integer\"\r\n )\r\n for limit in [-1, 0, 1.0, 2.0]:\r\n for method in [\"backfill\", \"bfill\", \"pad\", \"ffill\", None]:\r\n with pytest.raises(ValueError, match=msg):\r\n ser.fillna(1, limit=limit, method=method)\r\n",
"\"\"\"Sparse Dtype\"\"\"\r\n\r\nimport re\r\nfrom typing import TYPE_CHECKING, Any, List, Optional, Tuple, Type\r\nimport warnings\r\n\r\nimport numpy as np\r\n\r\nfrom pandas._typing import Dtype, DtypeObj\r\nfrom pandas.errors import PerformanceWarning\r\n\r\nfrom pandas.core.dtypes.base import ExtensionDtype, register_extension_dtype\r\nfrom pandas.core.dtypes.cast import astype_nansafe\r\nfrom pandas.core.dtypes.common import (\r\n is_bool_dtype,\r\n is_extension_array_dtype,\r\n is_object_dtype,\r\n is_scalar,\r\n is_string_dtype,\r\n pandas_dtype,\r\n)\r\nfrom pandas.core.dtypes.missing import isna, na_value_for_dtype\r\n\r\nif TYPE_CHECKING:\r\n from pandas.core.arrays.sparse.array import SparseArray # noqa: F401\r\n\r\n\r\n@register_extension_dtype\r\nclass SparseDtype(ExtensionDtype):\r\n \"\"\"\r\n Dtype for data stored in :class:`SparseArray`.\r\n\r\n This dtype implements the pandas ExtensionDtype interface.\r\n\r\n .. versionadded:: 0.24.0\r\n\r\n Parameters\r\n ----------\r\n dtype : str, ExtensionDtype, numpy.dtype, type, default numpy.float64\r\n The dtype of the underlying array storing the non-fill value values.\r\n fill_value : scalar, optional\r\n The scalar value not stored in the SparseArray. By default, this\r\n depends on `dtype`.\r\n\r\n =========== ==========\r\n dtype na_value\r\n =========== ==========\r\n float ``np.nan``\r\n int ``0``\r\n bool ``False``\r\n datetime64 ``pd.NaT``\r\n timedelta64 ``pd.NaT``\r\n =========== ==========\r\n\r\n The default value may be overridden by specifying a `fill_value`.\r\n\r\n Attributes\r\n ----------\r\n None\r\n\r\n Methods\r\n -------\r\n None\r\n \"\"\"\r\n\r\n # We include `_is_na_fill_value` in the metadata to avoid hash collisions\r\n # between SparseDtype(float, 0.0) and SparseDtype(float, nan).\r\n # Without is_na_fill_value in the comparison, those would be equal since\r\n # hash(nan) is (sometimes?) 0.\r\n _metadata = (\"_dtype\", \"_fill_value\", \"_is_na_fill_value\")\r\n\r\n def __init__(self, dtype: Dtype = np.float64, fill_value: Any = None):\r\n\r\n if isinstance(dtype, type(self)):\r\n if fill_value is None:\r\n fill_value = dtype.fill_value\r\n dtype = dtype.subtype\r\n\r\n dtype = pandas_dtype(dtype)\r\n if is_string_dtype(dtype):\r\n dtype = np.dtype(\"object\")\r\n\r\n if fill_value is None:\r\n fill_value = na_value_for_dtype(dtype)\r\n\r\n if not is_scalar(fill_value):\r\n raise ValueError(f\"fill_value must be a scalar. Got {fill_value} instead\")\r\n self._dtype = dtype\r\n self._fill_value = fill_value\r\n\r\n def __hash__(self):\r\n # Python3 doesn't inherit __hash__ when a base class overrides\r\n # __eq__, so we explicitly do it here.\r\n return super().__hash__()\r\n\r\n def __eq__(self, other: Any) -> bool:\r\n # We have to override __eq__ to handle NA values in _metadata.\r\n # The base class does simple == checks, which fail for NA.\r\n if isinstance(other, str):\r\n try:\r\n other = self.construct_from_string(other)\r\n except TypeError:\r\n return False\r\n\r\n if isinstance(other, type(self)):\r\n subtype = self.subtype == other.subtype\r\n if self._is_na_fill_value:\r\n # this case is complicated by two things:\r\n # SparseDtype(float, float(nan)) == SparseDtype(float, np.nan)\r\n # SparseDtype(float, np.nan) != SparseDtype(float, pd.NaT)\r\n # i.e. we want to treat any floating-point NaN as equal, but\r\n # not a floating-point NaN and a datetime NaT.\r\n fill_value = (\r\n other._is_na_fill_value\r\n and isinstance(self.fill_value, type(other.fill_value))\r\n or isinstance(other.fill_value, type(self.fill_value))\r\n )\r\n else:\r\n fill_value = self.fill_value == other.fill_value\r\n\r\n return subtype and fill_value\r\n return False\r\n\r\n @property\r\n def fill_value(self):\r\n \"\"\"\r\n The fill value of the array.\r\n\r\n Converting the SparseArray to a dense ndarray will fill the\r\n array with this value.\r\n\r\n .. warning::\r\n\r\n It's possible to end up with a SparseArray that has ``fill_value``\r\n values in ``sp_values``. This can occur, for example, when setting\r\n ``SparseArray.fill_value`` directly.\r\n \"\"\"\r\n return self._fill_value\r\n\r\n @property\r\n def _is_na_fill_value(self):\r\n return isna(self.fill_value)\r\n\r\n @property\r\n def _is_numeric(self) -> bool:\r\n return not is_object_dtype(self.subtype)\r\n\r\n @property\r\n def _is_boolean(self) -> bool:\r\n return is_bool_dtype(self.subtype)\r\n\r\n @property\r\n def kind(self):\r\n \"\"\"\r\n The sparse kind. Either 'integer', or 'block'.\r\n \"\"\"\r\n return self.subtype.kind\r\n\r\n @property\r\n def type(self):\r\n return self.subtype.type\r\n\r\n @property\r\n def subtype(self):\r\n return self._dtype\r\n\r\n @property\r\n def name(self):\r\n return f\"Sparse[{self.subtype.name}, {repr(self.fill_value)}]\"\r\n\r\n def __repr__(self) -> str:\r\n return self.name\r\n\r\n @classmethod\r\n def construct_array_type(cls) -> Type[\"SparseArray\"]:\r\n \"\"\"\r\n Return the array type associated with this dtype.\r\n\r\n Returns\r\n -------\r\n type\r\n \"\"\"\r\n from pandas.core.arrays.sparse.array import SparseArray # noqa: F811\r\n\r\n return SparseArray\r\n\r\n @classmethod\r\n def construct_from_string(cls, string: str) -> \"SparseDtype\":\r\n \"\"\"\r\n Construct a SparseDtype from a string form.\r\n\r\n Parameters\r\n ----------\r\n string : str\r\n Can take the following forms.\r\n\r\n string dtype\r\n ================ ============================\r\n 'int' SparseDtype[np.int64, 0]\r\n 'Sparse' SparseDtype[np.float64, nan]\r\n 'Sparse[int]' SparseDtype[np.int64, 0]\r\n 'Sparse[int, 0]' SparseDtype[np.int64, 0]\r\n ================ ============================\r\n\r\n It is not possible to specify non-default fill values\r\n with a string. An argument like ``'Sparse[int, 1]'``\r\n will raise a ``TypeError`` because the default fill value\r\n for integers is 0.\r\n\r\n Returns\r\n -------\r\n SparseDtype\r\n \"\"\"\r\n if not isinstance(string, str):\r\n raise TypeError(\r\n f\"'construct_from_string' expects a string, got {type(string)}\"\r\n )\r\n msg = f\"Cannot construct a 'SparseDtype' from '{string}'\"\r\n if string.startswith(\"Sparse\"):\r\n try:\r\n sub_type, has_fill_value = cls._parse_subtype(string)\r\n except ValueError as err:\r\n raise TypeError(msg) from err\r\n else:\r\n result = SparseDtype(sub_type)\r\n msg = (\r\n f\"Cannot construct a 'SparseDtype' from '{string}'.\\n\\nIt \"\r\n \"looks like the fill_value in the string is not \"\r\n \"the default for the dtype. Non-default fill_values \"\r\n \"are not supported. Use the 'SparseDtype()' \"\r\n \"constructor instead.\"\r\n )\r\n if has_fill_value and str(result) != string:\r\n raise TypeError(msg)\r\n return result\r\n else:\r\n raise TypeError(msg)\r\n\r\n @staticmethod\r\n def _parse_subtype(dtype: str) -> Tuple[str, bool]:\r\n \"\"\"\r\n Parse a string to get the subtype\r\n\r\n Parameters\r\n ----------\r\n dtype : str\r\n A string like\r\n\r\n * Sparse[subtype]\r\n * Sparse[subtype, fill_value]\r\n\r\n Returns\r\n -------\r\n subtype : str\r\n\r\n Raises\r\n ------\r\n ValueError\r\n When the subtype cannot be extracted.\r\n \"\"\"\r\n xpr = re.compile(r\"Sparse\\[(?P<subtype>[^,]*)(, )?(?P<fill_value>.*?)?\\]$\")\r\n m = xpr.match(dtype)\r\n has_fill_value = False\r\n if m:\r\n subtype = m.groupdict()[\"subtype\"]\r\n has_fill_value = bool(m.groupdict()[\"fill_value\"])\r\n elif dtype == \"Sparse\":\r\n subtype = \"float64\"\r\n else:\r\n raise ValueError(f\"Cannot parse {dtype}\")\r\n return subtype, has_fill_value\r\n\r\n @classmethod\r\n def is_dtype(cls, dtype: object) -> bool:\r\n dtype = getattr(dtype, \"dtype\", dtype)\r\n if isinstance(dtype, str) and dtype.startswith(\"Sparse\"):\r\n sub_type, _ = cls._parse_subtype(dtype)\r\n dtype = np.dtype(sub_type)\r\n elif isinstance(dtype, cls):\r\n return True\r\n return isinstance(dtype, np.dtype) or dtype == \"Sparse\"\r\n\r\n def update_dtype(self, dtype):\r\n \"\"\"\r\n Convert the SparseDtype to a new dtype.\r\n\r\n This takes care of converting the ``fill_value``.\r\n\r\n Parameters\r\n ----------\r\n dtype : Union[str, numpy.dtype, SparseDtype]\r\n The new dtype to use.\r\n\r\n * For a SparseDtype, it is simply returned\r\n * For a NumPy dtype (or str), the current fill value\r\n is converted to the new dtype, and a SparseDtype\r\n with `dtype` and the new fill value is returned.\r\n\r\n Returns\r\n -------\r\n SparseDtype\r\n A new SparseDtype with the correct `dtype` and fill value\r\n for that `dtype`.\r\n\r\n Raises\r\n ------\r\n ValueError\r\n When the current fill value cannot be converted to the\r\n new `dtype` (e.g. trying to convert ``np.nan`` to an\r\n integer dtype).\r\n\r\n\r\n Examples\r\n --------\r\n >>> SparseDtype(int, 0).update_dtype(float)\r\n Sparse[float64, 0.0]\r\n\r\n >>> SparseDtype(int, 1).update_dtype(SparseDtype(float, np.nan))\r\n Sparse[float64, nan]\r\n \"\"\"\r\n cls = type(self)\r\n dtype = pandas_dtype(dtype)\r\n\r\n if not isinstance(dtype, cls):\r\n if is_extension_array_dtype(dtype):\r\n raise TypeError(\"sparse arrays of extension dtypes not supported\")\r\n\r\n fill_value = astype_nansafe(np.array(self.fill_value), dtype).item()\r\n dtype = cls(dtype, fill_value=fill_value)\r\n\r\n return dtype\r\n\r\n @property\r\n def _subtype_with_str(self):\r\n \"\"\"\r\n Whether the SparseDtype's subtype should be considered ``str``.\r\n\r\n Typically, pandas will store string data in an object-dtype array.\r\n When converting values to a dtype, e.g. in ``.astype``, we need to\r\n be more specific, we need the actual underlying type.\r\n\r\n Returns\r\n -------\r\n >>> SparseDtype(int, 1)._subtype_with_str\r\n dtype('int64')\r\n\r\n >>> SparseDtype(object, 1)._subtype_with_str\r\n dtype('O')\r\n\r\n >>> dtype = SparseDtype(str, '')\r\n >>> dtype.subtype\r\n dtype('O')\r\n\r\n >>> dtype._subtype_with_str\r\n <class 'str'>\r\n \"\"\"\r\n if isinstance(self.fill_value, str):\r\n return type(self.fill_value)\r\n return self.subtype\r\n\r\n def _get_common_dtype(self, dtypes: List[DtypeObj]) -> Optional[DtypeObj]:\r\n # TODO for now only handle SparseDtypes and numpy dtypes => extend\r\n # with other compatibtle extension dtypes\r\n if any(\r\n isinstance(x, ExtensionDtype) and not isinstance(x, SparseDtype)\r\n for x in dtypes\r\n ):\r\n return None\r\n\r\n fill_values = [x.fill_value for x in dtypes if isinstance(x, SparseDtype)]\r\n fill_value = fill_values[0]\r\n\r\n # np.nan isn't a singleton, so we may end up with multiple\r\n # NaNs here, so we ignore tha all NA case too.\r\n if not (len(set(fill_values)) == 1 or isna(fill_values).all()):\r\n warnings.warn(\r\n \"Concatenating sparse arrays with multiple fill \"\r\n f\"values: '{fill_values}'. Picking the first and \"\r\n \"converting the rest.\",\r\n PerformanceWarning,\r\n stacklevel=6,\r\n )\r\n\r\n np_dtypes = [x.subtype if isinstance(x, SparseDtype) else x for x in dtypes]\r\n return SparseDtype(np.find_common_type(np_dtypes, []), fill_value=fill_value)\r\n",
"import numpy as np\r\n\r\nfrom pandas import Series, Timestamp, date_range\r\nimport pandas._testing as tm\r\nfrom pandas.api.types import is_scalar\r\n\r\n\r\nclass TestSeriesSearchSorted:\r\n def test_searchsorted(self):\r\n ser = Series([1, 2, 3])\r\n\r\n result = ser.searchsorted(1, side=\"left\")\r\n assert is_scalar(result)\r\n assert result == 0\r\n\r\n result = ser.searchsorted(1, side=\"right\")\r\n assert is_scalar(result)\r\n assert result == 1\r\n\r\n def test_searchsorted_numeric_dtypes_scalar(self):\r\n ser = Series([1, 2, 90, 1000, 3e9])\r\n res = ser.searchsorted(30)\r\n assert is_scalar(res)\r\n assert res == 2\r\n\r\n res = ser.searchsorted([30])\r\n exp = np.array([2], dtype=np.intp)\r\n tm.assert_numpy_array_equal(res, exp)\r\n\r\n def test_searchsorted_numeric_dtypes_vector(self):\r\n ser = Series([1, 2, 90, 1000, 3e9])\r\n res = ser.searchsorted([91, 2e6])\r\n exp = np.array([3, 4], dtype=np.intp)\r\n tm.assert_numpy_array_equal(res, exp)\r\n\r\n def test_searchsorted_datetime64_scalar(self):\r\n ser = Series(date_range(\"20120101\", periods=10, freq=\"2D\"))\r\n val = Timestamp(\"20120102\")\r\n res = ser.searchsorted(val)\r\n assert is_scalar(res)\r\n assert res == 1\r\n\r\n def test_searchsorted_datetime64_scalar_mixed_timezones(self):\r\n # GH 30086\r\n ser = Series(date_range(\"20120101\", periods=10, freq=\"2D\", tz=\"UTC\"))\r\n val = Timestamp(\"20120102\", tz=\"America/New_York\")\r\n res = ser.searchsorted(val)\r\n assert is_scalar(res)\r\n assert res == 1\r\n\r\n def test_searchsorted_datetime64_list(self):\r\n ser = Series(date_range(\"20120101\", periods=10, freq=\"2D\"))\r\n vals = [Timestamp(\"20120102\"), Timestamp(\"20120104\")]\r\n res = ser.searchsorted(vals)\r\n exp = np.array([1, 2], dtype=np.intp)\r\n tm.assert_numpy_array_equal(res, exp)\r\n\r\n def test_searchsorted_sorter(self):\r\n # GH8490\r\n ser = Series([3, 1, 2])\r\n res = ser.searchsorted([0, 3], sorter=np.argsort(ser))\r\n exp = np.array([0, 2], dtype=np.intp)\r\n tm.assert_numpy_array_equal(res, exp)\r\n",
"import numpy as np\r\nimport pytest\r\n\r\nfrom pandas.core.dtypes.common import ensure_platform_int\r\n\r\nimport pandas as pd\r\nfrom pandas import Float64Index, Index, Int64Index, RangeIndex\r\nimport pandas._testing as tm\r\n\r\nfrom ..test_numeric import Numeric\r\n\r\n# aliases to make some tests easier to read\r\nRI = RangeIndex\r\nI64 = Int64Index\r\nF64 = Float64Index\r\nOI = Index\r\n\r\n\r\nclass TestRangeIndex(Numeric):\r\n _holder = RangeIndex\r\n _compat_props = [\"shape\", \"ndim\", \"size\"]\r\n\r\n @pytest.fixture(\r\n params=[\r\n RangeIndex(start=0, stop=20, step=2, name=\"foo\"),\r\n RangeIndex(start=18, stop=-1, step=-2, name=\"bar\"),\r\n ],\r\n ids=[\"index_inc\", \"index_dec\"],\r\n )\r\n def index(self, request):\r\n return request.param\r\n\r\n def create_index(self) -> RangeIndex:\r\n return RangeIndex(start=0, stop=20, step=2)\r\n\r\n def test_can_hold_identifiers(self):\r\n idx = self.create_index()\r\n key = idx[0]\r\n assert idx._can_hold_identifiers_and_holds_name(key) is False\r\n\r\n def test_too_many_names(self):\r\n index = self.create_index()\r\n with pytest.raises(ValueError, match=\"^Length\"):\r\n index.names = [\"roger\", \"harold\"]\r\n\r\n @pytest.mark.parametrize(\r\n \"index, start, stop, step\",\r\n [\r\n (RangeIndex(5), 0, 5, 1),\r\n (RangeIndex(0, 5), 0, 5, 1),\r\n (RangeIndex(5, step=2), 0, 5, 2),\r\n (RangeIndex(1, 5, 2), 1, 5, 2),\r\n ],\r\n )\r\n def test_start_stop_step_attrs(self, index, start, stop, step):\r\n # GH 25710\r\n assert index.start == start\r\n assert index.stop == stop\r\n assert index.step == step\r\n\r\n @pytest.mark.parametrize(\"attr_name\", [\"_start\", \"_stop\", \"_step\"])\r\n def test_deprecated_start_stop_step_attrs(self, attr_name):\r\n # GH 26581\r\n idx = self.create_index()\r\n with tm.assert_produces_warning(FutureWarning):\r\n getattr(idx, attr_name)\r\n\r\n def test_copy(self):\r\n i = RangeIndex(5, name=\"Foo\")\r\n i_copy = i.copy()\r\n assert i_copy is not i\r\n assert i_copy.identical(i)\r\n assert i_copy._range == range(0, 5, 1)\r\n assert i_copy.name == \"Foo\"\r\n\r\n def test_repr(self):\r\n i = RangeIndex(5, name=\"Foo\")\r\n result = repr(i)\r\n expected = \"RangeIndex(start=0, stop=5, step=1, name='Foo')\"\r\n assert result == expected\r\n\r\n result = eval(result)\r\n tm.assert_index_equal(result, i, exact=True)\r\n\r\n i = RangeIndex(5, 0, -1)\r\n result = repr(i)\r\n expected = \"RangeIndex(start=5, stop=0, step=-1)\"\r\n assert result == expected\r\n\r\n result = eval(result)\r\n tm.assert_index_equal(result, i, exact=True)\r\n\r\n def test_insert(self):\r\n\r\n idx = RangeIndex(5, name=\"Foo\")\r\n result = idx[1:4]\r\n\r\n # test 0th element\r\n tm.assert_index_equal(idx[0:4], result.insert(0, idx[0]))\r\n\r\n # GH 18295 (test missing)\r\n expected = Float64Index([0, np.nan, 1, 2, 3, 4])\r\n for na in (np.nan, pd.NaT, None):\r\n result = RangeIndex(5).insert(1, na)\r\n tm.assert_index_equal(result, expected)\r\n\r\n def test_delete(self):\r\n\r\n idx = RangeIndex(5, name=\"Foo\")\r\n expected = idx[1:].astype(int)\r\n result = idx.delete(0)\r\n tm.assert_index_equal(result, expected)\r\n assert result.name == expected.name\r\n\r\n expected = idx[:-1].astype(int)\r\n result = idx.delete(-1)\r\n tm.assert_index_equal(result, expected)\r\n assert result.name == expected.name\r\n\r\n msg = \"index 5 is out of bounds for axis 0 with size 5\"\r\n with pytest.raises((IndexError, ValueError), match=msg):\r\n # either depending on numpy version\r\n result = idx.delete(len(idx))\r\n\r\n def test_view(self):\r\n i = RangeIndex(0, name=\"Foo\")\r\n i_view = i.view()\r\n assert i_view.name == \"Foo\"\r\n\r\n i_view = i.view(\"i8\")\r\n tm.assert_numpy_array_equal(i.values, i_view)\r\n\r\n i_view = i.view(RangeIndex)\r\n tm.assert_index_equal(i, i_view)\r\n\r\n def test_dtype(self):\r\n index = self.create_index()\r\n assert index.dtype == np.int64\r\n\r\n def test_cached_data(self):\r\n # GH 26565, GH26617\r\n # Calling RangeIndex._data caches an int64 array of the same length at\r\n # self._cached_data. This test checks whether _cached_data has been set\r\n idx = RangeIndex(0, 100, 10)\r\n\r\n assert idx._cached_data is None\r\n\r\n repr(idx)\r\n assert idx._cached_data is None\r\n\r\n str(idx)\r\n assert idx._cached_data is None\r\n\r\n idx.get_loc(20)\r\n assert idx._cached_data is None\r\n\r\n 90 in idx\r\n assert idx._cached_data is None\r\n\r\n 91 in idx\r\n assert idx._cached_data is None\r\n\r\n idx.all()\r\n assert idx._cached_data is None\r\n\r\n idx.any()\r\n assert idx._cached_data is None\r\n\r\n idx.format()\r\n assert idx._cache == {}\r\n\r\n df = pd.DataFrame({\"a\": range(10)}, index=idx)\r\n\r\n str(df)\r\n assert idx._cache == {}\r\n\r\n df.loc[50]\r\n assert idx._cached_data is None\r\n\r\n with pytest.raises(KeyError, match=\"51\"):\r\n df.loc[51]\r\n assert idx._cached_data is None\r\n\r\n df.loc[10:50]\r\n assert idx._cached_data is None\r\n\r\n df.iloc[5:10]\r\n assert idx._cached_data is None\r\n\r\n # actually calling idx._data\r\n assert isinstance(idx._data, np.ndarray)\r\n assert isinstance(idx._cached_data, np.ndarray)\r\n\r\n def test_is_monotonic(self):\r\n index = RangeIndex(0, 20, 2)\r\n assert index.is_monotonic is True\r\n assert index.is_monotonic_increasing is True\r\n assert index.is_monotonic_decreasing is False\r\n assert index._is_strictly_monotonic_increasing is True\r\n assert index._is_strictly_monotonic_decreasing is False\r\n\r\n index = RangeIndex(4, 0, -1)\r\n assert index.is_monotonic is False\r\n assert index._is_strictly_monotonic_increasing is False\r\n assert index.is_monotonic_decreasing is True\r\n assert index._is_strictly_monotonic_decreasing is True\r\n\r\n index = RangeIndex(1, 2)\r\n assert index.is_monotonic is True\r\n assert index.is_monotonic_increasing is True\r\n assert index.is_monotonic_decreasing is True\r\n assert index._is_strictly_monotonic_increasing is True\r\n assert index._is_strictly_monotonic_decreasing is True\r\n\r\n index = RangeIndex(2, 1)\r\n assert index.is_monotonic is True\r\n assert index.is_monotonic_increasing is True\r\n assert index.is_monotonic_decreasing is True\r\n assert index._is_strictly_monotonic_increasing is True\r\n assert index._is_strictly_monotonic_decreasing is True\r\n\r\n index = RangeIndex(1, 1)\r\n assert index.is_monotonic is True\r\n assert index.is_monotonic_increasing is True\r\n assert index.is_monotonic_decreasing is True\r\n assert index._is_strictly_monotonic_increasing is True\r\n assert index._is_strictly_monotonic_decreasing is True\r\n\r\n def test_equals_range(self):\r\n equiv_pairs = [\r\n (RangeIndex(0, 9, 2), RangeIndex(0, 10, 2)),\r\n (RangeIndex(0), RangeIndex(1, -1, 3)),\r\n (RangeIndex(1, 2, 3), RangeIndex(1, 3, 4)),\r\n (RangeIndex(0, -9, -2), RangeIndex(0, -10, -2)),\r\n ]\r\n for left, right in equiv_pairs:\r\n assert left.equals(right)\r\n assert right.equals(left)\r\n\r\n def test_logical_compat(self):\r\n idx = self.create_index()\r\n assert idx.all() == idx.values.all()\r\n assert idx.any() == idx.values.any()\r\n\r\n def test_identical(self):\r\n index = self.create_index()\r\n i = Index(index.copy())\r\n assert i.identical(index)\r\n\r\n # we don't allow object dtype for RangeIndex\r\n if isinstance(index, RangeIndex):\r\n return\r\n\r\n same_values_different_type = Index(i, dtype=object)\r\n assert not i.identical(same_values_different_type)\r\n\r\n i = index.copy(dtype=object)\r\n i = i.rename(\"foo\")\r\n same_values = Index(i, dtype=object)\r\n assert same_values.identical(index.copy(dtype=object))\r\n\r\n assert not i.identical(index)\r\n assert Index(same_values, name=\"foo\", dtype=object).identical(i)\r\n\r\n assert not index.copy(dtype=object).identical(index.copy(dtype=\"int64\"))\r\n\r\n def test_nbytes(self):\r\n\r\n # memory savings vs int index\r\n i = RangeIndex(0, 1000)\r\n assert i.nbytes < i._int64index.nbytes / 10\r\n\r\n # constant memory usage\r\n i2 = RangeIndex(0, 10)\r\n assert i.nbytes == i2.nbytes\r\n\r\n @pytest.mark.parametrize(\r\n \"start,stop,step\",\r\n [\r\n # can't\r\n (\"foo\", \"bar\", \"baz\"),\r\n # shouldn't\r\n (\"0\", \"1\", \"2\"),\r\n ],\r\n )\r\n def test_cant_or_shouldnt_cast(self, start, stop, step):\r\n msg = f\"Wrong type {type(start)} for value {start}\"\r\n with pytest.raises(TypeError, match=msg):\r\n RangeIndex(start, stop, step)\r\n\r\n def test_view_index(self):\r\n index = self.create_index()\r\n index.view(Index)\r\n\r\n def test_prevent_casting(self):\r\n index = self.create_index()\r\n result = index.astype(\"O\")\r\n assert result.dtype == np.object_\r\n\r\n def test_repr_roundtrip(self):\r\n index = self.create_index()\r\n tm.assert_index_equal(eval(repr(index)), index)\r\n\r\n def test_slice_keep_name(self):\r\n idx = RangeIndex(1, 2, name=\"asdf\")\r\n assert idx.name == idx[1:].name\r\n\r\n def test_explicit_conversions(self):\r\n\r\n # GH 8608\r\n # add/sub are overridden explicitly for Float/Int Index\r\n idx = RangeIndex(5)\r\n\r\n # float conversions\r\n arr = np.arange(5, dtype=\"int64\") * 3.2\r\n expected = Float64Index(arr)\r\n fidx = idx * 3.2\r\n tm.assert_index_equal(fidx, expected)\r\n fidx = 3.2 * idx\r\n tm.assert_index_equal(fidx, expected)\r\n\r\n # interops with numpy arrays\r\n expected = Float64Index(arr)\r\n a = np.zeros(5, dtype=\"float64\")\r\n result = fidx - a\r\n tm.assert_index_equal(result, expected)\r\n\r\n expected = Float64Index(-arr)\r\n a = np.zeros(5, dtype=\"float64\")\r\n result = a - fidx\r\n tm.assert_index_equal(result, expected)\r\n\r\n def test_has_duplicates(self, index):\r\n assert index.is_unique\r\n assert not index.has_duplicates\r\n\r\n def test_extended_gcd(self):\r\n index = self.create_index()\r\n result = index._extended_gcd(6, 10)\r\n assert result[0] == result[1] * 6 + result[2] * 10\r\n assert 2 == result[0]\r\n\r\n result = index._extended_gcd(10, 6)\r\n assert 2 == result[1] * 10 + result[2] * 6\r\n assert 2 == result[0]\r\n\r\n def test_min_fitting_element(self):\r\n result = RangeIndex(0, 20, 2)._min_fitting_element(1)\r\n assert 2 == result\r\n\r\n result = RangeIndex(1, 6)._min_fitting_element(1)\r\n assert 1 == result\r\n\r\n result = RangeIndex(18, -2, -2)._min_fitting_element(1)\r\n assert 2 == result\r\n\r\n result = RangeIndex(5, 0, -1)._min_fitting_element(1)\r\n assert 1 == result\r\n\r\n big_num = 500000000000000000000000\r\n\r\n result = RangeIndex(5, big_num * 2, 1)._min_fitting_element(big_num)\r\n assert big_num == result\r\n\r\n def test_max_fitting_element(self):\r\n result = RangeIndex(0, 20, 2)._max_fitting_element(17)\r\n assert 16 == result\r\n\r\n result = RangeIndex(1, 6)._max_fitting_element(4)\r\n assert 4 == result\r\n\r\n result = RangeIndex(18, -2, -2)._max_fitting_element(17)\r\n assert 16 == result\r\n\r\n result = RangeIndex(5, 0, -1)._max_fitting_element(4)\r\n assert 4 == result\r\n\r\n big_num = 500000000000000000000000\r\n\r\n result = RangeIndex(5, big_num * 2, 1)._max_fitting_element(big_num)\r\n assert big_num == result\r\n\r\n def test_pickle_compat_construction(self):\r\n # RangeIndex() is a valid constructor\r\n pass\r\n\r\n def test_slice_specialised(self):\r\n index = self.create_index()\r\n index.name = \"foo\"\r\n\r\n # scalar indexing\r\n res = index[1]\r\n expected = 2\r\n assert res == expected\r\n\r\n res = index[-1]\r\n expected = 18\r\n assert res == expected\r\n\r\n # slicing\r\n # slice value completion\r\n index_slice = index[:]\r\n expected = index\r\n tm.assert_index_equal(index_slice, expected)\r\n\r\n # positive slice values\r\n index_slice = index[7:10:2]\r\n expected = Index(np.array([14, 18]), name=\"foo\")\r\n tm.assert_index_equal(index_slice, expected)\r\n\r\n # negative slice values\r\n index_slice = index[-1:-5:-2]\r\n expected = Index(np.array([18, 14]), name=\"foo\")\r\n tm.assert_index_equal(index_slice, expected)\r\n\r\n # stop overshoot\r\n index_slice = index[2:100:4]\r\n expected = Index(np.array([4, 12]), name=\"foo\")\r\n tm.assert_index_equal(index_slice, expected)\r\n\r\n # reverse\r\n index_slice = index[::-1]\r\n expected = Index(index.values[::-1], name=\"foo\")\r\n tm.assert_index_equal(index_slice, expected)\r\n\r\n index_slice = index[-8::-1]\r\n expected = Index(np.array([4, 2, 0]), name=\"foo\")\r\n tm.assert_index_equal(index_slice, expected)\r\n\r\n index_slice = index[-40::-1]\r\n expected = Index(np.array([], dtype=np.int64), name=\"foo\")\r\n tm.assert_index_equal(index_slice, expected)\r\n\r\n index_slice = index[40::-1]\r\n expected = Index(index.values[40::-1], name=\"foo\")\r\n tm.assert_index_equal(index_slice, expected)\r\n\r\n index_slice = index[10::-1]\r\n expected = Index(index.values[::-1], name=\"foo\")\r\n tm.assert_index_equal(index_slice, expected)\r\n\r\n @pytest.mark.parametrize(\"step\", set(range(-5, 6)) - {0})\r\n def test_len_specialised(self, step):\r\n # make sure that our len is the same as np.arange calc\r\n start, stop = (0, 5) if step > 0 else (5, 0)\r\n\r\n arr = np.arange(start, stop, step)\r\n index = RangeIndex(start, stop, step)\r\n assert len(index) == len(arr)\r\n\r\n index = RangeIndex(stop, start, step)\r\n assert len(index) == 0\r\n\r\n @pytest.fixture(\r\n params=[\r\n ([RI(1, 12, 5)], RI(1, 12, 5)),\r\n ([RI(0, 6, 4)], RI(0, 6, 4)),\r\n ([RI(1, 3), RI(3, 7)], RI(1, 7)),\r\n ([RI(1, 5, 2), RI(5, 6)], RI(1, 6, 2)),\r\n ([RI(1, 3, 2), RI(4, 7, 3)], RI(1, 7, 3)),\r\n ([RI(-4, 3, 2), RI(4, 7, 2)], RI(-4, 7, 2)),\r\n ([RI(-4, -8), RI(-8, -12)], RI(0, 0)),\r\n ([RI(-4, -8), RI(3, -4)], RI(0, 0)),\r\n ([RI(-4, -8), RI(3, 5)], RI(3, 5)),\r\n ([RI(-4, -2), RI(3, 5)], I64([-4, -3, 3, 4])),\r\n ([RI(-2), RI(3, 5)], RI(3, 5)),\r\n ([RI(2), RI(2)], I64([0, 1, 0, 1])),\r\n ([RI(2), RI(2, 5), RI(5, 8, 4)], RI(0, 6)),\r\n ([RI(2), RI(3, 5), RI(5, 8, 4)], I64([0, 1, 3, 4, 5])),\r\n ([RI(-2, 2), RI(2, 5), RI(5, 8, 4)], RI(-2, 6)),\r\n ([RI(3), I64([-1, 3, 15])], I64([0, 1, 2, -1, 3, 15])),\r\n ([RI(3), F64([-1, 3.1, 15.0])], F64([0, 1, 2, -1, 3.1, 15.0])),\r\n ([RI(3), OI([\"a\", None, 14])], OI([0, 1, 2, \"a\", None, 14])),\r\n ([RI(3, 1), OI([\"a\", None, 14])], OI([\"a\", None, 14])),\r\n ]\r\n )\r\n def appends(self, request):\r\n \"\"\"Inputs and expected outputs for RangeIndex.append test\"\"\"\r\n return request.param\r\n\r\n def test_append(self, appends):\r\n # GH16212\r\n\r\n indices, expected = appends\r\n\r\n result = indices[0].append(indices[1:])\r\n tm.assert_index_equal(result, expected, exact=True)\r\n\r\n if len(indices) == 2:\r\n # Append single item rather than list\r\n result2 = indices[0].append(indices[1])\r\n tm.assert_index_equal(result2, expected, exact=True)\r\n\r\n def test_engineless_lookup(self):\r\n # GH 16685\r\n # Standard lookup on RangeIndex should not require the engine to be\r\n # created\r\n idx = RangeIndex(2, 10, 3)\r\n\r\n assert idx.get_loc(5) == 1\r\n tm.assert_numpy_array_equal(\r\n idx.get_indexer([2, 8]), ensure_platform_int(np.array([0, 2]))\r\n )\r\n with pytest.raises(KeyError, match=\"3\"):\r\n idx.get_loc(3)\r\n\r\n assert \"_engine\" not in idx._cache\r\n\r\n # Different types of scalars can be excluded immediately, no need to\r\n # use the _engine\r\n with pytest.raises(KeyError, match=\"'a'\"):\r\n idx.get_loc(\"a\")\r\n\r\n assert \"_engine\" not in idx._cache\r\n\r\n def test_format_empty(self):\r\n # GH35712\r\n empty_idx = self._holder(0)\r\n assert empty_idx.format() == []\r\n assert empty_idx.format(name=True) == [\"\"]\r\n",
"\"\"\"\r\nTesting for Isolation Forest algorithm (sklearn.ensemble.iforest).\r\n\"\"\"\r\n\r\n# Authors: Nicolas Goix <[email protected]>\r\n# Alexandre Gramfort <[email protected]>\r\n# License: BSD 3 clause\r\n\r\nimport pytest\r\n\r\nimport numpy as np\r\n\r\nfrom sklearn.utils._testing import assert_array_equal\r\nfrom sklearn.utils._testing import assert_array_almost_equal\r\nfrom sklearn.utils._testing import assert_raises\r\nfrom sklearn.utils._testing import assert_warns_message\r\nfrom sklearn.utils._testing import ignore_warnings\r\nfrom sklearn.utils._testing import assert_allclose\r\n\r\nfrom sklearn.model_selection import ParameterGrid\r\nfrom sklearn.ensemble import IsolationForest\r\nfrom sklearn.ensemble._iforest import _average_path_length\r\nfrom sklearn.model_selection import train_test_split\r\nfrom sklearn.datasets import load_diabetes, load_iris\r\nfrom sklearn.utils import check_random_state\r\nfrom sklearn.metrics import roc_auc_score\r\n\r\nfrom scipy.sparse import csc_matrix, csr_matrix\r\nfrom unittest.mock import Mock, patch\r\n\r\nrng = check_random_state(0)\r\n\r\n# load the iris dataset\r\n# and randomly permute it\r\niris = load_iris()\r\nperm = rng.permutation(iris.target.size)\r\niris.data = iris.data[perm]\r\niris.target = iris.target[perm]\r\n\r\n# also load the diabetes dataset\r\n# and randomly permute it\r\ndiabetes = load_diabetes()\r\nperm = rng.permutation(diabetes.target.size)\r\ndiabetes.data = diabetes.data[perm]\r\ndiabetes.target = diabetes.target[perm]\r\n\r\n\r\ndef test_iforest():\r\n \"\"\"Check Isolation Forest for various parameter settings.\"\"\"\r\n X_train = np.array([[0, 1], [1, 2]])\r\n X_test = np.array([[2, 1], [1, 1]])\r\n\r\n grid = ParameterGrid({\"n_estimators\": [3],\r\n \"max_samples\": [0.5, 1.0, 3],\r\n \"bootstrap\": [True, False]})\r\n\r\n with ignore_warnings():\r\n for params in grid:\r\n IsolationForest(random_state=rng,\r\n **params).fit(X_train).predict(X_test)\r\n\r\n\r\ndef test_iforest_sparse():\r\n \"\"\"Check IForest for various parameter settings on sparse input.\"\"\"\r\n rng = check_random_state(0)\r\n X_train, X_test, y_train, y_test = train_test_split(diabetes.data[:50],\r\n diabetes.target[:50],\r\n random_state=rng)\r\n grid = ParameterGrid({\"max_samples\": [0.5, 1.0],\r\n \"bootstrap\": [True, False]})\r\n\r\n for sparse_format in [csc_matrix, csr_matrix]:\r\n X_train_sparse = sparse_format(X_train)\r\n X_test_sparse = sparse_format(X_test)\r\n\r\n for params in grid:\r\n # Trained on sparse format\r\n sparse_classifier = IsolationForest(\r\n n_estimators=10, random_state=1, **params).fit(X_train_sparse)\r\n sparse_results = sparse_classifier.predict(X_test_sparse)\r\n\r\n # Trained on dense format\r\n dense_classifier = IsolationForest(\r\n n_estimators=10, random_state=1, **params).fit(X_train)\r\n dense_results = dense_classifier.predict(X_test)\r\n\r\n assert_array_equal(sparse_results, dense_results)\r\n\r\n\r\ndef test_iforest_error():\r\n \"\"\"Test that it gives proper exception on deficient input.\"\"\"\r\n X = iris.data\r\n\r\n # Test max_samples\r\n assert_raises(ValueError,\r\n IsolationForest(max_samples=-1).fit, X)\r\n assert_raises(ValueError,\r\n IsolationForest(max_samples=0.0).fit, X)\r\n assert_raises(ValueError,\r\n IsolationForest(max_samples=2.0).fit, X)\r\n # The dataset has less than 256 samples, explicitly setting\r\n # max_samples > n_samples should result in a warning. If not set\r\n # explicitly there should be no warning\r\n assert_warns_message(UserWarning,\r\n \"max_samples will be set to n_samples for estimation\",\r\n IsolationForest(max_samples=1000).fit, X)\r\n # note that assert_no_warnings does not apply since it enables a\r\n # PendingDeprecationWarning triggered by scipy.sparse's use of\r\n # np.matrix. See issue #11251.\r\n with pytest.warns(None) as record:\r\n IsolationForest(max_samples='auto').fit(X)\r\n user_warnings = [each for each in record\r\n if issubclass(each.category, UserWarning)]\r\n assert len(user_warnings) == 0\r\n with pytest.warns(None) as record:\r\n IsolationForest(max_samples=np.int64(2)).fit(X)\r\n user_warnings = [each for each in record\r\n if issubclass(each.category, UserWarning)]\r\n assert len(user_warnings) == 0\r\n\r\n assert_raises(ValueError, IsolationForest(max_samples='foobar').fit, X)\r\n assert_raises(ValueError, IsolationForest(max_samples=1.5).fit, X)\r\n\r\n # test X_test n_features match X_train one:\r\n assert_raises(ValueError, IsolationForest().fit(X).predict, X[:, 1:])\r\n\r\n\r\ndef test_recalculate_max_depth():\r\n \"\"\"Check max_depth recalculation when max_samples is reset to n_samples\"\"\"\r\n X = iris.data\r\n clf = IsolationForest().fit(X)\r\n for est in clf.estimators_:\r\n assert est.max_depth == int(np.ceil(np.log2(X.shape[0])))\r\n\r\n\r\ndef test_max_samples_attribute():\r\n X = iris.data\r\n clf = IsolationForest().fit(X)\r\n assert clf.max_samples_ == X.shape[0]\r\n\r\n clf = IsolationForest(max_samples=500)\r\n assert_warns_message(UserWarning,\r\n \"max_samples will be set to n_samples for estimation\",\r\n clf.fit, X)\r\n assert clf.max_samples_ == X.shape[0]\r\n\r\n clf = IsolationForest(max_samples=0.4).fit(X)\r\n assert clf.max_samples_ == 0.4*X.shape[0]\r\n\r\n\r\ndef test_iforest_parallel_regression():\r\n \"\"\"Check parallel regression.\"\"\"\r\n rng = check_random_state(0)\r\n\r\n X_train, X_test, y_train, y_test = train_test_split(diabetes.data,\r\n diabetes.target,\r\n random_state=rng)\r\n\r\n ensemble = IsolationForest(n_jobs=3,\r\n random_state=0).fit(X_train)\r\n\r\n ensemble.set_params(n_jobs=1)\r\n y1 = ensemble.predict(X_test)\r\n ensemble.set_params(n_jobs=2)\r\n y2 = ensemble.predict(X_test)\r\n assert_array_almost_equal(y1, y2)\r\n\r\n ensemble = IsolationForest(n_jobs=1,\r\n random_state=0).fit(X_train)\r\n\r\n y3 = ensemble.predict(X_test)\r\n assert_array_almost_equal(y1, y3)\r\n\r\n\r\ndef test_iforest_performance():\r\n \"\"\"Test Isolation Forest performs well\"\"\"\r\n\r\n # Generate train/test data\r\n rng = check_random_state(2)\r\n X = 0.3 * rng.randn(120, 2)\r\n X_train = np.r_[X + 2, X - 2]\r\n X_train = X[:100]\r\n\r\n # Generate some abnormal novel observations\r\n X_outliers = rng.uniform(low=-4, high=4, size=(20, 2))\r\n X_test = np.r_[X[100:], X_outliers]\r\n y_test = np.array([0] * 20 + [1] * 20)\r\n\r\n # fit the model\r\n clf = IsolationForest(max_samples=100, random_state=rng).fit(X_train)\r\n\r\n # predict scores (the lower, the more normal)\r\n y_pred = - clf.decision_function(X_test)\r\n\r\n # check that there is at most 6 errors (false positive or false negative)\r\n assert roc_auc_score(y_test, y_pred) > 0.98\r\n\r\n\r\[email protected](\"contamination\", [0.25, \"auto\"])\r\ndef test_iforest_works(contamination):\r\n # toy sample (the last two samples are outliers)\r\n X = [[-2, -1], [-1, -1], [-1, -2], [1, 1], [1, 2], [2, 1], [6, 3], [-4, 7]]\r\n\r\n # Test IsolationForest\r\n clf = IsolationForest(random_state=rng, contamination=contamination)\r\n clf.fit(X)\r\n decision_func = -clf.decision_function(X)\r\n pred = clf.predict(X)\r\n # assert detect outliers:\r\n assert np.min(decision_func[-2:]) > np.max(decision_func[:-2])\r\n assert_array_equal(pred, 6 * [1] + 2 * [-1])\r\n\r\n\r\ndef test_max_samples_consistency():\r\n # Make sure validated max_samples in iforest and BaseBagging are identical\r\n X = iris.data\r\n clf = IsolationForest().fit(X)\r\n assert clf.max_samples_ == clf._max_samples\r\n\r\n\r\ndef test_iforest_subsampled_features():\r\n # It tests non-regression for #5732 which failed at predict.\r\n rng = check_random_state(0)\r\n X_train, X_test, y_train, y_test = train_test_split(diabetes.data[:50],\r\n diabetes.target[:50],\r\n random_state=rng)\r\n clf = IsolationForest(max_features=0.8)\r\n clf.fit(X_train, y_train)\r\n clf.predict(X_test)\r\n\r\n\r\ndef test_iforest_average_path_length():\r\n # It tests non-regression for #8549 which used the wrong formula\r\n # for average path length, strictly for the integer case\r\n # Updated to check average path length when input is <= 2 (issue #11839)\r\n result_one = 2.0 * (np.log(4.0) + np.euler_gamma) - 2.0 * 4.0 / 5.0\r\n result_two = 2.0 * (np.log(998.0) + np.euler_gamma) - 2.0 * 998.0 / 999.0\r\n assert_allclose(_average_path_length([0]), [0.0])\r\n assert_allclose(_average_path_length([1]), [0.0])\r\n assert_allclose(_average_path_length([2]), [1.0])\r\n assert_allclose(_average_path_length([5]), [result_one])\r\n assert_allclose(_average_path_length([999]), [result_two])\r\n assert_allclose(\r\n _average_path_length(np.array([1, 2, 5, 999])),\r\n [0.0, 1.0, result_one, result_two],\r\n )\r\n # _average_path_length is increasing\r\n avg_path_length = _average_path_length(np.arange(5))\r\n assert_array_equal(avg_path_length, np.sort(avg_path_length))\r\n\r\n\r\ndef test_score_samples():\r\n X_train = [[1, 1], [1, 2], [2, 1]]\r\n clf1 = IsolationForest(contamination=0.1).fit(X_train)\r\n clf2 = IsolationForest().fit(X_train)\r\n assert_array_equal(clf1.score_samples([[2., 2.]]),\r\n clf1.decision_function([[2., 2.]]) + clf1.offset_)\r\n assert_array_equal(clf2.score_samples([[2., 2.]]),\r\n clf2.decision_function([[2., 2.]]) + clf2.offset_)\r\n assert_array_equal(clf1.score_samples([[2., 2.]]),\r\n clf2.score_samples([[2., 2.]]))\r\n\r\n\r\ndef test_iforest_warm_start():\r\n \"\"\"Test iterative addition of iTrees to an iForest \"\"\"\r\n\r\n rng = check_random_state(0)\r\n X = rng.randn(20, 2)\r\n\r\n # fit first 10 trees\r\n clf = IsolationForest(n_estimators=10, max_samples=20,\r\n random_state=rng, warm_start=True)\r\n clf.fit(X)\r\n # remember the 1st tree\r\n tree_1 = clf.estimators_[0]\r\n # fit another 10 trees\r\n clf.set_params(n_estimators=20)\r\n clf.fit(X)\r\n # expecting 20 fitted trees and no overwritten trees\r\n assert len(clf.estimators_) == 20\r\n assert clf.estimators_[0] is tree_1\r\n\r\n\r\n# mock get_chunk_n_rows to actually test more than one chunk (here one\r\n# chunk = 3 rows:\r\n@patch(\r\n \"sklearn.ensemble._iforest.get_chunk_n_rows\",\r\n side_effect=Mock(**{\"return_value\": 3}),\r\n)\r\[email protected](\r\n \"contamination, n_predict_calls\", [(0.25, 3), (\"auto\", 2)]\r\n)\r\ndef test_iforest_chunks_works1(\r\n mocked_get_chunk, contamination, n_predict_calls\r\n):\r\n test_iforest_works(contamination)\r\n assert mocked_get_chunk.call_count == n_predict_calls\r\n\r\n\r\n# idem with chunk_size = 5 rows\r\n@patch(\r\n \"sklearn.ensemble._iforest.get_chunk_n_rows\",\r\n side_effect=Mock(**{\"return_value\": 10}),\r\n)\r\[email protected](\r\n \"contamination, n_predict_calls\", [(0.25, 3), (\"auto\", 2)]\r\n)\r\ndef test_iforest_chunks_works2(\r\n mocked_get_chunk, contamination, n_predict_calls\r\n):\r\n test_iforest_works(contamination)\r\n assert mocked_get_chunk.call_count == n_predict_calls\r\n\r\n\r\ndef test_iforest_with_uniform_data():\r\n \"\"\"Test whether iforest predicts inliers when using uniform data\"\"\"\r\n\r\n # 2-d array of all 1s\r\n X = np.ones((100, 10))\r\n iforest = IsolationForest()\r\n iforest.fit(X)\r\n\r\n rng = np.random.RandomState(0)\r\n\r\n assert all(iforest.predict(X) == 1)\r\n assert all(iforest.predict(rng.randn(100, 10)) == 1)\r\n assert all(iforest.predict(X + 1) == 1)\r\n assert all(iforest.predict(X - 1) == 1)\r\n\r\n # 2-d array where columns contain the same value across rows\r\n X = np.repeat(rng.randn(1, 10), 100, 0)\r\n iforest = IsolationForest()\r\n iforest.fit(X)\r\n\r\n assert all(iforest.predict(X) == 1)\r\n assert all(iforest.predict(rng.randn(100, 10)) == 1)\r\n assert all(iforest.predict(np.ones((100, 10))) == 1)\r\n\r\n # Single row\r\n X = rng.randn(1, 10)\r\n iforest = IsolationForest()\r\n iforest.fit(X)\r\n\r\n assert all(iforest.predict(X) == 1)\r\n assert all(iforest.predict(rng.randn(100, 10)) == 1)\r\n assert all(iforest.predict(np.ones((100, 10))) == 1)\r\n"
]
| [
[
"numpy.repeat",
"numpy.dot",
"pandas.Timedelta",
"numpy.sum",
"pandas.date_range",
"numpy.random.randn",
"pandas._testing.assert_almost_equal",
"numpy.allclose",
"numpy.arange",
"numpy.random.randint",
"numpy.ptp",
"pandas.Series",
"pandas.util._test_decorators.skip_if_np_lt",
"pandas._testing.assert_series_equal"
],
[
"numpy.product",
"numpy.dot",
"numpy.minimum",
"numpy.multiply",
"numpy.finfo",
"numpy.max",
"numpy.divide",
"numpy.zeros_like",
"numpy.full",
"numpy.empty",
"numpy.log",
"numpy.arange",
"numpy.sqrt",
"numpy.atleast_2d",
"scipy.sparse.issparse",
"scipy.sparse.coo_matrix",
"numpy.linalg.multi_dot",
"numpy.zeros",
"numpy.shape",
"numpy.asarray",
"numpy.sum",
"numpy.abs",
"numpy.maximum"
],
[
"sklearn.utils._testing.assert_raise_message",
"sklearn.utils._testing.check_docstring_parameters",
"sklearn.utils.deprecation.deprecated",
"sklearn.utils._testing.ignore_warnings",
"sklearn.utils._testing.raises",
"sklearn.utils._testing.assert_no_warnings",
"numpy.arange",
"sklearn.utils._testing.assert_warns",
"sklearn.utils._testing.assert_raises_regex",
"sklearn.discriminant_analysis.LinearDiscriminantAnalysis",
"sklearn.utils._testing.assert_raises",
"scipy.sparse.csc_matrix",
"sklearn.utils.metaestimators.if_delegate_has_method",
"sklearn.utils._testing.set_random_state",
"sklearn.tree.DecisionTreeClassifier",
"sklearn.utils._testing.create_memmap_backed_data",
"numpy.testing.assert_array_equal",
"numpy.ones",
"sklearn.utils._testing._convert_container",
"sklearn.utils._testing.TempMemmap",
"sklearn.utils._testing.assert_allclose_dense_sparse"
],
[
"numpy.array",
"pandas.Index",
"numpy.asarray",
"pandas._testing.assert_numpy_array_equal",
"pandas.Series",
"pandas._testing.assert_index_equal"
],
[
"numpy.ix_"
],
[
"pandas._testing.reset_display_options",
"pandas.DataFrame",
"pandas.io.formats.format.set_eng_float_format",
"numpy.sqrt",
"pandas.io.formats.format.EngFormatter"
],
[
"numpy.isclose",
"pandas.DatetimeIndex",
"pandas.offsets.Day",
"pandas.CategoricalIndex",
"numpy.exp",
"pandas._testing.assert_categorical_equal",
"pandas.Timestamp",
"numpy.where",
"pandas.concat",
"pandas._testing.assert_series_equal",
"pandas.Timedelta",
"pandas.DataFrame",
"pandas._testing.is_number",
"numpy.sqrt",
"pandas._testing.getMixedTypeDict",
"pandas.Period",
"numpy.random.randn",
"pandas._testing.assert_frame_equal",
"pandas._testing.makeTimeSeries",
"pandas.Index",
"pandas.isna",
"numpy.errstate",
"pandas.date_range",
"pandas.to_timedelta",
"numpy.ones",
"pandas.Categorical",
"numpy.abs",
"pandas.Series",
"numpy.repeat"
],
[
"pandas.offsets.Minute",
"pandas._testing.equalContents",
"pandas.offsets.Hour",
"pandas.timedelta_range",
"numpy.arange",
"pandas._testing.assert_attr_equal",
"pandas._testing.assert_index_equal",
"pandas.TimedeltaIndex",
"pandas._testing.assert_copy"
],
[
"numpy.array",
"pandas._libs.tslibs.parsing.parse_time_string",
"pandas._libs.tslibs.parsing._does_string_look_like_datetime",
"pandas._testing.assert_numpy_array_equal",
"pandas._libs.tslibs.parsing.try_parse_dates",
"pandas._libs.tslibs.parsing._guess_datetime_format"
],
[
"pandas.Timestamp",
"pandas.Timedelta",
"pandas.Interval"
],
[
"numpy.concatenate",
"scipy.sparse.issparse",
"numpy.array",
"numpy.max",
"numpy.clip",
"numpy.asarray",
"numpy.zeros",
"numpy.zeros_like",
"numpy.sum",
"scipy.sparse.vstack",
"numpy.min",
"numpy.mean",
"numpy.split",
"numpy.finfo",
"numpy.issubdtype",
"numpy.all",
"numpy.linspace",
"numpy.unique"
],
[
"numpy.datetime64",
"pandas.Timedelta",
"pandas.DataFrame",
"pandas.Timestamp",
"pandas.Categorical",
"numpy.random.randint",
"pandas.Series",
"pandas._testing.assert_series_equal",
"pandas.Period"
],
[
"pandas.core.dtypes.missing.isna",
"pandas.core.dtypes.common.is_string_dtype",
"pandas.core.dtypes.missing.na_value_for_dtype",
"numpy.find_common_type",
"numpy.array",
"pandas.core.dtypes.common.is_scalar",
"pandas.core.dtypes.common.is_extension_array_dtype",
"pandas.core.dtypes.common.pandas_dtype",
"pandas.core.dtypes.common.is_object_dtype",
"pandas.core.dtypes.common.is_bool_dtype",
"numpy.dtype"
],
[
"numpy.array",
"pandas.api.types.is_scalar",
"pandas.date_range",
"pandas.Timestamp",
"pandas._testing.assert_numpy_array_equal",
"numpy.argsort",
"pandas.Series"
],
[
"pandas.Index",
"numpy.array",
"numpy.zeros",
"pandas._testing.assert_produces_warning",
"pandas.Float64Index",
"pandas.RangeIndex",
"pandas._testing.assert_numpy_array_equal",
"numpy.arange",
"pandas._testing.assert_index_equal"
],
[
"numpy.min",
"sklearn.model_selection.ParameterGrid",
"numpy.sort",
"sklearn.utils._testing.ignore_warnings",
"numpy.max",
"sklearn.utils._testing.assert_array_almost_equal",
"sklearn.utils._testing.assert_warns_message",
"sklearn.datasets.load_diabetes",
"numpy.log",
"numpy.arange",
"sklearn.ensemble.IsolationForest",
"numpy.array",
"sklearn.ensemble._iforest._average_path_length",
"sklearn.model_selection.train_test_split",
"sklearn.metrics.roc_auc_score",
"numpy.log2",
"numpy.random.RandomState",
"sklearn.utils._testing.assert_array_equal",
"numpy.ones",
"sklearn.utils.check_random_state",
"numpy.int64",
"sklearn.datasets.load_iris"
]
]
|
dkdanielkost/Theano-Style-Transfer | [
"70438d3de51d059ea2129119a8cfcc86d2b403a9"
]
| [
"src/vgg19/theano_model/vgg19_model.py"
]
| [
"import numpy\nimport os\nimport numpy as np\nimport logging\nfrom theano.tensor.signal import pool\nfrom theano.tensor.nnet.abstract_conv import bilinear_upsampling\nimport joblib\nfrom theano.tensor.nnet import conv2d\nfrom theano.tensor.nnet import relu,softmax\nimport theano\nimport theano.tensor as T\n\nfrom theano.tensor.signal.pool import pool_2d\ncwd = os.path.dirname(os.path.realpath(__file__))\n\n'''\n['convolution2d_4_weights',\n 'dense_1_weights',\n 'dense_2_weights',\n 'convolution2d_8_weights',\n 'convolution2d_5_weights',\n 'convolution2d_13_weights',\n 'convolution2d_7_weights',\n 'convolution2d_15_weights',\n 'convolution2d_59_weights',\n 'convolution2d_14_weights',\n 'convolution2d_16_weights',\n 'dense_1_weights',\n 'convolution2d_6_weights',\n 'convolution2d_3_weights',\n 'convolution2d_10_weights',\n 'convolution2d_1_weights',\n 'convolution2d_10_weights',\n 'convolution2d_60_weights',\n 'convolution2d_2_weights']\n'''\n\n\n# Read in layer weights and save to a dictionary\n# Read in layer weights and save to a dictionary\n\ncwd = os.getcwd()\ndirect = os.path.join(cwd,'theano_model','weights')\n# weights_layer_paths = joblib.load(os.path.join(cwd,'weight_names','layer_names_weights'))\nlayer_weights = {}\nfor layer_weight_path in range(16):\n# head,layer_name = os.path.split(layer_weight_path)\n layer_weights[str(layer_weight_path) + '_w'] = joblib.load(os.path.join(direct,str(layer_weight_path) + '_w'))\n\n\n# Read in bias weights and save to a dictionary\nfor bias_layer_path in range(16):\n layer_weights[str(bias_layer_path) + '_b'] = joblib.load(os.path.join(direct,str(bias_layer_path) + '_b'))\n\n\ndef drop(input, p=0.5):\n \"\"\"\n :type input: numpy.array\n :param input: layer or weight matrix on which dropout is applied\n\n :type p: float or double between 0. and 1.\n :param p: p probability of NOT dropping out a unit, therefore (1.-p) is the drop rate.\n\n \"\"\"\n rng = numpy.random.RandomState(1234)\n srng = T.shared_randomstreams.RandomStreams(rng.randint(999999))\n mask = srng.binomial(n=1, p=p, size=input.shape, dtype=theano.config.floatX)\n return input * mask\n\n\nclass DropoutHiddenLayer(object):\n def __init__(self, is_train, input, W=None, b=None,\n activation=relu, p=0.5):\n self.input = input\n\n self.W = W\n self.b = b\n\n lin_output = T.dot(input, self.W) + self.b\n\n self.output = activation(lin_output)\n # train_output = drop(output, p)\n # self.output = T.switch(T.neq(is_train, 0), train_output, p * output)\n self.params = [self.W, self.b]\n\n\nclass VGG19_conv2d_layer(object):\n \"\"\"Pool Layer of a convolutional network \"\"\"\n\n def __init__(self, input, layer_name,image_shape,\n activation=relu, border_mode=(2,2)):\n self.activation = activation\n self.input = input\n\n self.W = theano.shared(value=np.array(layer_weights[layer_name + '_w'],\n dtype=theano.config.floatX),\n borrow=True)\n self.b = theano.shared(value=np.array(layer_weights[layer_name + '_b'],\n dtype=theano.config.floatX\n )\n , borrow=True)\n\n self.conv_out = conv2d(\n input=input,\n input_shape=image_shape,\n filters=self.W,\n filter_shape=layer_weights[layer_name + '_w'].shape,\n border_mode=border_mode\n )\n\n self.output = activation(self.conv_out + self.b.dimshuffle('x', 0, 'x', 'x'))\n self.params = [self.W, self.b]\n self.input = input\n\nclass VGG19(object):\n\n def __init__(self,input_image_shape,pool_method = 'average_exc_pad'):\n IMAGE_H = input_image_shape[2]\n IMAGE_W = input_image_shape[3]\n self.input = theano.tensor.tensor4('input')\n self.conv1_1 = VGG19_conv2d_layer(input=self.input,\n layer_name='0',\n image_shape=input_image_shape,\n border_mode=(1,1))\n\n self.conv1_2 = VGG19_conv2d_layer(input=self.conv1_1.output,\n layer_name='1',\n image_shape=(None, 64, IMAGE_H, IMAGE_W),\n border_mode=(1,1))\n self.pool1 = pool_2d(\n input = self.conv1_2.output,\n ds = (2,2),\n mode = pool_method,\n ignore_border=True,\n st = (2,2))\n\n self.conv2_1 = VGG19_conv2d_layer(input=self.pool1,\n layer_name='2',\n image_shape=(None, 64, IMAGE_H/2, IMAGE_W/2),\n border_mode=(1,1))\n\n self.conv2_2 = VGG19_conv2d_layer(input=self.conv2_1.output,\n layer_name='3',\n image_shape=(None, 128, IMAGE_H/2, IMAGE_W/2),\n border_mode=(1,1))\n\n self.pool2 = pool_2d(\n input=self.conv2_2.output,\n ds=(2, 2),\n mode=pool_method,\n ignore_border=True,\n st=(2, 2))\n\n self.conv3_1 = VGG19_conv2d_layer(input=self.pool2,\n layer_name='4',\n image_shape=(None, 128, IMAGE_H/4, IMAGE_W/4),\n border_mode=(1, 1))\n self.conv3_2= VGG19_conv2d_layer(input=self.conv3_1.output,\n layer_name='5',\n image_shape=(None, 128, IMAGE_H/4, IMAGE_W/4),\n border_mode=(1, 1))\n self.conv3_3 = VGG19_conv2d_layer(input=self.conv3_2.output,\n layer_name='6',\n image_shape=(None, 128, IMAGE_H/4, IMAGE_W/4),\n border_mode=(1, 1))\n\n self.conv3_4 = VGG19_conv2d_layer(input=self.conv3_3.output,\n layer_name='7',\n image_shape=(None, 128, IMAGE_H/4, IMAGE_W/4),\n border_mode=(1, 1))\n\n self.pool3 = pool_2d(\n input=self.conv3_4.output,\n ds=(2, 2),\n mode=pool_method,\n ignore_border=True,\n st=(2, 2))\n\n self.conv4_1 = VGG19_conv2d_layer(input=self.pool3,\n layer_name='8',\n image_shape=(None, 512, IMAGE_H/8, IMAGE_W/8),\n border_mode=(1, 1))\n self.conv4_2 = VGG19_conv2d_layer(input=self.conv4_1.output,\n layer_name='9',\n image_shape=(None, 512, IMAGE_H/8, IMAGE_W/8),\n border_mode=(1, 1))\n self.conv4_3 = VGG19_conv2d_layer(input=self.conv4_2.output,\n layer_name='10',\n image_shape=(None, 512, IMAGE_H/8, IMAGE_W/8),\n border_mode=(1, 1))\n\n self.conv4_4 = VGG19_conv2d_layer(input=self.conv4_3.output,\n layer_name='11',\n image_shape=(None, 512, IMAGE_H/8, IMAGE_W/8),\n border_mode=(1, 1))\n\n self.pool4 = pool_2d(\n input=self.conv4_4.output,\n ds=(2, 2),\n mode=pool_method,\n ignore_border=True,\n st=(2, 2))\n\n self.conv5_1 = VGG19_conv2d_layer(input=self.pool4,\n layer_name='12',\n image_shape=(None, 512, IMAGE_H/16, IMAGE_W/16),\n border_mode=(1, 1))\n self.conv5_2 = VGG19_conv2d_layer(input=self.conv5_1.output,\n layer_name='13',\n image_shape=(None, 512, IMAGE_H/16, IMAGE_W/16),\n border_mode=(1, 1))\n self.conv5_3 = VGG19_conv2d_layer(input=self.conv5_2.output,\n layer_name='14',\n image_shape=(None, 512, IMAGE_H/16, IMAGE_W/16),\n border_mode=(1, 1))\n\n self.conv5_4 = VGG19_conv2d_layer(input=self.conv5_3.output,\n layer_name='15',\n image_shape=(None, 512, IMAGE_H/16, IMAGE_W/16),\n border_mode=(1, 1))\n\n self.pool5 = pool_2d(\n input=self.conv5_4.output,\n ds=(2, 2),\n mode=pool_method,\n ignore_border=True,\n st=(2, 2))\n\n # self.dense_1_input= self.pool5.flatten(2)\n #\n # self.dense_1 = DropoutHiddenLayer(is_train = numpy.cast['int32'](0),\n # input = self.dense_1_input,\n # W=layer_weights['dense_1_weights'],\n # b=layer_weights['dense_1_bias'],)\n #\n # self.dense_2 = DropoutHiddenLayer(is_train=numpy.cast['int32'](0),\n # input=self.dense_1.output,\n # W=layer_weights['dense_2_weights'],\n # b=layer_weights['dense_2_bias'], )\n #\n # self.dense_3 = DropoutHiddenLayer(is_train=numpy.cast['int32'](0),\n # input=self.dense_2.output,\n # W=layer_weights['dense_3_weights'],\n # b=layer_weights['dense_3_bias'],\n # activation=softmax )\n\n# model.add(Flatten())\n# model.add(Dense(4096, activation='relu'))\n# model.add(Dropout(0.5))\n# model.add(Dense(4096, activation='relu'))\n# model.add(Dropout(0.5))\n# model.add(Dense(1000, activation='softmax'))\n\n\nclass VGG16(object):\n\n def __init__(self,input_image_shape,pool_method = 'max'):\n self.input = theano.tensor.tensor4('input')\n self.conv1_1 = VGG19_conv2d_layer(input=self.input,\n layer_name='convolution2d_1',\n image_shape=input_image_shape,\n border_mode=(1,1))\n\n self.conv1_2 = VGG19_conv2d_layer(input=self.conv1_1.output,\n layer_name='convolution2d_2',\n image_shape=(None, 64, 224, 224),\n border_mode=(1,1))\n self.pool1 = pool_2d(\n input = self.conv1_2.output,\n ds = (2,2),\n mode = pool_method,\n ignore_border=True,\n st = (2,2))\n\n self.conv2_1 = VGG19_conv2d_layer(input=self.pool1,\n layer_name='convolution2d_3',\n image_shape=(None, 64, 112, 112),\n border_mode=(1,1))\n\n self.conv2_2 = VGG19_conv2d_layer(input=self.conv2_1.output,\n layer_name='convolution2d_4',\n image_shape=(None, 128, 112, 112),\n border_mode=(1,1))\n\n self.pool2 = pool_2d(\n input=self.conv2_2.output,\n ds=(2, 2),\n mode=pool_method,\n ignore_border=True,\n st=(2, 2))\n\n self.conv3_1 = VGG19_conv2d_layer(input=self.pool2,\n layer_name='convolution2d_5',\n image_shape=(None, 128, 56, 56),\n border_mode=(1, 1))\n self.conv3_2= VGG19_conv2d_layer(input=self.conv3_1.output,\n layer_name='convolution2d_6',\n image_shape=(None, 128, 56, 56),\n border_mode=(1, 1))\n self.conv3_3 = VGG19_conv2d_layer(input=self.conv3_2.output,\n layer_name='convolution2d_7',\n image_shape=(None, 128, 56, 56),\n border_mode=(1, 1))\n\n self.conv3_4 = VGG19_conv2d_layer(input=self.conv3_3.output,\n layer_name='convolution2d_8',\n image_shape=(None, 128, 56, 56),\n border_mode=(1, 1))\n\n self.pool3 = pool_2d(\n input=self.conv3_4.output,\n ds=(2, 2),\n mode=pool_method,\n ignore_border=True,\n st=(2, 2))\n\n self.conv4_1 = VGG19_conv2d_layer(input=self.pool3,\n layer_name='convolution2d_9',\n image_shape=(None, 512, 28, 28),\n border_mode=(1, 1))\n self.conv4_2 = VGG19_conv2d_layer(input=self.conv4_1.output,\n layer_name='convolution2d_10',\n image_shape=(None, 512, 28, 28),\n border_mode=(1, 1))\n self.conv4_3 = VGG19_conv2d_layer(input=self.conv4_2.output,\n layer_name='convolution2d_11',\n image_shape=(None, 512, 28, 28),\n border_mode=(1, 1))\n\n self.conv4_4 = VGG19_conv2d_layer(input=self.conv4_3.output,\n layer_name='convolution2d_12',\n image_shape=(None, 512, 28, 28),\n border_mode=(1, 1))\n\n self.pool4 = pool_2d(\n input=self.conv4_4.output,\n ds=(2, 2),\n mode=pool_method,\n ignore_border=True,\n st=(2, 2))\n\n self.conv5_1 = VGG19_conv2d_layer(input=self.pool4,\n layer_name='convolution2d_13',\n image_shape=(None, 512, 14, 14),\n border_mode=(1, 1))\n self.conv5_2 = VGG19_conv2d_layer(input=self.conv5_1.output,\n layer_name='convolution2d_14',\n image_shape=(None, 512, 14, 14),\n border_mode=(1, 1))\n self.conv5_3 = VGG19_conv2d_layer(input=self.conv5_2.output,\n layer_name='convolution2d_15',\n image_shape=(None, 512, 14, 14),\n border_mode=(1, 1))\n\n self.conv5_4 = VGG19_conv2d_layer(input=self.conv5_3.output,\n layer_name='convolution2d_16',\n image_shape=(None, 512, 14, 14),\n border_mode=(1, 1))\n"
]
| [
[
"numpy.array",
"numpy.random.RandomState"
]
]
|
jayantabh/haxball-imitation-learning | [
"fb02203dee6859443ac2bd4334144aacc9f16f89"
]
| [
"bots/BasicBot.py"
]
| [
"import replay\nimport torch\nimport os\n\nfrom bots import interactive\nfrom models.BasicModel import BasicModel\n\nclass BasicBot(interactive.Interactive):\n\n def __init__(self, channel_id, name):\n super().__init__(channel_id)\n\n # Load pre-trained model and set-up the bot\n self.model = BasicModel()\n path = os.path.join( os.getcwd(), 'saved_models', name )\n self.model.load_state_dict(torch.load(path, map_location=torch.device('cpu')))\n self.model.eval()\n\n def onUpdate(self):\n if self.player and len(self.game.players) == 2:\n # convert game state to tensor\n # tensor must be same format as how network was trained\n\n print(self.player.team)\n\n # forming input only works for two players currently\n state = [self.player.disc.x, self.player.disc.y, self.player.disc.vx, self.player.disc.vy]\n for player in self.game.players:\n if player.id != self.player.id:\n state.extend([player.disc.x, player.disc.y, player.disc.vx, player.disc.vy])\n\n state.extend([self.game.ball.x, self.game.ball.y, self.game.ball.vx, self.game.ball.vy])\n\n state_tensor = torch.tensor(state)\n\n # get output for model\n actions = self.model(state_tensor)\n actions = (actions > 0.5).tolist()\n \n # send input actions\n inputs = [replay.Input(1 << idx) for idx,x in enumerate(actions) if x != 0]\n self.setInput(*inputs)"
]
| [
[
"torch.device",
"torch.tensor"
]
]
|
hjmjohnson/MONAI | [
"dc7cd0ec25d4b27f321a31f13e707769922c66b3"
]
| [
"tests/test_squeezedimd.py"
]
| [
"# Copyright 2020 MONAI Consortium\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# http://www.apache.org/licenses/LICENSE-2.0\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport unittest\nimport numpy as np\nfrom parameterized import parameterized\nfrom monai.transforms import SqueezeDimd\n\n\nTEST_CASE_1 = [\n {\"keys\": [\"img\", \"seg\"], \"dim\": None},\n {\"img\": np.random.rand(1, 2, 1, 3), \"seg\": np.random.randint(0, 2, size=[1, 2, 1, 3])},\n (2, 3),\n]\n\nTEST_CASE_2 = [\n {\"keys\": [\"img\", \"seg\"], \"dim\": 2},\n {\"img\": np.random.rand(1, 2, 1, 8, 16), \"seg\": np.random.randint(0, 2, size=[1, 2, 1, 8, 16])},\n (1, 2, 8, 16),\n]\n\nTEST_CASE_3 = [\n {\"keys\": [\"img\", \"seg\"], \"dim\": -1},\n {\"img\": np.random.rand(1, 1, 16, 8, 1), \"seg\": np.random.randint(0, 2, size=[1, 1, 16, 8, 1])},\n (1, 1, 16, 8),\n]\n\nTEST_CASE_4 = [\n {\"keys\": [\"img\", \"seg\"]},\n {\"img\": np.random.rand(1, 2, 1, 3), \"seg\": np.random.randint(0, 2, size=[1, 2, 1, 3])},\n (2, 3),\n]\n\nTEST_CASE_5 = [\n {\"keys\": [\"img\", \"seg\"], \"dim\": -2},\n {\"img\": np.random.rand(1, 1, 16, 8, 1), \"seg\": np.random.randint(0, 2, size=[1, 1, 16, 8, 1])},\n]\n\nTEST_CASE_6 = [\n {\"keys\": [\"img\", \"seg\"], \"dim\": 0.5},\n {\"img\": np.random.rand(1, 1, 16, 8, 1), \"seg\": np.random.randint(0, 2, size=[1, 1, 16, 8, 1])},\n]\n\n\nclass TestSqueezeDim(unittest.TestCase):\n @parameterized.expand([TEST_CASE_1, TEST_CASE_2, TEST_CASE_3, TEST_CASE_4])\n def test_shape(self, input_param, test_data, expected_shape):\n result = SqueezeDimd(**input_param)(test_data)\n self.assertTupleEqual(result[\"img\"].shape, expected_shape)\n self.assertTupleEqual(result[\"seg\"].shape, expected_shape)\n\n @parameterized.expand([TEST_CASE_5, TEST_CASE_6])\n def test_invalid_inputs(self, input_param, test_data):\n with self.assertRaises(AssertionError):\n result = SqueezeDimd(**input_param)(test_data)\n\n\nif __name__ == \"__main__\":\n unittest.main()\n"
]
| [
[
"numpy.random.randint",
"numpy.random.rand"
]
]
|
massimo-nocentini/cagd | [
"baec0824951ebc17e23e16e71339dd8fd79b11c2"
]
| [
"surfaces/trianglesDrawing.py"
]
| [
"\nimport numpy as np\nimport matplotlib\nimport matplotlib.pyplot as plt\nfrom mpl_toolkits.mplot3d import Axes3D\n\nimport trianglesCore as tc\n\ndef draw(*surfaces, figure_size_tuple=(15,15)):\n\n sizex, sizey = figure_size_tuple\n matplotlib.rcParams['figure.figsize'] = [sizex, sizey]\n\n # necessary adjustment if `draw` is used for only one patch\n if len(surfaces) is 2 and not isinstance(surfaces[0], tuple):\n surface, triangles = surfaces\n surfaces = [(surface, triangles)]\n\n fig = plt.figure()\n ax = fig.add_subplot(1, 1, 1, projection='3d')\n\n for surface, triangles in surfaces:\n x, y, z = surface[0,:],surface[1,:],surface[2,:]\n ax.plot_trisurf(x, y, z,\n triangles=triangles, cmap=plt.cm.Spectral)#, edgecolor='none')\n\n return fig, ax\n\n\ndef draw_repeated_degree_elevation(\n control_net, snapshots=None, degrees=None, formatting_string=\"Order {}:\"):\n\n order, control_net = control_net\n\n if snapshots:\n def drawer(print_handler):\n nonlocal order, control_net\n runs = 2\n snapshots_list = [int(np.ceil(l)) for l in np.logspace(0,runs,num=snapshots)]\n s = 0\n for i in range(1, (10**runs)+1):\n order, control_net = tc.degree_elevation(order, control_net)\n if i == snapshots_list[s]:\n print_handler(order)\n s += 1\n elif degrees:\n def drawer(print_handler):\n nonlocal order, control_net, degrees\n degrees = sorted(degrees)\n\n for d, degree in enumerate(degrees):\n if degree > order-1: break\n\n for i in range(max(degrees)+1):\n order, control_net = tc.degree_elevation(order, control_net)\n if order-1 is degrees[d]:\n print_handler(order)\n d += 1\n if d == len(degrees): break\n\n\n def print_handler(order):\n\n if formatting_string is not False: print(formatting_string.format(order))\n\n fig = plt.figure()\n ax = fig.add_subplot(111, projection='3d')\n\n xs = control_net[0,:]\n ys = control_net[1,:]\n zs = control_net[2,:]\n ax.scatter(xs, ys, zs, c='r', marker='o')\n\n ax.set_xlabel('x')\n ax.set_ylabel('y')\n ax.set_zlabel('z')\n\n plt.show()\n\n drawer(print_handler) # finally draw some pictures\n\n return order, control_net\n"
]
| [
[
"matplotlib.pyplot.show",
"numpy.ceil",
"numpy.logspace",
"matplotlib.pyplot.figure"
]
]
|
mingewang/pytorch_deep_learning_by_example | [
"83c9e12364a359b9ef77f0645ca7815e9e817f58"
]
| [
"basic/basic_example1.py"
]
| [
"# -*- coding: utf-8 -*-\nimport torch\n\n# N is batch size; D_in is input dimension;\n# H is hidden dimension; D_out is output dimension.\nN, D_in, H, D_out = 64, 1000, 100, 10\n\n# Create random Tensors to hold inputs and outputs\nx = torch.randn(N, D_in)\ny = torch.randn(N, D_out)\n\n# Use the nn package to define our model and loss function.\nmodel = torch.nn.Sequential(\n torch.nn.Linear(D_in, H),\n torch.nn.ReLU(),\n torch.nn.Linear(H, D_out),\n)\nloss_fn = torch.nn.MSELoss(reduction='sum')\n\n# Use the optim package to define an Optimizer that will update the weights of\n# the model for us. Here we will use Adam; the optim package contains many other\n# optimization algoriths. The first argument to the Adam constructor tells the\n# optimizer which Tensors it should update.\nlearning_rate = 1e-4\noptimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)\n\nepochs = 5 \n\nfor t in range(500):\n # Forward pass: compute predicted y by passing x to the model.\n y_pred = model(x)\n\n # Compute and print loss.\n loss = loss_fn(y_pred, y)\n print(t, loss.item())\n\n # Before the backward pass, use the optimizer object to zero all of the\n # gradients for the variables it will update (which are the learnable\n # weights of the model). This is because by default, gradients are\n # accumulated in buffers( i.e, not overwritten) whenever .backward()\n # is called. Checkout docs of torch.autograd.backward for more details.\n optimizer.zero_grad()\n\n # Backward pass: compute gradient of the loss with respect to model\n # parameters\n loss.backward()\n\n # Calling the step function on an Optimizer makes an update to its\n # parameters\n optimizer.step()\n"
]
| [
[
"torch.nn.MSELoss",
"torch.nn.Linear",
"torch.randn",
"torch.nn.ReLU"
]
]
|
lambertsbennett/scikit-multiflow | [
"bc714fd5ee4f0a486adc00ec6ae39eafa64f81cc",
"bc714fd5ee4f0a486adc00ec6ae39eafa64f81cc"
]
| [
"src/skmultiflow/trees/stacked_single_target_hoeffding_tree_regressor.py",
"src/skmultiflow/drift_detection/kswin.py"
]
| [
"from operator import attrgetter\n\nimport numpy as np\n\nfrom skmultiflow.core import MultiOutputMixin\nfrom skmultiflow.trees import iSOUPTreeRegressor\nfrom skmultiflow.utils import get_dimensions\nfrom skmultiflow.trees.split_criterion import IntraClusterVarianceReductionSplitCriterion\n\nfrom skmultiflow.trees.nodes import LearningNode\nfrom skmultiflow.trees.nodes import SSTActiveLearningNode\nfrom skmultiflow.trees.nodes import SSTActiveLearningNodeAdaptive\nfrom skmultiflow.trees.nodes import SSTInactiveLearningNode\nfrom skmultiflow.trees.nodes import SSTInactiveLearningNodeAdaptive\n\n\nclass StackedSingleTargetHoeffdingTreeRegressor(iSOUPTreeRegressor, MultiOutputMixin):\n \"\"\"Stacked Single-target Hoeffding Tree regressor.\n\n Implementation of the Stacked Single-target Hoeffding Tree (SST-HT) method\n for multi-target regression as proposed by S. M. Mastelini, S. Barbon Jr.,\n and A. C. P. L. F. de Carvalho [1]_.\n\n Parameters\n ----------\n max_byte_size: int (default=33554432)\n Maximum memory consumed by the tree.\n memory_estimate_period: int (default=1000000)\n Number of instances between memory consumption checks.\n grace_period: int (default=200)\n Number of instances a leaf should observe between split attempts.\n split_confidence: float (default=0.0000001)\n Allowed error in split decision, a value closer to 0 takes longer to\n decide.\n tie_threshold: float (default=0.05)\n Threshold below which a split will be forced to break ties.\n binary_split: boolean (default=False)\n If True, only allow binary splits.\n stop_mem_management: boolean (default=False)\n If True, stop growing as soon as memory limit is hit.\n remove_poor_atts: boolean (default=False)\n If True, disable poor attributes.\n no_preprune: boolean (default=False)\n If True, disable pre-pruning.\n leaf_prediction: string (default='perceptron')\n | Prediction mechanism used at leafs.\n | 'perceptron' - Stacked perceptron\n | 'adaptive' - Adaptively chooses between the best predictor (mean,\n perceptron or stacked perceptron)\n nb_threshold: int (default=0)\n Number of instances a leaf should observe before allowing Naive Bayes.\n nominal_attributes: list, optional\n List of Nominal attributes. If emtpy, then assume that all attributes\n are numerical.\n learning_ratio_perceptron: float\n The learning rate of the perceptron.\n learning_ratio_decay: float\n Decay multiplier for the learning rate of the perceptron\n learning_ratio_const: Bool\n If False the learning ratio will decay with the number of examples seen\n random_state: int, RandomState instance or None, optional (default=None)\n If int, random_state is the seed used by the random number generator;\n If RandomState instance, random_state is the random number generator;\n If None, the random number generator is the RandomState instance used\n by `np.random`. Used when leaf_prediction is 'perceptron'.\n\n References\n ----------\n .. [1] Mastelini, S. M., Barbon Jr, S., de Carvalho, A. C. P. L. F. (2019).\n \"Online Multi-target regression trees with stacked leaf models\". arXiv\n preprint arXiv:1903.12483.\n\n Examples\n --------\n >>> # Imports\n >>> from skmultiflow.data import RegressionGenerator\n >>> from skmultiflow.trees import StackedSingleTargetHoeffdingTreeRegressor\n >>> import numpy as np\n >>>\n >>> # Setup a data stream\n >>> n_targets = 3\n >>> stream = RegressionGenerator(n_targets=n_targets, random_state=1, n_samples=200)\n >>>\n >>> # Setup the Stacked Single-target Hoeffding Tree Regressor\n >>> sst_ht = StackedSingleTargetHoeffdingTreeRegressor()\n >>>\n >>> # Auxiliary variables to control loop and track performance\n >>> n_samples = 0\n >>> max_samples = 200\n >>> y_pred = np.zeros((max_samples, n_targets))\n >>> y_true = np.zeros((max_samples, n_targets))\n >>>\n >>> # Run test-then-train loop for max_samples and while there is data\n >>> while n_samples < max_samples and stream.has_more_samples():\n >>> X, y = stream.next_sample()\n >>> y_true[n_samples] = y[0]\n >>> y_pred[n_samples] = sst_ht.predict(X)[0]\n >>> sst_ht.partial_fit(X, y)\n >>> n_samples += 1\n >>>\n >>> # Display results\n >>> print('Stacked Single-target Hoeffding Tree regressor example')\n >>> print('{} samples analyzed.'.format(n_samples))\n >>> print('Mean absolute error: {}'.format(np.mean(np.abs(y_true - y_pred))))\n \"\"\"\n\n # =====================================================================\n # == Stacked Single-target Hoeffding Regression Tree implementation ===\n # =====================================================================\n\n def __init__(self,\n max_byte_size=33554432,\n memory_estimate_period=1000000,\n grace_period=200,\n split_confidence=0.0000001,\n tie_threshold=0.05,\n binary_split=False,\n stop_mem_management=False,\n remove_poor_atts=False,\n leaf_prediction='perceptron',\n no_preprune=False,\n nb_threshold=0,\n nominal_attributes=None,\n learning_ratio_perceptron=0.02,\n learning_ratio_decay=0.001,\n learning_ratio_const=True,\n random_state=None):\n super().__init__(max_byte_size=max_byte_size,\n memory_estimate_period=memory_estimate_period,\n grace_period=grace_period,\n split_confidence=split_confidence,\n tie_threshold=tie_threshold,\n binary_split=binary_split,\n stop_mem_management=stop_mem_management,\n remove_poor_atts=remove_poor_atts,\n no_preprune=no_preprune,\n leaf_prediction=leaf_prediction,\n nb_threshold=nb_threshold,\n nominal_attributes=nominal_attributes)\n self.split_criterion = 'icvr' # intra cluster variance reduction\n self.learning_ratio_perceptron = learning_ratio_perceptron\n self.learning_ratio_decay = learning_ratio_decay\n self.learning_ratio_const = learning_ratio_const\n self.random_state = random_state\n\n self._tree_root = None\n self._decision_node_cnt = 0\n self._active_leaf_node_cnt = 0\n self._inactive_leaf_node_cnt = 0\n self._inactive_leaf_byte_size_estimate = 0.0\n self._active_leaf_byte_size_estimate = 0.0\n self._byte_size_estimate_overhead_fraction = 1.0\n self._growth_allowed = True\n self._train_weight_seen_by_model = 0.0\n\n self.examples_seen = 0\n self.sum_of_values = 0.0\n self.sum_of_squares = 0.0\n self.sum_of_attribute_values = 0.0\n self.sum_of_attribute_squares = 0.0\n\n # To add the n_targets property once\n self._n_targets_set = False\n\n @property\n def leaf_prediction(self):\n return self._leaf_prediction\n\n @leaf_prediction.setter\n def leaf_prediction(self, leaf_prediction):\n if leaf_prediction not in {self._PERCEPTRON, self._ADAPTIVE}:\n print(\"Invalid leaf_prediction option {}', will use default '{}'\".\n format(leaf_prediction, self._PERCEPTRON))\n self._leaf_prediction = self._PERCEPTRON\n else:\n self._leaf_prediction = leaf_prediction\n\n def _get_predictors_faded_error(self, X):\n \"\"\"Get the faded error of the leaf corresponding to the pased instance.\n\n Parameters\n ----------\n X: numpy.ndarray of length equal to the number of features.\n Instance attributes.\n\n Returns\n -------\n dict (predictor, fmae)\n \"\"\"\n fmaes = {}\n if self._tree_root is not None:\n found_node = self._tree_root.filter_instance_to_leaf(X, None, -1)\n leaf_node = found_node.node\n if leaf_node is None:\n leaf_node = found_node.parent\n if isinstance(leaf_node, LearningNode):\n fmaes['mean'] = leaf_node.fMAE_M\n fmaes['perceptron'] = leaf_node.fMAE_P\n fmaes['stacked_perceptron'] = leaf_node.fMAE_SP\n else:\n # If the found node is not a learning node, give preference to\n # the mean predictor\n fmaes['mean'] = np.zeros(self._n_targets)\n fmaes['perceptron'] = np.full(self._n_targets, np.Inf)\n fmaes['stacked_perceptron'] = np.full(self._n_targets, np.Inf)\n\n return fmaes\n\n def _new_learning_node(self, initial_class_observations=None, parent_node=None,\n is_active_node=True):\n \"\"\"Create a new learning node. The type of learning node depends on\n the tree configuration.\n \"\"\"\n if initial_class_observations is None:\n initial_class_observations = {}\n\n if is_active_node:\n if self.leaf_prediction == self._PERCEPTRON:\n return SSTActiveLearningNode(\n initial_class_observations,\n parent_node,\n random_state=self.random_state\n )\n elif self.leaf_prediction == self._ADAPTIVE:\n new_node = SSTActiveLearningNodeAdaptive(\n initial_class_observations,\n parent_node,\n random_state=self.random_state\n )\n # Resets faded errors\n new_node.fMAE_M = np.zeros(self._n_targets, dtype=np.float64)\n new_node.fMAE_P = np.zeros(self._n_targets, dtype=np.float64)\n new_node.fMAE_SP = np.zeros(self._n_targets, dtype=np.float64)\n return new_node\n else:\n if self.leaf_prediction == self._PERCEPTRON:\n return SSTInactiveLearningNode(\n initial_class_observations,\n parent_node,\n random_state=parent_node.random_state\n )\n elif self.leaf_prediction == self._ADAPTIVE:\n new_node = SSTInactiveLearningNodeAdaptive(\n initial_class_observations,\n parent_node,\n random_state=parent_node.random_state\n )\n new_node.fMAE_M = parent_node.fMAE_M\n new_node.fMAE_P = parent_node.fMAE_P\n new_node.fMAE_SP = parent_node.fMAE_SP\n return new_node\n\n def predict(self, X):\n \"\"\"Predicts the target value using mean class or the perceptron.\n\n Parameters\n ----------\n X: numpy.ndarray of shape (n_samples, n_features)\n Samples for which we want to predict the labels.\n\n Returns\n -------\n list\n Predicted target values.\n \"\"\"\n r, _ = get_dimensions(X)\n\n try:\n predictions = np.zeros((r, self._n_targets), dtype=np.float64)\n except AttributeError:\n return [0.0]\n for i in range(r):\n if self.leaf_prediction == self._PERCEPTRON:\n if self.examples_seen > 1:\n perceptron_weights = self.get_weights_for_instance(X[i])\n if perceptron_weights is None:\n # Instance was sorted to a non-learning node: use\n # mean prediction\n votes = self.get_votes_for_instance(X[i]).copy()\n number_of_examples_seen = votes[0]\n sum_of_values = votes[1]\n predictions[i] = sum_of_values / number_of_examples_seen\n continue\n\n normalized_sample = self.normalize_sample(X[i])\n normalized_base_prediction = np.matmul(\n perceptron_weights[0], normalized_sample\n )\n normalized_meta_prediction = np.matmul(\n perceptron_weights[1],\n np.append(normalized_base_prediction, 1.0)\n )\n mean = self.sum_of_values / self.examples_seen\n variance = (self.sum_of_squares -\n (self.sum_of_values *\n self.sum_of_values) /\n self.examples_seen) / (self.examples_seen - 1)\n sd = np.sqrt(variance, out=np.zeros_like(variance),\n where=variance >= 0.0)\n # Samples are normalized using just one sd, as proposed in\n # the iSoup-Tree method\n predictions[i] = normalized_meta_prediction * sd + mean\n elif self.leaf_prediction == self._ADAPTIVE:\n if self.examples_seen > 1:\n # Mean predictor\n votes = self.get_votes_for_instance(X[i]).copy()\n number_of_examples_seen = votes[0]\n sum_of_values = votes[1]\n pred_M = sum_of_values / number_of_examples_seen\n\n # Perceptron variants\n perceptron_weights = self.get_weights_for_instance(X[i])\n if perceptron_weights is None:\n # Instance was sorted to a non-learning node: use\n # mean prediction\n predictions[i] = pred_M\n continue\n else:\n normalized_sample = self.normalize_sample(X[i])\n\n # Standard perceptron\n normalized_base_prediction = np.matmul(\n perceptron_weights[0], normalized_sample\n )\n # Stacked perceptron\n normalized_meta_prediction = np.matmul(\n perceptron_weights[1],\n np.append(normalized_base_prediction, 1.0)\n )\n\n mean = self.sum_of_values / self.examples_seen\n variance = (self.sum_of_squares -\n (self.sum_of_values *\n self.sum_of_values) /\n self.examples_seen) / (self.examples_seen - 1)\n sd = np.sqrt(variance, out=np.zeros_like(variance),\n where=variance >= 0.0)\n\n pred_P = normalized_base_prediction * sd + mean\n pred_SP = normalized_meta_prediction * sd + mean\n\n # Gets faded errors for the related leaf predictors\n fmae = self._get_predictors_faded_error(X[i])\n\n # Selects, for each target, the best current performer\n for j in range(self._n_targets):\n b_pred = np.argmin([fmae['mean'][j],\n fmae['perceptron'][j],\n fmae['stacked_perceptron'][j]]\n )\n\n if b_pred == 0:\n # If all the expected errors are the same,\n # use the standard perceptron\n if fmae['mean'][j] == fmae['perceptron'][j] \\\n == fmae['stacked_perceptron'][j]:\n predictions[i, j] = pred_P[j]\n # Otherwise, use the simplest approach\n else:\n predictions[i, j] = pred_M[j]\n else:\n if b_pred == 1:\n # Use the stacked perceptron if its expected\n # error is the same than the error for the\n # standard perceptron\n if fmae['perceptron'][j] == \\\n fmae['stacked_perceptron'][j]:\n predictions[i, j] = pred_SP[j]\n else:\n predictions[i, j] = pred_P[j]\n else:\n predictions[i, j] = pred_SP[j]\n\n return predictions\n",
"import numpy as np\nfrom scipy import stats\nfrom skmultiflow.drift_detection.base_drift_detector import BaseDriftDetector\n\nclass KSWIN(BaseDriftDetector):\n r\"\"\" Kolmogorov-Smirnov Windowing method for concept drift detection.\n\n Parameters\n ----------\n alpha: float (default=0.005)\n Probability for the test statistic of the Kolmogorov-Smirnov-Test\n The alpha parameter is very sensitive, therefore should be set\n below 0.01.\n\n window_size: float (default=100)\n Size of the sliding window\n\n stat_size: float (default=30)\n Size of the statistic window\n\n data: numpy.ndarray of shape (n_samples, 1) (default=None,optional)\n Already collected data to avoid cold start.\n\n Notes\n -----\n KSWIN (Kolmogorov-Smirnov Windowing) [1]_ is a concept change detection method based\n on the Kolmogorov-Smirnov (KS) statistical test. KS-test is a statistical test with\n no assumption of underlying data distribution. KSWIN can monitor data or performance\n distributions. Note that the detector accepts one dimensional input as array.\n\n KSWIN maintains a sliding window :math:`\\Psi` of fixed size :math:`n` (window_size). The\n last :math:`r` (stat_size) samples of :math:`\\Psi` are assumed to represent the last\n concept considered as :math:`R`. From the first :math:`n-r` samples of :math:`\\Psi`,\n :math:`r` samples are uniformly drawn, representing an approximated last concept :math:`W`.\n\n The KS-test is performed on the windows :math:`R` and :math:`W` of the same size. KS\n -test compares the distance of the empirical cumulative data distribution :math:`dist(R,W)`.\n\n A concept drift is detected by KSWIN if:\n\n * :math:`dist(R,W) > \\sqrt{-\\frac{ln\\alpha}{r}}`\n\n -> The difference in empirical data distributions between the windows :math:`R` and :math:`W`\n is too large as that R and W come from the same distribution.\n\n References\n ----------\n .. [1] Christoph Raab, Moritz Heusinger, Frank-Michael Schleif, Reactive\n Soft Prototype Computing for Concept Drift Streams, Neurocomputing, 2020,\n\n Examples\n --------\n >>> # Imports\n >>> import numpy as np\n >>> from skmultiflow.data.sea_generator import SEAGenerator\n >>> from skmultiflow.drift_detection import KSWIN\n >>> import numpy as np\n >>> # Initialize KSWIN and a data stream\n >>> kswin = KSWIN(alpha=0.01)\n >>> stream = SEAGenerator(classification_function = 2,\n >>> random_state = 112, balance_classes = False,noise_percentage = 0.28)\n >>> # Store detections\n >>> detections = []\n >>> # Process stream via KSWIN and print detections\n >>> for i in range(1000):\n >>> data = stream.next_sample(10)\n >>> batch = data[0][0][0]\n >>> kswin.add_element(batch)\n >>> if kswin.detected_change():\n >>> print(\"\\rIteration {}\".format(i))\n >>> print(\"\\r KSWINReject Null Hyptheses\")\n >>> detections.append(i)\n >>> print(\"Number of detections: \"+str(len(detections)))\n \"\"\"\n def __init__(self, alpha=0.005, window_size=100, stat_size=30, data=None):\n super().__init__()\n self.window_size = window_size\n self.stat_size = stat_size\n self.alpha = alpha\n self.change_detected = False\n self.p_value = 0\n self.n = 0\n if self.alpha < 0 or self.alpha > 1:\n raise ValueError(\"Alpha must be between 0 and 1\")\n\n if self.window_size < 0:\n raise ValueError(\"window_size must be greater than 0\")\n\n if self.window_size < self.stat_size:\n raise ValueError(\"stat_size must be smaller than window_size\")\n\n if type(data) != np.ndarray or type(data) is None:\n self.window = np.array([])\n else:\n self.window = data\n\n def add_element(self, input_value):\n \"\"\" Add element to sliding window\n\n Adds an element on top of the sliding window and removes\n the oldest one from the window. Afterwards, the KS-test\n is performed.\n\n Parameters\n ----------\n input_value: ndarray\n New data sample the sliding window should add.\n \"\"\"\n self.n += 1\n currentLength = self.window.shape[0]\n if currentLength >= self.window_size:\n self.window = np.delete(self.window,0)\n rnd_window = np.random.choice(self.window[:-self.stat_size], self.stat_size)\n\n (st, self.p_value) = stats.ks_2samp(rnd_window, self.window[-self.stat_size:],mode=\"exact\")\n\n if self.p_value <= self.alpha and st > 0.1:\n self.change_detected = True\n self.window = self.window[-self.stat_size:]\n else:\n self.change_detected = False\n else: # Not enough samples in sliding window for a valid test\n self.change_detected = False\n\n self.window = np.concatenate([self.window,[input_value]])\n\n def detected_change(self):\n \"\"\" Get detected change\n\n Returns\n -------\n bool\n Whether or not a drift occurred\n\n \"\"\"\n return self.change_detected\n\n def reset(self):\n \"\"\" reset\n\n Resets the change detector parameters.\n \"\"\"\n self.p_value = 0\n self.window = np.array([])\n self.change_detected = False\n"
]
| [
[
"numpy.full",
"numpy.zeros_like",
"numpy.matmul",
"numpy.zeros",
"numpy.argmin",
"numpy.append"
],
[
"numpy.concatenate",
"numpy.array",
"numpy.delete",
"numpy.random.choice",
"scipy.stats.ks_2samp"
]
]
|
mrocklin/pygdf | [
"2de9407427da9497ebdf8951a12857be0fab31bb",
"2de9407427da9497ebdf8951a12857be0fab31bb"
]
| [
"pygdf/buffer.py",
"pygdf/tests/test_multi.py"
]
| [
"\nimport numpy as np\nfrom numba import cuda\n\nfrom . import cudautils, utils\nfrom .serialize import register_distributed_serializer\n\n\nclass Buffer(object):\n \"\"\"A 1D gpu buffer.\n \"\"\"\n _cached_ipch = None\n\n @classmethod\n def from_empty(cls, mem):\n \"\"\"From empty device array\n \"\"\"\n return cls(mem, size=0, capacity=mem.size)\n\n @classmethod\n def null(cls, dtype):\n \"\"\"Create a \"null\" buffer with a zero-sized device array.\n \"\"\"\n mem = cuda.device_array(0, dtype=dtype)\n return cls(mem, size=0, capacity=0)\n\n def __init__(self, mem, size=None, capacity=None, categorical=False):\n if size is None:\n if categorical:\n size = len(mem)\n else:\n size = mem.size\n if capacity is None:\n capacity = size\n self.mem = cudautils.to_device(mem)\n _BufferSentry(self.mem).ndim(1)\n self.size = size\n self.capacity = capacity\n self.dtype = self.mem.dtype\n\n def serialize(self, serialize, context=None):\n \"\"\"Called when dask.distributed is performing a serialization on this\n object.\n\n Do not use this directly. It is invoked by dask.distributed.\n\n Parameters\n ----------\n\n serialize : callable\n Used to serialize data that needs serialization .\n context : dict; optional\n If not ``None``, it contains information about the destination.\n\n Returns\n -------\n (header, frames)\n See custom serialization documentation in dask.distributed.\n \"\"\"\n from .serialize import should_use_ipc\n\n # Use destination info to determine if we should do IPC.\n use_ipc = should_use_ipc(context)\n header = {}\n # Should use IPC transfer\n if use_ipc:\n # Reuse IPC handle from previous call?\n if self._cached_ipch is not None:\n ipch = self._cached_ipch\n else:\n # Get new IPC handle\n ipch = self.to_gpu_array().get_ipc_handle()\n header['kind'] = 'ipc'\n header['mem'], frames = serialize(ipch)\n # Keep IPC handle alive\n self._cached_ipch = ipch\n # Not using IPC transfer\n else:\n header['kind'] = 'normal'\n # Serialize the buffer as a numpy array\n header['mem'], frames = serialize(self.to_array())\n return header, frames\n\n @classmethod\n def deserialize(cls, deserialize, header, frames):\n \"\"\"Called when dask.distributed is performing a deserialization for\n data of this class.\n\n Do not use this directly. It is invoked by dask.distributed.\n\n Parameters\n ----------\n\n deserialize : callable\n Used to deserialize data that needs further deserialization .\n header, frames : dict\n See custom serialization documentation in dask.distributed.\n\n Returns\n -------\n obj : Buffer\n Returns an instance of Buffer.\n \"\"\"\n # Using IPC?\n if header['kind'] == 'ipc':\n ipch = deserialize(header['mem'], frames)\n # Open IPC handle\n with ipch as data:\n # Copy remote data over\n mem = cuda.device_array_like(data)\n mem.copy_to_device(data)\n # Not using IPC\n else:\n # Deserialize the numpy array\n mem = deserialize(header['mem'], frames)\n mem.flags['WRITEABLE'] = True # XXX: hack for numba to work\n return Buffer(mem)\n\n def __reduce__(self):\n cpumem = self.to_array()\n # Note: pickled Buffer only stores *size* element.\n return type(self), (cpumem,)\n\n def __sizeof__(self):\n return int(self.mem.alloc_size)\n\n def __getitem__(self, arg):\n if isinstance(arg, slice):\n sliced = self.to_gpu_array()[arg]\n buf = Buffer(sliced)\n buf.dtype = self.dtype # for np.datetime64 support\n return buf\n elif isinstance(arg, int):\n arg = utils.normalize_index(arg, self.size)\n # the dtype argument is necessary for datetime64 support\n # because currently we can't pass datetime64 types into\n # cuda dev arrays, so the type of the cuda dev array is\n # an i64, and we view it as the dtype on the buffer\n return self.mem[arg].view(self.dtype)\n else:\n raise NotImplementedError(type(arg))\n\n @property\n def avail_space(self):\n return self.capacity - self.size\n\n def _sentry_capacity(self, size_needed):\n if size_needed > self.avail_space:\n raise MemoryError('insufficient space in buffer')\n\n def append(self, element):\n self._sentry_capacity(1)\n self.extend(np.asarray(element, dtype=self.dtype))\n\n def extend(self, array):\n needed = array.size\n self._sentry_capacity(needed)\n array = cudautils.astype(array, dtype=self.dtype)\n self.mem[self.size:].copy_to_device(array)\n self.size += needed\n\n def astype(self, dtype):\n if self.dtype == dtype:\n return self\n else:\n return Buffer(cudautils.astype(self.mem, dtype=dtype))\n\n def to_array(self):\n return self.to_gpu_array().copy_to_host()\n\n def to_gpu_array(self):\n return self.mem[:self.size]\n\n def copy(self):\n \"\"\"Deep copy the buffer\n \"\"\"\n return Buffer(mem=cudautils.copy_array(self.mem),\n size=self.size, capacity=self.capacity)\n\n def as_contiguous(self):\n out = Buffer(mem=cudautils.as_contiguous(self.mem),\n size=self.size, capacity=self.capacity)\n assert out.is_contiguous()\n return out\n\n def is_contiguous(self):\n return self.mem.is_c_contiguous()\n\n\nclass BufferSentryError(ValueError):\n pass\n\n\nclass _BufferSentry(object):\n def __init__(self, buf):\n self._buf = buf\n\n def dtype(self, dtype):\n if self._buf.dtype != dtype:\n raise BufferSentryError('dtype mismatch')\n return self\n\n def ndim(self, ndim):\n if self._buf.ndim != ndim:\n raise BufferSentryError('ndim mismatch')\n return self\n\n def contig(self):\n if not self._buf.is_c_contiguous():\n raise BufferSentryError('non contiguous')\n\n\nregister_distributed_serializer(Buffer)\n",
"# Copyright (c) 2018, NVIDIA CORPORATION.\n\nimport pytest\n\nimport pandas as pd\nimport pygdf as gd\n\n\ndef make_frames(index=None):\n df = pd.DataFrame({'x': range(10),\n 'y': list(map(float, range(10))),\n 'z': list('abcde')*2})\n df.z = df.z.astype('category')\n df2 = pd.DataFrame({'x': range(10, 20),\n 'y': list(map(float, range(10, 20))),\n 'z': list('edcba')*2})\n df2.z = df2.z.astype('category')\n gdf = gd.DataFrame.from_pandas(df)\n gdf2 = gd.DataFrame.from_pandas(df2)\n if index:\n df = df.set_index(index)\n df2 = df2.set_index(index)\n gdf = gdf.set_index(index)\n gdf2 = gdf2.set_index(index)\n return df, df2, gdf, gdf2\n\n\[email protected]('index', [False, 'z', 'y'])\ndef test_concat(index):\n df, df2, gdf, gdf2 = make_frames(index)\n # Make empty frame\n gdf_empty1 = gdf2[:0]\n assert len(gdf_empty1) == 0\n df_empty1 = gdf_empty1.to_pandas()\n # DataFrame\n res = gd.concat([gdf, gdf2, gdf, gdf_empty1]).to_pandas()\n sol = pd.concat([df, df2, df, df_empty1])\n pd.util.testing.assert_frame_equal(res, sol, check_names=False)\n\n # Series\n for c in [i for i in ('x', 'y', 'z') if i != index]:\n res = gd.concat([gdf[c], gdf2[c], gdf[c]]).to_pandas()\n sol = pd.concat([df[c], df2[c], df[c]])\n pd.util.testing.assert_series_equal(res, sol, check_names=False)\n\n # Index\n res = gd.concat([gdf.index, gdf2.index]).to_pandas()\n sol = df.index.append(df2.index)\n pd.util.testing.assert_index_equal(res, sol, check_names=False)\n\n\ndef test_concat_errors():\n df, df2, gdf, gdf2 = make_frames()\n\n # No objs\n with pytest.raises(ValueError):\n gd.concat([])\n\n # Mismatched types\n with pytest.raises(ValueError):\n gd.concat([gdf, gdf.x])\n\n # Unknown type\n with pytest.raises(ValueError):\n gd.concat(['bar', 'foo'])\n\n # Mismatched column dtypes\n with pytest.raises(ValueError):\n gd.concat([gdf.x, gdf.y])\n with pytest.raises(ValueError):\n gd.concat([gdf.x, gdf.z])\n\n # Mismatched index dtypes\n gdf3 = gdf2.set_index('z')\n gdf2.drop_column('z')\n with pytest.raises(ValueError):\n gd.concat([gdf2, gdf3])\n\n # Mismatched columns\n with pytest.raises(ValueError):\n gd.concat([gdf, gdf2])\n\n\ndef test_concat_misordered_columns():\n df, df2, gdf, gdf2 = make_frames(False)\n gdf2 = gdf2[['z', 'x', 'y']]\n df2 = df2[['z', 'x', 'y']]\n\n res = gd.concat([gdf, gdf2]).to_pandas()\n sol = pd.concat([df, df2])\n\n pd.util.testing.assert_frame_equal(res, sol, check_names=False)\n"
]
| [
[
"numpy.asarray"
],
[
"pandas.util.testing.assert_series_equal",
"pandas.util.testing.assert_index_equal",
"pandas.util.testing.assert_frame_equal",
"pandas.concat"
]
]
|
GuanlinLee/FPD-for-Adversarial-Robustness | [
"76b06cb8a68469f8ed4ed6bb5479ee86719175fb"
]
| [
"ResNet-50/SVHN/train.py"
]
| [
"import torchvision\nimport torchvision.transforms as transforms\nimport torch\nimport torch.utils.data\nimport resnet\nfrom torch.autograd import Variable\nfrom torch import nn\n\nimport early_stop\nfrom tqdm import tqdm\n\nimport os,sys\nimport numpy as np\n\nos.environ[\"CUDA_VISIBLE_DEVICES\"] = \"2\"\ntrain_globa_step=0\nval_globa_step=0\n\nwd=1e-50\nlearning_rate=1e-4\nepochs=100\nbatch_size=300\ntorch.backends.cudnn.benchmark = True\ntransform=transforms.Compose([\n torchvision.transforms.Resize((64,64)),\n torchvision.transforms.ToTensor(),\n \n ])\n\ntrainset = torchvision.datasets.SVHN(root='./data',split='train', download=True, transform=transform)\ntrainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size,\n shuffle=True, num_workers=16)\n\n\ntransform_test=transforms.Compose([torchvision.transforms.Resize((64,64)),\n transforms.ToTensor(),\n ])\n\ntestset = torchvision.datasets.SVHN(root='./data', split='test', download=True, transform=transform_test)\ntestloader = torch.utils.data.DataLoader(testset, batch_size=batch_size,\n shuffle=False, num_workers=16)\n\n\nn = resnet.resnet101().cuda()\n\nweight_p, bias_p = [],[]\nfor name, p in n.named_parameters():\n if 'bias' in name:\n bias_p += [p]\n else:\n weight_p += [p]\n\ntrans_params = list(map(id, n.trans_conv.parameters()))\nclass_params = list(map(id, n.group2.parameters()))\n\nbase_params = filter(lambda p: id(p) not in trans_params,\n n.parameters())\nbase_params = filter(lambda p: id(p) not in class_params,\n base_params)\n\n\n\nloss1 =nn.MSELoss()\nloss1.cuda()\nloss2=nn.CrossEntropyLoss()\nloss2.cuda()\noptimizer = torch.optim.Adam([{'params': base_params},\n {'params':n.trans_conv.parameters(),'lr':learning_rate},\n {'params':n.group2.parameters(),'lr':learning_rate}],\n lr=learning_rate,weight_decay=wd)\n\nopt = torch.optim.Adam([{'params': base_params},\n {'params':n.trans_conv.parameters(),'lr':learning_rate}],\n lr=learning_rate,weight_decay=wd)\n\nif os.path.exists('bestmodel_params.pkl'):\n checkpoint = torch.load('bestmodel_params.pkl')\n n.load_state_dict(checkpoint['state_dict'])\n optimizer.load_state_dict(checkpoint['opt_state_dict'])\n opt.load_state_dict(checkpoint['opt_state_dict2'])\n\nsch=torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer,factor=0.1,patience=10)\n\nes=early_stop.EarlyStopping('max',patience=20)\nfor epoch in range(epochs):\n loadertrain = tqdm(trainloader, desc='{} E{:03d}'.format('train', epoch), ncols=0)\n loadertest = tqdm(testloader, desc='{} E{:03d}'.format('test', epoch), ncols=0)\n epoch_loss = 0.0\n correct=0.0\n total=0.0\n total2=0.0\n correct2=0.0\n for x_train, y_train in loadertrain:\n n.train()\n x_train, y_train = Variable(x_train.cuda()),Variable(y_train.cuda())\n x_noise=torch.FloatTensor(x_train.size(0),3,64,64).uniform_(-0.01,0.01)\n x_noise=torch.clamp(x_noise,-0.01,0.01)\n x_train_noise=x_train+Variable(x_noise.cuda())\n y_pre,c_pre = n(x_train_noise)\n y_pre=y_pre.cuda()\n\n n.zero_grad()\n optimizer.zero_grad()\n loss = loss1(torch.mul(y_pre,1.0), torch.mul( x_train,1.0))\n if loss.item()>3:\n loss.backward(retain_graph=True)\n torch.nn.utils.clip_grad_norm_(n.parameters(), 5.0)\n opt.step()\n epoch_loss += loss.data.item()\n _, predicted = torch.max(c_pre.data, 1)\n total += y_train.size(0)\n correct += predicted.eq(y_train.data).cuda().sum()\n torch.cuda.empty_cache()\n else:\n loss_cl=loss2(c_pre,y_train)\n\n loss_sum=torch.mul(loss,1/1)+loss_cl\n loss_sum.backward(retain_graph=True)\n torch.nn.utils.clip_grad_norm_(n.parameters(), 5.0)\n optimizer.step()\n epoch_loss += loss_sum.data.item()\n _, predicted = torch.max(c_pre.data, 1)\n total += y_train.size(0)\n correct += predicted.eq(y_train.data).cuda().sum()\n\n train_globa_step+=1\n torch.cuda.empty_cache()\n if loss.item()<3:\n\n y_pre2, c_pre2 = n(y_pre)\n y_pre2 = y_pre2.cuda()\n\n n.zero_grad()\n optimizer.zero_grad()\n lossreg2 = loss1(torch.mul(y_pre2, 1.0), torch.mul( x_train, 1.0))\n loss_cl2 = loss2(c_pre2, y_train)\n _, predicted2 = torch.max(c_pre2.data, 1)\n total2 += y_train.size(0)\n correct2 += predicted2.eq(y_train.data).cuda().sum()\n loss_sum2 = torch.mul(lossreg2, 1 / 1) + loss_cl2\n loss_sum2.backward()\n torch.nn.utils.clip_grad_norm_(n.parameters(), 5.0)\n optimizer.step()\n torch.cuda.empty_cache()\n if train_globa_step% 20==0:\n\n n.eval()\n checkpoint = {\n 'state_dict': n.state_dict(),\n 'opt_state_dict': optimizer.state_dict(),\n 'opt_state_dict2':opt.state_dict(),\n 'epoch': epoch\n }\n\n torch.save(checkpoint, 'model_params.pkl')\n fmt = '{:.4f}'.format\n loadertrain.set_postfix(loss=fmt(loss.data.item()),\n\n acc=fmt(correct.item() / total * 100))\n\n if (epoch) % 1 ==0:\n test_loss = 0.0\n correct = 0.0\n total = 0.0\n n.eval()\n with torch.no_grad():\n for x_test, y_test in loadertest:\n x_test, y_test = Variable(x_test.cuda()), Variable(y_test.cuda())\n \n y_pre, c_pre = n(x_test)\n\n y_pre = y_pre.cuda()\n\n loss_cl = loss2(c_pre, y_test)\n loss = loss1(torch.mul(y_pre,1.0), torch.mul( x_test,1.0))\n\n loss_sum = torch.mul(loss,1/1) + loss_cl\n test_loss += loss_sum.data.item()\n _, predicted = torch.max(c_pre.data, 1)\n total += y_test.size(0)\n correct += predicted.eq(y_test.data).cuda().sum()\n val_globa_step+=1\n fmt = '{:.4f}'.format\n loadertest.set_postfix(loss=fmt(loss_sum.data.item()),\n\n acc=fmt(correct.item() / total * 100))\n sch.step(test_loss)\n fl=es.step(correct.item()/total*100, n,optimizer,opt,epoch)\n if fl:\n torch.cuda.empty_cache()\n sys.exit(0) \n torch.cuda.empty_cache()"
]
| [
[
"torch.mul",
"torch.nn.MSELoss",
"torch.max",
"torch.save",
"torch.no_grad",
"torch.clamp",
"torch.cuda.empty_cache",
"torch.optim.lr_scheduler.ReduceLROnPlateau",
"torch.utils.data.DataLoader",
"torch.load",
"torch.nn.CrossEntropyLoss"
]
]
|
hirowgit/2B3_python_owl_logic_database_course | [
"81096b287c32a067aa11a9a37ae5a4c6a0d1301e"
]
| [
"lec1_step3.py"
]
| [
"#!/usr/bin/env python\n# coding: utf-8\n\n# In[1]:\n\n\n## Python basics for novice data scientists, supported by Wagatsuma Lab@Kyutech \n#\n# The MIT License (MIT): Copyright (c) 2020 Hiroaki Wagatsuma and Wagatsuma Lab@Kyutech\n# \n# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the \"Software\"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:\n# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.\n# THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */\n#\n# # @Time : 2020-4-20 \n# # @Author : Hiroaki Wagatsuma\n# # @Site : https://github.com/hirowgit/2A_python_basic_course\n# # @IDE : Python 3.7.7 (default, Mar 10 2020, 15:43:27) [Clang 10.0.0 (clang-1000.11.45.5)] on darwin\n# # @File : lec1_step3.py \n\n\n# In[2]:\n\n\n# running without modules on mathematics\npi\n\n\n# In[3]:\n\n\n# module test: if you have an error when you run this code, you need to check the installation status of those modules\n\nimport math \nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\n\n\n# In[4]:\n\n\nimport math \npi=math.pi\nprint(pi)\n\n\n# In[5]:\n\n\nx = np.arange(-3.14, 3.14, 0.1)\ny = np.sin(x)\nplt.plot(x, y)\n\n\n# In[6]:\n\n\ns = pd.Series([2, 4, 6, np.nan, 7, 9])\nprint(s)\n\n\n# In[ ]:\n\n\n\n\n"
]
| [
[
"numpy.sin",
"matplotlib.pyplot.plot",
"numpy.arange",
"pandas.Series"
]
]
|
nagasudhirpulla/wrldc_scada_mumbai_dashboard | [
"bc107ef47568781b588316f0c5c0c0d2a08adac8"
]
| [
"src/services/scadaApiFetcher.py"
]
| [
"import requests\nimport json\nimport datetime as dt\nfrom typing import Dict, Union, List, Optional\nfrom src.typeDefs.scadaApiDataSample import IScadaApiDataSample\nimport pandas as pd\nimport random\n\n\nclass ScadaApiFetcher():\n apiHost: str = ''\n apiPort: int = 80\n isDummyFetch: bool = False\n\n def __init__(self, apiHost: str, apiPort: int, isDummyFetch=False):\n self.apiHost = apiHost\n self.apiPort = apiPort\n self.isDummyFetch = isDummyFetch\n\n def fetchPntHistData(self, pnt: str, startTime: dt.datetime, endTime: dt.datetime, fetchStrategy: str = 'snap', sampleFreq: int = 300) -> List[IScadaApiDataSample]:\n if self.isDummyFetch:\n if (startTime > endTime) or (sampleFreq == 0):\n return []\n currTime = startTime\n dataRes: List[IScadaApiDataSample] = []\n while currTime <= endTime:\n dataRes.append(\n {\"timestamp\": currTime, \"dval\": random.randint(1, 100), \"status\": \"GOOD\"})\n currTime = currTime + dt.timedelta(seconds=sampleFreq)\n return dataRes\n startTimeStr = startTime.strftime('%d/%m/%Y/%H:%M:%S')\n endTimeStr = endTime.strftime('%d/%m/%Y/%H:%M:%S')\n # print(req_date_str)\n params: Dict[str, Union[int, str]] = dict(\n pnt=pnt,\n strtime=startTimeStr,\n endtime=endTimeStr,\n secs=sampleFreq,\n type=fetchStrategy\n )\n try:\n # http://host:80/api/values/history?pnt=pntId&strtime=12/12/2019/00:00:00&endtime=13/12/2019/00:00:00&secs=900&type=average\n r = requests.get(\n url=\"http://{0}:{1}/api/values/history\".format(self.apiHost, self.apiPort), params=params)\n resTxt = r.text\n if pd.isna(resTxt) or (resTxt == '') or (resTxt == '[]') or (resTxt == 'null'):\n return []\n data = json.loads(resTxt)\n return data\n except:\n return []\n\n def fetchPntRtData(self, pnt) -> Optional[float]:\n if self.isDummyFetch:\n return random.randrange(1, 100)\n params = dict(\n pnt=pnt,\n )\n try:\n # http://host:80/api/values/real?pnt=pntId&strtime=12/12/2019/00:00:00&endtime=13/12/2019/00:00:00&secs=900&type=average\n r = requests.get(\n url=\"http://{0}:{1}/api/values/real\".format(self.apiHost, self.apiPort), params=params)\n resTxt = r.text\n if pd.isna(resTxt) or (resTxt == 'null') or (resTxt == ''):\n return None\n resData: IScadaApiDataSample = json.loads(resTxt)\n return float(resData['dval'])\n except:\n return None\n"
]
| [
[
"pandas.isna"
]
]
|
ksluck/Coadaptation | [
"aa16f277cd31c324a62c832ef2cef94e28d598b8"
]
| [
"RL/soft_actor.py"
]
| [
"from rlkit.torch.sac.policies import TanhGaussianPolicy\n# from rlkit.torch.sac.sac import SoftActorCritic\nfrom rlkit.torch.networks import FlattenMlp\nimport numpy as np\nfrom .rl_algorithm import RL_algorithm\nfrom rlkit.torch.sac.sac import SACTrainer as SoftActorCritic_rlkit\nimport rlkit.torch.pytorch_util as ptu\nimport torch\nimport utils\n\n# networks = {individual:, population:}\nclass SoftActorCritic(RL_algorithm):\n\n def __init__(self, config, env, replay, networks):\n \"\"\" Bascally a wrapper class for SAC from rlkit.\n\n Args:\n config: Configuration dictonary\n env: Environment\n replay: Replay buffer\n networks: dict containing two sub-dicts, 'individual' and 'population'\n which contain the networks.\n\n \"\"\"\n super().__init__(config, env, replay, networks)\n\n self._variant_pop = config['rl_algorithm_config']['algo_params_pop']\n self._variant_spec = config['rl_algorithm_config']['algo_params']\n\n self._ind_qf1 = networks['individual']['qf1']\n self._ind_qf2 = networks['individual']['qf2']\n self._ind_qf1_target = networks['individual']['qf1_target']\n self._ind_qf2_target = networks['individual']['qf2_target']\n self._ind_policy = networks['individual']['policy']\n\n self._pop_qf1 = networks['population']['qf1']\n self._pop_qf2 = networks['population']['qf2']\n self._pop_qf1_target = networks['population']['qf1_target']\n self._pop_qf2_target = networks['population']['qf2_target']\n self._pop_policy = networks['population']['policy']\n\n self._batch_size = config['rl_algorithm_config']['batch_size']\n self._nmbr_indiv_updates = config['rl_algorithm_config']['indiv_updates']\n self._nmbr_pop_updates = config['rl_algorithm_config']['pop_updates']\n\n self._algorithm_ind = SoftActorCritic_rlkit(\n env=self._env,\n policy=self._ind_policy,\n qf1=self._ind_qf1,\n qf2=self._ind_qf2,\n target_qf1=self._ind_qf1_target,\n target_qf2=self._ind_qf2_target,\n use_automatic_entropy_tuning = False,\n **self._variant_spec\n )\n\n self._algorithm_pop = SoftActorCritic_rlkit(\n env=self._env,\n policy=self._pop_policy,\n qf1=self._pop_qf1,\n qf2=self._pop_qf2,\n target_qf1=self._pop_qf1_target,\n target_qf2=self._pop_qf2_target,\n use_automatic_entropy_tuning = False,\n **self._variant_pop\n )\n\n # self._algorithm_ind.to(ptu.device)\n # self._algorithm_pop.to(ptu.device)\n\n def episode_init(self):\n \"\"\" Initializations to be done before the first episode.\n\n In this case basically creates a fresh instance of SAC for the\n individual networks and copies the values of the target network.\n \"\"\"\n self._algorithm_ind = SoftActorCritic_rlkit(\n env=self._env,\n policy=self._ind_policy,\n qf1=self._ind_qf1,\n qf2=self._ind_qf2,\n target_qf1=self._ind_qf1_target,\n target_qf2=self._ind_qf2_target,\n use_automatic_entropy_tuning = False,\n # alt_alpha = self._alt_alpha,\n **self._variant_spec\n )\n if self._config['rl_algorithm_config']['copy_from_gobal']:\n utils.copy_pop_to_ind(networks_pop=self._networks['population'], networks_ind=self._networks['individual'])\n # We have only to do this becasue the version of rlkit which we use\n # creates internally a target network\n # vf_dict = self._algorithm_pop.target_vf.state_dict()\n # self._algorithm_ind.target_vf.load_state_dict(vf_dict)\n # self._algorithm_ind.target_vf.eval()\n # self._algorithm_ind.to(ptu.device)\n\n def single_train_step(self, train_ind=True, train_pop=False):\n \"\"\" A single trianing step.\n\n Args:\n train_ind: Boolean. If true the individual networks will be trained.\n train_pop: Boolean. If true the population networks will be trained.\n \"\"\"\n if train_ind:\n # Get only samples from the species buffer\n self._replay.set_mode('species')\n # self._algorithm_ind.num_updates_per_train_call = self._variant_spec['num_updates_per_epoch']\n # self._algorithm_ind._try_to_train()\n for _ in range(self._nmbr_indiv_updates):\n batch = self._replay.random_batch(self._batch_size)\n self._algorithm_ind.train(batch)\n\n if train_pop:\n # Get only samples from the population buffer\n self._replay.set_mode('population')\n # self._algorithm_pop.num_updates_per_train_call = self._variant_pop['num_updates_per_epoch']\n # self._algorithm_pop._try_to_train()\n for _ in range(self._nmbr_pop_updates):\n batch = self._replay.random_batch(self._batch_size)\n self._algorithm_pop.train(batch)\n\n @staticmethod\n def create_networks(env, config):\n \"\"\" Creates all networks necessary for SAC.\n\n These networks have to be created before instantiating this class and\n used in the constructor.\n\n Args:\n config: A configuration dictonary containing population and\n individual networks\n\n Returns:\n A dictonary which contains the networks.\n \"\"\"\n network_dict = {\n 'individual' : SoftActorCritic._create_networks(env=env, config=config),\n 'population' : SoftActorCritic._create_networks(env=env, config=config),\n }\n return network_dict\n\n @staticmethod\n def _create_networks(env, config):\n \"\"\" Creates all networks necessary for SAC.\n\n These networks have to be created before instantiating this class and\n used in the constructor.\n\n TODO: Maybe this should be reworked one day...\n\n Args:\n config: A configuration dictonary.\n\n Returns:\n A dictonary which contains the networks.\n \"\"\"\n obs_dim = int(np.prod(env.observation_space.shape))\n action_dim = int(np.prod(env.action_space.shape))\n net_size = config['rl_algorithm_config']['net_size']\n hidden_sizes = [net_size] * config['rl_algorithm_config']['network_depth']\n # hidden_sizes = [net_size, net_size, net_size]\n qf1 = FlattenMlp(\n hidden_sizes=hidden_sizes,\n input_size=obs_dim + action_dim,\n output_size=1,\n ).to(device=ptu.device)\n qf2 = FlattenMlp(\n hidden_sizes=hidden_sizes,\n input_size=obs_dim + action_dim,\n output_size=1,\n ).to(device=ptu.device)\n qf1_target = FlattenMlp(\n hidden_sizes=hidden_sizes,\n input_size=obs_dim + action_dim,\n output_size=1,\n ).to(device=ptu.device)\n qf2_target = FlattenMlp(\n hidden_sizes=hidden_sizes,\n input_size=obs_dim + action_dim,\n output_size=1,\n ).to(device=ptu.device)\n policy = TanhGaussianPolicy(\n hidden_sizes=hidden_sizes,\n obs_dim=obs_dim,\n action_dim=action_dim,\n ).to(device=ptu.device)\n\n clip_value = 1.0\n for p in qf1.parameters():\n p.register_hook(lambda grad: torch.clamp(grad, -clip_value, clip_value))\n for p in qf2.parameters():\n p.register_hook(lambda grad: torch.clamp(grad, -clip_value, clip_value))\n for p in policy.parameters():\n p.register_hook(lambda grad: torch.clamp(grad, -clip_value, clip_value))\n\n return {'qf1' : qf1, 'qf2' : qf2, 'qf1_target' : qf1_target, 'qf2_target' : qf2_target, 'policy' : policy}\n\n @staticmethod\n def get_q_network(networks):\n \"\"\" Returns the q network from a dict of networks.\n\n This method extracts the q-network from the dictonary of networks\n created by the function create_networks.\n\n Args:\n networks: Dict containing the networks.\n\n Returns:\n The q-network as torch object.\n \"\"\"\n return networks['qf1']\n\n @staticmethod\n def get_policy_network(networks):\n \"\"\" Returns the policy network from a dict of networks.\n\n This method extracts the policy network from the dictonary of networks\n created by the function create_networks.\n\n Args:\n networks: Dict containing the networks.\n\n Returns:\n The policy network as torch object.\n \"\"\"\n return networks['policy']\n"
]
| [
[
"numpy.prod",
"torch.clamp"
]
]
|
MatKie/SGTPy | [
"8e98d92fedd2b07d834e547e5154ec8f70d80728",
"8e98d92fedd2b07d834e547e5154ec8f70d80728",
"8e98d92fedd2b07d834e547e5154ec8f70d80728"
]
| [
"sgtpy/vrmie_mixtures/density_solver.py",
"sgtpy/vrmie_pure/a2m_monomer.py",
"sgtpy/vrmie_pure/ideal.py"
]
| [
"from __future__ import division, print_function, absolute_import\nimport numpy as np\nfrom scipy.optimize import minimize_scalar, brentq\nfrom ..constants import Na\n\n\ndef dPsaft_fun(rho, x, temp_aux, saft):\n rhomolecular = Na * rho\n global Xass\n da, Xass = saft.d2afcn_drho_aux(x, rhomolecular, temp_aux, Xass)\n afcn, dafcn, d2afcn = da\n dPsaft = 2 * rhomolecular * dafcn + rhomolecular**2 * d2afcn\n return dPsaft\n\n\ndef Psaft_obj(rho, x, temp_aux, saft, Pspec):\n rhomolecular = Na * rho\n global Xass\n da, Xass = saft.dafcn_drho_aux(x, rhomolecular, temp_aux, Xass)\n afcn, dafcn = da\n Psaft = rhomolecular**2 * dafcn / Na\n return Psaft - Pspec\n\n\ndef density_newton_lim(rho_a, rho_b, x, temp_aux, P, Xass0, saft):\n rho = (rho_a + rho_b) / 2\n Psaft, dPsaft, Xass = saft.dP_drho_aux(x, rho, temp_aux, Xass0)\n for i in range(15):\n rho_old = rho\n FO = Psaft - P\n dFO = dPsaft\n drho = FO/dFO\n rho_new = rho - drho\n\n if FO > 0:\n rho_b = rho\n else:\n rho_a = rho\n\n if rho_a < rho_new < rho_b:\n rho = rho_new\n else:\n rho = (rho_a + rho_b) / 2\n\n if np.abs(rho - rho_old) < 1e-6:\n break\n Psaft, dPsaft, Xass = saft.dP_drho_aux(x, rho, temp_aux, Xass)\n return rho, Xass\n\n\ndef density_topliss(state, x, temp_aux, P, Xass0, saft):\n\n if state != 'L' and state != 'V':\n raise Warning(\"Not valid state. 'L' for liquid and 'V' for vapor.\")\n\n beta = temp_aux[0]\n # lower boundary a zero density\n rho_lb = 1e-5\n dP_lb = Na / beta\n\n # Upper boundary limit at infinity pressure\n etamax = 0.7405\n rho_lim = (6 * etamax) / np.dot(x, (saft.ms * np.pi * saft.sigma**3)) / Na\n ub_sucess = False\n rho_ub = 0.4 * rho_lim\n it = 0\n P_ub, dP_ub, Xass_ub = saft.dP_drho_aux(x, rho_ub, temp_aux, Xass0)\n while not ub_sucess and it < 5:\n it += 1\n P_ub, dP_ub, Xass_ub = saft.dP_drho_aux(x, rho_ub, temp_aux, Xass_ub)\n rho_ub += 0.15 * rho_lim\n ub_sucess = P_ub > P and dP_ub > 0\n\n # Derivative calculation at zero density\n rho_lb1 = 1e-4 * rho_lim\n P_lb1, dP_lb1, Xass_lb = saft.dP_drho_aux(x, rho_lb1, temp_aux, Xass0)\n d2P_lb1 = (dP_lb1 - dP_lb) / rho_lb1\n if d2P_lb1 > 0:\n flag = 3\n else:\n flag = 1\n\n global Xass\n Xass = Xass0\n\n # Stage 1\n bracket = [rho_lb, rho_ub]\n if flag == 1:\n # Found inflexion point\n sol_inf = minimize_scalar(dPsaft_fun, args=(x, temp_aux, saft),\n bounds=bracket, method='Bounded',\n options={'xatol': 1e-1})\n rho_inf = sol_inf.x\n dP_inf = sol_inf.fun\n if dP_inf > 0:\n flag = 3\n else:\n flag = 2\n\n # Stage 2\n if flag == 2:\n if state == 'L':\n bracket[0] = rho_inf\n elif state == 'V':\n bracket[1] = rho_inf\n rho_ext = brentq(dPsaft_fun, bracket[0], bracket[1],\n args=(x, temp_aux, saft), xtol=1e-2)\n P_ext, dP_ext, Xass = saft.dP_drho_aux(x, rho_ext, temp_aux, Xass)\n if P_ext > P and state == 'V':\n bracket[1] = rho_ext\n elif P_ext < P and state == 'L':\n bracket[0] = rho_ext\n else:\n flag = -1\n\n if flag == -1:\n rho = np.nan\n else:\n rho, Xass = density_newton_lim(bracket[0], bracket[1], x, temp_aux,\n P, Xass, saft)\n # rho = brentq(Psaft_obj, bracket[0], bracket[1],\n # args=(x, temp_aux, saft, P))\n\n return rho, Xass\n\n\ndef density_newton(rho0, x, temp_aux, P, Xass0, saft):\n\n rho = 1.*rho0\n Psaft, dPsaft, Xass = saft.dP_drho_aux(x, rho, temp_aux, Xass0)\n for i in range(15):\n FO = Psaft - P\n dFO = dPsaft\n drho = FO/dFO\n rho -= drho\n if np.abs(drho) < 1e-6:\n break\n Psaft, dPsaft, Xass = saft.dP_drho_aux(x, rho, temp_aux, Xass)\n return rho, Xass\n",
"from __future__ import division, print_function, absolute_import\nimport numpy as np\n\n\n# Second pertubation Eq 36\ndef a2m(suma_a2, khs, xi, cte_a2m):\n a2 = khs*(1+xi)*suma_a2*cte_a2m\n return a2\n\n\ndef da2m_deta(suma_a2, dKhs, dXi, cte_a2m):\n\n khs, dkhs = dKhs\n xi, dx1 = dXi\n x1 = 1. + xi\n\n #sum1, dsum1 = np.matmul(da1sb, x0lambda)\n sum1, dsum1 = suma_a2\n # a2 = khs*x1*eps*c2*sum1/2.\n a2 = khs*x1*sum1*cte_a2m\n\n da2 = sum1*x1*dkhs + khs * x1 * dsum1 + khs * sum1 * dx1\n da2 *= cte_a2m\n return np.hstack([a2, da2])\n\n\ndef d2a2m_deta(suma_a2, d2Khs, d2Xi, cte_a2m):\n\n khs, dkhs, d2khs = d2Khs\n xi, dx1, d2x1 = d2Xi\n x1 = 1. + xi\n\n sum1, dsum1, d2sum1 = suma_a2\n\n a2 = khs*x1*sum1*cte_a2m\n\n da2 = sum1*x1*dkhs + khs * x1 * dsum1 + khs * sum1 * dx1\n da2 *= cte_a2m\n\n d2a2 = d2khs * sum1 * x1 + d2x1 * sum1 * khs + d2sum1 * khs * x1\n d2a2 += 2 * dkhs * dsum1 * x1\n d2a2 += 2 * sum1 * dkhs * dx1\n d2a2 += 2 * khs * dsum1 * dx1\n d2a2 *= cte_a2m\n return np.hstack([a2, da2, d2a2])\n\n\ndef da2m_new_deta(suma_a2, dKhs, cte_a2m):\n\n khs, dkhs = dKhs\n # sum1, dsum1 = np.matmul(da1sb, x0lambda)\n sum1, dsum1 = suma_a2\n da2 = cte_a2m*(dkhs*sum1 + khs * dsum1)\n\n return da2\n\n\ndef d2a2m_new_deta(suma_a2, d2Khs, cte_a2m):\n\n khs, dkhs, d2khs = d2Khs\n # sum1, dsum1, d2sum1 = np.matmul(d2a1sb, x0lambda)\n sum1, dsum1, d2sum1 = suma_a2\n # aux = cte_a2m\n da2 = cte_a2m*(dkhs*sum1 + khs * dsum1)\n\n d2a2 = 2 * dkhs * dsum1 + sum1 * d2khs + d2sum1 * khs\n d2a2 *= cte_a2m\n\n return np.hstack([da2, d2a2])\n\n\ndef d3a2m_new_deta(suma_a2, d3Khs, cte_a2m):\n\n khs, dkhs, d2khs, d3khs = d3Khs\n # sum1, dsum1, d2sum1, d3sum1 = np.matmul(d3a1sb, x0lambda)\n sum1, dsum1, d2sum1, d3sum1 = suma_a2\n # aux = cte_a2m\n da2 = cte_a2m*(dkhs*sum1 + khs * dsum1)\n\n d2a2 = 2 * dkhs * dsum1 + sum1 * d2khs + d2sum1 * khs\n d2a2 *= cte_a2m\n\n d3a2 = 3 * dsum1 * d2khs + 3 * dkhs * d2sum1\n d3a2 += khs * d3sum1 + d3khs * sum1\n d3a2 *= cte_a2m\n return np.hstack([da2, d2a2, d3a2])\n",
"from __future__ import division, print_function, absolute_import\nimport numpy as np\n\n\nh = 6.626070150e-34 # J s\nme = 9.10938291e-31 # 1/Kg\n\n\n# Equation 68\ndef aideal(rho, beta):\n broglie_vol = h / np.sqrt(2*np.pi * me / beta)\n a = np.log(rho * broglie_vol**3) - 1\n return a\n\n\ndef daideal_drho(rho, beta):\n broglie_vol = h / np.sqrt(2*np.pi * me / beta)\n a = np.log(rho * broglie_vol**3) - 1\n da = 1./rho\n return np.hstack([a, da])\n\n\ndef d2aideal_drho(rho, beta):\n broglie_vol = h / np.sqrt(2*np.pi * me / beta)\n a = np.log(rho * broglie_vol**3) - 1\n da = 1./rho\n d2a = -1/rho**2\n return np.hstack([a, da, d2a])\n"
]
| [
[
"scipy.optimize.brentq",
"numpy.abs",
"numpy.dot",
"scipy.optimize.minimize_scalar"
],
[
"numpy.hstack"
],
[
"numpy.log",
"numpy.hstack",
"numpy.sqrt"
]
]
|
ml-jku/align-rudder | [
"26cf4b62a713e180063cefc2921981484ebb9165",
"26cf4b62a713e180063cefc2921981484ebb9165"
]
| [
"align_rudder/run_eight_alignrudder.py",
"align_rudder/run_four_bc.py"
]
| [
"import ray\nfrom ray import tune\nimport gym\nfrom align_rudder.learning.q_learning import Qlearning\nimport numpy as np\nimport random\nimport os\nimport pkg_resources\nimport shutil\n\nconfig = {\n 'env_id': 'align_rudder:EightRooms-v0', # environment for the experiment\n 'exp_name': 'align-rudder', # name of the experiment\n 'gamma': 1.0, # Discount factor for q learning algorithm\n 'total_timesteps': 10000000,\n 'max_episodes': 100000,\n 'learning_rate': 0.1,\n 'epsilon': 0.2, # exploration constant\n 'num_seq_store': 10, # max sequences to use for alignment or storing\n 'num_clusters': 15, # Number of clusters to use in k-means\n 'consensus_thresh': 0.9, # Threshold for consensus\n 'eval': 40,\n 'top_n': 12,\n 'rudder': True, # Use rudder or not\n 'mode': 'log', # 'log' or 'exp'\n 'stop_criteria': '80opt',\n 'enough_seq': 3, # How many sequences are enough for sequence alignment\n 'num_demo_use': tune.grid_search([2, 5, 10, 50, 100]), # number of demonstrations\n 'consensus_type': 'all', # Select between most common or threshold all sequences: all, most_common\n 'cluster_type': 'AP', # Use default clustering, SpectralClustering, AffinityPropogation: default, SC, AP\n 'seed': tune.grid_search([i for i in range(10)]), # Seed for experiment\n 'anneal_eps': 1.0, # annealing rate for exploration\n 'eps_lb': 0.0, # eps anneal lower bound\n 'rr_thresh': 0.005, # Inverse visitation freq below thresh, set rr to zero\n 'log_every': 10, # log every timesteps\n 'normalise_rr_by_max': True, # normalize rr by maximum reward in rr\n 'normalisation_scale': 10, # scale factor compared to original reward\n 'use_succ': True,\n 'use_demo': True,\n 'demo_path': 'demonstrations/eight_rooms.npy',\n 'update_alignment:': False,\n 'max_reward': 1,\n 'use_exp_replay': False,\n 'memory_len': 30000,\n 'init_mean': False,\n 'use_new_form': True\n}\n\n\ndef run(config):\n run_path = os.getcwd()\n env_id = config['env_id']\n env = gym.make(env_id)\n # set seed\n np.random.seed(config['seed'])\n random.seed(config['seed'])\n demo_path = pkg_resources.resource_filename(\"align_rudder\", config[\"demo_path\"])\n\n rl = Qlearning(env=env, eps=config['epsilon'], alpha=config['learning_rate'],\n total_timesteps=config['total_timesteps'],\n num_store_seq=config['num_seq_store'], rudder=config['rudder'], enough_seq=config['enough_seq'],\n num_clusters=config['num_clusters'], top_n=config['top_n'],\n consensus_type=config['consensus_type'],\n consensus_thresh=config['consensus_thresh'], cluster_type=config['cluster_type'],\n run_path=run_path,\n anneal_eps=config['anneal_eps'], eps_lb=config['eps_lb'], rr_thresh=config['rr_thresh'],\n log_every=config['log_every'], normalise_rr_by_max=config['normalise_rr_by_max'],\n normalisation_scale=config['normalisation_scale'], use_succ=config['use_succ'],\n use_demo=config['use_demo'],\n demo_path=demo_path,\n num_demo_use=config['num_demo_use'],\n max_episodes=config['max_episodes'], max_reward=config['max_reward'],\n mode=config['mode'],\n gamma=config['gamma'], stop_criteria=config['stop_criteria'], seed=config['seed'],\n init_mean=config['init_mean'], use_new_form=config['use_new_form'])\n\n rl.learn()\n\n\nif __name__ == \"__main__\":\n # clear output dir\n if os.path.exists(os.path.join(\"results\", \"eight_rooms_alignrudder\")):\n shutil.rmtree(os.path.join(\"results\", \"eight_rooms_alignrudder\"))\n\n ray.init(temp_dir='/tmp/ray-eight-align', log_to_driver=False)\n print(\"Starting Runs...\")\n # run(config)\n tune.run(run, config=config, local_dir=\"results/\", name=\"eight_rooms_alignrudder\")\n print(\"Finished!\")\n",
"import os\nimport pkg_resources\nimport numpy as np\nimport random\nfrom ray import tune\nimport ray\nimport gym\nfrom align_rudder.learning.q_learning import Qlearning\nimport shutil\n\nconfig = {\n 'env_id': 'align_rudder:FourRooms-v0', # environment for the experiment\n 'exp_name': 'align-rudder-bc', # name of the experiment\n 'gamma': 1.0, # Discount factor for q learning algorithm\n 'total_timesteps': 10000000,\n 'max_episodes': 100000,\n 'learning_rate': 0.01,\n 'epsilon': 0.2, # exploration constant\n 'num_seq_store': 10, # max sequences to use for alignment or storing\n 'num_clusters': 10, # Number of clusters to use in k-means\n 'consensus_thresh': 0.9, # Threshold for consensus\n 'eval': 40,\n 'top_n': 12,\n 'rudder': False, # Use rudder or not\n 'mode': 'log',\n 'stop_criteria': '80opt',\n 'enough_seq': 3, # How many sequences are enough for sequence alignment\n 'num_demo_use': tune.grid_search([2, 5, 10, 50, 100]), # number of demonstrations\n 'consensus_type': 'all', # Select between most common or threshold all sequences: all, most_common\n 'cluster_type': 'AP', # Use default clustering, SpectralClustering, AffinityPropogation: default, SC, AP\n 'seed': tune.grid_search([i for i in range(10)]), # Seed for experiment\n 'anneal_eps': 1.0, # annealing rate for exploration\n 'eps_lb': 0.0, # eps anneal lower bound\n 'rr_thresh': 0.005, # Inverse visitation freq below thresh, set rr to zero\n 'log_every': 10, # log every timesteps\n 'normalise_rr_by_max': True, # normalize rr by maximum reward in rr\n 'normalisation_scale': 10, # scale factor compared to original reward\n 'use_succ': False,\n 'use_demo': True,\n 'demo_path': \"demonstrations/four_rooms.npy\",\n 'update_cluster_every': 500,\n 'update_alignment:': False,\n 'max_reward': 1,\n 'use_exp_replay': False,\n 'memory_len': 30000,\n 'init_mean': False\n}\n\n\ndef run(config):\n run_path = os.getcwd()\n env_id = config['env_id']\n env = gym.make(env_id)\n demo_path = pkg_resources.resource_filename(\"align_rudder\", config[\"demo_path\"])\n # set seed\n np.random.seed(config['seed'])\n random.seed(config['seed'])\n\n rl = Qlearning(env=env, eps=config['epsilon'], alpha=config['learning_rate'],\n total_timesteps=config['total_timesteps'],\n num_store_seq=config['num_seq_store'], rudder=config['rudder'], enough_seq=config['enough_seq'],\n num_clusters=config['num_clusters'], top_n=config['top_n'],\n consensus_type=config['consensus_type'],\n consensus_thresh=config['consensus_thresh'], cluster_type=config['cluster_type'],\n run_path=run_path,\n anneal_eps=config['anneal_eps'], eps_lb=config['eps_lb'], rr_thresh=config['rr_thresh'],\n log_every=config['log_every'], normalise_rr_by_max=config['normalise_rr_by_max'],\n normalisation_scale=config['normalisation_scale'], eval=config['eval'], use_succ=config['use_succ'],\n use_demo=config['use_demo'],\n demo_path=demo_path,\n num_demo_use=config['num_demo_use'],\n max_episodes=config['max_episodes'], max_reward=config['max_reward'],\n mode=config['mode'],\n gamma=config['gamma'], stop_criteria=config['stop_criteria'], seed=config['seed'],\n init_mean=config['init_mean'])\n rl.learn()\n\n\nif __name__ == \"__main__\":\n # clear output dir\n if os.path.exists(os.path.join(\"results\", \"four_rooms_bc\")):\n shutil.rmtree(os.path.join(\"results\", \"four_rooms_bc\"))\n\n ray.init(temp_dir='/tmp/ray-four-bc', log_to_driver=False)\n print(\"Starting Runs...\")\n tune.run(run, config=config, local_dir=\"results/\", name=\"four_rooms_bc\", resources_per_trial={'cpu': 1})\n print(\"Finished!\")\n"
]
| [
[
"numpy.random.seed"
],
[
"numpy.random.seed"
]
]
|
lisadunlap/explainable-nbdt | [
"e045bfd0b55b21fd87c9a233b73a0ca77672efff"
]
| [
"nbdt/utils.py"
]
| [
"'''Some helper functions for PyTorch, including:\n - get_mean_and_std: calculate the mean and std value of dataset.\n - msr_init: net parameter initialization.\n - progress_bar: progress bar mimic xlua.progress.\n'''\nimport os\nimport sys\nimport time\nimport math\nimport numpy as np\nfrom numpy import linalg as LA\n\nimport torch\nimport torch.nn as nn\nimport torch.nn.init as init\nimport torchvision.transforms as transforms\nfrom gensim.models import Word2Vec\n\nfrom pathlib import Path\n\n# tree-generation consntants\nMETHODS = ('prune', 'wordnet', 'random', 'image', 'induced', 'self-induced', 'clustered', 'extra_paths', 'weighted',\n 'replace_node', 'insert_node', 'induced-attributes', 'prettify')\nDATASETS = ('CIFAR10', 'CIFAR10IncludeClasses', 'CIFAR100', 'TinyImagenet200', 'TinyImagenet200IncludeClasses', 'Imagenet1000',\n 'TinyImagenet200CombineClasses', 'MiniPlaces', 'AnimalsWithAttributes2', 'CUB2011', 'MiniImagenet')\n\nDATASET_TO_FOLDER_NAME = {\n 'CIFAR10': 'CIFAR10',\n 'CIFAR10ExcludeLabels': 'CIFAR10-zeroshot',\n 'CIFAR10ExcludeClasses': 'CIFAR10',\n 'CIFAR10IncludeLabels': 'CIFAR10-zeroshot',\n 'CIFAR10IncludeClasses': 'CIFAR10',\n 'CIFAR100': 'CIFAR100',\n 'TinyImagenet200': 'tiny-imagenet-200',\n 'TinyImagenet200IncludeClasses': 'tiny-imagenet-200-custom',\n 'Imagenet1000' : 'imagenet-1000',\n 'TinyImagenet200CombineClasses': 'tiny-imagenet-200-custom-combined',\n 'MiniPlaces': 'miniplaces',\n 'AnimalsWithAttributes2': 'Animals_with_Attributes2',\n 'CUB2011': 'CUB_200_2011',\n 'MiniImagenet': 'mini-imagenet'\n}\n\n# main script constants\nCIFAR10PATHSANITY = 'CIFAR10PathSanity'\n\nDEFAULT_CIFAR10_TREE = './data/CIFAR10/graph-wordnet-single.json'\nDEFAULT_CIFAR10_WNIDS = './data/CIFAR10/wnids.txt'\nDEFAULT_CIFAR100_TREE = './data/CIFAR100/graph-wordnet-single.json'\nDEFAULT_CIFAR100_WNIDS = './data/CIFAR100/wnids.txt'\nDEFAULT_TINYIMAGENET200_TREE = './data/tiny-imagenet-200/graph-wordnet-single.json'\nDEFAULT_TINYIMAGENET200_WNIDS = './data/tiny-imagenet-200/wnids.txt'\nDEFAULT_IMAGENET1000_TREE = './data/imagenet-1000/graph-wordnet-single.json'\nDEFAULT_IMAGENET1000_WNIDS = './data/imagenet-1000/wnids.txt'\nDEFAULT_MINIPLACES_TREE = '/data/miniplaces/graph-default.json'\nDEFAULT_MINIPLACES_WNID = './data/miniplaces/wnids.txt'\nDEFAULT_AWA2_TREE = '/data/Animals_with_Attributes2/graph-default.json'\nDEFAULT_AWA2_WNID = './data/Animals_with_Attributes2/wnids.txt'\nDEFAULT_CUB_TREE = '/data/CUB_200_2011/graph-default.json'\nDEFAULT_CUB_WNID = './data/CUB_200_2011/wnids.txt'\nDEFAULT_MiniImagenet_TREE = './data/mini-imagenet/graph-default.json'\nDEFAULT_MiniImagenet_WNID = './data/mini-imagenet/wnids.txt'\n\n\nDATASET_TO_PATHS = {\n 'CIFAR10': {\n 'path_graph': DEFAULT_CIFAR10_TREE,\n 'path_wnids': DEFAULT_CIFAR10_WNIDS\n },\n 'CIFAR100': {\n 'path_graph': DEFAULT_CIFAR100_TREE,\n 'path_wnids': DEFAULT_CIFAR100_WNIDS\n },\n 'TinyImagenet200': {\n 'path_graph': DEFAULT_TINYIMAGENET200_TREE,\n 'path_wnids': DEFAULT_TINYIMAGENET200_WNIDS\n },\n 'Imagenet1000': {\n 'path_graph': DEFAULT_IMAGENET1000_TREE,\n 'path_wnids': DEFAULT_IMAGENET1000_WNIDS\n },\n 'MiniPlaces': {\n 'path_graph': DEFAULT_MINIPLACES_TREE,\n 'path_wnids': DEFAULT_MINIPLACES_WNID\n },\n 'AnimalsWithAttributes2': {\n 'path_graph': DEFAULT_AWA2_TREE,\n 'path_wnids': DEFAULT_AWA2_WNID\n },\n 'CUB2011': {\n 'path_graph': DEFAULT_CUB_TREE,\n 'path_wnids': DEFAULT_CUB_WNID\n },\n 'MiniImagenet': {\n 'path_graph': DEFAULT_MiniImagenet_TREE,\n 'path_wnids': DEFAULT_MiniImagenet_WNID\n }\n}\n\nWORD2VEC_NAMES_TO_MODEL = {\n 'wiki': {\n 'name': 'glove-wiki-gigaword-300',\n 'dim': 300\n },\n 'wiki-300': {\n 'name': 'glove-wiki-gigaword-300',\n 'dim': 300\n },\n 'wiki-200': {\n 'name': 'glove-wiki-gigaword-200',\n 'dim': 200\n },\n 'wiki-100': {\n 'name': 'glove-wiki-gigaword-100',\n 'dim': 100\n },\n 'wiki-50': {\n 'name': 'glove-wiki-gigaword-50',\n 'dim': 50\n },\n\n 'twitter': {\n 'name': 'glove-twitter-200',\n 'dim': 200\n }\n}\n\ndef populate_kwargs(args, kwargs, object, name='Dataset', keys=(), globals={}):\n for key in keys:\n accepts_key = getattr(object, f'accepts_{key}', False)\n if not accepts_key:\n continue\n assert key in args or callable(accepts_key)\n\n value = getattr(args, key, None)\n if callable(accepts_key):\n kwargs[key] = accepts_key(**globals)\n Colors.cyan(f'{key}:\\t(callable)')\n elif accepts_key and value:\n kwargs[key] = value\n Colors.cyan(f'{key}:\\t{value}')\n elif value:\n Colors.red(\n f'Warning: {name} does not support custom '\n f'{key}: {value}')\n\n\ndef get_transform_from_name(dataset_name, dataset, input_size):\n transform_train = transforms.Compose([\n transforms.RandomCrop(32, padding=4),\n transforms.RandomHorizontalFlip(),\n transforms.ToTensor(),\n transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),\n ])\n\n transform_test = transforms.Compose([\n transforms.ToTensor(),\n transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),\n ])\n\n # , 'TinyImagenet200IncludeClasses'\n if dataset_name in ('TinyImagenet200', 'Imagenet1000', 'CUB2011'):\n default_input_size = 64 if 'TinyImagenet200' in dataset_name else 224\n input_size = input_size or default_input_size\n transform_train = dataset.transform_train(input_size)\n transform_test = dataset.transform_val(input_size)\n\n if dataset_name in ('MiniImagenet'):\n default_input_size = 84\n input_size = input_size or default_input_size\n transform_train = dataset.transform_train(input_size)\n transform_test = dataset.transform_val(input_size)\n # transform_train = transforms.Compose([\n # transforms.Resize(84),\n # transforms.RandomCrop(84, padding=8),\n # transforms.RandomHorizontalFlip(),\n # transforms.ToTensor(),\n # transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)),\n # ])\n # transform_test = transforms.Compose([\n # transforms.ToTensor(),\n # transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)),\n # ])\n\n if dataset_name in ('MiniPlaces', 'AnimalsWithAttributes2'):\n transform_train = dataset.transform_train()\n transform_test = dataset.transform_test()\n\n\n return transform_train, transform_test\n\n\nclass Colors:\n RED = '\\x1b[31m'\n GREEN = '\\x1b[32m'\n ENDC = '\\033[0m'\n BOLD = '\\033[1m'\n CYAN = '\\x1b[36m'\n\n @classmethod\n def red(cls, *args):\n print(cls.RED + args[0], *args[1:], cls.ENDC)\n\n @classmethod\n def green(cls, *args):\n print(cls.GREEN + args[0], *args[1:], cls.ENDC)\n\n @classmethod\n def cyan(cls, *args):\n print(cls.CYAN + args[0], *args[1:], cls.ENDC)\n\n @classmethod\n def bold(cls, *args):\n print(cls.BOLD + args[0], *args[1:], cls.ENDC)\n\n\ndef get_mean_and_std(dataset):\n '''Compute the mean and std value of dataset.'''\n dataloader = torch.utils.data.DataLoader(dataset, batch_size=1, shuffle=True, num_workers=2)\n mean = torch.zeros(3)\n std = torch.zeros(3)\n print('==> Computing mean and std..')\n for inputs, targets in dataloader:\n for i in range(3):\n mean[i] += inputs[:,i,:,:].mean()\n std[i] += inputs[:,i,:,:].std()\n mean.div_(len(dataset))\n std.div_(len(dataset))\n return mean, std\n\ndef init_params(net):\n '''Init layer parameters.'''\n for m in net.modules():\n if isinstance(m, nn.Conv2d):\n init.kaiming_normal(m.weight, mode='fan_out')\n if m.bias:\n init.constant(m.bias, 0)\n elif isinstance(m, nn.BatchNorm2d):\n init.constant(m.weight, 1)\n init.constant(m.bias, 0)\n elif isinstance(m, nn.Linear):\n init.normal(m.weight, std=1e-3)\n if m.bias:\n init.constant(m.bias, 0)\n\n\ntry:\n _, term_width = os.popen('stty size', 'r').read().split()\n term_width = int(term_width)\nexcept Exception as e:\n print(e)\n term_width = 50\n\nTOTAL_BAR_LENGTH = 65.\nlast_time = time.time()\nbegin_time = last_time\ndef progress_bar(current, total, msg=None):\n global last_time, begin_time\n if current == 0:\n begin_time = time.time() # Reset for new bar.\n\n cur_len = int(TOTAL_BAR_LENGTH*current/total)\n rest_len = int(TOTAL_BAR_LENGTH - cur_len) - 1\n\n sys.stdout.write(' [')\n for i in range(cur_len):\n sys.stdout.write('=')\n sys.stdout.write('>')\n for i in range(rest_len):\n sys.stdout.write('.')\n sys.stdout.write(']')\n\n cur_time = time.time()\n step_time = cur_time - last_time\n last_time = cur_time\n tot_time = cur_time - begin_time\n\n L = []\n L.append(' Step: %s' % format_time(step_time))\n L.append(' | Tot: %s' % format_time(tot_time))\n if msg:\n L.append(' | ' + msg)\n\n msg = ''.join(L)\n sys.stdout.write(msg)\n for i in range(term_width-int(TOTAL_BAR_LENGTH)-len(msg)-3):\n sys.stdout.write(' ')\n\n # Go back to the center of the bar.\n for i in range(term_width-int(TOTAL_BAR_LENGTH/2)+2):\n sys.stdout.write('\\b')\n sys.stdout.write(' %d/%d ' % (current+1, total))\n\n if current < total-1:\n sys.stdout.write('\\r')\n else:\n sys.stdout.write('\\n')\n sys.stdout.flush()\n\ndef format_time(seconds):\n days = int(seconds / 3600/24)\n seconds = seconds - days*3600*24\n hours = int(seconds / 3600)\n seconds = seconds - hours*3600\n minutes = int(seconds / 60)\n seconds = seconds - minutes*60\n secondsf = int(seconds)\n seconds = seconds - secondsf\n millis = int(seconds*1000)\n\n f = ''\n i = 1\n if days > 0:\n f += str(days) + 'D'\n i += 1\n if hours > 0 and i <= 2:\n f += str(hours) + 'h'\n i += 1\n if minutes > 0 and i <= 2:\n f += str(minutes) + 'm'\n i += 1\n if secondsf > 0 and i <= 2:\n f += str(secondsf) + 's'\n i += 1\n if millis > 0 and i <= 2:\n f += str(millis) + 'ms'\n i += 1\n if f == '':\n f = '0ms'\n return f\n\n\ndef set_np_printoptions():\n np.set_printoptions(formatter={'float': lambda x: \"{0:0.3f}\".format(x)})\n\n\ndef generate_fname(dataset, model, path_graph, wnid=None, name='',\n trainset=None, include_labels=(), exclude_labels=(),\n include_classes=(), num_samples=0, max_leaves_supervised=-1,\n min_leaves_supervised=-1, tree_supervision_weight=0.5,\n weighted_average=False, fine_tune=False,\n loss='CrossEntropyLoss', word2vec=False, **kwargs):\n fname = 'ckpt'\n fname += '-' + dataset\n fname += '-' + model\n if name:\n fname += '-' + name\n if path_graph:\n path = Path(path_graph)\n fname += '-' + path.stem.replace('graph-', '', 1)\n if include_labels:\n labels = \",\".join(map(str, include_labels))\n fname += f'-incl{labels}'\n if exclude_labels:\n labels = \",\".join(map(str, exclude_labels))\n fname += f'-excl{labels}'\n if include_classes:\n labels = \",\".join(map(str, include_classes))\n fname += f'-incc{labels}'\n if num_samples != 0 and num_samples is not None:\n fname += f'-samples{num_samples}'\n if loss != 'CrossEntropyLoss':\n fname += f'-{loss}'\n if max_leaves_supervised > 0:\n fname += f'-mxls{max_leaves_supervised}'\n if min_leaves_supervised > 0:\n fname += f'-mnls{min_leaves_supervised}'\n if tree_supervision_weight is not None and tree_supervision_weight != 1:\n fname += f'-tsw{tree_supervision_weight}'\n if weighted_average:\n fname += '-weighted'\n if word2vec:\n fname += '-word2vec'\n return fname\n\ndef get_saved_word2vec(path, dimension, projection_matrix):\n word_vec = np.load(path)\n word_vec = np.asarray(word_vec).reshape(1, dimension)\n word_vec = np.matmul(word_vec, projection_matrix)[0]\n return np.array(word_vec / LA.norm(word_vec), dtype=float)\n\ndef get_word_embedding(cls, trainset, dataset_name='CIFAR10'):\n word2vec_path = os.path.join(os.path.join(trainset.root, DATASET_TO_FOLDER_NAME[dataset_name]), \"word2vec/\")\n word_vec = np.load(word2vec_path + cls + '.npy')\n return word_vec/LA.norm(word_vec)\n\n\ndef word2vec_model(net, trainset, dataset_name='CIFAR10', exclude_classes=None, pretrained=False):\n \"\"\" Sets FC layer weights to word2vec embeddings, freezing them unless\n exclude classes is given, in which case those specific rows are frozen in\n the backward call\"\"\"\n\n print('==> Adding in word2vec embeddings...')\n if isinstance(net, nn.DataParallel):\n module = net.module\n else:\n module = net\n if pretrained:\n layer = module.fc\n else:\n layer = module.linear\n word2vec_path = os.path.join(os.path.join('./data',DATASET_TO_FOLDER_NAME[dataset_name]), \"word2vec/\")\n if not os.path.exists(word2vec_path):\n raise Exception(\"No saved word2vec embeddings, run generate_word2vec.py\")\n fc_weights = []\n\n for i, cls in enumerate(trainset.classes):\n word_vec = np.load(word2vec_path+cls+'.npy')\n word_vec /= LA.norm(word_vec)\n print(word_vec.shape, len(fc_weights))\n fc_weights = np.append(fc_weights, word_vec)\n print(fc_weights.shape)\n print(trainset.classes, fc_weights.shape)\n fc_weights = fc_weights.reshape((len(trainset.classes), int(fc_weights.shape[0]/len(trainset.classes))))\n layer = nn.Linear(fc_weights.shape[1], len(trainset.classes)).to(\"cuda\")\n layer.weight = nn.Parameter(torch.from_numpy(fc_weights).float().to(\"cuda\"))\n # Colors.cyan(\"All word2vec checks passed!\")\n\n # freeze layer\n layer.weight.requires_grad = False\n layer.bias.requires_grad = False\n layer.requires_grad = False\n Colors.cyan(\"Freezing FC weights..\")\n return net\n\ndef test_word2vec(net, trainset, dataset_name='CIFAR10', exclude_classes=None, dimension=300):\n \"\"\" Check that word2vec weights are frozen in ZS rows \"\"\"\n word2vec_path = os.path.join(os.path.join('./data', DATASET_TO_FOLDER_NAME[dataset_name]), \"word2vec/\")\n if not os.path.exists(word2vec_path):\n raise Exception(\"No saved word2vec embeddings, run generate_word2vec.py\")\n\n net.eval()\n\n # get FC weights\n fc_weights = net.module.linear.weight.detach().cpu().numpy()\n\n # if no exclude classes, all FC rows should be word2vec embeddings\n if not exclude_classes:\n for i, cls in enumerate(trainset.classes):\n word_vec = word_vec = np.load(word2vec_path+cls+'.npy')\n assert all(fc_weights[i] == word_vec)\n else:\n for i, cls in enumerate(exclude_classes):\n word_vec = word_vec = np.load(word2vec_path+cls+'.npy')\n assert all(fc_weights[i] == word_vec)\n Colors.cyan(\"Freezing certain FC rows check passed!\")\n\ndef normalize_weights(net, pretrained=True):\n \"\"\" Check that word2vec weights are frozen in ZS rows \"\"\"\n net.eval()\n\n if pretrained:\n layer = net.module.fc\n else:\n layer = net.module.linear\n\n # get FC weights\n fc_weights = layer.weight.detach().cpu().numpy()\n for i in range(len(fc_weights)):\n fc_weights[i] -= np.mean(fc_weights[i])\n fc_weights[i] /= LA.norm(fc_weights[i])\n layer.weight = nn.Parameter(torch.from_numpy(fc_weights).float().to(\"cuda\"))\n layer.weight.requires_grad = False\n return net\n\nclass LabelSmoothingLoss(nn.Module):\n def __init__(self, classes, smoothing=0.0, dim=-1, seen_to_zsl_cls={}):\n super(LabelSmoothingLoss, self).__init__()\n self.confidence = 1.0 - smoothing\n self.smoothing = smoothing\n self.cls = classes\n self.dim = dim\n self.seen_to_zsl_cls = seen_to_zsl_cls\n\n def smooth_one_hot(self, labels):\n \"\"\" Create Soft Label \"\"\"\n assert 0 <= self.smoothing < 1\n num_classes = len(self.cls)\n label_shape = torch.Size((labels.size(0), num_classes))\n confidence = 1.0 - self.smoothing\n\n if self.smoothing == 0 or not self.seen_to_zsl_cls:\n return torch.zeros_like(label_shape).scatter_(1, labels.data.unsqueeze(1), confidence)\n\n with torch.no_grad():\n true_dist = torch.zeros(size=label_shape, device=labels.device)\n true_dist.scatter_(1, labels.data.unsqueeze(1), 1)\n for seen, zsl in self.seen_to_zsl_cls.items():\n zsl_idx, seen_idx = self.cls.index(zsl), self.cls.index(seen)\n seen_selector = torch.zeros_like(labels.data.unsqueeze(1))\n seen_selector[true_dist[:, seen_idx] == 1] = seen_idx\n zsl_selector = torch.zeros_like(labels.data.unsqueeze(1))\n zsl_selector[true_dist[:, seen_idx] == 1] = zsl_idx\n true_dist.scatter_(1, seen_selector, confidence)\n true_dist.scatter_(1, zsl_selector, self.smoothing)\n return true_dist\n\n def forward(self, pred, target):\n pred = pred.log_softmax(dim=self.dim)\n with torch.no_grad():\n # true_dist = pred.data.clone()\n soft_label = self.smooth_one_hot(target)\n return torch.mean(torch.sum(-soft_label * pred, dim=self.dim))\n\nclass MaskLoss(nn.Module):\n def __init__(self, size_average=None, reduce=None, reduction='mean'):\n super(MaskLoss, self).__init__()\n self.reduction = reduction\n\n def forward(self, input, target):\n N, W = input.size()\n A = torch.min(input, target)\n values, index = torch.max(target, 0)\n B = 1/(1+torch.exp(-100*(target-.55*values)))\n sums = []\n for n in range(N):\n value = values[n]\n idx = index[n]\n tar = target[n]\n inp = input[n]\n a = torch.min(inp, tar)\n b = 1/(1+torch.exp(-100*(tar-.55*value)))\n sums.append(2*torch.div(torch.dot(a,b), torch.sum(inp+target, axis=-1)))\n sums = torch.stack(sums)\n sums[torch.isnan(sums)] = 0.0\n # return torch.mean(2*torch.div(torch.bmm(A.view(N, 1, W), B.view(N, W, 1)).view(1, N),\n # torch.sum(input+target, axis=-1)), dim=-1)\n return sums.mean()\n\ndef replicate(inputs, labels):\n \"\"\"\n inputs: torch Tensor size Bx(anything)\n labels: torch tensor size Bx(num_classes)\n (multilabel, where labels[i,j] is 1 if image i has class j, 0 otherwise)\n Return:\n rep_inputs size Kx(anything), where K is the number of 1's that appeared in all labels\n rep_labels size Kx1, where rep_labels[i] is a class number that appeared in images[i]\n Example:\n inputs = torch.zeros((2,3))\n labels = torch.Tensor([\n [0,1,1,0],\n [0,1,0,0]\n ])\n rep_inputs, rep_labels = replicate(inputs, labels)\n assert rep_inputs.shape == (3,3)\n assert torch.all(rep_labels == torch.Tensor([1,2,1]))\n \"\"\"\n input_dim = len(inputs.shape)\n rep_inputs, rep_labels = None, None\n for (sample, label) in zip(inputs,labels):\n if rep_inputs is None:\n rep_labels = torch.where(label == 1.)[0]\n rep_inputs = sample.unsqueeze(0).repeat(len(rep_labels),*([1] * (input_dim-1)))\n else:\n new_rep_labels = torch.where(label == 1.)[0]\n new_reps = sample.unsqueeze(0).repeat(len(new_rep_labels),*([1] * (input_dim-1)))\n rep_labels = torch.cat((rep_labels, new_rep_labels))\n rep_inputs = torch.cat((rep_inputs, new_reps))\n return rep_inputs, rep_labels\n\ndef replicate_outputs(inputs, num_replicate):\n \"\"\"\n inputs: torch Tensor size Bx(anything)\n labels: torch tensor size Bx(num_classes)\n (multilabel, where labels[i,j] is 1 if image i has class j, 0 otherwise)\n Return:\n rep_inputs size Kx(anything), where K is the number of 1's that appeared in all labels\n rep_labels size Kx1, where rep_labels[i] is a class number that appeared in images[i]\n Example:\n inputs = torch.zeros((2,3))\n labels = torch.Tensor([\n [0,1,1,0],\n [0,1,0,0]\n ])\n rep_inputs, rep_labels = replicate(inputs, labels)\n assert rep_inputs.shape == (3,3)\n assert torch.all(rep_labels == torch.Tensor([1,2,1]))\n \"\"\"\n ret = {i:None for i in range(num_replicate)}\n for i in range(num_replicate):\n ret[i] = inputs.clone()\n return ret"
]
| [
[
"torch.cat",
"torch.stack",
"torch.nn.init.constant",
"torch.isnan",
"numpy.load",
"torch.nn.init.kaiming_normal",
"numpy.mean",
"torch.exp",
"torch.where",
"torch.sum",
"numpy.linalg.norm",
"torch.utils.data.DataLoader",
"numpy.append",
"torch.zeros_like",
"torch.zeros",
"numpy.matmul",
"torch.min",
"torch.max",
"torch.nn.init.normal",
"numpy.asarray",
"torch.no_grad",
"torch.from_numpy",
"torch.dot"
]
]
|
antoineMoPa/glumpy | [
"901df7eb37cd728c2fe7e54920392b700b46c0ac",
"901df7eb37cd728c2fe7e54920392b700b46c0ac"
]
| [
"examples/gloo-arrows.py",
"glumpy/app/console.py"
]
| [
"# -----------------------------------------------------------------------------\n# Copyright (c) 2009-2016 Nicolas P. Rougier. All rights reserved.\n# Distributed under the (new) BSD License.\n# -----------------------------------------------------------------------------\nimport numpy as np\nfrom glumpy import app, gl, gloo\nfrom glumpy.transforms import Position, OrthographicProjection, PanZoom\n\n# Create window\nwindow = app.Window(width=2*512, height=512, color=(1,1,1,1))\n\n# What to draw when necessary\[email protected]\ndef on_draw(dt):\n window.clear()\n program.draw(gl.GL_POINTS)\n program['orientation'][-1] += np.pi/1024.0\n\n# Setup some markers\nn = 500+1\ndata = np.zeros(n, dtype=[('position', np.float32, 2),\n ('fg_color', np.float32, 4),\n ('bg_color', np.float32, 4),\n ('size', np.float32, 1),\n ('head', np.float32, 1),\n ('orientation', np.float32, 1),\n ('linewidth', np.float32, 1)])\ndata = data.view(gloo.VertexBuffer)\ndata['linewidth'] = 1\ndata['fg_color'] = 0, 0, 0, 1\ndata['bg_color'] = 0, 0, 0, 1\ndata['orientation'] = 0\ndata['head'] = 0.25\nradius, theta, dtheta = 245.0, 0.0, 6.5 / 180.0 * np.pi\nfor i in range(500):\n theta += dtheta\n x = 256 + radius * np.cos(theta)\n y = 256 + radius * np.sin(theta)\n r = 10.1 - i * 0.01\n radius -= 0.4\n data['orientation'][i] = theta + np.pi\n data['position'][i] = x, y\n data['size'][i] = 2 * r\n data['linewidth'][i] = 1.5 - 0.5*i/500.\n\ndata['position'][-1] = 512+256, 256\ndata['size'][-1] = 512/np.sqrt(2)\ndata['linewidth'][-1] = 16.0\ndata['fg_color'][-1] = 0, 0, 0, 1\ndata['bg_color'][-1] = .95, .95, .95, 1\ndata['orientation'][-1] = 0\n\nprogram = gloo.Program(\"arrows/arrow.vert\", \"arrows/arrow.frag\")\nprogram.bind(data)\nprogram['antialias'] = 1.00\nprogram['arrow'] = \"stealth\"\nprogram['paint'] = \"filled\"\ntransform = OrthographicProjection(Position(\"position\"))\nprogram['transform'] = transform\nwindow.attach(transform)\n\napp.run()\n",
"# -----------------------------------------------------------------------------\n# Copyright (c) 2009-2016 Nicolas P. Rougier. All rights reserved.\n# Distributed under the (new) BSD License.\n# -----------------------------------------------------------------------------\n\"\"\" Fast and failsafe GL console \"\"\"\nimport numpy as np\nfrom glumpy import gl, glm, gloo\n\n\n# Translated from\n# http://www.piclist.com/tecHREF/datafile/charset/extractor/charset_extractor.htm\n__font_6x8__ = np.array([\n (0x00,0x00,0x00,0x00,0x00,0x00), (0x10,0xE3,0x84,0x10,0x01,0x00),\n (0x6D,0xB4,0x80,0x00,0x00,0x00), (0x00,0xA7,0xCA,0x29,0xF2,0x80),\n (0x20,0xE4,0x0C,0x09,0xC1,0x00), (0x65,0x90,0x84,0x21,0x34,0xC0),\n (0x21,0x45,0x08,0x55,0x23,0x40), (0x30,0xC2,0x00,0x00,0x00,0x00),\n (0x10,0x82,0x08,0x20,0x81,0x00), (0x20,0x41,0x04,0x10,0x42,0x00),\n (0x00,0xA3,0x9F,0x38,0xA0,0x00), (0x00,0x41,0x1F,0x10,0x40,0x00),\n (0x00,0x00,0x00,0x00,0xC3,0x08), (0x00,0x00,0x1F,0x00,0x00,0x00),\n (0x00,0x00,0x00,0x00,0xC3,0x00), (0x00,0x10,0x84,0x21,0x00,0x00),\n (0x39,0x14,0xD5,0x65,0x13,0x80), (0x10,0xC1,0x04,0x10,0x43,0x80),\n (0x39,0x10,0x46,0x21,0x07,0xC0), (0x39,0x10,0x4E,0x05,0x13,0x80),\n (0x08,0x62,0x92,0x7C,0x20,0x80), (0x7D,0x04,0x1E,0x05,0x13,0x80),\n (0x18,0x84,0x1E,0x45,0x13,0x80), (0x7C,0x10,0x84,0x20,0x82,0x00),\n (0x39,0x14,0x4E,0x45,0x13,0x80), (0x39,0x14,0x4F,0x04,0x23,0x00),\n (0x00,0x03,0x0C,0x00,0xC3,0x00), (0x00,0x03,0x0C,0x00,0xC3,0x08),\n (0x08,0x42,0x10,0x20,0x40,0x80), (0x00,0x07,0xC0,0x01,0xF0,0x00),\n (0x20,0x40,0x81,0x08,0x42,0x00), (0x39,0x10,0x46,0x10,0x01,0x00),\n (0x39,0x15,0xD5,0x5D,0x03,0x80), (0x39,0x14,0x51,0x7D,0x14,0x40),\n (0x79,0x14,0x5E,0x45,0x17,0x80), (0x39,0x14,0x10,0x41,0x13,0x80),\n (0x79,0x14,0x51,0x45,0x17,0x80), (0x7D,0x04,0x1E,0x41,0x07,0xC0),\n (0x7D,0x04,0x1E,0x41,0x04,0x00), (0x39,0x14,0x17,0x45,0x13,0xC0),\n (0x45,0x14,0x5F,0x45,0x14,0x40), (0x38,0x41,0x04,0x10,0x43,0x80),\n (0x04,0x10,0x41,0x45,0x13,0x80), (0x45,0x25,0x18,0x51,0x24,0x40),\n (0x41,0x04,0x10,0x41,0x07,0xC0), (0x45,0xB5,0x51,0x45,0x14,0x40),\n (0x45,0x95,0x53,0x45,0x14,0x40), (0x39,0x14,0x51,0x45,0x13,0x80),\n (0x79,0x14,0x5E,0x41,0x04,0x00), (0x39,0x14,0x51,0x55,0x23,0x40),\n (0x79,0x14,0x5E,0x49,0x14,0x40), (0x39,0x14,0x0E,0x05,0x13,0x80),\n (0x7C,0x41,0x04,0x10,0x41,0x00), (0x45,0x14,0x51,0x45,0x13,0x80),\n (0x45,0x14,0x51,0x44,0xA1,0x00), (0x45,0x15,0x55,0x55,0x52,0x80),\n (0x45,0x12,0x84,0x29,0x14,0x40), (0x45,0x14,0x4A,0x10,0x41,0x00),\n (0x78,0x21,0x08,0x41,0x07,0x80), (0x38,0x82,0x08,0x20,0x83,0x80),\n (0x01,0x02,0x04,0x08,0x10,0x00), (0x38,0x20,0x82,0x08,0x23,0x80),\n (0x10,0xA4,0x40,0x00,0x00,0x00), (0x00,0x00,0x00,0x00,0x00,0x3F),\n (0x30,0xC1,0x00,0x00,0x00,0x00), (0x00,0x03,0x81,0x3D,0x13,0xC0),\n (0x41,0x07,0x91,0x45,0x17,0x80), (0x00,0x03,0x91,0x41,0x13,0x80),\n (0x04,0x13,0xD1,0x45,0x13,0xC0), (0x00,0x03,0x91,0x79,0x03,0x80),\n (0x18,0x82,0x1E,0x20,0x82,0x00), (0x00,0x03,0xD1,0x44,0xF0,0x4E),\n (0x41,0x07,0x12,0x49,0x24,0x80), (0x10,0x01,0x04,0x10,0x41,0x80),\n (0x08,0x01,0x82,0x08,0x24,0x8C), (0x41,0x04,0x94,0x61,0x44,0x80),\n (0x10,0x41,0x04,0x10,0x41,0x80), (0x00,0x06,0x95,0x55,0x14,0x40),\n (0x00,0x07,0x12,0x49,0x24,0x80), (0x00,0x03,0x91,0x45,0x13,0x80),\n (0x00,0x07,0x91,0x45,0x17,0x90), (0x00,0x03,0xD1,0x45,0x13,0xC1),\n (0x00,0x05,0x89,0x20,0x87,0x00), (0x00,0x03,0x90,0x38,0x13,0x80),\n (0x00,0x87,0x88,0x20,0xA1,0x00), (0x00,0x04,0x92,0x49,0x62,0x80),\n (0x00,0x04,0x51,0x44,0xA1,0x00), (0x00,0x04,0x51,0x55,0xF2,0x80),\n (0x00,0x04,0x92,0x31,0x24,0x80), (0x00,0x04,0x92,0x48,0xE1,0x18),\n (0x00,0x07,0x82,0x31,0x07,0x80), (0x18,0x82,0x18,0x20,0x81,0x80),\n (0x10,0x41,0x00,0x10,0x41,0x00), (0x30,0x20,0x83,0x08,0x23,0x00),\n (0x29,0x40,0x00,0x00,0x00,0x00), (0x10,0xE6,0xD1,0x45,0xF0,0x00)], dtype=np.float32)\n\n__vertex__ = \"\"\"\n#version 120\nuniform mat4 projection;\nuniform float scale;\nuniform vec4 color;\nattribute vec2 position;\nattribute vec3 bytes_012, bytes_345;\nvarying vec4 v_color;\nvarying vec3 v_bytes_012, v_bytes_345;\nvoid main (void)\n{\n gl_Position = projection*vec4(position*scale, 0.0, 1.0);\n gl_PointSize = 8.0 * scale;\n\n v_color = color;\n v_bytes_012 = bytes_012;\n v_bytes_345 = bytes_345;\n}\n\"\"\"\n\n__fragment__ = \"\"\"\n#version 120\nfloat segment(float edge0, float edge1, float x)\n{\n return step(edge0,x) * (1.0-step(edge1,x));\n}\nvarying vec4 v_color;\nvarying vec3 v_bytes_012, v_bytes_345;\nvoid main(void)\n{\n vec2 uv = floor(gl_PointCoord.xy * 8.0);\n if(uv.x > 5.0) discard;\n if(uv.y > 7.0) discard;\n float index = floor( (uv.y*6.0+uv.x)/8.0 );\n float offset = floor( mod(uv.y*6.0+uv.x,8.0));\n float byte = segment(0.0,1.0,index) * v_bytes_012.x\n + segment(1.0,2.0,index) * v_bytes_012.y\n + segment(2.0,3.0,index) * v_bytes_012.z\n + segment(3.0,4.0,index) * v_bytes_345.x\n + segment(4.0,5.0,index) * v_bytes_345.y\n + segment(5.0,6.0,index) * v_bytes_345.z;\n if( floor(mod(byte / (128.0/pow(2.0,offset)), 2.0)) > 0.0 )\n gl_FragColor = v_color;\n else\n discard;\n}\n\"\"\"\n\n\nclass Console(object):\n \"\"\" Fast and failsafe GL console \"\"\"\n\n def __init__(self, rows, cols, scale=2, color=(0,0,0,1)):\n\n # Harcoded because of font above and shader program\n self._cwidth = 6\n self._cheight = 8\n self._scale = int(max(scale,1))\n\n dtype = [(\"position\", np.float32, 2),\n (\"glyph\", np.float32, 6)]\n self._program = gloo.Program(__vertex__, __fragment__)\n self._data = np.zeros((rows,cols), dtype).view(gloo.VertexBuffer)\n dtype = [(\"position\", np.float32, 2),\n (\"bytes_012\", np.float32, 3),\n (\"bytes_345\", np.float32, 3)]\n self._program.bind(self._data.view(dtype))\n\n # Initialize glyph position (they won't move)\n C,R = np.meshgrid(np.arange(cols), np.arange(rows))\n self._data['position'][...,0] = 4.0 + self.cwidth*C\n self._data['position'][...,1] = 4.0 + self.cheight*R\n\n self._program['scale'] = self._scale\n self._program['color'] = color\n self._rows, self._cols = rows, cols\n self._row = 0\n\n\n @property\n def scale(self):\n return self._scale\n\n\n @property\n def rows(self):\n return self._rows\n\n\n @property\n def cols(self):\n return self._cols\n\n\n @property\n def cwidth(self):\n return self._cwidth\n\n\n @property\n def cheight(self):\n return self._cheight + 2\n\n\n def on_resize(self, width, height):\n \"\"\" Update console projection \"\"\"\n\n self._program[\"projection\"] = glm.ortho(0, width, height, 0, -1, +1)\n\n\n def draw(self):\n \"\"\" Draw console \"\"\"\n\n self._program.draw(gl.GL_POINTS)\n\n\n def clear(self):\n \"\"\" Clear console \"\"\"\n\n self._data[\"glyph\"] = 0\n self._row = 0\n\n\n def write(self, text=\"\"):\n \"\"\" Write text and scroll \"\"\"\n\n # Clear line\n self._data[\"glyph\"][self._row] = 0\n\n if len(text):\n # Crop text if necessary\n text = text[:self._cols]\n # Write text\n I = np.array([ord(c)-32 for c in text])\n self._data[\"glyph\"][self._row,:len(text)] = __font_6x8__[I]\n\n # Update row and scroll if necessary\n self._row += 1\n if self._row > self._rows-1:\n self._data[\"glyph\"][:-n] = self._data[\"glyph\"][n:]\n self._data[\"glyph\"][-n:] = 0\n self._row = self._rows-1\n"
]
| [
[
"numpy.sin",
"numpy.sqrt",
"numpy.zeros",
"numpy.cos"
],
[
"numpy.array",
"numpy.arange",
"numpy.zeros"
]
]
|
fdeugenio/photutils | [
"33c8b15cbbda85dc11c86a73217422dcb61398b7",
"33c8b15cbbda85dc11c86a73217422dcb61398b7",
"33c8b15cbbda85dc11c86a73217422dcb61398b7"
]
| [
"photutils/aperture/mask.py",
"photutils/psf/tests/test_photometry.py",
"photutils/psf/tests/test_epsf.py"
]
| [
"# Licensed under a 3-clause BSD style license - see LICENSE.rst\n\nimport numpy as np\nimport astropy.units as u\n\n\n__all__ = ['ApertureMask']\n\n\nclass ApertureMask:\n \"\"\"\n Class for an aperture mask.\n\n Parameters\n ----------\n data : array_like\n A 2D array representing the fractional overlap of an aperture on\n the pixel grid. This should be the full-sized (i.e. not\n truncated) array that is the direct output of one of the\n low-level `photutils.geometry` functions.\n\n bbox : `photutils.BoundingBox`\n The bounding box object defining the aperture minimal bounding\n box.\n \"\"\"\n\n def __init__(self, data, bbox):\n self.data = np.asanyarray(data)\n if self.data.shape != bbox.shape:\n raise ValueError('mask data and bounding box must have the same '\n 'shape')\n self.bbox = bbox\n self._mask = (self.data == 0)\n\n def __array__(self):\n \"\"\"\n Array representation of the mask data array (e.g., for matplotlib).\n \"\"\"\n\n return self.data\n\n @property\n def shape(self):\n \"\"\"\n The shape of the mask data array.\n \"\"\"\n\n return self.data.shape\n\n def _overlap_slices(self, shape):\n \"\"\"\n Calculate the slices for the overlapping part of the bounding\n box and an array of the given shape.\n\n Parameters\n ----------\n shape : tuple of int\n The ``(ny, nx)`` shape of array where the slices are to be\n applied.\n\n Returns\n -------\n slices_large : tuple of slices\n A tuple of slice objects for each axis of the large array,\n such that ``large_array[slices_large]`` extracts the region\n of the large array that overlaps with the small array.\n\n slices_small : slice\n A tuple of slice objects for each axis of the small array,\n such that ``small_array[slices_small]`` extracts the region\n of the small array that is inside the large array.\n \"\"\"\n\n if len(shape) != 2:\n raise ValueError('input shape must have 2 elements.')\n\n xmin = self.bbox.ixmin\n xmax = self.bbox.ixmax\n ymin = self.bbox.iymin\n ymax = self.bbox.iymax\n\n if xmin >= shape[1] or ymin >= shape[0] or xmax <= 0 or ymax <= 0:\n # no overlap of the aperture with the data\n return None, None\n\n slices_large = (slice(max(ymin, 0), min(ymax, shape[0])),\n slice(max(xmin, 0), min(xmax, shape[1])))\n\n slices_small = (slice(max(-ymin, 0),\n min(ymax - ymin, shape[0] - ymin)),\n slice(max(-xmin, 0),\n min(xmax - xmin, shape[1] - xmin)))\n\n return slices_large, slices_small\n\n def _to_image_partial_overlap(self, image):\n \"\"\"\n Return an image of the mask in a 2D array, where the mask\n is not fully within the image (i.e. partial or no overlap).\n \"\"\"\n\n # find the overlap of the mask on the output image shape\n slices_large, slices_small = self._overlap_slices(image.shape)\n\n if slices_small is None:\n return None # no overlap\n\n # insert the mask into the output image\n image[slices_large] = self.data[slices_small]\n\n return image\n\n def to_image(self, shape):\n \"\"\"\n Return an image of the mask in a 2D array of the given shape,\n taking any edge effects into account.\n\n Parameters\n ----------\n shape : tuple of int\n The ``(ny, nx)`` shape of the output array.\n\n Returns\n -------\n result : `~numpy.ndarray`\n A 2D array of the mask.\n \"\"\"\n\n if len(shape) != 2:\n raise ValueError('input shape must have 2 elements.')\n\n image = np.zeros(shape)\n\n if self.bbox.ixmin < 0 or self.bbox.iymin < 0:\n return self._to_image_partial_overlap(image)\n\n try:\n image[self.bbox.slices] = self.data\n except ValueError: # partial or no overlap\n image = self._to_image_partial_overlap(image)\n\n return image\n\n def cutout(self, data, fill_value=0., copy=False):\n \"\"\"\n Create a cutout from the input data over the mask bounding box,\n taking any edge effects into account.\n\n Parameters\n ----------\n data : array_like\n A 2D array on which to apply the aperture mask.\n\n fill_value : float, optional\n The value used to fill pixels where the aperture mask does\n not overlap with the input ``data``. The default is 0.\n\n copy : bool, optional\n If `True` then the returned cutout array will always be hold\n a copy of the input ``data``. If `False` and the mask is\n fully within the input ``data``, then the returned cutout\n array will be a view into the input ``data``. In cases\n where the mask partially overlaps or has no overlap with the\n input ``data``, the returned cutout array will always hold a\n copy of the input ``data`` (i.e. this keyword has no\n effect).\n\n Returns\n -------\n result : `~numpy.ndarray`\n A 2D array cut out from the input ``data`` representing the\n same cutout region as the aperture mask. If there is a\n partial overlap of the aperture mask with the input data,\n pixels outside of the data will be assigned to\n ``fill_value``. `None` is returned if there is no overlap\n of the aperture with the input ``data``.\n \"\"\"\n\n data = np.asanyarray(data)\n if (data.ndim != 2) and (data.ndim != 3):\n raise ValueError('data must be a 2D or 3D array.')\n\n partial_overlap = False\n if self.bbox.ixmin < 0 or self.bbox.iymin < 0:\n partial_overlap = True\n\n if not partial_overlap:\n # try this for speed -- the result may still be a partial\n # overlap, in which case the next block will be triggered\n if copy:\n cutout = data[(Ellipsis,)+self.bbox.slices].copy() # preserves Quantity\n else:\n cutout = data[(Ellipsis,)+self.bbox.slices]\n\n if partial_overlap or (cutout.shape[-2:] != self.shape):\n slices_large, slices_small = self._overlap_slices(data.shape[-2:])\n\n if slices_small is None:\n return None # no overlap\n\n # cutout is a copy\n output_shape = self.shape if data.ndim==2 else (data.shape[0],)+self.shape\n cutout = np.zeros(output_shape, dtype=data.dtype)\n cutout[:] = fill_value\n cutout[(Ellipsis,)+slices_small] = data[(Ellipsis,)+slices_large]\n\n if isinstance(data, u.Quantity):\n cutout = u.Quantity(cutout, unit=data.unit)\n\n return cutout\n\n def multiply(self, data, fill_value=0.):\n \"\"\"\n Multiply the aperture mask with the input data, taking any edge\n effects into account.\n\n The result is a mask-weighted cutout from the data.\n\n Parameters\n ----------\n data : array_like or `~astropy.units.Quantity`\n The 2D array to multiply with the aperture mask.\n\n fill_value : float, optional\n The value is used to fill pixels where the aperture mask\n does not overlap with the input ``data``. The default is 0.\n\n Returns\n -------\n result : `~numpy.ndarray` or `None`\n A 2D mask-weighted cutout from the input ``data``. If there\n is a partial overlap of the aperture mask with the input\n data, pixels outside of the data will be assigned to\n ``fill_value`` before being multipled with the mask. `None`\n is returned if there is no overlap of the aperture with the\n input ``data``.\n \"\"\"\n\n # make a copy to prevent changing the input data\n cutout = self.cutout(data, fill_value=fill_value, copy=True)\n\n if cutout is None:\n return None\n else:\n # needed to zero out non-finite data values outside of the\n # aperture mask but within the bounding box\n cutout[self._mask] = 0.\n\n return cutout * self.data\n",
"# Licensed under a 3-clause BSD style license - see LICENSE.rst\n\nimport pytest\nimport numpy as np\nfrom numpy.testing import assert_allclose, assert_array_equal, assert_equal\n\nfrom astropy.convolution.utils import discretize_model\nfrom astropy.modeling import Parameter, Fittable2DModel\nfrom astropy.modeling.fitting import LevMarLSQFitter\nfrom astropy.modeling.models import Gaussian2D, Moffat2D\nfrom astropy.stats import gaussian_sigma_to_fwhm, SigmaClip\nfrom astropy.table import Table\nfrom astropy.tests.helper import catch_warnings\nfrom astropy.utils.exceptions import AstropyUserWarning\n\nfrom ..groupstars import DAOGroup\nfrom ..models import IntegratedGaussianPRF\nfrom ..photometry import (DAOPhotPSFPhotometry, BasicPSFPhotometry,\n IterativelySubtractedPSFPhotometry)\nfrom ..sandbox import DiscretePRF\nfrom ..utils import prepare_psf_model\nfrom ...background import StdBackgroundRMS, MMMBackground\nfrom ...datasets import make_gaussian_prf_sources_image, make_noise_image\nfrom ...detection import DAOStarFinder\n\ntry:\n import scipy # noqa\n HAS_SCIPY = True\nexcept ImportError:\n HAS_SCIPY = False\n\n\ndef make_psf_photometry_objs(std=1, sigma_psf=1):\n \"\"\"\n Produces baseline photometry objects which are then\n modified as-needed in specific tests below\n \"\"\"\n\n daofind = DAOStarFinder(threshold=5.0*std,\n fwhm=sigma_psf*gaussian_sigma_to_fwhm)\n daogroup = DAOGroup(1.5*sigma_psf*gaussian_sigma_to_fwhm)\n threshold = 5. * std\n fwhm = sigma_psf * gaussian_sigma_to_fwhm\n crit_separation = 1.5 * sigma_psf * gaussian_sigma_to_fwhm\n\n daofind = DAOStarFinder(threshold=threshold, fwhm=fwhm)\n daogroup = DAOGroup(crit_separation)\n mode_bkg = MMMBackground()\n psf_model = IntegratedGaussianPRF(sigma=sigma_psf)\n fitter = LevMarLSQFitter()\n\n basic_phot_obj = BasicPSFPhotometry(finder=daofind,\n group_maker=daogroup,\n bkg_estimator=mode_bkg,\n psf_model=psf_model,\n fitter=fitter,\n fitshape=(11, 11))\n\n iter_phot_obj = IterativelySubtractedPSFPhotometry(finder=daofind,\n group_maker=daogroup,\n bkg_estimator=mode_bkg,\n psf_model=psf_model,\n fitter=fitter, niters=1,\n fitshape=(11, 11))\n\n dao_phot_obj = DAOPhotPSFPhotometry(crit_separation=crit_separation,\n threshold=threshold, fwhm=fwhm,\n psf_model=psf_model, fitshape=(11, 11),\n niters=1)\n\n return (basic_phot_obj, iter_phot_obj, dao_phot_obj)\n\n\nsigma_psfs = []\n\n# A group of two overlapped stars and an isolated one\nsigma_psfs.append(2)\nsources1 = Table()\nsources1['flux'] = [800, 1000, 1200]\nsources1['x_0'] = [13, 18, 25]\nsources1['y_0'] = [16, 16, 25]\nsources1['sigma'] = [sigma_psfs[-1]] * 3\nsources1['theta'] = [0] * 3\nsources1['id'] = [1, 2, 3]\nsources1['group_id'] = [1, 1, 2]\n\n\n# one single group with four stars.\nsigma_psfs.append(2)\nsources2 = Table()\nsources2['flux'] = [700, 800, 700, 800]\nsources2['x_0'] = [12, 17, 12, 17]\nsources2['y_0'] = [15, 15, 20, 20]\nsources2['sigma'] = [sigma_psfs[-1]] * 4\nsources2['theta'] = [0] * 4\nsources2['id'] = [1, 2, 3, 4]\nsources2['group_id'] = [1, 1, 1, 1]\n\n# one faint star and one brither companion\n# although they are in the same group, the detection algorithm\n# is not able to detect the fainter star, hence photometry should\n# be performed with niters > 1 or niters=None\nsigma_psfs.append(2)\nsources3 = Table()\nsources3['flux'] = [10000, 1000]\nsources3['x_0'] = [18, 13]\nsources3['y_0'] = [17, 19]\nsources3['sigma'] = [sigma_psfs[-1]] * 2\nsources3['theta'] = [0] * 2\nsources3['id'] = [1] * 2\nsources3['group_id'] = [1] * 2\nsources3['iter_detected'] = [1, 2]\n\n\[email protected]('not HAS_SCIPY')\[email protected](\"sigma_psf, sources\", [(sigma_psfs[2], sources3)])\ndef test_psf_photometry_niters(sigma_psf, sources):\n img_shape = (32, 32)\n # generate image with read-out noise (Gaussian) and\n # background noise (Poisson)\n image = (make_gaussian_prf_sources_image(img_shape, sources) +\n make_noise_image(img_shape, type='poisson', mean=6.,\n random_state=1) +\n make_noise_image(img_shape, type='gaussian', mean=0.,\n stddev=2., random_state=1))\n cp_image = image.copy()\n sigma_clip = SigmaClip(sigma=3.)\n bkgrms = StdBackgroundRMS(sigma_clip)\n std = bkgrms(image)\n\n phot_obj = make_psf_photometry_objs(std, sigma_psf)[1:3]\n for iter_phot_obj in phot_obj:\n iter_phot_obj.niters = None\n\n result_tab = iter_phot_obj(image)\n residual_image = iter_phot_obj.get_residual_image()\n\n assert (result_tab['x_0_unc'] < 1.96 * sigma_psf /\n np.sqrt(sources['flux'])).all()\n assert (result_tab['y_0_unc'] < 1.96 * sigma_psf /\n np.sqrt(sources['flux'])).all()\n assert (result_tab['flux_unc'] < 1.96 *\n np.sqrt(sources['flux'])).all()\n\n assert_allclose(result_tab['x_fit'], sources['x_0'], rtol=1e-1)\n assert_allclose(result_tab['y_fit'], sources['y_0'], rtol=1e-1)\n assert_allclose(result_tab['flux_fit'], sources['flux'], rtol=1e-1)\n assert_array_equal(result_tab['id'], sources['id'])\n assert_array_equal(result_tab['group_id'], sources['group_id'])\n assert_array_equal(result_tab['iter_detected'],\n sources['iter_detected'])\n assert_allclose(np.mean(residual_image), 0.0, atol=1e1)\n\n # make sure image is note overwritten\n assert_array_equal(cp_image, image)\n\n\[email protected]('not HAS_SCIPY')\[email protected](\"sigma_psf, sources\",\n [(sigma_psfs[0], sources1),\n (sigma_psfs[1], sources2),\n # these ensure that the test *fails* if the model\n # PSFs are the wrong shape\n pytest.param(sigma_psfs[0]/1.2, sources1,\n marks=pytest.mark.xfail()),\n pytest.param(sigma_psfs[1]*1.2, sources2,\n marks=pytest.mark.xfail())])\ndef test_psf_photometry_oneiter(sigma_psf, sources):\n \"\"\"\n Tests in an image with a group of two overlapped stars and an\n isolated one.\n \"\"\"\n\n img_shape = (32, 32)\n # generate image with read-out noise (Gaussian) and\n # background noise (Poisson)\n image = (make_gaussian_prf_sources_image(img_shape, sources) +\n make_noise_image(img_shape, type='poisson', mean=6.,\n random_state=1) +\n make_noise_image(img_shape, type='gaussian', mean=0.,\n stddev=2., random_state=1))\n cp_image = image.copy()\n\n sigma_clip = SigmaClip(sigma=3.)\n bkgrms = StdBackgroundRMS(sigma_clip)\n std = bkgrms(image)\n phot_objs = make_psf_photometry_objs(std, sigma_psf)\n\n for phot_proc in phot_objs:\n result_tab = phot_proc(image)\n residual_image = phot_proc.get_residual_image()\n assert (result_tab['x_0_unc'] < 1.96 * sigma_psf /\n np.sqrt(sources['flux'])).all()\n assert (result_tab['y_0_unc'] < 1.96 * sigma_psf /\n np.sqrt(sources['flux'])).all()\n assert (result_tab['flux_unc'] < 1.96 *\n np.sqrt(sources['flux'])).all()\n assert_allclose(result_tab['x_fit'], sources['x_0'], rtol=1e-1)\n assert_allclose(result_tab['y_fit'], sources['y_0'], rtol=1e-1)\n assert_allclose(result_tab['flux_fit'], sources['flux'], rtol=1e-1)\n assert_array_equal(result_tab['id'], sources['id'])\n assert_array_equal(result_tab['group_id'], sources['group_id'])\n assert_allclose(np.mean(residual_image), 0.0, atol=1e1)\n\n # test fixed photometry\n phot_proc.psf_model.x_0.fixed = True\n phot_proc.psf_model.y_0.fixed = True\n\n pos = Table(names=['x_0', 'y_0'], data=[sources['x_0'],\n sources['y_0']])\n cp_pos = pos.copy()\n\n result_tab = phot_proc(image, pos)\n residual_image = phot_proc.get_residual_image()\n assert 'x_0_unc' not in result_tab.colnames\n assert 'y_0_unc' not in result_tab.colnames\n assert (result_tab['flux_unc'] < 1.96 *\n np.sqrt(sources['flux'])).all()\n assert_array_equal(result_tab['x_fit'], sources['x_0'])\n assert_array_equal(result_tab['y_fit'], sources['y_0'])\n assert_allclose(result_tab['flux_fit'], sources['flux'], rtol=1e-1)\n assert_array_equal(result_tab['id'], sources['id'])\n assert_array_equal(result_tab['group_id'], sources['group_id'])\n assert_allclose(np.mean(residual_image), 0.0, atol=1e1)\n\n # make sure image is not overwritten\n assert_array_equal(cp_image, image)\n\n # make sure initial guess table is not modified\n assert_array_equal(cp_pos, pos)\n\n # resets fixed positions\n phot_proc.psf_model.x_0.fixed = False\n phot_proc.psf_model.y_0.fixed = False\n\n\[email protected]('not HAS_SCIPY')\ndef test_niters_errors():\n iter_phot_obj = make_psf_photometry_objs()[1]\n\n # tests that niters is set to an integer even if the user inputs\n # a float\n iter_phot_obj.niters = 1.1\n assert_equal(iter_phot_obj.niters, 1)\n\n # test that a ValueError is raised if niters <= 0\n with pytest.raises(ValueError):\n iter_phot_obj.niters = 0\n\n # test that it's OK to set niters to None\n iter_phot_obj.niters = None\n\n\[email protected]('not HAS_SCIPY')\ndef test_fitshape_errors():\n basic_phot_obj = make_psf_photometry_objs()[0]\n\n # first make sure setting to a scalar does the right thing (and makes\n # no errors)\n basic_phot_obj.fitshape = 11\n assert np.all(basic_phot_obj.fitshape == (11, 11))\n\n # test that a ValuError is raised if fitshape has even components\n with pytest.raises(ValueError):\n basic_phot_obj.fitshape = (2, 2)\n with pytest.raises(ValueError):\n basic_phot_obj.fitshape = 2\n\n # test that a ValueError is raised if fitshape has non positive\n # components\n with pytest.raises(ValueError):\n basic_phot_obj.fitshape = (-1, 0)\n\n # test that a ValueError is raised if fitshape has more than two\n # dimensions\n with pytest.raises(ValueError):\n basic_phot_obj.fitshape = (3, 3, 3)\n\n\[email protected]('not HAS_SCIPY')\ndef test_aperture_radius_errors():\n basic_phot_obj = make_psf_photometry_objs()[0]\n\n # test that aperture_radius was set to None by default\n assert_equal(basic_phot_obj.aperture_radius, None)\n\n # test that a ValueError is raised if aperture_radius is non positive\n with pytest.raises(ValueError):\n basic_phot_obj.aperture_radius = -3\n\n\[email protected]('not HAS_SCIPY')\ndef test_finder_errors():\n iter_phot_obj = make_psf_photometry_objs()[1]\n\n with pytest.raises(ValueError):\n iter_phot_obj.finder = None\n\n with pytest.raises(ValueError):\n iter_phot_obj = IterativelySubtractedPSFPhotometry(\n finder=None, group_maker=DAOGroup(1),\n bkg_estimator=MMMBackground(),\n psf_model=IntegratedGaussianPRF(1), fitshape=(11, 11))\n\n\[email protected]('not HAS_SCIPY')\ndef test_finder_positions_warning():\n basic_phot_obj = make_psf_photometry_objs(sigma_psf=2)[0]\n positions = Table()\n positions['x_0'] = [12.8, 18.2, 25.3]\n positions['y_0'] = [15.7, 16.5, 25.1]\n\n image = (make_gaussian_prf_sources_image((32, 32), sources1) +\n make_noise_image((32, 32), type='poisson', mean=6.,\n random_state=1))\n\n with catch_warnings(AstropyUserWarning):\n result_tab = basic_phot_obj(image=image, init_guesses=positions)\n assert_array_equal(result_tab['x_0'], positions['x_0'])\n assert_array_equal(result_tab['y_0'], positions['y_0'])\n assert_allclose(result_tab['x_fit'], positions['x_0'], rtol=1e-1)\n assert_allclose(result_tab['y_fit'], positions['y_0'], rtol=1e-1)\n\n with pytest.raises(ValueError):\n basic_phot_obj.finder = None\n result_tab = basic_phot_obj(image=image)\n\n\[email protected]('not HAS_SCIPY')\ndef test_aperture_radius():\n img_shape = (32, 32)\n\n # generate image with read-out noise (Gaussian) and\n # background noise (Poisson)\n image = (make_gaussian_prf_sources_image(img_shape, sources1) +\n make_noise_image(img_shape, type='poisson', mean=6.,\n random_state=1) +\n make_noise_image(img_shape, type='gaussian', mean=0.,\n stddev=2., random_state=1))\n\n basic_phot_obj = make_psf_photometry_objs()[0]\n\n # test that aperture radius is properly set whenever the PSF model has\n # a `fwhm` attribute\n class PSFModelWithFWHM(Fittable2DModel):\n x_0 = Parameter(default=1)\n y_0 = Parameter(default=1)\n flux = Parameter(default=1)\n fwhm = Parameter(default=5)\n\n def __init__(self, fwhm=fwhm.default):\n super().__init__(fwhm=fwhm)\n\n def evaluate(self, x, y, x_0, y_0, flux, fwhm):\n return flux / (fwhm * (x - x_0)**2 * (y - y_0)**2)\n\n psf_model = PSFModelWithFWHM()\n basic_phot_obj.psf_model = psf_model\n basic_phot_obj(image)\n assert_equal(basic_phot_obj.aperture_radius, psf_model.fwhm.value)\n\n\nPARS_TO_SET_0 = {'x_0': 'x_0', 'y_0': 'y_0', 'flux_0': 'flux'}\nPARS_TO_OUTPUT_0 = {'x_fit': 'x_0', 'y_fit': 'y_0', 'flux_fit': 'flux'}\nPARS_TO_SET_1 = PARS_TO_SET_0.copy()\nPARS_TO_SET_1['sigma_0'] = 'sigma'\nPARS_TO_OUTPUT_1 = PARS_TO_OUTPUT_0.copy()\nPARS_TO_OUTPUT_1['sigma_fit'] = 'sigma'\n\n\[email protected](\"actual_pars_to_set, actual_pars_to_output,\"\n \"is_sigma_fixed\", [(PARS_TO_SET_0, PARS_TO_OUTPUT_0,\n True),\n (PARS_TO_SET_1, PARS_TO_OUTPUT_1,\n False)])\[email protected]('not HAS_SCIPY')\ndef test_define_fit_param_names(actual_pars_to_set, actual_pars_to_output,\n is_sigma_fixed):\n psf_model = IntegratedGaussianPRF()\n psf_model.sigma.fixed = is_sigma_fixed\n\n basic_phot_obj = make_psf_photometry_objs()[0]\n basic_phot_obj.psf_model = psf_model\n\n basic_phot_obj._define_fit_param_names()\n assert_equal(basic_phot_obj._pars_to_set, actual_pars_to_set)\n assert_equal(basic_phot_obj._pars_to_output, actual_pars_to_output)\n\n\n# tests previously written to psf_photometry\n\nPSF_SIZE = 11\nGAUSSIAN_WIDTH = 1.\nIMAGE_SIZE = 101\n\n# Position and FLUXES of test sources\nINTAB = Table([[50., 23, 12, 86], [50., 83, 80, 84],\n [np.pi * 10, 3.654, 20., 80 / np.sqrt(3)]],\n names=['x_0', 'y_0', 'flux_0'])\n\n# Create test psf\npsf_model = Gaussian2D(1. / (2 * np.pi * GAUSSIAN_WIDTH ** 2), PSF_SIZE // 2,\n PSF_SIZE // 2, GAUSSIAN_WIDTH, GAUSSIAN_WIDTH)\ntest_psf = discretize_model(psf_model, (0, PSF_SIZE), (0, PSF_SIZE),\n mode='oversample')\n\n# Set up grid for test image\nimage = np.zeros((IMAGE_SIZE, IMAGE_SIZE))\n\n# Add sources to test image\nfor x, y, flux in INTAB:\n model = Gaussian2D(flux / (2 * np.pi * GAUSSIAN_WIDTH ** 2),\n x, y, GAUSSIAN_WIDTH, GAUSSIAN_WIDTH)\n image += discretize_model(model, (0, IMAGE_SIZE), (0, IMAGE_SIZE),\n mode='oversample')\n\n# Some tests require an image with wider sources.\nWIDE_GAUSSIAN_WIDTH = 3.\nWIDE_INTAB = Table([[50, 23.2], [50.5, 1], [10, 20]],\n names=['x_0', 'y_0', 'flux_0'])\nwide_image = np.zeros((IMAGE_SIZE, IMAGE_SIZE))\n\n# Add sources to test image\nfor x, y, flux in WIDE_INTAB:\n model = Gaussian2D(flux / (2 * np.pi * WIDE_GAUSSIAN_WIDTH ** 2),\n x, y, WIDE_GAUSSIAN_WIDTH, WIDE_GAUSSIAN_WIDTH)\n wide_image += discretize_model(model, (0, IMAGE_SIZE), (0, IMAGE_SIZE),\n mode='oversample')\n\n\[email protected]('not HAS_SCIPY')\ndef test_psf_photometry_discrete():\n \"\"\" Test psf_photometry with discrete PRF model. \"\"\"\n\n prf = DiscretePRF(test_psf, subsampling=1)\n basic_phot = BasicPSFPhotometry(group_maker=DAOGroup(2),\n bkg_estimator=None, psf_model=prf,\n fitshape=7)\n f = basic_phot(image=image, init_guesses=INTAB)\n\n for n in ['x', 'y', 'flux']:\n assert_allclose(f[n + '_0'], f[n + '_fit'], rtol=1e-6)\n\n\[email protected]('not HAS_SCIPY')\ndef test_tune_coordinates():\n \"\"\"\n Test psf_photometry with discrete PRF model and coordinates that need\n to be adjusted in the fit.\n \"\"\"\n\n prf = DiscretePRF(test_psf, subsampling=1)\n prf.x_0.fixed = False\n prf.y_0.fixed = False\n # Shift all sources by 0.3 pixels\n intab = INTAB.copy()\n intab['x_0'] += 0.3\n\n basic_phot = BasicPSFPhotometry(group_maker=DAOGroup(2),\n bkg_estimator=None, psf_model=prf,\n fitshape=7)\n\n f = basic_phot(image=image, init_guesses=intab)\n for n in ['x', 'y', 'flux']:\n assert_allclose(f[n + '_0'], f[n + '_fit'], rtol=1e-3)\n\n\[email protected]('not HAS_SCIPY')\ndef test_psf_boundary():\n \"\"\"\n Test psf_photometry with discrete PRF model at the boundary of the data.\n \"\"\"\n\n prf = DiscretePRF(test_psf, subsampling=1)\n\n basic_phot = BasicPSFPhotometry(group_maker=DAOGroup(2),\n bkg_estimator=None, psf_model=prf,\n fitshape=7, aperture_radius=5.5)\n\n intab = Table(data=[[1], [1]], names=['x_0', 'y_0'])\n f = basic_phot(image=image, init_guesses=intab)\n assert_allclose(f['flux_fit'], 0, atol=1e-8)\n\n\[email protected]('not HAS_SCIPY')\ndef test_aperture_radius_value_error():\n \"\"\"\n Test psf_photometry with discrete PRF model at the boundary of the data.\n \"\"\"\n\n prf = DiscretePRF(test_psf, subsampling=1)\n\n basic_phot = BasicPSFPhotometry(group_maker=DAOGroup(2),\n bkg_estimator=None, psf_model=prf,\n fitshape=7)\n\n intab = Table(data=[[1], [1]], names=['x_0', 'y_0'])\n with pytest.raises(ValueError) as err:\n basic_phot(image=image, init_guesses=intab)\n\n assert 'aperture_radius is None' in str(err.value)\n\n\[email protected]('not HAS_SCIPY')\ndef test_psf_boundary_gaussian():\n \"\"\"\n Test psf_photometry with discrete PRF model at the boundary of the data.\n \"\"\"\n\n psf = IntegratedGaussianPRF(GAUSSIAN_WIDTH)\n\n basic_phot = BasicPSFPhotometry(group_maker=DAOGroup(2),\n bkg_estimator=None, psf_model=psf,\n fitshape=7)\n\n intab = Table(data=[[1], [1]], names=['x_0', 'y_0'])\n f = basic_phot(image=image, init_guesses=intab)\n assert_allclose(f['flux_fit'], 0, atol=1e-8)\n\n\[email protected]('not HAS_SCIPY')\ndef test_psf_photometry_gaussian():\n \"\"\"\n Test psf_photometry with Gaussian PSF model.\n \"\"\"\n\n psf = IntegratedGaussianPRF(sigma=GAUSSIAN_WIDTH)\n\n basic_phot = BasicPSFPhotometry(group_maker=DAOGroup(2),\n bkg_estimator=None, psf_model=psf,\n fitshape=7)\n f = basic_phot(image=image, init_guesses=INTAB)\n for n in ['x', 'y', 'flux']:\n assert_allclose(f[n + '_0'], f[n + '_fit'], rtol=1e-3)\n\n\[email protected]('not HAS_SCIPY')\[email protected](\"renormalize_psf\", (True, False))\ndef test_psf_photometry_gaussian2(renormalize_psf):\n \"\"\"\n Test psf_photometry with Gaussian PSF model from Astropy.\n \"\"\"\n\n psf = Gaussian2D(1. / (2 * np.pi * GAUSSIAN_WIDTH ** 2), PSF_SIZE // 2,\n PSF_SIZE // 2, GAUSSIAN_WIDTH, GAUSSIAN_WIDTH)\n psf = prepare_psf_model(psf, xname='x_mean', yname='y_mean',\n renormalize_psf=renormalize_psf)\n\n basic_phot = BasicPSFPhotometry(group_maker=DAOGroup(2),\n bkg_estimator=None, psf_model=psf,\n fitshape=7)\n f = basic_phot(image=image, init_guesses=INTAB)\n\n for n in ['x', 'y']:\n assert_allclose(f[n + '_0'], f[n + '_fit'], rtol=1e-1)\n assert_allclose(f['flux_0'], f['flux_fit'], rtol=1e-1)\n\n\[email protected]('not HAS_SCIPY')\ndef test_psf_photometry_moffat():\n \"\"\"\n Test psf_photometry with Moffat PSF model from Astropy.\n \"\"\"\n\n psf = Moffat2D(1. / (2 * np.pi * GAUSSIAN_WIDTH ** 2), PSF_SIZE // 2,\n PSF_SIZE // 2, 1, 1)\n psf = prepare_psf_model(psf, xname='x_0', yname='y_0',\n renormalize_psf=False)\n\n basic_phot = BasicPSFPhotometry(group_maker=DAOGroup(2),\n bkg_estimator=None, psf_model=psf,\n fitshape=7)\n f = basic_phot(image=image, init_guesses=INTAB)\n f.pprint(max_width=-1)\n\n for n in ['x', 'y']:\n assert_allclose(f[n + '_0'], f[n + '_fit'], rtol=1e-3)\n # image was created with a gaussian, so flux won't match exactly\n assert_allclose(f['flux_0'], f['flux_fit'], rtol=1e-1)\n\n\[email protected]('not HAS_SCIPY')\ndef test_psf_fitting_data_on_edge():\n \"\"\"\n No mask is input explicitly here, but source 2 is so close to the\n edge that the subarray that's extracted gets a mask internally.\n \"\"\"\n\n psf_guess = IntegratedGaussianPRF(flux=1, sigma=WIDE_GAUSSIAN_WIDTH)\n psf_guess.flux.fixed = psf_guess.x_0.fixed = psf_guess.y_0.fixed = False\n basic_phot = BasicPSFPhotometry(group_maker=DAOGroup(2),\n bkg_estimator=None, psf_model=psf_guess,\n fitshape=7)\n\n outtab = basic_phot(image=wide_image, init_guesses=WIDE_INTAB)\n\n for n in ['x', 'y', 'flux']:\n assert_allclose(outtab[n + '_0'], outtab[n + '_fit'],\n rtol=0.05, atol=0.1)\n",
"# Licensed under a 3-clause BSD style license - see LICENSE.rst\n\nimport numpy as np\nfrom numpy.testing import assert_allclose\nimport pytest\n\nfrom astropy.modeling.fitting import LevMarLSQFitter\nfrom astropy.nddata import NDData\nfrom astropy.table import Table\n\nfrom ..epsf import EPSFBuilder, EPSFFitter\nfrom ..epsf_stars import extract_stars, EPSFStar, EPSFStars\nfrom ...centroids import gaussian1d_moments\nfrom ...datasets import make_gaussian_sources_image\n\ntry:\n import scipy # noqa\n HAS_SCIPY = True\nexcept ImportError:\n HAS_SCIPY = False\n\n\[email protected]('not HAS_SCIPY')\nclass TestEPSFBuild:\n def setup_class(self):\n \"\"\"\n Create a simulated image for testing.\n \"\"\"\n\n from scipy.spatial import cKDTree\n\n shape = (500, 500)\n\n # define random star positions\n nstars = 50\n from astropy.utils.misc import NumpyRNGContext\n with NumpyRNGContext(12345): # seed for repeatability\n xx = np.random.uniform(low=0, high=shape[1], size=nstars)\n yy = np.random.uniform(low=0, high=shape[0], size=nstars)\n\n # enforce a minimum separation\n min_dist = 25\n coords = [(yy[0], xx[0])]\n for xxi, yyi in zip(xx, yy):\n newcoord = [yyi, xxi]\n dist, distidx = cKDTree([newcoord]).query(coords, 1)\n if np.min(dist) > min_dist:\n coords.append(newcoord)\n yy, xx = np.transpose(coords)\n\n with NumpyRNGContext(12345): # seed for repeatability\n zz = np.random.uniform(low=0, high=200000., size=len(xx))\n\n # define a table of model parameters\n self.stddev = 2.\n sources = Table()\n sources['amplitude'] = zz\n sources['x_mean'] = xx\n sources['y_mean'] = yy\n sources['x_stddev'] = np.zeros(len(xx)) + self.stddev\n sources['y_stddev'] = sources['x_stddev']\n sources['theta'] = 0.\n\n self.data = make_gaussian_sources_image(shape, sources)\n self.nddata = NDData(self.data)\n\n init_stars = Table()\n init_stars['x'] = xx.astype(int)\n init_stars['y'] = yy.astype(int)\n self.init_stars = init_stars\n\n def test_extract_stars(self):\n size = 25\n stars = extract_stars(self.nddata, self.init_stars, size=size)\n\n assert len(stars) == 41\n assert isinstance(stars, EPSFStars)\n assert isinstance(stars[0], EPSFStar)\n assert stars[0].data.shape == (size, size)\n\n def test_epsf_build(self):\n \"\"\"\n This is an end-to-end test of EPSFBuilder on a simulated image.\n \"\"\"\n\n size = 25\n oversampling = 4.\n stars = extract_stars(self.nddata, self.init_stars, size=size)\n epsf_builder = EPSFBuilder(oversampling=oversampling, maxiters=20,\n progress_bar=False)\n epsf, fitted_stars = epsf_builder(stars)\n\n ref_size = (size * oversampling) + 1\n assert epsf.data.shape == (ref_size, ref_size)\n\n y0 = int((ref_size - 1) / 2)\n z = epsf.data[y0, :]\n ampl, peak, sigma = gaussian1d_moments(z)\n assert_allclose(ampl, 0.002487, rtol=1e-4)\n assert_allclose(peak, y0, rtol=1e-3)\n assert_allclose(sigma, oversampling * self.stddev, rtol=1e-5)\n\n def test_epsf_build_invalid_fitter(self):\n \"\"\"\n Test that the input fitter is an EPSFFitter instance.\n \"\"\"\n\n with pytest.raises(TypeError):\n EPSFBuilder(fitter=EPSFFitter, maxiters=3)\n\n with pytest.raises(TypeError):\n EPSFBuilder(fitter=LevMarLSQFitter(), maxiters=3)\n\n with pytest.raises(TypeError):\n EPSFBuilder(fitter=LevMarLSQFitter, maxiters=3)\n"
]
| [
[
"numpy.asanyarray",
"numpy.zeros"
],
[
"numpy.testing.assert_allclose",
"numpy.zeros",
"numpy.testing.assert_equal",
"numpy.testing.assert_array_equal",
"numpy.mean",
"numpy.sqrt",
"numpy.all"
],
[
"numpy.testing.assert_allclose",
"scipy.spatial.cKDTree",
"numpy.min",
"numpy.random.uniform",
"numpy.transpose"
]
]
|
Jarred-Sumner/im2smpl | [
"cb3a09ee99815939e9f7d55479920a32703be9ce"
]
| [
"main.py"
]
| [
"# Software License Agreement (BSD License)\n#\n# Copyright (c) 2019, Zerong Zheng ([email protected])\n# All rights reserved.\n#\n# Redistribution and use in source and binary forms, with or without\n# modification, are permitted provided that the following conditions are met:\n# * Redistributions of source code must retain the above copyright\n# notice, this list of conditions and the following disclaimer.\n# * Redistributions in binary form must reproduce the above copyright\n# notice, this list of conditions and the following disclaimer in the\n# documentation and/or other materials provided with the distribution.\n# * Neither the name of the <organization> nor the\n# names of its contributors may be used to endorse or promote products\n# derived from this software without specific prior written permission.\n#\n# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\n# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\n# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n# DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY\n# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\n# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\n# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\n# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n\nfrom __future__ import print_function, absolute_import, division\n\nimport os\nimport numpy as np\nimport cv2 as cv\nimport argparse\nimport random\nimport string\nimport shutil\nfrom subprocess import call\nimport pynvml\nimport time\n\npynvml.nvmlInit()\n\n\ndef parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument('--img_file', type=str, required=True, help='path to image file')\n parser.add_argument('--out_dir', type=str, required=True, help='output directory')\n return parser.parse_args()\n\n\ndef waitgpu(empty_thres_duration=7):\n empty_flag = 0\n while True:\n handle = pynvml.nvmlDeviceGetHandleByIndex(0)\n meminfo = pynvml.nvmlDeviceGetMemoryInfo(handle)\n usage_percent = float(meminfo.used)/float(meminfo.total)\n if usage_percent < 0.1:\n if empty_flag >= empty_thres_duration: # empty for 5 second\n break\n empty_flag += 1\n time.sleep(1)\n continue\n empty_flag = 0\n print('GPU is busy right now....waiting....')\n print('meminfo.used/meminfo.total = %f' % usage_percent)\n time.sleep(np.random.randint(5, 15))\n\n\ndef detect_human(fname, out_dir):\n \"\"\" obtains bounding box of the subject in the input image\"\"\"\n waitgpu()\n print('\\n\\nStep 1. Human Detection RCNN')\n # generate a temporal script to call RCNN\n shutil.copy('./detect_human.py', './AlphaPose/human-detection/tools/')\n temp_shname = ''.join(random.sample(string.ascii_letters + string.digits, 8)) + '.sh'\n temp_shname = os.path.join('./', temp_shname)\n with open(temp_shname, 'w') as fp:\n fp.write('#!/usr/local/bin/bash\\n')\n fp.write('cd ./AlphaPose/human-detection/tools\\n')\n fp.write('python2 detect_human.py --img_file %s --out_dir %s\\n'\n % (fname, out_dir))\n fp.write('cd ../../../\\n')\n call(['sh', temp_shname])\n os.remove(temp_shname)\n # os.remove('./AlphaPose/human-detection/tools/detect_human.py')\n\n\ndef crop_or_pad_img(fname, out_dir):\n \"\"\" crops or pads the original image to make the subject located at the center\n of the image and occupy 90% of the image\n \"\"\"\n print('\\n\\nStep 2. Image cropping or padding')\n img_dir, img_name = os.path.split(img_fname)\n with open(os.path.join(out_dir, img_name + '.bbox.txt'), 'r') as fp:\n lines = fp.readlines()\n if lines[-1] == '':\n lines = lines[:-1]\n if len(lines) > 1:\n print('Warning: More than 1 bounding boxes are detected. '\n 'Only the first one is used.')\n entries = lines[0].split(' ')\n xmin, ymin = int(entries[0]), int(entries[1])\n xmax, ymax = int(entries[2]), int(entries[3])\n x_center = int((xmin+xmax)/2)\n y_center = int((ymin+ymax)/2)\n edge_len = int(max(xmax-xmin, ymax-ymin) * 1.2)\n edge_len_half = int(edge_len/2)\n\n img = cv.imread(fname)\n cv.imwrite(os.path.join(out_dir, img_name[:-4]+'_orig.png'), img)\n if len(img.shape) == 2:\n img = cv.cvtColor(img, cv.COLOR_GRAY2RGB)\n h, w = img.shape[0], img.shape[1]\n img_pad = np.zeros((3*h, 3*w, 3), dtype=np.uint8)\n img_pad[h:(h*2), w:(w*2), :] = img\n crop_tl = (h+y_center-edge_len_half, w+x_center-edge_len_half)\n crop_dr = (h+y_center+edge_len_half, w+x_center+edge_len_half)\n img_crop = img_pad[crop_tl[0]:crop_dr[0], crop_tl[1]:crop_dr[1], :]\n cv.imwrite(os.path.join(out_dir, img_name), img_crop)\n cv.imwrite(os.path.join(out_dir, img_name), img_crop)\n\n\ndef infer_smpl_and_pose(fname, out_dir):\n waitgpu()\n print('\\n\\nStep 3a Body model estimation using HMR. ')\n shutil.copy('./infer_smpl.py', './hmr/')\n temp_shname = ''.join(random.sample(string.ascii_letters + string.digits, 8)) + '.sh'\n temp_shname = os.path.join('./', temp_shname)\n with open(temp_shname, 'w') as fp:\n fp.write('#!/usr/local/bin/bash\\n')\n fp.write('cd ./hmr/\\n')\n fp.write('python2 infer_smpl.py --img_path %s --out_dir %s\\n' % (fname, out_dir))\n fp.write('cd ../\\n')\n call(['sh', temp_shname])\n os.remove(temp_shname)\n # os.remove('./hmr/infer_smpl.py')\n\n print('\\n\\nStep 3b Pose estimation using AlphaPose')\n img_dir, img_name = os.path.split(img_fname)\n tmp_folder = ''.join(random.sample(string.ascii_letters + string.digits, 8))\n os.mkdir(os.path.join('./AlphaPose/examples', tmp_folder))\n os.mkdir(os.path.join('./AlphaPose/examples', tmp_folder, 'demo'))\n os.mkdir(os.path.join('./AlphaPose/examples', tmp_folder, 'results'))\n call(['cp', os.path.join(out_dir, img_name),\n os.path.join('./AlphaPose/examples', tmp_folder, 'demo/1.jpg')])\n call(['./AlphaPose/run.sh', '--indir', os.path.join('./examples', tmp_folder, 'demo'),\n '--outdir', os.path.join('./examples', tmp_folder, 'results'), '--vis'])\n call(['mv', os.path.join('./AlphaPose/examples', tmp_folder, 'results/POSE/pred.txt'),\n os.path.join(out_dir, img_name+'.joints.txt')])\n call(['mv', os.path.join('./AlphaPose/examples', tmp_folder, 'results/POSE/scores.txt'),\n os.path.join(out_dir, img_name+'.joint_scores.txt')])\n call(['rm', '-r', os.path.join('./AlphaPose/examples', tmp_folder)])\n\n print('\\n\\nStep 3c Image segmentation')\n shutil.copy('./segment_by_parsing.py', './LIP_JPPNet/')\n temp_shname = ''.join(random.sample(string.ascii_letters + string.digits, 8)) + '.sh'\n temp_shname = os.path.join('./', temp_shname)\n with open(temp_shname, 'w') as fp:\n fp.write('#!/usr/local/bin/bash\\n')\n fp.write('cd ./LIP_JPPNet/\\n')\n fp.write('python2 segment_by_parsing.py --img_file %s --out_dir %s\\n' % (fname, out_dir))\n fp.write('cd ../\\n')\n call(['sh', temp_shname])\n os.remove(temp_shname)\n # os.remove('./LIP_JPPNet/segment_by_parsing.py')\n\n\ndef optimize_smpl(fname, out_dir):\n print('\\n\\nStep 4 SMPL model optimization')\n shutil.copy('./fit_3d_accurate.py', './smplify_public/code/')\n temp_shname = ''.join(random.sample(string.ascii_letters + string.digits, 8)) + '.sh'\n temp_shname = os.path.join('./', temp_shname)\n with open(temp_shname, 'w') as fp:\n fp.write('#!/usr/local/bin/bash\\n')\n fp.write('cd ./smplify_public/code\\n')\n fp.write('python2 fit_3d_accurate.py --img_file %s --out_dir %s\\n' % (fname, out_dir))\n fp.write('cd ../../\\n')\n call(['sh', temp_shname])\n os.remove(temp_shname)\n # os.remove('smplify_public/code/fit_3d_accurate.py')\n\n\ndef main(img_fname, out_dir):\n print('image file: ' + img_fname)\n print('output directory: ' + out_dir)\n if not os.path.isfile(img_fname):\n raise IOError('Image file does not exist!')\n if not os.path.exists(out_dir):\n os.mkdir(out_dir)\n\n detect_human(img_fname, out_dir)\n crop_or_pad_img(img_fname, out_dir)\n infer_smpl_and_pose(img_fname, out_dir)\n optimize_smpl(img_fname, out_dir)\n\n\nif __name__ == '__main__':\n args = parse_args()\n img_fname = args.img_file\n out_dir = args.out_dir\n img_fname = os.path.abspath(img_fname)\n out_dir = os.path.abspath(out_dir)\n main(img_fname, out_dir)\n"
]
| [
[
"numpy.random.randint",
"numpy.zeros"
]
]
|
mostafa-mahmoud/HyPRec | [
"f18318f179dd9f9af7cf01a11f13f0aefb42b3bb"
]
| [
"tests/collaborative_tests.py"
]
| [
"#!/usr/bin/env python\nimport numpy\nimport unittest\nfrom lib.abstract_recommender import AbstractRecommender\nfrom lib.collaborative_filtering import CollaborativeFiltering\nfrom lib.evaluator import Evaluator\nfrom util.data_parser import DataParser\nfrom util.model_initializer import ModelInitializer\n\n\nclass TestcaseBase(unittest.TestCase):\n def setUp(self):\n \"\"\"\n Setup method that is called at the beginning of each test.\n \"\"\"\n self.documents, self.users = 30, 4\n documents_cnt, users_cnt = self.documents, self.users\n self.n_factors = 5\n self.n_iterations = 20\n self.k_folds = 3\n self.hyperparameters = {'n_factors': self.n_factors, '_lambda': 0.01}\n self.options = {'k_folds': self.k_folds, 'n_iterations': self.n_iterations}\n self.initializer = ModelInitializer(self.hyperparameters.copy(), self.n_iterations)\n\n def mock_get_ratings_matrix(self=None):\n return [[int(not bool((article + user) % 3)) for article in range(documents_cnt)]\n for user in range(users_cnt)]\n self.ratings_matrix = numpy.array(mock_get_ratings_matrix())\n self.evaluator = Evaluator(self.ratings_matrix)\n setattr(DataParser, \"get_ratings_matrix\", mock_get_ratings_matrix)\n\n\nclass TestALS(TestcaseBase):\n def runTest(self):\n cf = CollaborativeFiltering(self.initializer, self.evaluator, self.hyperparameters,\n self.options, load_matrices=False)\n self.assertEqual(cf.n_factors, self.n_factors)\n self.assertEqual(cf.n_items, self.documents)\n cf.train()\n self.assertEqual(cf.get_predictions().shape, (self.users, self.documents))\n self.assertTrue(isinstance(cf, AbstractRecommender))\n shape = (self.users, self.documents)\n ratings = cf.get_ratings()\n self.assertLessEqual(numpy.amax(ratings), 1 + 1e-6)\n self.assertGreaterEqual(numpy.amin(ratings), -1e-6)\n self.assertTrue(ratings.shape == shape)\n rounded_predictions = cf.rounded_predictions()\n self.assertLessEqual(numpy.amax(rounded_predictions), 1 + 1e-6)\n self.assertGreaterEqual(numpy.amin(rounded_predictions), -1e-6)\n self.assertTrue(rounded_predictions.shape == shape)\n recall = cf.evaluator.calculate_recall(ratings, cf.get_predictions())\n self.assertTrue(-1e-6 <= recall <= 1 + 1e-6)\n random_user = int(numpy.random.random() * self.users)\n random_item = int(numpy.random.random() * self.documents)\n random_prediction = cf.predict(random_user, random_item)\n self.assertTrue(isinstance(random_prediction, numpy.float64))\n"
]
| [
[
"numpy.random.random",
"numpy.amax",
"numpy.amin"
]
]
|
dcronbach/pandapipes | [
"312fef81ddd0fb3eb23ec1c5bbc2848d568faa52",
"312fef81ddd0fb3eb23ec1c5bbc2848d568faa52"
]
| [
"pandapipes/test/io/test_file_io.py",
"pandapipes/test/openmodelica_comparison/test_water_openmodelica.py"
]
| [
"# Copyright (c) 2020 by Fraunhofer Institute for Energy Economics\n# and Energy System Technology (IEE), Kassel. All rights reserved.\n# Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.\n\nimport os\n\nimport pandapipes\nimport pytest\nfrom pandapower.test.toolbox import tempdir\nfrom pandas.testing import assert_frame_equal\n\n\n# @pytest.fixture()\ndef load_net():\n # create test network\n\n net = pandapipes.create_empty_network(\"test_net\", fluid=\"lgas\")\n j1 = pandapipes.create_junction(net, pn_bar=1.05, tfluid_k=293.15,\n name=\"Connection to External Grid\", geodata=(0, 0))\n j2 = pandapipes.create_junction(net, pn_bar=1.05, tfluid_k=293.15, name=\"Junction 2\",\n geodata=(2, 0))\n j3 = pandapipes.create_junction(net, pn_bar=1.05, tfluid_k=293.15, name=\"Junction 3\",\n geodata=(7, 4))\n j4 = pandapipes.create_junction(net, pn_bar=1.05, tfluid_k=293.15, name=\"Junction 4\",\n geodata=(7, -4))\n j5 = pandapipes.create_junction(net, pn_bar=1.05, tfluid_k=293.15, name=\"Junction 5\",\n geodata=(5, 3))\n j6 = pandapipes.create_junction(net, pn_bar=1.05, tfluid_k=293.15, name=\"Junction 6\",\n geodata=(5, -3))\n\n pandapipes.create_ext_grid(net, junction=j1, p_bar=1.1, t_k=293.15, name=\"Grid Connection\")\n\n pandapipes.create_pipe_from_parameters(net, from_junction=j1, to_junction=j2, length_km=10,\n diameter_m=0.05, name=\"Pipe 1\", geodata=[(0, 0), (2, 0)])\n pandapipes.create_pipe_from_parameters(net, from_junction=j2, to_junction=j3, length_km=2,\n diameter_m=0.05, name=\"Pipe 2\",\n geodata=[(2, 0), (2, 4), (7, 4)])\n pandapipes.create_pipe_from_parameters(net, from_junction=j2, to_junction=j4, length_km=2.5,\n diameter_m=0.05, name=\"Pipe 3\",\n geodata=[(2, 0), (2, -4), (7, -4)])\n pandapipes.create_pipe_from_parameters(net, from_junction=j3, to_junction=j5, length_km=1,\n diameter_m=0.05, name=\"Pipe 4\",\n geodata=[(7, 4), (7, 3), (5, 3)])\n pandapipes.create_pipe_from_parameters(net, from_junction=j4, to_junction=j6, length_km=1,\n diameter_m=0.05, name=\"Pipe 5\",\n geodata=[(7, -4), (7, -3), (5, -3)])\n\n pandapipes.create_valve(net, from_junction=j5, to_junction=j6, diameter_m=0.05,\n opened=True)\n\n pandapipes.create_sink(net, junction=j4, mdot_kg_per_s=5.45e-5, name=\"Sink 1\")\n\n pandapipes.create_source(net, junction=j3, mdot_kg_per_s=3.45e-5)\n\n return net\n\n\ndef test_pickle(tempdir):\n \"\"\"\n Checks if a network saved and reloaded as a pickle file is identical.\n :return:\n :rtype:\n \"\"\"\n\n net = load_net()\n filename = os.path.join(tempdir, \"test_net_1.p\")\n\n # save test network\n pandapipes.to_pickle(net, filename)\n\n # load test network\n net2 = pandapipes.from_pickle(filename)\n\n # check if saved and loaded versions are identical\n assert pandapipes.nets_equal(net, net2), \"Error in comparison after saving to Pickle.\"\n\n\ndef test_json(tempdir):\n \"\"\"\n Checks if a network saved and reloaded as a json file is identical.\n :return:\n :rtype:\n \"\"\"\n net = load_net()\n filename = os.path.join(tempdir, \"test_net_1.json\")\n\n # save test network\n pandapipes.to_json(net, filename)\n\n # load test network\n net2 = pandapipes.from_json(filename)\n\n # check if saved and loaded versions are identical\n assert_frame_equal(net.pipe_geodata, net2.pipe_geodata)\n del net.pipe_geodata\n del net2.pipe_geodata\n\n assert pandapipes.nets_equal(net, net2), \"Error in comparison after saving to JSON.\"\n\n\ndef test_json_string():\n \"\"\"\n Checks if a network saved and reloaded as a json file is identical.\n :return:\n :rtype:\n \"\"\"\n net = load_net()\n\n # save test network\n json_string = pandapipes.to_json(net)\n\n # load test network\n net2 = pandapipes.from_json_string(json_string)\n\n # check if saved and loaded versions are identical\n assert_frame_equal(net.pipe_geodata, net2.pipe_geodata)\n del net.pipe_geodata\n del net2.pipe_geodata\n\n assert pandapipes.nets_equal(net, net2),\\\n \"Error in comparison after saving to JSON string.\"\n\n\nif __name__ == '__main__':\n pytest.main([\"test_file_io.py\"])\n",
"# Copyright (c) 2020 by Fraunhofer Institute for Energy Economics\n# and Energy System Technology (IEE), Kassel. All rights reserved.\n# Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.\n\nimport os\nimport pytest\nimport numpy as np\nimport pandapipes.networks.simple_water_networks as nw\nfrom pandapipes.pipeflow import logger as pf_logger\nfrom pandapipes.test.openmodelica_comparison.pipeflow_openmodelica_comparison\\\n import pipeflow_openmodelica_comparison\n\ntry:\n import pplog as logging\nexcept ImportError:\n import logging\n\nlogger = logging.getLogger(__name__)\nlogger.setLevel(logging.INFO)\npf_logger.setLevel(logging.WARNING)\n\n\n# ---------- TEST AREA: combined networks ----------\n# mixed_net\ndef test_case_combined_mixed(log_results=False):\n net = nw.water_combined_mixed()\n p_diff, v_diff_abs = pipeflow_openmodelica_comparison(net, log_results)\n assert np.all(p_diff < 0.01)\n assert np.all(v_diff_abs < 0.05)\n\n\n# versatility\ndef test_case_combined_versatility(log_results=False):\n net = nw.water_combined_versatility()\n p_diff, v_diff_abs = pipeflow_openmodelica_comparison(net, log_results)\n assert np.all(p_diff < 0.06) # only in one place the comparison for 0.01 is not correct\n assert np.all(v_diff_abs < 0.05)\n\n\n# ---------- TEST AREA: meshed networks ----------\n# delta\ndef test_case_meshed_delta(log_results=False):\n net = nw.water_meshed_delta()\n p_diff, v_diff_abs = pipeflow_openmodelica_comparison(net, log_results)\n assert np.all(p_diff < 0.01)\n assert np.all(v_diff_abs < 0.05)\n\n\n# two_valves\ndef test_case_meshed_2valves(log_results=False):\n net = nw.water_meshed_2valves()\n p_diff, v_diff_abs = pipeflow_openmodelica_comparison(net, log_results)\n assert np.all(p_diff < 0.01)\n assert np.all(v_diff_abs < 0.05)\n\n\n# pumps\ndef test_case_meshed_pumps(log_results=False):\n net = nw.water_meshed_pumps()\n p_diff, v_diff_abs = pipeflow_openmodelica_comparison(net, log_results)\n assert np.all(p_diff < 0.02) # in two places the comparison for 0.01 is not correct\n assert np.all(v_diff_abs < 0.05)\n\n\n# heights\ndef test_case_meshed_heights(log_results=False):\n net = nw.water_meshed_heights()\n p_diff, v_diff_abs = pipeflow_openmodelica_comparison(net, log_results)\n assert np.all(p_diff < 0.01)\n assert np.all(v_diff_abs < 0.05)\n\n\n# ---------- TEST AREA: one pipe ----------\n# pipe_1\ndef test_case_one_pipe_1(log_results=False):\n net = nw.water_one_pipe1()\n p_diff, v_diff_abs = pipeflow_openmodelica_comparison(net, log_results)\n assert np.all(p_diff < 0.01)\n assert np.all(v_diff_abs < 0.05)\n\n\n# pipe_2\ndef test_case_one_pipe_2(log_results=False):\n net = nw.water_one_pipe2()\n p_diff, v_diff_abs = pipeflow_openmodelica_comparison(net, log_results)\n assert np.all(p_diff < 0.01)\n assert np.all(v_diff_abs < 0.05)\n\n\n# pipe_3\ndef test_case_one_pipe_3(log_results=False):\n net = nw.water_one_pipe3()\n p_diff, v_diff_abs = pipeflow_openmodelica_comparison(net, log_results)\n assert np.all(p_diff < 0.01)\n assert np.all(v_diff_abs < 0.05)\n\n\n# ---------- TEST AREA: strand net ----------\n# cross_3ext\ndef test_case_strand_net_cross3ext(log_results=False):\n net = nw.water_strand_cross()\n p_diff, v_diff_abs = pipeflow_openmodelica_comparison(net, log_results)\n assert np.all(p_diff < 0.01)\n assert np.all(v_diff_abs < 0.05)\n\n\n# strand_net\ndef test_case_strand_net(log_results=False):\n net = nw.water_simple_strand_net()\n p_diff, v_diff_abs = pipeflow_openmodelica_comparison(net, log_results)\n assert np.all(p_diff < 0.01)\n assert np.all(v_diff_abs < 0.05)\n\n\n# two_pipes\ndef test_case_strand_net_2pipes(log_results=False):\n net = nw.water_strand_2pipes()\n p_diff, v_diff_abs = pipeflow_openmodelica_comparison(net, log_results)\n assert np.all(p_diff < 0.01)\n assert np.all(v_diff_abs < 0.05)\n\n\n# two_pumps\ndef test_case_strand_net_2pumps(log_results=False):\n net = nw.water_strand_net_2pumps()\n p_diff, v_diff_abs = pipeflow_openmodelica_comparison(net, log_results)\n assert np.all(p_diff < 0.01)\n assert np.all(v_diff_abs < 0.05)\n\n\n# ---------- TEST AREA: t_cross ----------\n# t_cross\ndef test_case_tcross(log_results=False):\n net = nw.water_tcross()\n p_diff, v_diff_abs = pipeflow_openmodelica_comparison(net, log_results)\n assert np.all(p_diff < 0.01)\n assert np.all(v_diff_abs < 0.05)\n\n\n# valves\ndef test_case_tcross_valves(log_results=False):\n net = nw.water_tcross_valves()\n p_diff, v_diff_abs = pipeflow_openmodelica_comparison(net, log_results)\n assert np.all(p_diff < 0.4) # only in one place the comparison for 0.01 is not correct\n assert np.all(v_diff_abs < 0.05)\n\n\n# ---------- TEST AREA: two pressure junctions ----------\n# two_pipes\ndef test_case_2eg_two_pipes(log_results=False):\n net = nw.water_2eg_two_pipes()\n p_diff, v_diff_abs = pipeflow_openmodelica_comparison(net, log_results)\n assert np.all(p_diff < 0.01)\n assert np.all(v_diff_abs < 0.05)\n\n\nif __name__ == \"__main__\":\n pytest.main([os.path.join(os.path.dirname(__file__), \"test_water_openmodelica.py\")])\n"
]
| [
[
"pandas.testing.assert_frame_equal"
],
[
"numpy.all"
]
]
|
LiuHaolan/models | [
"1639b3039237c3997c51ff87f0b6113bb2e8d236",
"1639b3039237c3997c51ff87f0b6113bb2e8d236"
]
| [
"scripts/compare_speed_with_pytorch.py",
"Vision/classification/image/poseNet/train_oneflow.py"
]
| [
"import numpy as np\n\nimport time\nimport tempfile\nimport os\nimport importlib.util\nimport argparse\nfrom typing import Sequence\nimport subprocess\nimport re\n\n\nimport oneflow as flow\nimport oneflow._oneflow_internal as oneflow_internal\n\n\nDEFAULT_TIMES = 20\ngpu_memory_used_by_oneflow = 0\n\n\ndef import_file(path):\n spec = importlib.util.spec_from_file_location(\"mod\", path)\n mod = importlib.util.module_from_spec(spec)\n spec.loader.exec_module(mod)\n return mod\n\n\ndef sync(x):\n if test_oneflow:\n x.numpy()\n else:\n x.cpu()\n\n\ndef gpu_memory_used():\n output = subprocess.check_output(\n [\n \"nvidia-smi\",\n \"--query-compute-apps=pid,used_gpu_memory\",\n \"--format=csv,noheader\",\n ]\n )\n output = output.decode(\"utf-8\").strip()\n my_pid = os.getpid()\n mem_used_by_me = 0\n for line in output.split(\"\\n\"):\n pid, mem_used = map(int, re.split(\",? \", line)[:2])\n if pid == my_pid:\n mem_used_by_me += mem_used\n return mem_used_by_me\n\n\ndef print_rank_0(*args, **kwargs):\n rank = int(os.getenv(\"RANK\", \"0\"))\n if rank == 0:\n print(*args, **kwargs)\n\n\ndef test(\n model_path: str,\n module_name: str,\n input_shape: Sequence[int],\n disable_backward=False,\n times=DEFAULT_TIMES,\n no_verbose=False,\n ddp=False,\n ddp_broadcast_buffers=False,\n show_memory=True,\n):\n framework_name = \"OneFlow\" if test_oneflow else \"PyTorch\"\n if test_oneflow:\n python_module = import_file(model_path)\n torch = flow\n else:\n with open(model_path) as f:\n buf = f.read()\n\n lines = buf.split(\"\\n\")\n for i, line in enumerate(lines):\n if \"import\" not in line and len(line.strip()) != 0:\n break\n lines = (\n lines[:i]\n + [\n \"import torch as flow\",\n \"import torch.nn as nn\",\n \"from torch import Tensor\",\n \"from torch.nn import Parameter\",\n ]\n + lines[i:]\n )\n buf = \"\\n\".join(lines)\n with tempfile.NamedTemporaryFile(\"w\", suffix=\".py\") as f:\n f.write(buf)\n f.flush()\n python_module = import_file(f.name)\n\n import torch\n\n if ddp:\n import torch.distributed as dist\n\n local_rank_env_var = os.getenv(\"LOCAL_RANK\")\n assert local_rank_env_var is not None\n rank = int(local_rank_env_var)\n torch.cuda.set_device(rank)\n\n dist.init_process_group(backend=\"nccl\", init_method=\"env://\")\n\n Net = getattr(python_module, module_name)\n\n warmup_times = 5\n\n m = Net()\n m = m.to(\"cuda\")\n\n if ddp:\n if test_oneflow:\n m = torch.nn.parallel.DistributedDataParallel(\n m, broadcast_buffers=ddp_broadcast_buffers\n )\n else:\n m = torch.nn.parallel.DistributedDataParallel(\n m, device_ids=[rank], broadcast_buffers=ddp_broadcast_buffers\n )\n\n def run_model(m, x):\n if disable_backward:\n with torch.no_grad():\n return m(x)\n else:\n return m(x)\n\n learning_rate = 0.01\n mom = 0.9\n optimizer = torch.optim.SGD(m.parameters(), lr=learning_rate, momentum=mom)\n\n # input tensor of OneFlow should set requires_grad=False due to a bug\n x = torch.tensor(\n np.ones(input_shape).astype(np.float32), requires_grad=not test_oneflow\n ).to(\"cuda\")\n for i in range(warmup_times + times):\n if i == warmup_times:\n start = time.time()\n y = run_model(m, x)\n if not disable_backward:\n y = y.sum()\n y.backward()\n optimizer.zero_grad()\n optimizer.step()\n sync(y)\n end = time.time()\n total_time_ms = (end - start) * 1000\n time_per_run_ms = total_time_ms / times\n if no_verbose:\n print_rank_0(f\"{framework_name}: {time_per_run_ms:.1f}ms\")\n else:\n print_rank_0(\n f\"{framework_name} {module_name} time: {time_per_run_ms:.1f}ms (= {total_time_ms:.1f}ms / {times}, input_shape={input_shape}{', backward is disabled' if disable_backward else ''}{', ddp' if ddp else ''}{', ddp_broadcast_buffers is disabled' if not ddp_broadcast_buffers else ''}{f', world size={flow.env.get_world_size()}' if flow.env.get_world_size() != 1 else ''})\"\n )\n if show_memory:\n global gpu_memory_used_by_oneflow\n if test_oneflow:\n gpu_memory_used_by_oneflow = gpu_memory_used()\n\n print_rank_0(\n f\"{framework_name} GPU used (rank 0): {gpu_memory_used_by_oneflow} MiB\"\n )\n else:\n print_rank_0(\n f\"{framework_name} GPU used (rank 0, estimated): {gpu_memory_used() - gpu_memory_used_by_oneflow} MiB\"\n )\n if ddp and not test_oneflow:\n import torch.distributed as dist\n\n dist.destroy_process_group()\n\n return time_per_run_ms\n\n\nif __name__ == \"__main__\":\n parser = argparse.ArgumentParser()\n parser.add_argument(\"model_path\", type=str)\n parser.add_argument(\"module_name\", type=str)\n parser.add_argument(\"input_shape\", type=str)\n parser.add_argument(\"--times\", type=int, default=DEFAULT_TIMES)\n parser.add_argument(\"--disable-backward\", action=\"store_true\")\n parser.add_argument(\"--no-verbose\", action=\"store_true\")\n parser.add_argument(\"--ddp\", action=\"store_true\")\n parser.add_argument(\"--ddp-no-broadcast-buffers\", action=\"store_true\")\n parser.add_argument(\"--only-oneflow\", action=\"store_true\")\n parser.add_argument(\"--only-pytorch\", action=\"store_true\")\n parser.add_argument(\"--no-show-memory\", action=\"store_true\")\n\n args = parser.parse_args()\n input_shape = list(map(int, args.input_shape.split(\"x\")))\n\n global test_oneflow\n\n if not args.only_pytorch:\n # NOTE: PyTorch must run after OneFlow for correct memory usage\n test_oneflow = True\n oneflow_time = test(\n args.model_path,\n args.module_name,\n input_shape,\n disable_backward=args.disable_backward,\n times=args.times,\n no_verbose=args.no_verbose,\n ddp=args.ddp,\n ddp_broadcast_buffers=not args.ddp_no_broadcast_buffers,\n show_memory=not args.no_show_memory,\n )\n\n if not args.only_oneflow:\n test_oneflow = False\n pytorch_time = test(\n args.model_path,\n args.module_name,\n input_shape,\n disable_backward=args.disable_backward,\n times=args.times,\n no_verbose=args.no_verbose,\n ddp=args.ddp,\n ddp_broadcast_buffers=not args.ddp_no_broadcast_buffers,\n show_memory=not args.no_show_memory,\n )\n\n if not args.only_pytorch and not args.only_oneflow:\n relative_speed = pytorch_time / oneflow_time\n if args.no_verbose:\n print_rank_0(f\"Relative speed: {relative_speed:.2f}\")\n else:\n print_rank_0(\n f\"Relative speed: {relative_speed:.2f} (= {pytorch_time:.1f}ms / {oneflow_time:.1f}ms)\"\n )\n",
"import oneflow as flow\nimport argparse\nimport numpy as np\nimport os\nimport time\n\nfrom models.posenet import PoseNet\n\nfrom utils.ofrecord_data_utils import OFRecordDataLoader\n\n\ndef _parse_args():\n parser = argparse.ArgumentParser(\"flags for train posenet\")\n parser.add_argument(\n \"--save_checkpoint_path\",\n type=str,\n default=\"./checkpoints\",\n help=\"save checkpoint root dir\",\n )\n parser.add_argument(\n \"--load_checkpoint\", type=str, default=\"\", help=\"load checkpoint\"\n )\n parser.add_argument(\n \"--ofrecord_path\", type=str, default=\"./ofrecord\", help=\"dataset path\"\n )\n # training hyper-parameters\n parser.add_argument(\n \"--learning_rate\", type=float, default=0.001, help=\"learning rate\"\n )\n parser.add_argument(\"--mom\", type=float, default=0.9, help=\"momentum\")\n parser.add_argument(\"--epochs\", type=int, default=1000, help=\"training epochs\")\n parser.add_argument(\n \"--train_batch_size\", type=int, default=32, help=\"train batch size\"\n )\n parser.add_argument(\"--val_batch_size\", type=int, default=32, help=\"val batch size\")\n\n return parser.parse_args()\n\n\ndef main(args):\n flow.enable_eager_execution()\n\n train_data_loader = OFRecordDataLoader(\n ofrecord_root=args.ofrecord_path,\n mode=\"train\",\n # NOTE(Liang Depeng): needs to explictly set the dataset size\n dataset_size=7459,\n batch_size=args.train_batch_size,\n )\n\n val_data_loader = OFRecordDataLoader(\n ofrecord_root=args.ofrecord_path,\n mode=\"val\",\n dataset_size=1990,\n batch_size=args.val_batch_size,\n )\n\n # oneflow init\n start_t = time.time()\n posenet_module = PoseNet()\n\n if args.load_checkpoint != \"\":\n posenet_module.load_state_dict(flow.load(args.load_checkpoint))\n\n end_t = time.time()\n print(\"init time : {}\".format(end_t - start_t))\n\n of_cross_entropy = flow.nn.CrossEntropyLoss()\n\n posenet_module.to(\"cuda\")\n of_cross_entropy.to(\"cuda\")\n\n of_sgd = flow.optim.SGD(\n posenet_module.parameters(), lr=args.learning_rate, momentum=args.mom\n )\n\n of_losses = []\n all_samples = len(val_data_loader) * args.val_batch_size\n print_interval = 100\n\n for epoch in range(args.epochs):\n posenet_module.train()\n\n for b in range(len(train_data_loader)):\n image, label = train_data_loader.get_batch()\n\n # oneflow train\n start_t = time.time()\n image = image.to(\"cuda\")\n label = label.to(\"cuda\")\n logits = posenet_module(image)\n loss = of_cross_entropy(logits, label)\n\n loss.backward()\n of_sgd.step()\n of_sgd.zero_grad()\n end_t = time.time()\n if b % print_interval == 0:\n l = loss.numpy()\n of_losses.append(l)\n print(\n \"epoch {} train iter {} oneflow loss {}, train time : {}\".format(\n epoch, b, l, end_t - start_t\n )\n )\n\n print(\"epoch %d train done, start validation\" % epoch)\n posenet_module.eval()\n correct_of = 0.0\n for b in range(len(val_data_loader)):\n image, label = val_data_loader.get_batch()\n\n start_t = time.time()\n image = image.to(\"cuda\")\n with flow.no_grad():\n logits = posenet_module(image)\n predictions = logits.softmax()\n of_predictions = predictions.numpy()\n clsidxs = np.argmax(of_predictions, axis=1)\n\n label_nd = label.numpy()\n for i in range(args.val_batch_size):\n if clsidxs[i] == label_nd[i]:\n correct_of += 1\n end_t = time.time()\n\n print(\"epoch %d, oneflow top1 val acc: %f\" % (epoch, correct_of / all_samples))\n flow.save(\n posenet_module.state_dict(),\n os.path.join(\n args.save_checkpoint_path,\n \"epoch_%d_val_acc_%f\" % (epoch, correct_of / all_samples),\n ),\n )\n\n writer = open(\"of_losses.txt\", \"w\")\n for o in of_losses:\n writer.write(\"%f\\n\" % o)\n writer.close()\n\n\nif __name__ == \"__main__\":\n args = _parse_args()\n main(args)\n"
]
| [
[
"torch.distributed.destroy_process_group",
"torch.distributed.init_process_group",
"torch.no_grad",
"numpy.ones",
"torch.nn.parallel.DistributedDataParallel",
"torch.cuda.set_device"
],
[
"numpy.argmax"
]
]
|
ksasi/DICTOL_python | [
"d2ea3f2a2fdb07c76e63d75e11edf9c8b11d9e69"
]
| [
"dictol/base.py"
]
| [
"from __future__ import print_function\nimport numpy as np\n\n\nclass BaseModel(object):\n \"\"\"\n base dictionary learning model for classification\n \"\"\"\n # def __init__(self)\n def predict(self, data):\n raise NotImplementedError\n\n\n def evaluate(self, data, label):\n pred = self.predict(data)\n acc = np.sum(pred == label)/float(len(label))\n print('accuracy = {:.2f} %'.format(100 * acc))\n return acc\n\n"
]
| [
[
"numpy.sum"
]
]
|
sebastianbernasek/growth | [
"6d1cace75b19ad8b6130d0940584c24dd26bbe91"
]
| [
"growth/cells/cells.py"
]
| [
"from os.path import join\nimport numpy as np\nfrom functools import reduce\nfrom operator import add\n\n\nclass Cell:\n\n def __init__(self, xy=None, chromosomes=None, lineage=''):\n\n # set generation\n self.lineage = lineage\n\n # set chromosomes\n if chromosomes is None:\n chromosomes = np.array([0, 1])\n self.chromosomes = chromosomes\n\n # set position\n if xy is None:\n xy = np.zeros(2, dtype=float)\n self.xy = xy\n\n @property\n def generation(self):\n return len(self.lineage)\n\n @property\n def genotype(self):\n return self.chromosomes.sum()\n\n @property\n def phenotype(self):\n return np.random.normal(loc=self.genotype, scale=1.)\n\n def copy(self):\n \"\"\" Returns copy of cell. \"\"\"\n return self.__class__(self.xy, self.chromosomes, self.lineage)\n\n def set_xy(self, xy):\n self.xy = xy\n\n def recombine(self, rate=0.):\n\n # duplicate chromosomes\n chromosomes = np.tile(self.chromosomes, 2)\n\n # recombination\n if np.random.random() <= rate:\n chromosomes.sort()\n\n return chromosomes\n\n def divide(self, recombination_rate=0., reference_population=1000):\n\n # set average spacing between cells\n spacing = np.sqrt(2/reference_population) / 1e5\n\n # perform recombination\n chromosomes = self.recombine(rate=recombination_rate)\n\n # determine child positions\n jitter = np.random.normal(scale=spacing, size=(2, 2))\n xy_a, xy_b = self.xy+jitter[0], self.xy+jitter[1]\n\n # instantiate children\n daughter_a = self.__class__(xy_a, chromosomes[:2], self.lineage+'0')\n daughter_b = self.__class__(xy_b, chromosomes[2:], self.lineage+'1')\n\n return [daughter_a, daughter_b]\n\n def grow(self, max_generation=3, **kwargs):\n \"\"\"\n Recursive growth.\n \"\"\"\n\n # stopping criterion\n if self.generation >= max_generation:\n return [self]\n\n # divide\n else:\n children = self.divide(**kwargs)\n recurse = lambda x: x.grow(max_generation=max_generation, **kwargs)\n return reduce(add, map(recurse, children))\n"
]
| [
[
"numpy.random.normal",
"numpy.array",
"numpy.zeros",
"numpy.tile",
"numpy.sqrt",
"numpy.random.random"
]
]
|
Guaguago/CommonGen | [
"0a81b4edb8cd111571eba817eb994420f1070c48"
]
| [
"evaluation/Traditional/eval_metrics/rouge/rouge.py"
]
| [
"#!/usr/bin/env python\n# \n# File Name : rouge.py\n#\n# Description : Computes ROUGE-L metric as described by Lin and Hovey (2004)\n#\n# Creation Date : 2015-01-07 06:03\n# Author : Ramakrishna Vedantam <[email protected]>\n\nimport numpy as np\nimport pdb\n\ndef my_lcs(string, sub):\n \"\"\"\n Calculates longest common subsequence for a pair of tokenized strings\n :param string : list of str : tokens from a string split using whitespace\n :param sub : list of str : shorter string, also split using whitespace\n :returns: length (list of int): length of the longest common subsequence between the two strings\n\n Note: my_lcs only gives length of the longest common subsequence, not the actual LCS\n \"\"\"\n if(len(string)< len(sub)):\n sub, string = string, sub\n\n lengths = [[0 for i in range(0,len(sub)+1)] for j in range(0,len(string)+1)]\n\n for j in range(1,len(sub)+1):\n for i in range(1,len(string)+1):\n if(string[i-1] == sub[j-1]):\n lengths[i][j] = lengths[i-1][j-1] + 1\n else:\n lengths[i][j] = max(lengths[i-1][j] , lengths[i][j-1])\n\n return lengths[len(string)][len(sub)]\n\nclass Rouge():\n '''\n Class for computing ROUGE-L score for a set of candidate sentences for the MS COCO test set\n\n '''\n def __init__(self):\n # vrama91: updated the value below based on discussion with Hovey\n self.beta = 1.2\n\n def calc_score(self, candidate, refs):\n \"\"\"\n Compute ROUGE-L score given one candidate and references for an image\n :param candidate: str : candidate sentence to be evaluated\n :param refs: list of str : COCO reference sentences for the particular image to be evaluated\n :returns score: int (ROUGE-L score for the candidate evaluated against references)\n \"\"\"\n assert(len(candidate)==1)\t\n assert(len(refs)>0) \n prec = []\n rec = []\n\n # split into tokens\n token_c = candidate[0].split(\" \")\n \t\n for reference in refs:\n # split into tokens\n token_r = reference.split(\" \")\n # compute the longest common subsequence\n lcs = my_lcs(token_r, token_c)\n prec.append(lcs/float(len(token_c)))\n rec.append(lcs/float(len(token_r)))\n\n prec_max = max(prec)\n rec_max = max(rec)\n\n if(prec_max!=0 and rec_max !=0):\n score = ((1 + self.beta**2)*prec_max*rec_max)/float(rec_max + self.beta**2*prec_max)\n else:\n score = 0.0\n return score\n\n def compute_score(self, gts, res):\n \"\"\"\n Computes Rouge-L score given a set of reference and candidate sentences for the dataset\n Invoked by evaluate_captions.py \n :param hypo_for_image: dict : candidate / test sentences with \"image name\" key and \"tokenized sentences\" as values \n :param ref_for_image: dict : reference MS-COCO sentences with \"image name\" key and \"tokenized sentences\" as values\n :returns: average_score: float (mean ROUGE-L score computed by averaging scores for all the images)\n \"\"\"\n assert(gts.keys() == res.keys())\n imgIds = gts.keys()\n\n score = []\n for id in imgIds:\n hypo = res[id]\n ref = gts[id]\n\n score.append(self.calc_score(hypo, ref))\n\n # Sanity check.\n assert(type(hypo) is list)\n assert(len(hypo) == 1)\n assert(type(ref) is list)\n assert(len(ref) > 0)\n\n average_score = np.mean(np.array(score))\n return average_score, np.array(score)\n\n def method(self):\n return \"Rouge\"\n\n# if __name__ == \"__main__\":\n#\n# cand_1 = \"A boy picks an apple tree and places it into bags.\"\n# cand_2 = \"Two girls pick many red apples from trees and place them in a large bag.\"\n# ref = \"A boy picks an apple from a tree and places it into bags.\"\n# concepts = [\"pick\", \"apple\", \"tree\", \"place\", \"bag\"]\n#\n#\n# rouge = Rouge()\n# print rouge.calc_score([cand_1], ref)"
]
| [
[
"numpy.array"
]
]
|
dnandha/grraspn | [
"0a660d3f73487ea2f8caabf791809de283e8b806"
]
| [
"detectron2/modeling/proposal_generator/rrpn.py"
]
| [
"# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved\nimport logging\nfrom typing import Dict\nimport torch\n\nfrom detectron2.layers import ShapeSpec\n\nfrom ..box_regression import Box2BoxTransformRotated\nfrom .build import PROPOSAL_GENERATOR_REGISTRY\nfrom .rpn import RPN\nfrom .rrpn_outputs import RRPNOutputs, find_top_rrpn_proposals\n\nlogger = logging.getLogger(__name__)\n\n\n@PROPOSAL_GENERATOR_REGISTRY.register()\nclass RRPN(RPN):\n \"\"\"\n Rotated RPN subnetwork.\n Please refer to https://arxiv.org/pdf/1703.01086.pdf for the original RRPN paper:\n Ma, J., Shao, W., Ye, H., Wang, L., Wang, H., Zheng, Y., & Xue, X. (2018).\n Arbitrary-oriented scene text detection via rotation proposals.\n IEEE Transactions on Multimedia, 20(11), 3111-3122.\n \"\"\"\n\n def __init__(self, cfg, input_shape: Dict[str, ShapeSpec]):\n super().__init__(cfg, input_shape)\n self.box2box_transform = Box2BoxTransformRotated(weights=cfg.MODEL.RPN.BBOX_REG_WEIGHTS)\n\n def forward(self, images, features, gt_instances=None):\n \"\"\"\n Args:\n images (ImageList): input images of length `N`\n features (dict[str: Tensor]): input data as a mapping from feature\n map name to tensor. Axis 0 represents the number of images `N` in\n the input data; axes 1-3 are channels, height, and width, which may\n vary between feature maps (e.g., if a feature pyramid is used).\n gt_instances (list[Instances], optional): a length `N` list of `Instances`s.\n Each `Instances` stores ground-truth instances for the corresponding image.\n\n Returns:\n proposals: list[Instances] or None\n loss: dict[Tensor]\n \"\"\"\n gt_boxes = [x.gt_boxes for x in gt_instances] if gt_instances is not None else None\n del gt_instances\n features = [features[f] for f in self.in_features]\n pred_objectness_logits, pred_anchor_deltas = self.rpn_head(features)\n anchors = self.anchor_generator(features)\n\n outputs = RRPNOutputs(\n self.box2box_transform,\n self.anchor_matcher,\n self.batch_size_per_image,\n self.positive_fraction,\n images,\n pred_objectness_logits,\n pred_anchor_deltas,\n anchors,\n self.boundary_threshold,\n gt_boxes,\n self.smooth_l1_beta,\n self.lambda_\n )\n\n if self.training:\n losses = outputs.losses()\n else:\n losses = {}\n\n with torch.no_grad():\n # Find the top proposals by applying NMS and removing boxes that\n # are too small. The proposals are treated as fixed for approximate\n # joint training with roi heads. This approach ignores the derivative\n # w.r.t. the proposal boxes’ coordinates that are also network\n # responses, so is approximate.\n proposals = find_top_rrpn_proposals(\n outputs.predict_proposals(),\n outputs.predict_objectness_logits(),\n images,\n self.nms_thresh,\n self.pre_nms_topk[self.training],\n self.post_nms_topk[self.training],\n self.min_box_side_len,\n self.training,\n )\n\n return proposals, losses\n"
]
| [
[
"torch.no_grad"
]
]
|
data-centric-ai/dcbench | [
"831ab2359d686739d0b0c7a589974ce08448e58d"
]
| [
"dcbench/common/modeling.py"
]
| [
"from abc import abstractmethod\n\nimport PIL\nimport pytorch_lightning as pl\nimport torch\nimport torch.nn as nn\nimport torchvision.transforms as transforms\nfrom torch.hub import load_state_dict_from_url\nfrom torchvision.models import DenseNet as _DenseNet\nfrom torchvision.models import ResNet as _ResNet\nfrom torchvision.models.densenet import _load_state_dict\nfrom torchvision.models.densenet import model_urls as densenet_model_urls\nfrom torchvision.models.resnet import BasicBlock, Bottleneck\nfrom torchvision.models.resnet import model_urls as resnet_model_urls\n\n\nclass Model(pl.LightningModule):\n\n DEFAULT_CONFIG = {}\n\n def __init__(self, config: dict = None):\n super().__init__()\n self.config = self.DEFAULT_CONFIG.copy()\n if config is not None:\n self.config.update(config)\n\n self._set_model()\n\n @abstractmethod\n def _set_model(self):\n raise NotImplementedError()\n\n\nclass ResNet(_ResNet):\n\n ACTIVATION_DIMS = [64, 128, 256, 512]\n ACTIVATION_WIDTH_HEIGHT = [64, 32, 16, 8]\n RESNET_TO_ARCH = {\"resnet18\": [2, 2, 2, 2], \"resnet50\": [3, 4, 6, 3]}\n\n def __init__(\n self,\n num_classes: int,\n arch: str = \"resnet18\",\n dropout: float = 0.0,\n pretrained: bool = True,\n ):\n if arch not in self.RESNET_TO_ARCH:\n raise ValueError(\n f\"config['classifier'] must be one of: {self.RESNET_TO_ARCH.keys()}\"\n )\n\n block = BasicBlock if arch == \"resnet18\" else Bottleneck\n super().__init__(block, self.RESNET_TO_ARCH[arch])\n if pretrained:\n state_dict = load_state_dict_from_url(\n resnet_model_urls[arch], progress=True\n )\n self.load_state_dict(state_dict)\n\n # self.fc = nn.Linear(512 * block.expansion, num_classes)\n self.fc = nn.Sequential(\n nn.Dropout(dropout), nn.Linear(512 * block.expansion, num_classes)\n )\n\n\ndef default_transform(img: PIL.Image.Image):\n return transforms.Compose(\n [\n transforms.Resize(256),\n transforms.CenterCrop(224),\n transforms.ToTensor(),\n transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),\n ]\n )(img)\n\n\ndef default_train_transform(img: PIL.Image.Image):\n return transforms.Compose(\n [\n transforms.RandomResizedCrop(224),\n transforms.RandomHorizontalFlip(),\n transforms.ToTensor(),\n transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),\n ]\n )(img)\n\n\nclass DenseNet(_DenseNet):\n\n DENSENET_TO_ARCH = {\n \"densenet121\": {\n \"growth_rate\": 32,\n \"block_config\": (6, 12, 24, 16),\n \"num_init_features\": 64,\n }\n }\n\n def __init__(\n self, num_classes: int, arch: str = \"densenet121\", pretrained: bool = True\n ):\n if arch not in self.DENSENET_TO_ARCH:\n raise ValueError(\n f\"config['classifier'] must be one of: {self.DENSENET_TO_ARCH.keys()}\"\n )\n\n super().__init__(**self.DENSENET_TO_ARCH[arch])\n if pretrained:\n _load_state_dict(self, densenet_model_urls[arch], progress=True)\n\n self.classifier = nn.Linear(self.classifier.in_features, num_classes)\n\n\nclass VisionClassifier(Model):\n\n DEFAULT_CONFIG = {\n \"lr\": 1e-4,\n \"model_name\": \"resnet\",\n \"arch\": \"resnet18\",\n \"pretrained\": True,\n \"num_classes\": 2,\n \"transform\": default_transform,\n \"train_transform\": default_train_transform,\n }\n\n def _set_model(self):\n if self.config[\"model_name\"] == \"resnet\":\n self.model = ResNet(\n num_classes=self.config[\"num_classes\"],\n arch=self.config[\"arch\"],\n pretrained=self.config[\"pretrained\"],\n )\n elif self.config[\"model_name\"] == \"densenet\":\n self.model = DenseNet(\n num_classes=self.config[\"num_classes\"], arch=self.config[\"arch\"]\n )\n else:\n raise ValueError(f\"Model name {self.config['model_name']} not supported.\")\n\n def forward(self, x):\n return self.model(x)\n\n def training_step(self, batch, batch_idx):\n inputs, targets, _ = batch[\"input\"], batch[\"target\"], batch[\"id\"]\n outs = self.forward(inputs)\n\n loss = nn.functional.cross_entropy(outs, targets)\n self.log(\"train_loss\", loss, on_step=True, logger=True)\n return loss\n\n def validation_step(self, batch, batch_idx):\n inputs, targets = batch[\"input\"], batch[\"target\"]\n\n outs = self.forward(inputs)\n loss = nn.functional.cross_entropy(outs, targets)\n self.log(\"valid_loss\", loss)\n\n def validation_epoch_end(self, outputs) -> None:\n for metric_name, metric in self.metrics.items():\n self.log(f\"valid_{metric_name}\", metric.compute())\n metric.reset()\n\n def test_epoch_end(self, outputs) -> None:\n return self.validation_epoch_end(outputs)\n\n def test_step(self, batch, batch_idx):\n return self.validation_step(batch, batch_idx)\n\n def configure_optimizers(self):\n optimizer = torch.optim.Adam(self.parameters(), lr=self.config[\"lr\"])\n return optimizer\n"
]
| [
[
"torch.nn.Linear",
"torch.nn.functional.cross_entropy",
"torch.hub.load_state_dict_from_url",
"torch.nn.Dropout"
]
]
|
johnnycakes79/SpiceyPy | [
"7b63a1555df0adb7926cf5a6cfff14746a9dc4c1"
]
| [
"SpiceyPy/support_types.py"
]
| [
"# Collection of supporting functions for wrapper functions\n__author__ = 'AndrewAnnex'\nfrom ctypes import c_char_p, c_bool, c_int, c_double, c_char, c_void_p, sizeof, \\\n POINTER, pointer, Array, create_string_buffer, create_unicode_buffer, cast, Structure, \\\n CFUNCTYPE, string_at\n\nimport numpy\nfrom numpy import ctypeslib as numpc\nimport six\n\nerrorformat = \"\"\"\n================================================================================\n\nToolkit version: {tkvsn}\n\n{short} --\n{explain}\n{long}\n\n{traceback}\n\n================================================================================\\\n\"\"\"\n\nclass SpiceyError(Exception):\n \"\"\"\n SpiceyError wraps CSPICE errors.\n :type value: str\n \"\"\"\n def __init__(self, value):\n self.value = value\n\n def __str__(self):\n return self.value\n\n\ndef toDoubleVector(x):\n return DoubleArray.from_param(param=x)\n\n\ndef toDoubleMatrix(x):\n return DoubleMatrix.from_param(param=x)\n\n\ndef toIntVector(x):\n return IntArray.from_param(param=x)\n\n\ndef toBoolVector(x):\n return BoolArray.from_param(param=x)\n\n\ndef toPythonString(inString):\n if six.PY2:\n if isinstance(inString, c_char_p):\n return toPythonString(inString.value)\n return string_at(inString)\n elif six.PY3:\n if isinstance(inString, c_char_p):\n return toPythonString(inString.value)\n return bytes.decode(string_at(inString))\n\n\ndef listtocharvector(x):\n assert (isinstance(x, list))\n return (c_char_p * len(x))(*[stringToCharP(y) for y in x])\n\n\ndef charvector(ndim=1, lenvals=10):\n return ((c_char * lenvals) * ndim)()\n\n\ndef listtodoublematrix(data, x=3, y=3):\n matrix = ((c_double * x) * y)()\n for i, row in enumerate(data):\n matrix[i] = tuple(row)\n return matrix\n\n\ndef emptyCharArray(xLen=None, yLen=None):\n if not yLen:\n yLen = 1\n if not xLen:\n xLen = 1\n if isinstance(xLen, c_int):\n xLen = xLen.value\n if isinstance(yLen, c_int):\n yLen = yLen.value\n return ((c_char * xLen) * yLen)()\n\n\ndef emptyDoubleMatrix(x=3, y=3):\n return ((c_double * x) * y)()\n\n\ndef emptyDoubleVector(n):\n if isinstance(n, c_int):\n n = n.value\n assert(isinstance(n, int))\n return (c_double * n)()\n\n\ndef emptyIntVector(n):\n if isinstance(n, c_int):\n n = n.value\n assert (isinstance(n, int))\n return (c_int * n)()\n\n\ndef vectorToList(x):\n if isinstance(x[0], bool):\n return numpy.fromiter(x, numpy.bool, count=len(x))\n elif isinstance(x[0], int):\n return numpy.fromiter(x, numpy.int_, count=len(x))\n elif isinstance(x[0], float):\n return numpy.fromiter(x, numpy.float64, count=len(x))\n elif isinstance(x[0].value, bytes):\n return [toPythonString(y) for y in x]\n\n\ndef matrixToList(x):\n return numpc.as_array(x)\n\n\ndef stringToCharP(inobject, inlen=None):\n\n \"\"\"\n :param inobject: input string, int for getting null string of length of int\n :param inlen: optional parameter, length of a given string can be specified\n :return:\n \"\"\"\n if inlen and isinstance(inobject, str):\n return create_string_buffer(inobject.encode(encoding='UTF-8'), inlen)\n if isinstance(inobject, bytes):\n return inobject\n if isinstance(inobject, c_int):\n return stringToCharP(\" \" * inobject.value)\n if isinstance(inobject, int):\n return stringToCharP(\" \" * inobject)\n return c_char_p(inobject.encode(encoding='UTF-8'))\n\n\ndef listToCharArray(inList, xLen=None, yLen=None):\n assert (isinstance(inList, list))\n if not yLen:\n yLen = len(inList)\n if not xLen:\n xLen = max(len(s) for s in inList) + 1\n if isinstance(xLen, c_int):\n xLen = xLen.value\n if isinstance(yLen, c_int):\n yLen = yLen.value\n return ((c_char * xLen) * yLen)(*[stringToCharP(l, inlen=xLen) for l in inList])\n\n\ndef listToCharArrayPtr(inList, xLen=None, yLen=None):\n assert (isinstance(inList, list))\n if not yLen:\n yLen = len(inList)\n if not xLen:\n xLen = max(len(s) for s in inList) + 1\n if isinstance(xLen, c_int):\n xLen = xLen.value\n if isinstance(yLen, c_int):\n yLen = yLen.value\n return cast(((c_char * xLen) * yLen)(*[stringToCharP(l, inlen=xLen) for l in inList]), c_char_p)\n\n\nclass DoubleArrayType:\n # Class type that will handle all double vectors, inspiration from python cookbook 3rd edition\n def from_param(self, param):\n typename = type(param).__name__\n if hasattr(self, 'from_' + typename):\n return getattr(self, 'from_' + typename)(param)\n elif isinstance(param, Array):\n return param\n else:\n raise TypeError(\"Can't convert %s\" % typename)\n\n # Cast from lists/tuples\n def from_list(self, param):\n val = ((c_double) * len(param))(*param)\n return val\n\n # Cast from Tuple\n def from_tuple(self, param):\n val = ((c_double) * len(param))(*param)\n return val\n\n # Cast from a numpy array,\n def from_ndarray(self, param):\n # return param.data_as(POINTER(c_double))\n # the above older method does not work with functions which take vectors of known size\n return numpy.ctypeslib.as_ctypes(param)\n\n # Cast from array.array objects\n def from_array(self, param):\n if param.typecode != 'd':\n raise TypeError('must be an array of doubles')\n ptr, _ = param.buffer_info()\n return cast(ptr, POINTER(c_double))\n\n\nclass DoubleMatrixType:\n # Class type that will handle all double matricies, inspiration from python cookbook 3rd edition\n def from_param(self, param):\n typename = type(param).__name__\n if hasattr(self, 'from_' + typename):\n return getattr(self, 'from_' + typename)(param)\n elif isinstance(param, Array):\n return param\n else:\n raise TypeError(\"Can't convert %s\" % typename)\n\n # Cast from lists/tuples\n def from_list(self, param):\n val = ((c_double * len(param[0])) * len(param))(*[DoubleArray.from_param(x) for x in param])\n return val\n\n # Cast from Tuple\n def from_tuple(self, param):\n val = ((c_double * len(param[0])) * len(param))(*[DoubleArray.from_param(x) for x in param])\n return val\n\n # Cast from a numpy array\n def from_ndarray(self, param):\n #return param.data_as(POINTER(c_double))\n return numpy.ctypeslib.as_ctypes(param)\n\n # Cast from a numpy matrix\n def from_matrix(self, param):\n #return param.data_as(POINTER(c_double))\n return numpy.ctypeslib.as_ctypes(param)\n\n\nclass IntArrayType:\n # Class type that will handle all int vectors, inspiration from python cookbook 3rd edition\n def from_param(self, param):\n typename = type(param).__name__\n if hasattr(self, 'from_' + typename):\n return getattr(self, 'from_' + typename)(param)\n elif isinstance(param, Array):\n return param\n else:\n raise TypeError(\"Can't convert %s\" % typename)\n\n # Cast from lists/tuples\n def from_list(self, param):\n val = ((c_int) * len(param))(*param)\n return val\n\n # Cast from Tuple\n def from_tuple(self, param):\n val = ((c_int) * len(param))(*param)\n return val\n\n # Cast from a numpy array\n def from_ndarray(self, param):\n #return param.data_as(POINTER(c_int)) # not sure if long is same as int, it should be..\n #return numpy.ctypeslib.as_ctypes(param)\n return self.from_param(param.tolist())\n\n # Cast from array.array objects\n def from_array(self, param):\n if param.typecode != 'i':\n raise TypeError('must be an array of ints')\n ptr, _ = param.buffer_info()\n return cast(ptr, POINTER(c_int))\n\n\nclass BoolArrayType:\n # Class type that will handle all int vectors, inspiration from python cookbook 3rd edition\n def from_param(self, param):\n typename = type(param).__name__\n if hasattr(self, 'from_' + typename):\n return getattr(self, 'from_' + typename)(param)\n elif isinstance(param, Array):\n return param\n else:\n raise TypeError(\"Can't convert %s\" % typename)\n\n # Cast from lists/tuples\n def from_list(self, param):\n val = ((c_bool) * len(param))(*param)\n return val\n\n # Cast from Tuple\n def from_tuple(self, param):\n val = ((c_bool) * len(param))(*param)\n return val\n\n # Cast from a numpy array\n def from_ndarray(self, param):\n #return param.data_as(POINTER(c_int)) # not sure if long is same as int, it should be..\n #return numpy.ctypeslib.as_ctypes(param)\n return self.from_param(param.tolist())\n\n\nDoubleArray = DoubleArrayType()\n\nIntArray = IntArrayType()\n\nBoolArray = BoolArrayType()\n\nDoubleMatrix = DoubleMatrixType()\n\n\nclass Plane(Structure):\n _fields_ = [\n ('_normal', c_double * 3),\n ('_constant', c_double)\n ]\n\n @property\n def normal(self):\n return vectorToList(self._normal)\n\n @property\n def constant(self):\n return self._constant\n\n def __str__(self):\n return '<Plane: normal=%s; constant=%s>' % (', '.join([str(x) for x in self._normal]), self._constant)\n\n\nclass Ellipse(Structure):\n _fields_ = [\n ('_center', c_double * 3),\n ('_semi_major', c_double * 3),\n ('_semi_minor', c_double * 3)\n ]\n\n @property\n def center(self):\n return vectorToList(self._center)\n\n @property\n def semi_major(self):\n return vectorToList(self._semi_major)\n\n @property\n def semi_minor(self):\n return vectorToList(self._semi_minor)\n\n def __str__(self):\n return '<SpiceEllipse: center = %s, semi_major = %s, semi_minor = %s>' % \\\n (self.center, self.semi_major, self.semi_minor)\n\n\nclass DataType(object):\n SPICE_CHR = 0\n SPICE_DP = 1\n SPICE_INT = 2\n SPICE_TIME = 3\n SPICE_BOOL = 4\n CHR = 0\n DP = 1\n INT = 2\n TIME = 3\n BOOL = 4\n\n def __init__(self):\n pass\n\n\nclass SpiceEKDataType(c_int):\n _fields_ = [\n ('SPICE_CHR', c_int(0)),\n ('SPICE_DP', c_int(1)),\n ('SPICE_INT', c_int(2)),\n ('SPICE_TIME', c_int(3)),\n ('SPICE_BOOL', c_int(4)),\n ]\n\n\nclass SpiceEKExprClass(c_int):\n _fields_ = [\n ('SPICE_EK_EXP_COL', c_int(0)),\n ('SPICE_EK_EXP_FUNC', c_int(1)),\n ('SPICE_EK_EXP_EXPR', c_int(2))\n ]\n\n\nclass SpiceEKAttDsc(Structure):\n _fields_ = [\n ('_cclass', c_int),\n ('_dtype', SpiceEKDataType),\n ('_strlen', c_int),\n ('_size', c_int),\n ('_indexd', c_bool),\n ('_nullok', c_bool)\n ]\n\n @property\n def cclass(self):\n return self._cclass\n\n @property\n def dtype(self):\n return self._dtype.value\n\n @property\n def strlen(self):\n return self._strlen\n\n @property\n def size(self):\n return self._size\n\n @property\n def indexd(self):\n return self._indexd\n\n @property\n def nullok(self):\n return self._nullok\n\n def __str__(self):\n return '<SpiceEKAttDsc cclass = %s, dtype = %s, strlen = %s, size = %s, indexd = %s, nullok = %s >' % \\\n (self.cclass, self.dtype, self.strlen, self.size, self.indexd, self.nullok)\n\n\nclass SpiceEKSegSum(Structure):\n _fields_ = [\n ('_tabnam', c_char * 65),\n ('_nrows', c_int),\n ('_ncols', c_int),\n ('_cnames', (c_char * 100) * 33),\n ('_cdescrs', SpiceEKAttDsc * 100)\n ]\n\n @property\n def tabnam(self):\n return toPythonString(self._tabnam)\n\n @property\n def nrows(self):\n return self._nrows\n\n @property\n def ncols(self):\n return self._ncols\n\n @property\n def cnames(self):\n return vectorToList(self._cnames)[0:self.ncols]\n\n @property\n def cdescrs(self):\n return self._cdescrs[0:self.ncols]\n\n def __str__(self):\n return '<SpiceEKSegSum tabnam = %s, nrows = %s, ncols = %s, cnames = %s, cdescrs = %s >' % (self.tabnam, self.nrows, self.ncols, self.cnames, self.cdescrs)\n\n\n#SpiceCell implementation below is inpart from github.com/DaRasch/spiceminer/\n# and modified as needed for this author, maybe we should work together?\n\n### helper classes/functions ###\nBITSIZE = {'char': sizeof(c_char), 'int': sizeof(c_int), 'double': sizeof(c_double)}\n\n\ndef _char_getter(data_p, index, length):\n return toPythonString((c_char * length).from_address(data_p + index * length * BITSIZE['char']))\n\n\ndef _double_getter(data_p, index, length):\n return c_double.from_address(data_p + index * BITSIZE['double']).value\n\n\ndef _int_getter(data_p, index, length):\n return c_int.from_address(data_p + index * BITSIZE['int']).value\n\n\ndef SPICEDOUBLE_CELL(size):\n return SpiceCell.double(size)\n\n\ndef SPICEINT_CELL(size):\n return SpiceCell.integer(size)\n\n\ndef SPICECHAR_CELL(size, length):\n return SpiceCell.character(size, length)\n\n\nclass SpiceCell(Structure):\n #Most written by DaRasch\n DATATYPES_ENUM = {'char': 0, 'double': 1, 'int': 2, 'time': 3, 'bool': 4}\n DATATYPES_GET = [_char_getter, _double_getter] + [_int_getter] * 3\n baseSize = 6\n minCharLen = 6\n CTRLBLOCK = 6\n _fields_ = [\n ('dtype', c_int),\n ('length', c_int),\n ('size', c_int),\n ('card', c_int),\n ('isSet', c_int),\n ('adjust', c_int),\n ('init', c_int),\n ('base', c_void_p),\n ('data', c_void_p)\n ]\n\n def __init__(self, dtype=None, length=None, size=None, card=None, isSet=None, base=None, data=None):\n super(SpiceCell, self).__init__()\n self.dtype = dtype\n self.length = length\n self.size = size\n self.card = card\n self.isSet = isSet\n self.adjust = 0 # Always False, because not implemented\n self.init = 0 # Always False, because this is the constructor\n self.base = base # void pointer\n self.data = data\n\n def __str__(self):\n return '<SpiceCell dtype = %s, length = %s, size = %s, card = %s, isSet = %s, adjust = %s, init = %s, base = %s, data = %s>' % (self.dtype, self.length, self.size, self.card, self.isSet, self.adjust, self.init, self.base, self.data)\n\n def is_int(self):\n return self.dtype == 2\n\n def is_double(self):\n return self.dtype == 1\n\n def is_char(self):\n return self.dtype == 0\n\n def is_time(self):\n return self.dtype == 3\n\n def is_bool(self):\n return self.dtype == 4\n\n def is_set(self):\n return self.isSet == 1\n\n @classmethod\n def character(cls, size, length):\n base = (c_char * ((cls.CTRLBLOCK + size) * length))()\n data = (c_char * (size * length)).from_buffer(\n base, cls.CTRLBLOCK * BITSIZE['char'] * length)\n instance = cls(cls.DATATYPES_ENUM['char'], length, size, 0, 1,\n cast(base, c_void_p),\n cast(data, c_void_p))\n return instance\n\n @classmethod\n def integer(cls, size):\n base = (c_int * (cls.CTRLBLOCK + size))()\n data = (c_int * size).from_buffer(\n base, cls.CTRLBLOCK * BITSIZE['int'])\n instance = cls(cls.DATATYPES_ENUM['int'], 0, size, 0, 1,\n cast(base, c_void_p),\n cast(data, c_void_p))\n return instance\n\n @classmethod\n def double(cls, size):\n base = (c_double * (cls.CTRLBLOCK + size))()\n data = (c_double * size).from_buffer(\n base, cls.CTRLBLOCK * BITSIZE['double'])\n instance = cls(cls.DATATYPES_ENUM['double'], 0, size, 0, 1,\n cast(base, c_void_p),\n cast(data, c_void_p))\n return instance\n\n def __len__(self):\n return self.card\n\n def __iter__(self):\n getter = SpiceCell.DATATYPES_GET[self.dtype]\n length, card, data = self.length, self.card, self.data\n for i in range(card):\n yield (getter(data, i, length))\n\n def __contains__(self, key):\n return key in self.__iter__()\n\n def __getitem__(self, key):\n getter = SpiceCell.DATATYPES_GET[self.dtype]\n length, card, data = self.length, self.card, self.data\n if isinstance(key, slice):\n start, stop, step = key.start or 0, key.stop or -1, key.step or 1\n #TODO Typechecking\n if card == 0:\n return []\n else:\n return list(getter(data, i, length)\n for i in range(start % card, stop % card + 1, step))\n if key in range(-card, card):\n return getter(data, key, length)\n elif not isinstance(key, int):\n msg = 'SpiceCell inices must be integers, not {}'.format(type(key))\n raise TypeError(msg)\n else:\n raise IndexError('SpiceCell index out of range')\n\n def reset(self):\n self.card = 0\n self.init = 0"
]
| [
[
"numpy.ctypeslib.as_ctypes",
"numpy.ctypeslib.as_array"
]
]
|
matthiaskoenig/memote | [
"7c14cd304523dda83eaf4835ee007243e8673f85"
]
| [
"memote/experimental/growth.py"
]
| [
"# -*- coding: utf-8 -*-\n\n# Copyright 2018 Novo Nordisk Foundation Center for Biosustainability,\n# Technical University of Denmark.\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\"\"\"Provide an interface for growth experiments.\"\"\"\n\nfrom __future__ import absolute_import\n\nimport logging\n\nfrom pandas import DataFrame\n\nfrom memote.experimental.experiment import Experiment\n\n__all__ = (\"GrowthExperiment\",)\n\nLOGGER = logging.getLogger(__name__)\n\n\nclass GrowthExperiment(Experiment):\n \"\"\"Represent a growth experiment.\"\"\"\n\n SCHEMA = \"growth.json\"\n\n def __init__(self, **kwargs):\n \"\"\"\n Initialize a growth experiment.\n\n Parameters\n ----------\n kwargs\n\n \"\"\"\n super(GrowthExperiment, self).__init__(**kwargs)\n\n def load(self, dtype_conversion=None):\n \"\"\"\n Load the data table and corresponding validation schema.\n\n Parameters\n ----------\n dtype_conversion : dict\n Column names as keys and corresponding type for loading the data.\n Please take a look at the `pandas documentation\n <https://pandas.pydata.org/pandas-docs/stable/io.html#specifying-column-data-types>`__\n for detailed explanations.\n\n \"\"\"\n if dtype_conversion is None:\n dtype_conversion = {\"growth\": str}\n super(GrowthExperiment, self).load(dtype_conversion=dtype_conversion)\n self.data[\"growth\"] = self.data[\"growth\"].isin(self.TRUTHY)\n\n def evaluate(self, model, threshold=0.1):\n \"\"\"Evaluate in silico growth rates.\"\"\"\n with model:\n if self.medium is not None:\n self.medium.apply(model)\n if self.objective is not None:\n model.objective = self.objective\n model.add_cons_vars(self.constraints)\n threshold *= model.slim_optimize()\n growth = list()\n for row in self.data.itertuples(index=False):\n with model:\n exchange = model.reactions.get_by_id(row.exchange)\n if bool(exchange.reactants):\n exchange.lower_bound = -row.uptake\n else:\n exchange.upper_bound = row.uptake\n growth.append(model.slim_optimize() >= threshold)\n return DataFrame({\n \"exchange\": self.data[\"exchange\"],\n \"growth\": growth\n })\n"
]
| [
[
"pandas.DataFrame"
]
]
|
DaoDaoer/PaddleSeg | [
"7fe2e41de0f192494b8f2088ee500bb55d17708e",
"7fe2e41de0f192494b8f2088ee500bb55d17708e"
]
| [
"contrib/DomainAdaptation/train.py",
"paddleseg/transforms/transforms.py"
]
| [
"# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport random\nimport argparse\nimport numpy as np\nimport paddle\n\nfrom paddleseg.utils import logger, get_sys_env\n\nimport utils\nfrom cvlibs import Config\nfrom script.train import Trainer\nfrom datasets import CityDataset, GTA5Dataset, SYNTHIADataset\n\n\ndef parse_args():\n parser = argparse.ArgumentParser(description='Model training')\n\n # params of training\n parser.add_argument(\n \"--config\", dest=\"cfg\", help=\"The config file.\", default=None, type=str)\n parser.add_argument(\n '--iters',\n dest='iters',\n help='iters for training',\n type=int,\n default=None)\n parser.add_argument(\n '--batch_size',\n dest='batch_size',\n help='Mini batch size of one gpu or cpu',\n type=int,\n default=None)\n parser.add_argument(\n '--learning_rate',\n dest='learning_rate',\n help='Learning rate',\n type=float,\n default=None)\n parser.add_argument(\n '--save_interval',\n dest='save_interval',\n help='How many iters to save a model snapshot once during training.',\n type=int,\n default=1000)\n parser.add_argument(\n '--resume_model',\n dest='resume_model',\n help='The path of resume model',\n type=str,\n default=None)\n parser.add_argument(\n '--save_dir',\n dest='save_dir',\n help='The directory for saving the model snapshot',\n type=str,\n default='./output')\n parser.add_argument(\n '--keep_checkpoint_max',\n dest='keep_checkpoint_max',\n help='Maximum number of checkpoints to save',\n type=int,\n default=5)\n parser.add_argument(\n '--num_workers',\n dest='num_workers',\n help='Num workers for data loader',\n type=int,\n default=0)\n parser.add_argument(\n '--do_eval',\n dest='do_eval',\n help='Eval while training',\n action='store_true')\n parser.add_argument(\n '--log_iters',\n dest='log_iters',\n help='Display logging information at every log_iters',\n default=10,\n type=int)\n parser.add_argument(\n '--use_vdl',\n dest='use_vdl',\n help='Whether to record the data to VisualDL during training',\n action='store_true')\n parser.add_argument(\n '--seed',\n dest='seed',\n help='Set the random seed during training.',\n default=42,\n type=int)\n parser.add_argument(\n '--fp16', dest='fp16', help='Whther to use amp', action='store_true')\n parser.add_argument(\n '--data_format',\n dest='data_format',\n help=\n 'Data format that specifies the layout of input. It can be \"NCHW\" or \"NHWC\". Default: \"NCHW\".',\n type=str,\n default='NCHW')\n\n return parser.parse_args()\n\n\ndef main(args):\n if args.seed is not None:\n paddle.seed(args.seed)\n np.random.seed(args.seed)\n random.seed(args.seed)\n logger.info('Set seed to {}'.format(args.seed))\n\n env_info = get_sys_env()\n info = ['{}: {}'.format(k, v) for k, v in env_info.items()]\n info = '\\n'.join(['', format('Environment Information', '-^48s')] + info +\n ['-' * 48])\n logger.info(info)\n\n place = 'gpu' if env_info['Paddle compiled with cuda'] and env_info[\n 'GPUs used'] else 'cpu'\n\n paddle.set_device(place)\n\n if not args.cfg:\n raise RuntimeError('No configuration file specified.')\n\n cfg = Config(\n args.cfg,\n learning_rate=args.learning_rate,\n iters=args.iters,\n batch_size=args.batch_size)\n\n if cfg.dic[\"data\"][\"source\"][\"dataset\"] == 'synthia':\n train_dataset_src = SYNTHIADataset(\n split='train', **cfg.dic[\"data\"][\"source\"][\"kwargs\"])\n val_dataset_src = SYNTHIADataset(\n split='val', **cfg.dic[\"data\"][\"source\"][\"kwargs\"])\n elif cfg.dic[\"data\"][\"source\"][\"dataset\"] == 'gta5':\n train_dataset_src = GTA5Dataset(\n split='train', **cfg.dic[\"data\"][\"source\"][\"kwargs\"])\n val_dataset_src = GTA5Dataset(\n split='val', **cfg.dic[\"data\"][\"source\"][\"kwargs\"])\n else:\n raise NotImplementedError()\n if cfg.dic[\"data\"][\"target\"][\"dataset\"] == 'cityscapes':\n train_dataset_tgt = CityDataset(\n split='train', **cfg.dic[\"data\"][\"target\"][\"kwargs\"])\n val_dataset_tgt = CityDataset(\n split='val', **cfg.dic[\"data\"][\"target\"][\"kwargs\"])\n else:\n raise NotImplementedError()\n\n val_dataset_tgt = val_dataset_tgt if args.do_eval else None\n val_dataset_src = val_dataset_src if args.do_eval else None\n\n if train_dataset_src is None:\n raise RuntimeError(\n 'The training dataset is not specified in the configuration file.')\n elif len(train_dataset_src) == 0:\n raise ValueError(\n 'The length of train_dataset is 0. Please check if your dataset is valid'\n )\n\n msg = '\\n---------------Config Information---------------\\n'\n msg += str(cfg)\n msg += '------------------------------------------------'\n logger.info(msg)\n\n trainer = Trainer(model=cfg.model, cfg=cfg.dic)\n trainer.train(\n train_dataset_src,\n train_dataset_tgt,\n val_dataset_tgt=val_dataset_tgt,\n val_dataset_src=val_dataset_src,\n optimizer=cfg.optimizer,\n save_dir=args.save_dir,\n iters=cfg.iters,\n batch_size=cfg.batch_size,\n resume_model=args.resume_model,\n save_interval=args.save_interval,\n log_iters=args.log_iters,\n num_workers=args.num_workers,\n use_vdl=args.use_vdl,\n keep_checkpoint_max=args.keep_checkpoint_max,\n test_config=cfg.test_config)\n\n\nif __name__ == '__main__':\n args = parse_args()\n main(args)\n",
"# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport random\nimport math\n\nimport cv2\nimport numpy as np\nfrom PIL import Image\n\nfrom paddleseg.cvlibs import manager\nfrom paddleseg.transforms import functional\n\n\[email protected]_component\nclass Compose:\n \"\"\"\n Do transformation on input data with corresponding pre-processing and augmentation operations.\n The shape of input data to all operations is [height, width, channels].\n\n Args:\n transforms (list): A list contains data pre-processing or augmentation. Empty list means only reading images, no transformation.\n to_rgb (bool, optional): If converting image to RGB color space. Default: True.\n\n Raises:\n TypeError: When 'transforms' is not a list.\n ValueError: when the length of 'transforms' is less than 1.\n \"\"\"\n\n def __init__(self, transforms, to_rgb=True):\n if not isinstance(transforms, list):\n raise TypeError('The transforms must be a list!')\n self.transforms = transforms\n self.to_rgb = to_rgb\n\n def __call__(self, im, label=None):\n \"\"\"\n Args:\n im (str|np.ndarray): It is either image path or image object.\n label (str|np.ndarray): It is either label path or label ndarray.\n\n Returns:\n (tuple). A tuple including image, image info, and label after transformation.\n \"\"\"\n if isinstance(im, str):\n im = cv2.imread(im).astype('float32')\n if isinstance(label, str):\n label = np.asarray(Image.open(label))\n if im is None:\n raise ValueError('Can\\'t read The image file {}!'.format(im))\n if self.to_rgb:\n im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)\n\n for op in self.transforms:\n outputs = op(im, label)\n im = outputs[0]\n if len(outputs) == 2:\n label = outputs[1]\n im = np.transpose(im, (2, 0, 1))\n return (im, label)\n\n\[email protected]_component\nclass RandomHorizontalFlip:\n \"\"\"\n Flip an image horizontally with a certain probability.\n\n Args:\n prob (float, optional): A probability of horizontally flipping. Default: 0.5.\n \"\"\"\n\n def __init__(self, prob=0.5):\n self.prob = prob\n\n def __call__(self, im, label=None):\n if random.random() < self.prob:\n im = functional.horizontal_flip(im)\n if label is not None:\n label = functional.horizontal_flip(label)\n if label is None:\n return (im, )\n else:\n return (im, label)\n\n\[email protected]_component\nclass RandomVerticalFlip:\n \"\"\"\n Flip an image vertically with a certain probability.\n\n Args:\n prob (float, optional): A probability of vertical flipping. Default: 0.1.\n \"\"\"\n\n def __init__(self, prob=0.1):\n self.prob = prob\n\n def __call__(self, im, label=None):\n if random.random() < self.prob:\n im = functional.vertical_flip(im)\n if label is not None:\n label = functional.vertical_flip(label)\n if label is None:\n return (im, )\n else:\n return (im, label)\n\n\[email protected]_component\nclass Resize:\n \"\"\"\n Resize an image.\n\n Args:\n target_size (list|tuple, optional): The target size of image. Default: (512, 512).\n interp (str, optional): The interpolation mode of resize is consistent with opencv.\n ['NEAREST', 'LINEAR', 'CUBIC', 'AREA', 'LANCZOS4', 'RANDOM']. Note that when it is\n 'RANDOM', a random interpolation mode would be specified. Default: \"LINEAR\".\n\n Raises:\n TypeError: When 'target_size' type is neither list nor tuple.\n ValueError: When \"interp\" is out of pre-defined methods ('NEAREST', 'LINEAR', 'CUBIC',\n 'AREA', 'LANCZOS4', 'RANDOM').\n \"\"\"\n\n # The interpolation mode\n interp_dict = {\n 'NEAREST': cv2.INTER_NEAREST,\n 'LINEAR': cv2.INTER_LINEAR,\n 'CUBIC': cv2.INTER_CUBIC,\n 'AREA': cv2.INTER_AREA,\n 'LANCZOS4': cv2.INTER_LANCZOS4\n }\n\n def __init__(self, target_size=(512, 512), interp='LINEAR'):\n self.interp = interp\n if not (interp == \"RANDOM\" or interp in self.interp_dict):\n raise ValueError(\"`interp` should be one of {}\".format(\n self.interp_dict.keys()))\n if isinstance(target_size, list) or isinstance(target_size, tuple):\n if len(target_size) != 2:\n raise ValueError(\n '`target_size` should include 2 elements, but it is {}'.\n format(target_size))\n else:\n raise TypeError(\n \"Type of `target_size` is invalid. It should be list or tuple, but it is {}\"\n .format(type(target_size)))\n\n self.target_size = target_size\n\n def __call__(self, im, label=None):\n \"\"\"\n Args:\n im (np.ndarray): The Image data.\n label (np.ndarray, optional): The label data. Default: None.\n\n Returns:\n (tuple). When label is None, it returns (im, ), otherwise it returns (im, label),\n\n Raises:\n TypeError: When the 'img' type is not numpy.\n ValueError: When the length of \"im\" shape is not 3.\n \"\"\"\n\n if not isinstance(im, np.ndarray):\n raise TypeError(\"Resize: image type is not numpy.\")\n if len(im.shape) != 3:\n raise ValueError('Resize: image is not 3-dimensional.')\n if self.interp == \"RANDOM\":\n interp = random.choice(list(self.interp_dict.keys()))\n else:\n interp = self.interp\n im = functional.resize(im, self.target_size, self.interp_dict[interp])\n if label is not None:\n label = functional.resize(label, self.target_size,\n cv2.INTER_NEAREST)\n\n if label is None:\n return (im, )\n else:\n return (im, label)\n\n\[email protected]_component\nclass ResizeByLong:\n \"\"\"\n Resize the long side of an image to given size, and then scale the other side proportionally.\n\n Args:\n long_size (int): The target size of long side.\n \"\"\"\n\n def __init__(self, long_size):\n self.long_size = long_size\n\n def __call__(self, im, label=None):\n \"\"\"\n Args:\n im (np.ndarray): The Image data.\n label (np.ndarray, optional): The label data. Default: None.\n\n Returns:\n (tuple). When label is None, it returns (im, ), otherwise it returns (im, label).\n \"\"\"\n\n im = functional.resize_long(im, self.long_size)\n if label is not None:\n label = functional.resize_long(label, self.long_size,\n cv2.INTER_NEAREST)\n\n if label is None:\n return (im, )\n else:\n return (im, label)\n\n\[email protected]_component\nclass ResizeByShort:\n \"\"\"\n Resize the short side of an image to given size, and then scale the other side proportionally.\n\n Args:\n short_size (int): The target size of short side.\n \"\"\"\n\n def __init__(self, short_size):\n self.short_size = short_size\n\n def __call__(self, im, label=None):\n \"\"\"\n Args:\n im (np.ndarray): The Image data.\n label (np.ndarray, optional): The label data. Default: None.\n\n Returns:\n (tuple). When label is None, it returns (im, ), otherwise it returns (im, label).\n \"\"\"\n\n im = functional.resize_short(im, self.short_size)\n if label is not None:\n label = functional.resize_short(label, self.short_size,\n cv2.INTER_NEAREST)\n\n if label is None:\n return (im, )\n else:\n return (im, label)\n\n\[email protected]_component\nclass LimitLong:\n \"\"\"\n Limit the long edge of image.\n\n If the long edge is larger than max_long, resize the long edge\n to max_long, while scale the short edge proportionally.\n\n If the long edge is smaller than min_long, resize the long edge\n to min_long, while scale the short edge proportionally.\n\n Args:\n max_long (int, optional): If the long edge of image is larger than max_long,\n it will be resize to max_long. Default: None.\n min_long (int, optional): If the long edge of image is smaller than min_long,\n it will be resize to min_long. Default: None.\n \"\"\"\n\n def __init__(self, max_long=None, min_long=None):\n if max_long is not None:\n if not isinstance(max_long, int):\n raise TypeError(\n \"Type of `max_long` is invalid. It should be int, but it is {}\"\n .format(type(max_long)))\n if min_long is not None:\n if not isinstance(min_long, int):\n raise TypeError(\n \"Type of `min_long` is invalid. It should be int, but it is {}\"\n .format(type(min_long)))\n if (max_long is not None) and (min_long is not None):\n if min_long > max_long:\n raise ValueError(\n '`max_long should not smaller than min_long, but they are {} and {}'\n .format(max_long, min_long))\n self.max_long = max_long\n self.min_long = min_long\n\n def __call__(self, im, label=None):\n \"\"\"\n Args:\n im (np.ndarray): The Image data.\n label (np.ndarray, optional): The label data. Default: None.\n\n Returns:\n (tuple). When label is None, it returns (im, ), otherwise it returns (im, label).\n \"\"\"\n h, w = im.shape[0], im.shape[1]\n long_edge = max(h, w)\n target = long_edge\n if (self.max_long is not None) and (long_edge > self.max_long):\n target = self.max_long\n elif (self.min_long is not None) and (long_edge < self.min_long):\n target = self.min_long\n\n if target != long_edge:\n im = functional.resize_long(im, target)\n if label is not None:\n label = functional.resize_long(label, target, cv2.INTER_NEAREST)\n\n if label is None:\n return (im, )\n else:\n return (im, label)\n\n\[email protected]_component\nclass ResizeRangeScaling:\n \"\"\"\n Resize the long side of an image into a range, and then scale the other side proportionally.\n\n Args:\n min_value (int, optional): The minimum value of long side after resize. Default: 400.\n max_value (int, optional): The maximum value of long side after resize. Default: 600.\n \"\"\"\n\n def __init__(self, min_value=400, max_value=600):\n if min_value > max_value:\n raise ValueError('min_value must be less than max_value, '\n 'but they are {} and {}.'.format(\n min_value, max_value))\n self.min_value = min_value\n self.max_value = max_value\n\n def __call__(self, im, label=None):\n \"\"\"\n Args:\n im (np.ndarray): The Image data.\n label (np.ndarray, optional): The label data. Default: None.\n\n Returns:\n (tuple). When label is None, it returns (im, ), otherwise it returns (im, label).\n \"\"\"\n\n if self.min_value == self.max_value:\n random_size = self.max_value\n else:\n random_size = int(\n np.random.uniform(self.min_value, self.max_value) + 0.5)\n im = functional.resize_long(im, random_size, cv2.INTER_LINEAR)\n if label is not None:\n label = functional.resize_long(label, random_size,\n cv2.INTER_NEAREST)\n\n if label is None:\n return (im, )\n else:\n return (im, label)\n\n\[email protected]_component\nclass ResizeStepScaling:\n \"\"\"\n Scale an image proportionally within a range.\n\n Args:\n min_scale_factor (float, optional): The minimum scale. Default: 0.75.\n max_scale_factor (float, optional): The maximum scale. Default: 1.25.\n scale_step_size (float, optional): The scale interval. Default: 0.25.\n\n Raises:\n ValueError: When min_scale_factor is smaller than max_scale_factor.\n \"\"\"\n\n def __init__(self,\n min_scale_factor=0.75,\n max_scale_factor=1.25,\n scale_step_size=0.25):\n if min_scale_factor > max_scale_factor:\n raise ValueError(\n 'min_scale_factor must be less than max_scale_factor, '\n 'but they are {} and {}.'.format(min_scale_factor,\n max_scale_factor))\n self.min_scale_factor = min_scale_factor\n self.max_scale_factor = max_scale_factor\n self.scale_step_size = scale_step_size\n\n def __call__(self, im, label=None):\n \"\"\"\n Args:\n im (np.ndarray): The Image data.\n label (np.ndarray, optional): The label data. Default: None.\n\n Returns:\n (tuple). When label is None, it returns (im, ), otherwise it returns (im, label).\n \"\"\"\n\n if self.min_scale_factor == self.max_scale_factor:\n scale_factor = self.min_scale_factor\n\n elif self.scale_step_size == 0:\n scale_factor = np.random.uniform(self.min_scale_factor,\n self.max_scale_factor)\n\n else:\n num_steps = int((self.max_scale_factor - self.min_scale_factor) /\n self.scale_step_size + 1)\n scale_factors = np.linspace(self.min_scale_factor,\n self.max_scale_factor,\n num_steps).tolist()\n np.random.shuffle(scale_factors)\n scale_factor = scale_factors[0]\n w = int(round(scale_factor * im.shape[1]))\n h = int(round(scale_factor * im.shape[0]))\n\n im = functional.resize(im, (w, h), cv2.INTER_LINEAR)\n if label is not None:\n label = functional.resize(label, (w, h), cv2.INTER_NEAREST)\n\n if label is None:\n return (im, )\n else:\n return (im, label)\n\n\[email protected]_component\nclass Normalize:\n \"\"\"\n Normalize an image.\n\n Args:\n mean (list, optional): The mean value of a data set. Default: [0.5, 0.5, 0.5].\n std (list, optional): The standard deviation of a data set. Default: [0.5, 0.5, 0.5].\n\n Raises:\n ValueError: When mean/std is not list or any value in std is 0.\n \"\"\"\n\n def __init__(self, mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5)):\n self.mean = mean\n self.std = std\n if not (isinstance(self.mean, (list, tuple))\n and isinstance(self.std, (list, tuple))):\n raise ValueError(\n \"{}: input type is invalid. It should be list or tuple\".format(\n self))\n from functools import reduce\n if reduce(lambda x, y: x * y, self.std) == 0:\n raise ValueError('{}: std is invalid!'.format(self))\n\n def __call__(self, im, label=None):\n \"\"\"\n Args:\n im (np.ndarray): The Image data.\n label (np.ndarray, optional): The label data. Default: None.\n\n Returns:\n (tuple). When label is None, it returns (im, ), otherwise it returns (im, label).\n \"\"\"\n\n mean = np.array(self.mean)[np.newaxis, np.newaxis, :]\n std = np.array(self.std)[np.newaxis, np.newaxis, :]\n im = functional.normalize(im, mean, std)\n\n if label is None:\n return (im, )\n else:\n return (im, label)\n\n\[email protected]_component\nclass Padding:\n \"\"\"\n Add bottom-right padding to a raw image or annotation image.\n\n Args:\n target_size (list|tuple): The target size after padding.\n im_padding_value (list, optional): The padding value of raw image.\n Default: [127.5, 127.5, 127.5].\n label_padding_value (int, optional): The padding value of annotation image. Default: 255.\n\n Raises:\n TypeError: When target_size is neither list nor tuple.\n ValueError: When the length of target_size is not 2.\n \"\"\"\n\n def __init__(self,\n target_size,\n im_padding_value=(127.5, 127.5, 127.5),\n label_padding_value=255):\n if isinstance(target_size, list) or isinstance(target_size, tuple):\n if len(target_size) != 2:\n raise ValueError(\n '`target_size` should include 2 elements, but it is {}'.\n format(target_size))\n else:\n raise TypeError(\n \"Type of target_size is invalid. It should be list or tuple, now is {}\"\n .format(type(target_size)))\n self.target_size = target_size\n self.im_padding_value = im_padding_value\n self.label_padding_value = label_padding_value\n\n def __call__(self, im, label=None):\n \"\"\"\n Args:\n im (np.ndarray): The Image data.\n label (np.ndarray, optional): The label data. Default: None.\n\n Returns:\n (tuple). When label is None, it returns (im, ), otherwise it returns (im, label).\n \"\"\"\n\n im_height, im_width = im.shape[0], im.shape[1]\n if isinstance(self.target_size, int):\n target_height = self.target_size\n target_width = self.target_size\n else:\n target_height = self.target_size[1]\n target_width = self.target_size[0]\n pad_height = target_height - im_height\n pad_width = target_width - im_width\n if pad_height < 0 or pad_width < 0:\n raise ValueError(\n 'The size of image should be less than `target_size`, but the size of image ({}, {}) is larger than `target_size` ({}, {})'\n .format(im_width, im_height, target_width, target_height))\n else:\n im = cv2.copyMakeBorder(\n im,\n 0,\n pad_height,\n 0,\n pad_width,\n cv2.BORDER_CONSTANT,\n value=self.im_padding_value)\n if label is not None:\n label = cv2.copyMakeBorder(\n label,\n 0,\n pad_height,\n 0,\n pad_width,\n cv2.BORDER_CONSTANT,\n value=self.label_padding_value)\n if label is None:\n return (im, )\n else:\n return (im, label)\n\n\[email protected]_component\nclass PaddingByAspectRatio:\n \"\"\"\n\n Args:\n aspect_ratio (int|float, optional): The aspect ratio = width / height. Default: 1.\n \"\"\"\n\n def __init__(self,\n aspect_ratio=1,\n im_padding_value=(127.5, 127.5, 127.5),\n label_padding_value=255):\n self.aspect_ratio = aspect_ratio\n self.im_padding_value = im_padding_value\n self.label_padding_value = label_padding_value\n\n def __call__(self, im, label=None):\n \"\"\"\n Args:\n im (np.ndarray): The Image data.\n label (np.ndarray, optional): The label data. Default: None.\n\n Returns:\n (tuple). When label is None, it returns (im, ), otherwise it returns (im, label).\n \"\"\"\n\n img_height = im.shape[0]\n img_width = im.shape[1]\n ratio = img_width / img_height\n if ratio == self.aspect_ratio:\n if label is None:\n return (im, )\n else:\n return (im, label)\n elif ratio > self.aspect_ratio:\n img_height = int(img_width / self.aspect_ratio)\n else:\n img_width = int(img_height * self.aspect_ratio)\n padding = Padding((img_width, img_height),\n im_padding_value=self.im_padding_value,\n label_padding_value=self.label_padding_value)\n return padding(im, label)\n\n\[email protected]_component\nclass RandomPaddingCrop:\n \"\"\"\n Crop a sub-image from a raw image and annotation image randomly. If the target cropping size\n is larger than original image, then the bottom-right padding will be added.\n\n Args:\n crop_size (tuple, optional): The target cropping size. Default: (512, 512).\n im_padding_value (list, optional): The padding value of raw image.\n Default: [127.5, 127.5, 127.5].\n label_padding_value (int, optional): The padding value of annotation image. Default: 255.\n\n Raises:\n TypeError: When crop_size is neither list nor tuple.\n ValueError: When the length of crop_size is not 2.\n \"\"\"\n\n def __init__(self,\n crop_size=(512, 512),\n im_padding_value=(127.5, 127.5, 127.5),\n label_padding_value=255):\n if isinstance(crop_size, list) or isinstance(crop_size, tuple):\n if len(crop_size) != 2:\n raise ValueError(\n 'Type of `crop_size` is list or tuple. It should include 2 elements, but it is {}'\n .format(crop_size))\n else:\n raise TypeError(\n \"The type of `crop_size` is invalid. It should be list or tuple, but it is {}\"\n .format(type(crop_size)))\n self.crop_size = crop_size\n self.im_padding_value = im_padding_value\n self.label_padding_value = label_padding_value\n\n def __call__(self, im, label=None):\n \"\"\"\n Args:\n im (np.ndarray): The Image data.\n label (np.ndarray, optional): The label data. Default: None.\n\n Returns:\n (tuple). When label is None, it returns (im, ), otherwise it returns (im, label).\n \"\"\"\n\n if isinstance(self.crop_size, int):\n crop_width = self.crop_size\n crop_height = self.crop_size\n else:\n crop_width = self.crop_size[0]\n crop_height = self.crop_size[1]\n\n img_height = im.shape[0]\n img_width = im.shape[1]\n\n if img_height == crop_height and img_width == crop_width:\n if label is None:\n return (im, )\n else:\n return (im, label)\n else:\n pad_height = max(crop_height - img_height, 0)\n pad_width = max(crop_width - img_width, 0)\n if (pad_height > 0 or pad_width > 0):\n im = cv2.copyMakeBorder(\n im,\n 0,\n pad_height,\n 0,\n pad_width,\n cv2.BORDER_CONSTANT,\n value=self.im_padding_value)\n if label is not None:\n label = cv2.copyMakeBorder(\n label,\n 0,\n pad_height,\n 0,\n pad_width,\n cv2.BORDER_CONSTANT,\n value=self.label_padding_value)\n img_height = im.shape[0]\n img_width = im.shape[1]\n\n if crop_height > 0 and crop_width > 0:\n h_off = np.random.randint(img_height - crop_height + 1)\n w_off = np.random.randint(img_width - crop_width + 1)\n\n im = im[h_off:(crop_height + h_off), w_off:(\n w_off + crop_width), :]\n if label is not None:\n label = label[h_off:(crop_height + h_off), w_off:(\n w_off + crop_width)]\n if label is None:\n return (im, )\n else:\n return (im, label)\n\n \[email protected]_component\nclass RandomCenterCrop:\n \"\"\"\n Crops the given the input data at the center.\n Args:\n retain_ratio (tuple or list, optional): The length of the input list or tuple must be 2. Default: (0.5, 0.5).\n the first value is used for width and the second is for height.\n In addition, the minimum size of the cropped image is [width * retain_ratio[0], height * retain_ratio[1]].\n Raises:\n TypeError: When retain_ratio is neither list nor tuple. Default: None.\n ValueError: When the value of retain_ratio is not in [0-1].\n \"\"\"\n\n def __init__(self,\n retain_ratio=(0.5, 0.5)):\n if isinstance(retain_ratio, list) or isinstance(retain_ratio, tuple):\n if len(retain_ratio) != 2:\n raise ValueError(\n 'When type of `retain_ratio` is list or tuple, it shoule include 2 elements, but it is {}'.format(\n retain_ratio)\n )\n if retain_ratio[0] > 1 or retain_ratio[1] > 1 or retain_ratio[0] < 0 or retain_ratio[1] < 0:\n raise ValueError(\n 'Value of `retain_ratio` should be in [0, 1], but it is {}'.format(retain_ratio)\n )\n else:\n raise TypeError(\n \"The type of `retain_ratio` is invalid. It should be list or tuple, but it is {}\"\n .format(type(retain_ratio)))\n self.retain_ratio = retain_ratio\n\n def __call__(self, im, label=None):\n \"\"\"\n Args:\n im (np.ndarray): The Image data.\n label (np.ndarray, optional): The label data. Default: None.\n Returns:\n (tuple). When label is None, it returns (im, ), otherwise it returns (im, label).\n \"\"\"\n retain_width = self.retain_ratio[0]\n retain_height = self.retain_ratio[1]\n\n img_height = im.shape[0]\n img_width = im.shape[1]\n\n if retain_width == 1. and retain_height == 1.:\n if label is None:\n return (im,)\n else:\n return (im, label)\n else:\n randw = np.random.randint(img_width * (1 - retain_width))\n randh = np.random.randint(img_height * (1 - retain_height))\n offsetw = 0 if randw == 0 else np.random.randint(randw)\n offseth = 0 if randh == 0 else np.random.randint(randh)\n p0, p1, p2, p3 = offseth, img_height + offseth - randh, offsetw, img_width + offsetw - randw\n im = im[p0:p1, p2:p3, :]\n if label is not None:\n label = label[p0:p1, p2:p3, :]\n\n if label is None:\n return (im,)\n else:\n return (im, label)\n \n \[email protected]_component\nclass ScalePadding:\n \"\"\"\n Add center padding to a raw image or annotation image,then scale the\n image to target size.\n\n Args:\n target_size (list|tuple, optional): The target size of image. Default: (512, 512).\n im_padding_value (list, optional): The padding value of raw image.\n Default: [127.5, 127.5, 127.5].\n label_padding_value (int, optional): The padding value of annotation image. Default: 255.\n\n Raises:\n TypeError: When target_size is neither list nor tuple.\n ValueError: When the length of target_size is not 2.\n \"\"\"\n\n def __init__(self,\n target_size=(512, 512),\n im_padding_value=(127.5, 127.5, 127.5),\n label_padding_value=255):\n if isinstance(target_size, list) or isinstance(target_size, tuple):\n if len(target_size) != 2:\n raise ValueError(\n '`target_size` should include 2 elements, but it is {}'.\n format(target_size))\n else:\n raise TypeError(\n \"Type of `target_size` is invalid. It should be list or tuple, but it is {}\"\n .format(type(target_size)))\n\n self.target_size = target_size\n self.im_padding_value = im_padding_value\n self.label_padding_value = label_padding_value\n\n def __call__(self, im, label=None):\n \"\"\"\n Args:\n im (np.ndarray): The Image data.\n label (np.ndarray, optional): The label data. Default: None.\n\n Returns:\n (tuple). When label is None, it returns (im, ), otherwise it returns (im, label).\n \"\"\"\n height = im.shape[0]\n width = im.shape[1]\n\n new_im = np.zeros(\n (max(height, width), max(height, width), 3)) + self.im_padding_value\n if label is not None:\n new_label = np.zeros((max(height, width), max(\n height, width))) + self.label_padding_value\n\n if height > width:\n padding = int((height - width) / 2)\n new_im[:, padding:padding + width, :] = im\n if label is not None:\n new_label[:, padding:padding + width] = label\n else:\n padding = int((width - height) / 2)\n new_im[padding:padding + height, :, :] = im\n if label is not None:\n new_label[padding:padding + height, :] = label\n\n im = np.uint8(new_im)\n im = functional.resize(im, self.target_size, interp=cv2.INTER_CUBIC)\n if label is not None:\n label = np.uint8(new_label)\n label = functional.resize(\n label, self.target_size, interp=cv2.INTER_CUBIC)\n if label is None:\n return (im, )\n else:\n return (im, label)\n\n\[email protected]_component\nclass RandomNoise:\n \"\"\"\n Superimposing noise on an image with a certain probability.\n\n Args:\n prob (float, optional): A probability of blurring an image. Default: 0.5.\n max_sigma(float, optional): The maximum value of standard deviation of the distribution.\n Default: 10.0.\n \"\"\"\n\n def __init__(self, prob=0.5, max_sigma=10.0):\n self.prob = prob\n self.max_sigma = max_sigma\n\n def __call__(self, im, label=None):\n \"\"\"\n Args:\n im (np.ndarray): The Image data.\n label (np.ndarray, optional): The label data. Default: None.\n\n Returns:\n (tuple). When label is None, it returns (im, ), otherwise it returns (im, label).\n \"\"\"\n if random.random() < self.prob:\n mu = 0\n sigma = random.random() * self.max_sigma\n im = np.array(im, dtype=np.float32)\n im += np.random.normal(mu, sigma, im.shape)\n im[im > 255] = 255\n im[im < 0] = 0\n\n if label is None:\n return (im, )\n else:\n return (im, label)\n\n\[email protected]_component\nclass RandomBlur:\n \"\"\"\n Blurring an image by a Gaussian function with a certain probability.\n\n Args:\n prob (float, optional): A probability of blurring an image. Default: 0.1.\n blur_type(str, optional): A type of blurring an image,\n gaussian stands for cv2.GaussianBlur,\n median stands for cv2.medianBlur,\n blur stands for cv2.blur,\n random represents randomly selected from above.\n Default: gaussian.\n \"\"\"\n\n def __init__(self, prob=0.1, blur_type=\"gaussian\"):\n self.prob = prob\n self.blur_type = blur_type\n\n def __call__(self, im, label=None):\n \"\"\"\n Args:\n im (np.ndarray): The Image data.\n label (np.ndarray, optional): The label data. Default: None.\n\n Returns:\n (tuple). When label is None, it returns (im, ), otherwise it returns (im, label).\n \"\"\"\n\n if self.prob <= 0:\n n = 0\n elif self.prob >= 1:\n n = 1\n else:\n n = int(1.0 / self.prob)\n if n > 0:\n if np.random.randint(0, n) == 0:\n radius = np.random.randint(3, 10)\n if radius % 2 != 1:\n radius = radius + 1\n if radius > 9:\n radius = 9\n im = np.array(im, dtype='uint8')\n if self.blur_type == \"gaussian\":\n im = cv2.GaussianBlur(im, (radius, radius), 0, 0)\n elif self.blur_type == \"median\":\n im = cv2.medianBlur(im, radius)\n elif self.blur_type == \"blur\":\n im = cv2.blur(im, (radius, radius))\n elif self.blur_type == \"random\":\n select = random.random()\n if select < 0.3:\n im = cv2.GaussianBlur(im, (radius, radius), 0)\n elif select < 0.6:\n im = cv2.medianBlur(im, radius)\n else:\n im = cv2.blur(im, (radius, radius))\n else:\n im = cv2.GaussianBlur(im, (radius, radius), 0, 0)\n im = np.array(im, dtype='float32')\n if label is None:\n return (im, )\n else:\n return (im, label)\n\n\[email protected]_component\nclass RandomRotation:\n \"\"\"\n Rotate an image randomly with padding.\n\n Args:\n max_rotation (float, optional): The maximum rotation degree. Default: 15.\n im_padding_value (list, optional): The padding value of raw image.\n Default: [127.5, 127.5, 127.5].\n label_padding_value (int, optional): The padding value of annotation image. Default: 255.\n \"\"\"\n\n def __init__(self,\n max_rotation=15,\n im_padding_value=(127.5, 127.5, 127.5),\n label_padding_value=255):\n self.max_rotation = max_rotation\n self.im_padding_value = im_padding_value\n self.label_padding_value = label_padding_value\n\n def __call__(self, im, label=None):\n \"\"\"\n Args:\n im (np.ndarray): The Image data.\n label (np.ndarray, optional): The label data. Default: None.\n\n Returns:\n (tuple). When label is None, it returns (im, ), otherwise it returns (im, label).\n \"\"\"\n\n if self.max_rotation > 0:\n (h, w) = im.shape[:2]\n do_rotation = np.random.uniform(-self.max_rotation,\n self.max_rotation)\n pc = (w // 2, h // 2)\n r = cv2.getRotationMatrix2D(pc, do_rotation, 1.0)\n cos = np.abs(r[0, 0])\n sin = np.abs(r[0, 1])\n\n nw = int((h * sin) + (w * cos))\n nh = int((h * cos) + (w * sin))\n\n (cx, cy) = pc\n r[0, 2] += (nw / 2) - cx\n r[1, 2] += (nh / 2) - cy\n dsize = (nw, nh)\n im = cv2.warpAffine(\n im,\n r,\n dsize=dsize,\n flags=cv2.INTER_LINEAR,\n borderMode=cv2.BORDER_CONSTANT,\n borderValue=self.im_padding_value)\n if label is not None:\n label = cv2.warpAffine(\n label,\n r,\n dsize=dsize,\n flags=cv2.INTER_NEAREST,\n borderMode=cv2.BORDER_CONSTANT,\n borderValue=self.label_padding_value)\n\n if label is None:\n return (im, )\n else:\n return (im, label)\n\n\[email protected]_component\nclass RandomScaleAspect:\n \"\"\"\n Crop a sub-image from an original image with a range of area ratio and aspect and\n then scale the sub-image back to the size of the original image.\n\n Args:\n min_scale (float, optional): The minimum area ratio of cropped image to the original image. Default: 0.5.\n aspect_ratio (float, optional): The minimum aspect ratio. Default: 0.33.\n \"\"\"\n\n def __init__(self, min_scale=0.5, aspect_ratio=0.33):\n self.min_scale = min_scale\n self.aspect_ratio = aspect_ratio\n\n def __call__(self, im, label=None):\n \"\"\"\n Args:\n im (np.ndarray): The Image data.\n label (np.ndarray, optional): The label data. Default: None.\n\n Returns:\n (tuple). When label is None, it returns (im, ), otherwise it returns (im, label).\n \"\"\"\n\n if self.min_scale != 0 and self.aspect_ratio != 0:\n img_height = im.shape[0]\n img_width = im.shape[1]\n for i in range(0, 10):\n area = img_height * img_width\n target_area = area * np.random.uniform(self.min_scale, 1.0)\n aspectRatio = np.random.uniform(self.aspect_ratio,\n 1.0 / self.aspect_ratio)\n\n dw = int(np.sqrt(target_area * 1.0 * aspectRatio))\n dh = int(np.sqrt(target_area * 1.0 / aspectRatio))\n if (np.random.randint(10) < 5):\n tmp = dw\n dw = dh\n dh = tmp\n\n if (dh < img_height and dw < img_width):\n h1 = np.random.randint(0, img_height - dh)\n w1 = np.random.randint(0, img_width - dw)\n\n im = im[h1:(h1 + dh), w1:(w1 + dw), :]\n im = cv2.resize(\n im, (img_width, img_height),\n interpolation=cv2.INTER_LINEAR)\n if label is not None:\n label = label[h1:(h1 + dh), w1:(w1 + dw)]\n label = cv2.resize(\n label, (img_width, img_height),\n interpolation=cv2.INTER_NEAREST)\n break\n if label is None:\n return (im, )\n else:\n return (im, label)\n\n\[email protected]_component\nclass RandomDistort:\n \"\"\"\n Distort an image with random configurations.\n\n Args:\n brightness_range (float, optional): A range of brightness. Default: 0.5.\n brightness_prob (float, optional): A probability of adjusting brightness. Default: 0.5.\n contrast_range (float, optional): A range of contrast. Default: 0.5.\n contrast_prob (float, optional): A probability of adjusting contrast. Default: 0.5.\n saturation_range (float, optional): A range of saturation. Default: 0.5.\n saturation_prob (float, optional): A probability of adjusting saturation. Default: 0.5.\n hue_range (int, optional): A range of hue. Default: 18.\n hue_prob (float, optional): A probability of adjusting hue. Default: 0.5.\n sharpness_range (float, optional): A range of sharpness. Default: 0.5.\n sharpness_prob (float, optional): A probability of adjusting saturation. Default: 0.\n \"\"\"\n\n def __init__(self,\n brightness_range=0.5,\n brightness_prob=0.5,\n contrast_range=0.5,\n contrast_prob=0.5,\n saturation_range=0.5,\n saturation_prob=0.5,\n hue_range=18,\n hue_prob=0.5,\n sharpness_range=0.5,\n sharpness_prob=0):\n self.brightness_range = brightness_range\n self.brightness_prob = brightness_prob\n self.contrast_range = contrast_range\n self.contrast_prob = contrast_prob\n self.saturation_range = saturation_range\n self.saturation_prob = saturation_prob\n self.hue_range = hue_range\n self.hue_prob = hue_prob\n self.sharpness_range = sharpness_range\n self.sharpness_prob = sharpness_prob\n\n def __call__(self, im, label=None):\n \"\"\"\n Args:\n im (np.ndarray): The Image data.\n label (np.ndarray, optional): The label data. Default: None.\n\n Returns:\n (tuple). When label is None, it returns (im, ), otherwise it returns (im, label).\n \"\"\"\n\n brightness_lower = 1 - self.brightness_range\n brightness_upper = 1 + self.brightness_range\n contrast_lower = 1 - self.contrast_range\n contrast_upper = 1 + self.contrast_range\n saturation_lower = 1 - self.saturation_range\n saturation_upper = 1 + self.saturation_range\n hue_lower = -self.hue_range\n hue_upper = self.hue_range\n sharpness_lower = 1 - self.sharpness_range\n sharpness_upper = 1 + self.sharpness_range\n ops = [\n functional.brightness, functional.contrast, functional.saturation,\n functional.hue, functional.sharpness\n ]\n random.shuffle(ops)\n params_dict = {\n 'brightness': {\n 'brightness_lower': brightness_lower,\n 'brightness_upper': brightness_upper\n },\n 'contrast': {\n 'contrast_lower': contrast_lower,\n 'contrast_upper': contrast_upper\n },\n 'saturation': {\n 'saturation_lower': saturation_lower,\n 'saturation_upper': saturation_upper\n },\n 'hue': {\n 'hue_lower': hue_lower,\n 'hue_upper': hue_upper\n },\n 'sharpness': {\n 'sharpness_lower': sharpness_lower,\n 'sharpness_upper': sharpness_upper,\n }\n }\n prob_dict = {\n 'brightness': self.brightness_prob,\n 'contrast': self.contrast_prob,\n 'saturation': self.saturation_prob,\n 'hue': self.hue_prob,\n 'sharpness': self.sharpness_prob\n }\n im = im.astype('uint8')\n im = Image.fromarray(im)\n for id in range(len(ops)):\n params = params_dict[ops[id].__name__]\n prob = prob_dict[ops[id].__name__]\n params['im'] = im\n if np.random.uniform(0, 1) < prob:\n im = ops[id](**params)\n im = np.asarray(im).astype('float32')\n if label is None:\n return (im, )\n else:\n return (im, label)\n\n\[email protected]_component\nclass RandomAffine:\n \"\"\"\n Affine transform an image with random configurations.\n\n Args:\n size (tuple, optional): The target size after affine transformation. Default: (224, 224).\n translation_offset (float, optional): The maximum translation offset. Default: 0.\n max_rotation (float, optional): The maximum rotation degree. Default: 15.\n min_scale_factor (float, optional): The minimum scale. Default: 0.75.\n max_scale_factor (float, optional): The maximum scale. Default: 1.25.\n im_padding_value (float, optional): The padding value of raw image. Default: (128, 128, 128).\n label_padding_value (int, optional): The padding value of annotation image. Default: (255, 255, 255).\n \"\"\"\n\n def __init__(self,\n size=(224, 224),\n translation_offset=0,\n max_rotation=15,\n min_scale_factor=0.75,\n max_scale_factor=1.25,\n im_padding_value=(128, 128, 128),\n label_padding_value=(255, 255, 255)):\n self.size = size\n self.translation_offset = translation_offset\n self.max_rotation = max_rotation\n self.min_scale_factor = min_scale_factor\n self.max_scale_factor = max_scale_factor\n self.im_padding_value = im_padding_value\n self.label_padding_value = label_padding_value\n\n def __call__(self, im, label=None):\n \"\"\"\n Args:\n im (np.ndarray): The Image data.\n label (np.ndarray, optional): The label data. Default: None.\n\n Returns:\n (tuple). When label is None, it returns (im, ), otherwise it returns (im, label).\n \"\"\"\n\n w, h = self.size\n bbox = [0, 0, im.shape[1] - 1, im.shape[0] - 1]\n x_offset = (random.random() - 0.5) * 2 * self.translation_offset\n y_offset = (random.random() - 0.5) * 2 * self.translation_offset\n dx = (w - (bbox[2] + bbox[0])) / 2.0\n dy = (h - (bbox[3] + bbox[1])) / 2.0\n\n matrix_trans = np.array([[1.0, 0, dx], [0, 1.0, dy], [0, 0, 1.0]])\n\n angle = random.random() * 2 * self.max_rotation - self.max_rotation\n scale = random.random() * (self.max_scale_factor - self.min_scale_factor\n ) + self.min_scale_factor\n scale *= np.mean(\n [float(w) / (bbox[2] - bbox[0]),\n float(h) / (bbox[3] - bbox[1])])\n alpha = scale * math.cos(angle / 180.0 * math.pi)\n beta = scale * math.sin(angle / 180.0 * math.pi)\n\n centerx = w / 2.0 + x_offset\n centery = h / 2.0 + y_offset\n matrix = np.array(\n [[alpha, beta, (1 - alpha) * centerx - beta * centery],\n [-beta, alpha, beta * centerx + (1 - alpha) * centery],\n [0, 0, 1.0]])\n\n matrix = matrix.dot(matrix_trans)[0:2, :]\n im = cv2.warpAffine(\n np.uint8(im),\n matrix,\n tuple(self.size),\n flags=cv2.INTER_LINEAR,\n borderMode=cv2.BORDER_CONSTANT,\n borderValue=self.im_padding_value)\n if label is not None:\n label = cv2.warpAffine(\n np.uint8(label),\n matrix,\n tuple(self.size),\n flags=cv2.INTER_NEAREST,\n borderMode=cv2.BORDER_CONSTANT)\n if label is None:\n return (im, )\n else:\n return (im, label)\n"
]
| [
[
"numpy.random.seed"
],
[
"numpy.random.normal",
"numpy.array",
"numpy.uint8",
"numpy.asarray",
"numpy.random.shuffle",
"numpy.random.uniform",
"numpy.random.randint",
"numpy.transpose",
"numpy.abs",
"numpy.sqrt",
"numpy.linspace"
]
]
|
fumiyanll23/AtCoder | [
"362ca9fcacb5415c1458bc8dee5326ba2cc70b65"
]
| [
"ABC/186/b_ans.py"
]
| [
"import numpy as np\n\ndef main():\n # input\n H, W = map(int, input().split())\n Ass = [[*map(int, input().split())] for _ in range(H)]\n\n # compute\n Ass = np.array(Ass)\n\n # output\n print(np.sum(Ass - np.min(Ass)))\n\n\nif __name__ == '__main__':\n main()\n"
]
| [
[
"numpy.array",
"numpy.min"
]
]
|
frozenburst/download_audioset | [
"a4ce2fbdeaf23c155717800bd17a986b5c1f51ad"
]
| [
"as_download.py"
]
| [
"'''\n================================================\n DOWNLOAD_AUDIOSET REPOSITORY\n================================================\nOriginal:\n repository name: download_audioset\n repository version: 1.0\n repository link: https://github.com/jim-schwoebel/download_audioset\n author: Jim Schwoebel\n author contact: [email protected]\n description: downloads the raw audio files from AudioSet (released by Google).\n license category: opensource\n license: Apache 2.0 license\n organization name: NeuroLex Laboratories, Inc.\n location: Seattle, WA\n website: https://neurolex.ai\n release date: 2018-11-08\n\nEdit:\n repository name: download_audioset\n repository version: 1.1\n repository link: https://github.com/frozenburst/download_audioset\n author: POYU WU\n release date: 2020-11-10\n\nThis code (download_audioset) is hereby released under a Apache 2.0 license license.\n\nFor more information, check out the license terms below.\n\n================================================\n SPECIAL NOTES\n================================================\n\nThis script parses through the entire balanced audioset dataset and downloads\nall the raw audio files. The files are arranged in folders according to their\nrepresentative classes.\n\nPlease ensure that you have roughly 35GB of free space on your computer before\ndownloading the files. Note that it may take up to 2 days to fully download\nall the files.\n\nEnjoy! - :)\n\n#-Jim\n\n================================================\n LICENSE TERMS\n================================================\n\nCopyright 2018 NeuroLex Laboratories, Inc.\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n\n================================================\n SERVICE STATEMENT\n================================================\n\nIf you are using the code written for a larger project, we are\nhappy to consult with you and help you with deployment. Our team\nhas >10 world experts in Kafka distributed architectures, microservices\nbuilt on top of Node.js / Python / Docker, and applying machine learning to\nmodel speech and text data.\n\nWe have helped a wide variety of enterprises - small businesses,\nresearchers, enterprises, and/or independent developers.\n\nIf you would like to work with us let us know @ [email protected].\n\nusage: as_download.py [options]\n\noptions:\n --data_pth=<data path>\n --label_pth=<labels.xlsx>\n --segment_file=<xlsx file>\n --partial=<0, 1, 2, ...> # The unbalance csv could split to parts for parallel.\n'''\n\n################################################################################\n## IMPORT STATEMENTS ##\n################################################################################\n\nimport pafy, os, shutil, time, ffmpy\nimport os.path as op\nimport pandas as pd\nimport soundfile as sf\n\nfrom natsort import natsorted\nfrom tqdm import tqdm\nfrom pathlib import Path\nfrom docopt import docopt\n\n################################################################################\n## HELPER FUNCTIONS ##\n################################################################################\n\n#function to clean labels\ndef convertlabels(sortlist,labels,textlabels):\n\n clabels=list()\n # Debug for sortlist data type, split with each label ids.\n sortlist = sortlist.split(',')\n\n for i in range(len(sortlist)):\n #find index in list corresponding\n index=labels.index(sortlist[i])\n clabel=textlabels[index]\n #pull out converted label\n clabels.append(clabel)\n\n return clabels\n\n\ndef download_audio(link):\n listdir=os.listdir()\n cmd = f\"youtube-dl --quiet -f 'bestaudio[ext=m4a]' '{link}'\"\n print(cmd)\n os.system(cmd)\n listdir2=os.listdir()\n filename=''\n for i in range(len(listdir2)):\n if listdir2[i] not in listdir and listdir2[i].endswith('.m4a'):\n filename=listdir2[i]\n break\n\n return filename\n\n################################################################################\n## MAIN SCRIPT ##\n################################################################################\n\nif __name__ == '__main__':\n args = docopt(__doc__)\n print(args)\n data_pth = args['--data_pth']\n label_pth = args['--label_pth']\n segment_file = args['--segment_file']\n partial = args['--partial']\n\n if data_pth is None:\n raise ValueError(\"Please set the path for model's output.\")\n if label_pth is None:\n raise ValueError(\"Please set the path for model's output.\")\n if segment_file is None:\n raise ValueError(\"Please set the path for model's output.\")\n if partial is not None:\n print(\"Partial detected. The naming of wav would follow the partial name.\")\n \n defaultdir=os.getcwd()\n os.chdir(defaultdir)\n\n #load labels of the videos\n\n #number, label, words\n loadfile=pd.read_excel(label_pth)\n\n number=loadfile.iloc[:,0].tolist()\n labels=loadfile.iloc[:,1].tolist()\n textlabels=loadfile.iloc[:,2].tolist()\n #remove spaces for folders\n for i in range(len(textlabels)):\n textlabels[i]=textlabels[i].replace(' ','')\n\n #now load data for download\n xlsx_filename = segment_file\n if op.isfile(xlsx_filename) is False:\n raise ValueError(\"Xlsx file of segment is not exits with value:\", xlsx_filename) \n loadfile2=pd.read_excel(xlsx_filename)\n\n # ylabels have to be cleaned to make a good list (CSV --> LIST)\n yid=loadfile2.iloc[:,0].tolist()[2:]\n ystart=loadfile2.iloc[:,1].tolist()[2:]\n yend=loadfile2.iloc[:,2].tolist()[2:]\n ylabels=loadfile2.iloc[:,3].tolist()[2:]\n\n dataset_dir = data_pth\n if op.isdir(dataset_dir) is False:\n raise ValueError(\"Dataset directory is not exits with path:\", dataset_dir)\n\n #make folders\n if partial is not None:\n # segment_folder_name = op.basename(xlsx_filename).split('.')[0]\n # Easy method is the best solution.\n segment_folder_name = 'unbalanced_train_segments'\n else:\n segment_folder_name = op.basename(xlsx_filename).split('.')[0]\n try:\n defaultdir2=op.join(dataset_dir, segment_folder_name)\n os.chdir(defaultdir2)\n except:\n defaultdir2=op.join(dataset_dir, segment_folder_name)\n os.mkdir(defaultdir2)\n os.chdir(defaultdir2)\n\n # Should implement the check of existed file as well.\n # Implemented by frozenburst\n existing_wavfiles=list()\n for dirname in tqdm(sorted(Path(defaultdir2).glob('*'))):\n if partial is not None:\n for filename in sorted(Path(dirname).glob(f'{partial}_*')):\n existing_wavfiles.append(op.basename(filename))\n else:\n for filename in sorted(Path(dirname).glob(f'*')):\n existing_wavfiles.append(op.basename(filename))\n\n # get last file checkpoint to leave off\n existing_wavfiles=natsorted(existing_wavfiles)\n print(existing_wavfiles)\n try:\n lastfile=int(existing_wavfiles[-1].split('.')[0][7:])\n except:\n lastfile=0\n\n #iterate through entire CSV file, look for '--' if found, find index, delete section, then go to next index\n slink='https://www.youtube.com/watch?v='\n\n for i in tqdm(range(len(yid))):\n if i < lastfile:\n # print('Skipping, already downloaded file...')\n continue\n else:\n link=slink+yid[i]\n start=float(ystart[i])\n end=float(yend[i])\n # print(ylabels[i])\n clabels=convertlabels(ylabels[i],labels,textlabels)\n # print(clabels)\n\n if clabels != []:\n #change to the right directory\n for j in range(len(clabels)):\n newdir = op.join(defaultdir2, clabels[j])\n if op.isdir(newdir) is False:\n os.mkdir(newdir)\n os.chdir(newdir)\n #if it is the first download, pursue this path to download video\n lastdir=os.getcwd()\n\n if partial is not None:\n filename_check = f'{partial}_snipped'+str(i)+'.wav'\n else:\n filename_check = 'snipped'+str(i)+'.wav'\n\n if filename_check not in os.listdir():\n try:\n # use YouTube DL to download audio\n filename=download_audio(link)\n extension='.m4a'\n #get file extension and convert to .wav for processing later\n os.rename(filename,'%s%s'%(str(i),extension))\n filename='%s%s'%(str(i),extension)\n if extension not in ['.wav']:\n xindex=filename.find(extension)\n filename=filename[0:xindex]\n ff=ffmpy.FFmpeg(\n inputs={filename+extension:None},\n outputs={filename+'.wav':None}\n )\n ff.run()\n os.remove(filename+extension)\n\n file=filename+'.wav'\n data,samplerate=sf.read(file)\n totalframes=len(data)\n totalseconds=totalframes/samplerate\n startsec=start\n startframe=samplerate*startsec\n endsec=end\n endframe=samplerate*endsec\n # print(startframe)\n # print(endframe)\n if partial is not None:\n newname = f'{partial}_snipped'+file\n else:\n newname = 'snipped'+file\n sf.write(newname, data[int(startframe):int(endframe)], samplerate)\n snippedfile=newname\n os.remove(file)\n\n except:\n print('no urls')\n\n #sleep 3 second sleep to prevent IP from getting banned\n time.sleep(2)\n else:\n print('skipping, already downloaded file...')\n\n"
]
| [
[
"pandas.read_excel"
]
]
|
wuwuwuyuanhang/python | [
"eb5ac23cb46c4beeab1638fda963dd154b9db1b7"
]
| [
"opencv/q23.py"
]
| [
"# @Auther : wuwuwu \n# @Time : 2020/4/15 \n# @File : q23.py\n# @Description : 直方图均衡化\n\nimport cv2 as cv\nimport numpy as np\nfrom matplotlib import pyplot as plt\n\ndef histogramEqualization(img, Zmax=255):\n \"\"\"\n 直方图均衡化\n :param img:\n :param Zmax: 像素的最大取值\n :return:\n \"\"\"\n H, W, C = img.shape\n S = H * W * C\n\n dst = img.copy()\n\n sum_h = 0\n\n for i in range(1, 255):\n index = np.where(img == i)\n sum_h += len(img[index])\n dst[index] = Zmax / S * sum_h\n\n return np.clip(dst, 0, 255).astype(np.uint8)\n\nif __name__ == '__main__':\n img = cv.imread('lenna.jpg')\n dst = histogramEqualization(img, Zmax=255)\n plt.figure()\n plt.hist(img.flatten(), bins=255, rwidth=0.8, range=(0, 255))\n plt.title('input histogram')\n plt.figure()\n plt.hist(dst.flatten(), bins=255, rwidth=0.8, range=(0, 255))\n plt.title('output histogram')\n plt.show()\n cv.imshow('input', img)\n cv.imshow('output', dst)\n cv.waitKey(0)\n cv.destroyAllWindows()"
]
| [
[
"matplotlib.pyplot.title",
"matplotlib.pyplot.figure",
"numpy.where",
"numpy.clip",
"matplotlib.pyplot.show"
]
]
|
voodoohop/Creative-Adversarial-Networks | [
"7d8632b7bfe12a698f61c442aa9c1a07d68d21c9"
]
| [
"utils.py"
]
| [
"\"\"\"\nSome codes from https://github.com/Newmu/dcgan_code\n\"\"\"\nfrom __future__ import division\nimport math\nimport json\nimport random\nimport pprint\nimport scipy.misc\nimport numpy as np\nfrom time import gmtime, strftime\nfrom six.moves import xrange\nfrom glob import glob\nimport cv2\nimport imageio\n\nimport tensorflow as tf\nimport tensorflow.contrib.slim as slim\n\npp = pprint.PrettyPrinter()\n\nget_stddev = lambda x, k_h, k_w: 1/math.sqrt(k_w*k_h*x.get_shape()[-1])\n\ndef show_all_variables():\n model_vars = tf.trainable_variables()\n slim.model_analyzer.analyze_vars(model_vars, print_info=True)\n\ndef get_image(image_path, input_height, input_width,\n resize_height=64, resize_width=64,\n crop=True, grayscale=False):\n image = imread(image_path, grayscale)\n try:\n return transform(image, input_height, input_width,\n resize_height, resize_width, crop)\n except ValueError :\n print(\"Bad image. filepath: \", image_path)\n except AttributeError:\n print(\"Bad image. filepath: \", image_path)\ndef save_images(images, size, image_path):\n return imsave(inverse_transform(images), size, image_path)\n\ndef imread(path, grayscale = False):\n try:\n if (grayscale):\n img = cv2.imread(path)\n new_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n return cv2.imread(new_img, flatten = True).astype(np.float)\n else:\n img = cv2.imread(path)\n new_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n return new_img.astype(np.float)\n except(TypeError):\n print(path)\n\n#Do\ndef test_images(path_glob):\n for path in path_glob:\n imread(path)\n\ndef merge_images(images, size):\n return inverse_transform(images)\n\ndef merge(images, size):\n h, w = images.shape[1], images.shape[2]\n if (images.shape[3] in (3,4)):\n c = images.shape[3]\n img = np.zeros((h * size[0], w * size[1], c))\n for idx, image in enumerate(images):\n i = idx % size[1]\n j = idx // size[1]\n img[j * h:j * h + h, i * w:i * w + w, :] = image\n return img\n elif images.shape[3]==1:\n img = np.zeros((h * size[0], w * size[1]))\n for idx, image in enumerate(images):\n i = idx % size[1]\n j = idx // size[1]\n img[j * h:j * h + h, i * w:i * w + w] = image[:,:,0]\n return img\n else:\n raise ValueError('in merge(images,size) images parameter '\n 'must have dimensions: HxW or HxWx3 or HxWx4')\n\ndef imsave(images, size, path):\n image = np.squeeze(merge(images, size))\n return scipy.misc.imsave(path, image)\n\ndef center_crop(x, crop_h, crop_w,\n resize_h=64, resize_w=64):\n if crop_w is None:\n crop_w = crop_h\n h, w = x.shape[:2]\n j = int(round((h - crop_h)/2.))\n i = int(round((w - crop_w)/2.))\n return scipy.misc.imresize(\n x[j:j+crop_h, i:i+crop_w], [resize_h, resize_w])\n\ndef transform(image, input_height, input_width,\n resize_height=64, resize_width=64, crop=True):\n if crop:\n cropped_image = center_crop(\n image, input_height, input_width,\n resize_height, resize_width)\n else:\n cropped_image = cv2.resize(image, (resize_height, resize_width))\n return np.array(cropped_image)/127.5 - 1.\n\ndef inverse_transform(images):\n return (images+1.)/2.\n\ndef make_gif(images, fname, duration=2, true_image=False):\n import moviepy.editor as mpy\n\n def make_frame(t):\n try:\n x = images[int(len(images)/duration*t)]\n except:\n x = images[-1]\n\n if true_image:\n return x.astype(np.uint8)\n else:\n return ((x+1)/2*255).astype(np.uint8)\n\n clip = mpy.VideoClip(make_frame, duration=duration)\n clip.write_gif(fname, fps = len(images) / duration)\n\ndef visualize(sess, dcgan, config, option):\n image_frame_dim = int(math.ceil(config.batch_size**.5))\n if option == 0:\n z_sample = np.random.normal(0, 1, size=(config.batch_size, dcgan.z_dim))\n z_sample /= np.linalg.norm(z_sample, axis=0)\n samples = sess.run(dcgan.sampler, feed_dict={dcgan.z: z_sample})\n save_images(samples, [image_frame_dim, image_frame_dim], '/content/gdrive/My Drive/samples/test_%s.png' % strftime(\"%Y%m%d%H%M%S\", gmtime()))\n elif option == 1:\n values = np.arange(0, 1, 1./config.batch_size)\n for idx in xrange(100):\n print(\" [*] %d\" % idx)\n z_sample = np.zeros([config.batch_size, dcgan.z_dim])\n for kdx, z in enumerate(z_sample):\n z[idx] = values[kdx]\n\n if config.dataset == \"mnist\":\n y = np.random.choice(10, config.batch_size)\n y_one_hot = np.zeros((config.batch_size, 10))\n y_one_hot[np.arange(config.batch_size), y] = 1\n\n samples = sess.run(dcgan.sampler, feed_dict={dcgan.z: z_sample, dcgan.y: y_one_hot})\n elif config.dataset == 'wikiart':\n y = np.random.choice(27, config.batch_size)\n y_one_hot = np.zeros((config.batch_size, 27))\n y_one_hot[np.arange(config.batch_size), y] = 1\n\n samples = sess.run(dcgan.sampler, feed_dict={dcgan.z: z_sample, dcgan.y: y_one_hot})\n save_images(samples, [image_frame_dim, image_frame_dim], './samples/test_arange_%s.png' % (idx))\n elif option == 2:\n values = np.arange(0, 1, 1./config.batch_size)\n for idx in [random.randint(0, 99) for _ in xrange(100)]:\n print(\" [*] %d\" % idx)\n z = np.random.uniform(-0.2, 0.2, size=(dcgan.z_dim))\n z_sample = np.tile(z, (config.batch_size, 1))\n #z_sample = np.zeros([config.batch_size, dcgan.z_dim])\n for kdx, z in enumerate(z_sample):\n z[idx] = values[kdx]\n\n if config.dataset == \"mnist\":\n y = np.random.choice(10, config.batch_size)\n y_one_hot = np.zeros((config.batch_size, 10))\n y_one_hot[np.arange(config.batch_size), y] = 1\n\n samples = sess.run(dcgan.sampler, feed_dict={dcgan.z: z_sample, dcgan.y: y_one_hot})\n elif config.dataset == 'wikiart':\n y = np.random.choice(27, config.batch_size)\n y_one_hot = np.zeros((config.batch_size, 27))\n y_one_hot[np.arange(config.batch_size), y] = 1\n\n samples = sess.run(dcgan.sampler, feed_dict={dcgan.z: z_sample, dcgan.y: y_one_hot})\n\n try:\n make_gif(samples, './samples/test_gif_%s.gif' % (idx))\n except:\n save_images(samples, [image_frame_dim, image_frame_dim], './samples/test_%s.png' % strftime(\"%Y%m%d%H%M%S\", gmtime()))\n elif option == 3:\n values = np.arange(0, 1, 1./config.batch_size)\n for idx in xrange(100):\n print(\" [*] %d\" % idx)\n z_sample = np.zeros([config.batch_size, dcgan.z_dim])\n for kdx, z in enumerate(z_sample):\n z[idx] = values[kdx]\n\n samples = sess.run(dcgan.sampler, feed_dict={dcgan.z: z_sample})\n make_gif(samples, './samples/test_gif_%s.gif' % (idx))\n elif option == 4:\n image_set = []\n values = np.arange(0, 1, 1./config.batch_size)\n\n for idx in xrange(100):\n print(\" [*] %d\" % idx)\n z_sample = np.zeros([config.batch_size, dcgan.z_dim])\n for kdx, z in enumerate(z_sample): z[idx] = values[kdx]\n\n image_set.append(sess.run(dcgan.sampler, feed_dict={dcgan.z: z_sample}))\n make_gif(image_set[-1], './samples/test_gif_%s.gif' % (idx))\n\n new_image_set = [merge(np.array([images[idx] for images in image_set]), [10, 10]) \\\n for idx in range(64) + range(63, -1, -1)]\n make_gif(new_image_set, './samples/test_gif_merged.gif', duration=8)\ndef get_max_end(path_dir, num_len=3, fname_pattern='*.jpg'):\n max_ = 0\n for f in glob(path_dir + fname_pattern):\n curr = int(f[-num_len-4:-4])\n if curr > max_:\n max_ = curr\n return max_\n\ndef image_manifold_size(num_images):\n print(num_images)\n manifold_h = int(np.floor(np.sqrt(num_images)))\n manifold_w = int(np.ceil(np.sqrt(num_images)))\n assert manifold_h * manifold_w == num_images\n return manifold_h, manifold_w\n\nif __name__ == '__main__':\n print('Getting image!')\n import time\n start = time.time()\n get_image(\"albert-gleizes_acrobats-1916.jpg\",256,256,256,256)\n end = (time.time() - start)\n print ('Took : {.:%4f}'.format(end))"
]
| [
[
"tensorflow.trainable_variables",
"numpy.random.normal",
"numpy.linalg.norm",
"numpy.array",
"numpy.random.choice",
"numpy.zeros",
"numpy.tile",
"numpy.random.uniform",
"numpy.arange",
"numpy.sqrt",
"tensorflow.contrib.slim.model_analyzer.analyze_vars"
]
]
|
Vaden4d/logo-classifier | [
"18c397e52352da8e79868158123c13bf0417130f"
]
| [
"train.py"
]
| [
"import os\nimport argparse\nimport pandas as pd\nfrom tqdm import tqdm\n\nimport torch\nimport torch.nn as nn\nimport pytorch_lightning as pl\nfrom pytorch_lightning.callbacks import ModelCheckpoint \n\nfrom utils.models import EfficientNetModel, EfficientNetSSL\nfrom utils.transforms import get_transforms\nfrom utils.loaders import get_loaders, get_loader\nfrom utils.losses import LabelSmoothingLoss\nfrom utils.misc import seed_everything, predict_on_loader\nfrom utils.visualization import display_metrics\nfrom utils.dataset import ImageDataset\n\nfrom mixmatch_pytorch import MixMatchLoader, get_mixmatch_loss\n\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.metrics import f1_score, confusion_matrix, precision_score, recall_score\n\nparser = argparse.ArgumentParser(description='PyTorch Lightning Training')\nparser.add_argument('--epochs', default=20, type=int, metavar='N',\n help='Number of total training epochs')\nparser.add_argument('--batch_size', default=32, type=int, metavar='N',\n help='Train and test batch size') \nparser.add_argument('--gpu', default=1, type=int,\n help='0 if CPU mode, 1 if GPU')\nparser.add_argument(\"--ssl\", action=\"store_true\",\n help=\"Use semi-supervised pipeline\")\nparser.add_argument('--csv', default='dataset_with_weak_labels.csv', type=str,\n help='Training .csv file with target column')\nparser.add_argument('--target_column', default='weak_label', type=str,\n help='Name of target column of the .csv file'\n )\nparser.add_argument('--validate', action=\"store_true\",\n help=\"Validate model on labeled dataset\"\n)\nparser.add_argument('--validation_csv', default=\"labeled_part.csv\",\n help=\"Validation .csv file with labeled target\"\n)\nparser.add_argument('--target_validation', default=\"label\",\n help=\"Name of target column in validation dataset\"\n)\nparser.add_argument('--test_size', default=0.2, type=float,\n help='Test dataset size'\n )\nparser.add_argument('--image_size', default=224, type=int,\n help='Desired image size'\n)\nparser.add_argument('--num_workers', default=2, type=int,\n help='Number of processes for PyTorch data loaders'\n )\nparser.add_argument('--random_state', default=42, type=int,\n help='Random seed for all random operations'\n )\nargs = parser.parse_args()\n\ndevice = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\nargs.gpu = args.gpu if torch.cuda.is_available() else 0\nseed_everything(args.random_state)\n\n# target_column has unique values in set -1, 0, 1\n# -1 corresponds to the unlabeled data\ndf = pd.read_csv(args.csv)\nlabeled = df[df[args.target_column] > -1]\nif args.ssl:\n print(\"Semi-supervised learning model is on...\")\n unlabeled = df[df[args.target_column] == -1]\n\n# weights to initialize bias of FC layer of classifier\nweight = labeled.groupby(args.target_column).count()[\"path\"] / labeled.shape[0]\nweight = torch.Tensor(weight.values).log()\n\ntrain_labeled, test_labeled = train_test_split(labeled, test_size=args.test_size, stratify=labeled[args.target_column], random_state=args.random_state)\n\ntrain_transform, valid_transform = get_transforms(img_size=args.image_size)\ntrain_labeled_loader, valid_labeled_loader = get_loaders(\n train_labeled,\n test_labeled,\n train_transform,\n valid_transform,\n target_column=args.target_column,\n batch_size=args.batch_size,\n num_workers=args.num_workers,\n shuffle=True\n)\n\nif args.ssl:\n dataset_unlabeled = ImageDataset(unlabeled, train_transform, target_column=None)\n\nloss = LabelSmoothingLoss(num_classes=2, smoothing=0.2, weight=None)\n\nif args.ssl:\n print(\"Semi-supervised learning model is configured...\")\n model = EfficientNetSSL(loss=loss, num_classes=2, weight=weight)\nelse:\n model = EfficientNetModel(loss=loss, num_classes=2, weight=weight)\n\nmodel_checkpoint = ModelCheckpoint(monitor=\"val_acc_f1\",\n verbose=True,\n dirpath=\"models/\",\n mode=\"max\",\n filename=\"{epoch}_{val_acc_f1:.4f}\")\n\nif args.ssl:\n # SSL approach changes only train dataloader and model class\n train_loader = MixMatchLoader(\n train_labeled_loader,\n dataset_unlabeled,\n model,\n output_transform=nn.Softmax(dim=-1),\n K=2,\n T=0.5,\n alpha=0.75\n )\nelse:\n train_loader = train_labeled_loader\n\ntrainer = pl.Trainer(gpus=args.gpu,\n max_epochs=args.epochs,\n precision=16,\n auto_lr_find=True,\n callbacks=[model_checkpoint])\ntrainer.fit(model, train_loader, valid_labeled_loader)\n\ntest_labeled[\"pred\"] = predict_on_loader(valid_labeled_loader, model, device)\ntest_labeled.to_csv(\"test_labeled_with_preds.csv\", index=False)\n\n# TODO\n# threshold tuning\nprint(\"Metrics results on the test sample with weak labels:\")\ndisplay_metrics(test_labeled[args.target_column], test_labeled[\"pred\"], threshold=0.5)\n\nif args.validate:\n\n validation = pd.read_csv(args.validation_csv)\n validation[args.target_validation] = validation[args.target_validation].apply(lambda x: 1 if x == \"logo\" else 0)\n\n labeled_loader = get_loader(\n validation,\n \"label\",\n valid_transform,\n batch_size=args.batch_size,\n num_workers=args.num_workers,\n shuffle=False\n )\n\n validation[\"pred\"] = predict_on_loader(labeled_loader, model, device)\n validation.to_csv(\"labeled_with_preds.csv\", index=False)\n print(\"Metrics results on the labeled sample with strong labels:\")\n display_metrics(validation[\"label\"], validation[\"pred\"], threshold=0.5)\n\n"
]
| [
[
"torch.nn.Softmax",
"torch.cuda.is_available",
"sklearn.model_selection.train_test_split",
"pandas.read_csv",
"torch.Tensor"
]
]
|
rudranshsharma123/jina | [
"cdc66eb44fe1ae5c84ba6ddfe0a6173476f773bb"
]
| [
"tests/unit/types/document/test_converters.py"
]
| [
"import os\n\nimport numpy as np\nimport pytest\n\nfrom jina import Document, __windows__\n\ncur_dir = os.path.dirname(os.path.abspath(__file__))\n\n\ndef test_uri_to_blob():\n doc = Document(uri=os.path.join(cur_dir, 'test.png'))\n doc.convert_image_uri_to_blob()\n assert isinstance(doc.blob, np.ndarray)\n assert doc.mime_type == 'image/png'\n assert doc.blob.shape == (85, 152, 3) # h,w,c\n\n\ndef test_datauri_to_blob():\n doc = Document(uri=os.path.join(cur_dir, 'test.png'))\n doc.convert_uri_to_datauri()\n doc.convert_image_datauri_to_blob()\n assert isinstance(doc.blob, np.ndarray)\n assert doc.mime_type == 'image/png'\n assert doc.blob.shape == (85, 152, 3) # h,w,c\n\n\ndef test_buffer_to_blob():\n doc = Document(uri=os.path.join(cur_dir, 'test.png'))\n doc.convert_uri_to_buffer()\n doc.convert_image_buffer_to_blob()\n assert isinstance(doc.blob, np.ndarray)\n assert doc.mime_type == 'image/png'\n assert doc.blob.shape == (85, 152, 3) # h,w,c\n\n\ndef test_convert_buffer_to_blob():\n rand_state = np.random.RandomState(0)\n array = rand_state.random([10, 10])\n doc = Document(content=array.tobytes())\n assert doc.content_type == 'buffer'\n intialiazed_buffer = doc.buffer\n\n doc.convert_buffer_to_blob()\n assert doc.content_type == 'blob'\n converted_buffer_in_one_of = doc.buffer\n assert intialiazed_buffer != converted_buffer_in_one_of\n np.testing.assert_almost_equal(doc.content.reshape([10, 10]), array)\n\n\[email protected]('resize_method', ['BILINEAR', 'NEAREST', 'BICUBIC', 'LANCZOS'])\[email protected](\n 'arr_size, channel_axis, height, width',\n [\n ((32 * 28), -1, None, None), # single line\n ([32, 28], -1, None, None), # without channel info\n ([32, 28, 3], -1, None, None), # h, w, c (rgb)\n ([3, 32, 28], 0, None, None), # c, h, w (rgb)\n ([1, 32, 28], 0, None, None), # c, h, w, (greyscale)\n ([32, 28, 1], -1, None, None), # h, w, c, (greyscale)\n ((32 * 28), -1, 896, 1), # single line\n ([32, 28], -1, 32, 28), # without channel info\n ([32, 28, 3], -1, 32, 28), # h, w, c (rgb)\n ([3, 32, 28], 0, 32, 28), # c, h, w (rgb)\n ([1, 32, 28], 0, 32, 28), # c, h, w, (greyscale)\n ([32, 28, 1], -1, 32, 28), # h, w, c, (greyscale)\n ],\n)\ndef test_convert_image_blob_to_uri(arr_size, channel_axis, width, height, resize_method):\n doc = Document(content=np.random.randint(0, 255, arr_size))\n assert doc.blob.any()\n assert not doc.uri\n doc.convert_image_blob_to_uri(\n channel_axis=channel_axis, width=width, height=height, resize_method=resize_method\n )\n assert doc.uri.startswith('data:image/png;base64,')\n assert doc.mime_type == 'image/png'\n\n\[email protected](\n condition=__windows__, reason='x-python is not detected on windows CI'\n)\[email protected](\n 'uri, mimetype',\n [\n (__file__, 'text/x-python'),\n ('http://google.com/index.html', 'text/html'),\n ('https://google.com/index.html', 'text/html'),\n ],\n)\ndef test_convert_uri_to_buffer(uri, mimetype):\n d = Document(uri=uri)\n assert not d.buffer\n d.convert_uri_to_buffer()\n assert d.buffer\n assert d.mime_type == mimetype\n\n\[email protected](\n 'converter', ['convert_buffer_to_uri', 'convert_content_to_uri']\n)\ndef test_convert_buffer_to_uri(converter):\n d = Document(content=open(__file__).read().encode(), mime_type='text/x-python')\n assert d.buffer\n getattr(d, converter)()\n assert d.uri.startswith('data:text/x-python;')\n\n\[email protected]('converter', ['convert_text_to_uri', 'convert_content_to_uri'])\ndef test_convert_text_to_uri(converter):\n d = Document(content=open(__file__).read(), mime_type='text/x-python')\n assert d.text\n getattr(d, converter)()\n assert d.uri.startswith('data:text/x-python;')\n\n\[email protected](\n condition=__windows__, reason='x-python is not detected on windows CI'\n)\[email protected](\n 'uri, mimetype',\n [\n pytest.param(\n __file__,\n 'text/x-python',\n marks=pytest.mark.xfail(\n condition=__windows__, reason='x-python is not detected on windows CI'\n ),\n ),\n ('http://google.com/index.html', 'text/html'),\n ('https://google.com/index.html', 'text/html'),\n ],\n)\ndef test_convert_uri_to_text(uri, mimetype):\n doc = Document(uri=uri, mime_type=mimetype)\n doc.convert_uri_to_text()\n if mimetype == 'text/html':\n assert '<!doctype html>' in doc.text\n elif mimetype == 'text/x-python':\n text_from_file = open(__file__).read()\n assert doc.text == text_from_file\n\n\ndef test_convert_text_to_uri_and_back():\n text_from_file = open(__file__).read()\n doc = Document(content=text_from_file, mime_type='text/x-python')\n assert doc.text\n assert doc.mime_type == 'text/x-python'\n doc.convert_text_to_uri()\n doc.convert_uri_to_text()\n assert doc.mime_type == 'text/plain'\n assert doc.text == text_from_file\n\n\ndef test_convert_content_to_uri():\n d = Document(content=np.random.random([10, 10]))\n with pytest.raises(NotImplementedError):\n d.convert_content_to_uri()\n\n\[email protected](\n 'uri, mimetype',\n [\n (__file__, 'text/x-python'),\n ('http://google.com/index.html', 'text/html'),\n ('https://google.com/index.html', 'text/html'),\n ],\n)\ndef test_convert_uri_to_data_uri(uri, mimetype):\n doc = Document(uri=uri, mime_type=mimetype)\n doc.convert_uri_to_datauri()\n assert doc.uri.startswith(f'data:{mimetype}')\n assert doc.mime_type == mimetype\n"
]
| [
[
"numpy.random.random",
"numpy.random.randint",
"numpy.random.RandomState"
]
]
|
evgeniya-egupova/mmsegmentation | [
"3857f19321ad6af41c8a6af364898ee050225f4c"
]
| [
"mmseg/models/scalar_schedulers/step.py"
]
| [
"import numpy as np\n\nfrom ..builder import SCALAR_SCHEDULERS\nfrom .base import BaseScalarScheduler\n\n\n@SCALAR_SCHEDULERS.register_module()\nclass StepScalarScheduler(BaseScalarScheduler):\n def __init__(self, scales, num_iters, by_epoch=False):\n super(StepScalarScheduler, self).__init__()\n\n self.by_epoch = by_epoch\n\n assert len(scales) == len(num_iters) + 1\n assert len(scales) > 0\n\n self._scales = list(scales)\n self._iter_ranges = list(num_iters) + [np.iinfo(np.int32).max]\n\n def _get_value(self, step, epoch_size):\n if step is None:\n return float(self._scales[-1])\n\n out_scale_idx = 0\n for iter_range in self._iter_ranges:\n if self.by_epoch:\n iter_threshold = epoch_size * iter_range\n else:\n iter_threshold = iter_range\n\n if step < iter_threshold:\n break\n\n out_scale_idx += 1\n\n return float(self._scales[out_scale_idx])\n"
]
| [
[
"numpy.iinfo"
]
]
|
Raeyi/multipooling-AdaPECT | [
"9632b98ff1612344de798321298f6488f1c303b0"
]
| [
"ArbitraryCS_main.py"
]
| [
"# coding:utf8\n\nimport torch as t\nimport torchvision as tv\nimport torchnet as tnt\n\nfrom torch.utils import data\nfrom transformer_net import TransformerNet\nimport utils\nfrom PackedVGG import Vgg16\nfrom torch.nn import functional as F\nimport tqdm\nimport os\nimport ipdb\n# from WCT2_train import WCT2\n# import model\n\nfrom LapSobGaus_train import Lap_Sob_Gaus\nimport net\n\nimport Ovodus_Laplace_model\nimport utils_\nfrom WCT2_train import train_transform\nfrom tensorboardX import SummaryWriter\n\nfrom pathlib import Path\n\nfrom torchvision.utils import save_image\n\nmean = [0.485, 0.456, 0.406]\nstd = [0.229, 0.224, 0.225]\n\nIMAGENET_MEAN = [0.485, 0.456, 0.406]\nIMAGENET_STD = [0.229, 0.224, 0.225]\n\n\nclass Config(object):\n # General Args\n use_gpu = True\n model_path = None # pretrain model path (for resume training or test)\n\n # Train Args\n image_size = 448 # image crop_size for training\n batch_size = 2\n data_root = r'F:\\DataSets\\train2017' # 'data/' dataset root：$data_root/coco/a.jpg D:\\CoCo_Dataset\\train2017\n num_workers = 4 # dataloader num of workers\n\n lr = 1e-4\n epoches = 20 # total epoch to train\n content_weight = 1e10 # weight of content_loss\n style_weight = 1e2 # weight of style_loss\n\n style_path = 'style_input' # style image path\n env = 'onlyencodercontent_58_Laps_test_nores_noDynamic_10_2' # visdom env\n plot_every = 1 # visualize in visdom for every 10 batch\n\n debug_file = '/tmp/debugnn' # touch $debug_fie to interrupt and enter ipdb\n\n # Test Args\n content_path = 'input.png' # input file to do style transfer [for test]\n result_path = 'output.png' # style transfer result [for test]\n\n option_unpool = 'sum'\n cpu = False\n transfer_at_encoder = True\n transfer_at_decoder = True\n transfer_at_skip = True\n verbose = True\n save_dir = './onlyencodercontent/nores_noDynamic/58_LapSobGaus_experiments_10_2'\n log_dir = './onlyencodercontent/nores_noDynamic/58_LapSobGaus_logs_10_2'\n\n lr_decay = 5e-5\n\n\ndef adjust_learning_rate(lr ,optimizer, iteration_count, lr_decay):\n \"\"\"Imitating the original implementation\"\"\"\n lr = lr / (1.0 + lr_decay * iteration_count)\n for param_group in optimizer.param_groups:\n param_group['lr'] = lr\n\ndef train(**kwargs):\n opt = Config()\n for k_, v_ in kwargs.items():\n setattr(opt, k_, v_)\n\n device = 'cpu' if opt.cpu or not t.cuda.is_available() else 'cuda:0'\n device = t.device(device)\n # device=t.device('cuda') if opt.use_gpu else t.device('cpu')\n vis = utils_.Visualizer(opt.env)\n\n save_dir = Path(opt.save_dir)\n save_dir.mkdir(exist_ok=True, parents=True)\n log_dir = Path(opt.log_dir)\n log_dir.mkdir(exist_ok=True, parents=True)\n writer = SummaryWriter(log_dir=str(log_dir))\n # Data loading\n transfroms = tv.transforms.Compose([\n tv.transforms.Resize(opt.image_size),\n tv.transforms.CenterCrop(opt.image_size),\n tv.transforms.ToTensor(),\n #tv.transforms.Normalize(mean=IMAGENET_MEAN, std=IMAGENET_STD),\n #tv.transforms.Lambda(lambda x: x*255)\n ])\n dataset = tv.datasets.ImageFolder(opt.data_root, transfroms)\n dataloader = data.DataLoader(dataset, opt.batch_size)\n\n # style transformer network\n # transformer = TransformerNet()\n print('come!')\n # visualizer = Visualizer(config) # create a visualizer that display/save images and plots\n # device = 'cpu' if opt.cpu or not t.cuda.is_available() else 'cuda:0'\n # device = t.device(device)\n\n transfer_at = set()\n if opt.transfer_at_encoder:\n transfer_at.add('encoder')\n if opt.transfer_at_decoder:\n transfer_at.add('decoder')\n if opt.transfer_at_skip:\n transfer_at.add('skip')\n # save_dir = Path(config.save_dir)\n # save_dir.mkdir(exist_ok=True, parents=True)\n # log_dir = Path(config.log_dir)\n # log_dir.mkdir(exist_ok=True, parents=True)\n # writer = SummaryWriter(log_dir=str(log_dir))\n # vgg = net.vgg\n wct2 = Lap_Sob_Gaus(transfer_at=transfer_at, option_unpool=opt.option_unpool, device=device,\n verbose=False)\n\n encoder = Ovodus_Laplace_model.Lap_Sob_GausEncoder(opt.option_unpool).to(device)\n decoder = Ovodus_Laplace_model.Lap_Sob_GausDecoder(opt.option_unpool).to(device)\n # vgg.load_state_dict(torch.load(config.vgg))\n # vgg = nn.Sequential(*list(vgg.children())[:31])\n laps = Lap_Sob_Gaus(transfer_at=transfer_at, option_unpool='sum', device=device)\n network = net.Net(encoder, decoder)\n network.train()\n network.to(device)\n transformer = network\n if opt.model_path:\n transformer.load_state_dict(t.load(opt.model_path, map_location=lambda _s, _: _s))\n transformer.to(device)\n\n # Vgg16 for Perceptual Loss\n # vgg = Vgg16().eval()\n # vgg.to(device)\n # for param in vgg.parameters():\n # param.requires_grad = False\n\n # Optimizer\n # optimizer = t.optim.Adam(transformer.parameters(), opt.lr)\n enoptimizer = t.optim.Adam(network.encoder.parameters(), lr=opt.lr, betas=(0.9, 0.999))\n deoptimizer = t.optim.Adam(network.decoder.parameters(), lr=opt.lr, betas=(0.9, 0.999))\n\n # # Get style image\n # style_dataloader = utils_.get_style_data(opt.style_path, opt.batch_size)\n # #style_list = list(enumerate(style_dataloader))\n # for ii, (style, _) in tqdm.tqdm(enumerate(style_dataloader)):\n # #a = style\n # style = style.expand(opt.batch_size, 3, 256, 256)\n # vis.img('style', (style.data[0] * 0.225 + 0.45).clamp(min=0, max=1))\n # #style_list.append(style)\n #\n # style = style.to(device)\n # #\n # # #\n # # # # gram matrix for style image\n # with t.no_grad():\n # features_style = vgg(style)\n # gram_style = [utils_.gram_matrix(y) for y in features_style]\n\n # Loss meter\n style_meter = tnt.meter.AverageValueMeter()\n content_meter = tnt.meter.AverageValueMeter()\n\n for epoch in range(opt.epoches):\n # for jj, (style, _) in tqdm.tqdm(enumerate(style_dataloader)):\n # a = style\n # vis.img('style', (style.data[0] * 0.225 + 0.45).clamp(min=0, max=1))\n # style = style.to(device)\n\n #\n\n\n content_meter.reset()\n style_meter.reset()\n for ii, (x, _) in tqdm.tqdm(enumerate(dataloader)):\n if epoch == 0:\n adjust_learning_rate(opt.lr, enoptimizer, iteration_count=ii, lr_decay=opt.lr_decay)\n adjust_learning_rate(opt.lr, deoptimizer, iteration_count=ii, lr_decay=opt.lr_decay)\n print(opt.lr)\n # style = style_list[ii][1][0]\n # # style = style_list[ii]\n # style = style.to(device)\n # # # gram matrix for style image\n # with t.no_grad():\n # features_style = vgg(style)\n # gram_style = [utils_.gram_matrix(y) for y in features_style]\n style_dataloader = utils_.get_style_data(opt.style_path, opt.batch_size)\n # style_list = list(enumerate(style_dataloader))\n for jj, (style, _) in tqdm.tqdm(enumerate(style_dataloader)):\n # a = style\n style = style.expand(opt.batch_size, 3, 256, 256)\n #vis.img('style', (style.data[0] * 0.225 + 0.45).clamp(min=0, max=1))\n vis.img('style', (style.data[0]).clamp(min=0, max=1))\n # style_list.append(style)\n\n style = style.to(device)\n #\n # #\n # # # gram matrix for style image\n # with t.no_grad():\n # features_style = vgg(style)\n # gram_style = [utils_.gram_matrix(y) for y in features_style]\n # Train\n enoptimizer.zero_grad()\n deoptimizer.zero_grad()\n x = x.to(device)\n #y = network(x, style, Laps=laps)\n # if (ii + 1) % 10 == 0:\n # print(y)\n # y = y.clamp_(0, 1) * 255\n #y = utils_.normalize_batch(y)\n #x = utils_.normalize_batch(x)\n\n # features_y = vgg(y)\n # features_x = vgg(x)\n\n # # content loss\n # content_loss = opt.content_weight * F.mse_loss(features_y.relu2_2, features_x.relu2_2)\n #\n # # style loss\n # style_loss = 0\n #\n # for ft_y, gm_s in zip(features_y, gram_style):\n # gram_y = utils_.gram_matrix(ft_y)\n # style_loss += F.mse_loss(gram_y, gm_s.expand_as(gram_y))\n y, content_feats, content_loss, style_loss = network(x, style, Laps=laps)\n content_loss *= opt.content_weight\n style_loss *= opt.style_weight\n total_loss = content_loss + style_loss\n total_loss.backward()\n enoptimizer.step()\n deoptimizer.step()\n\n # Loss smooth for visualization\n content_meter.add(content_loss.item())\n style_meter.add(style_loss.item())\n\n if ii % 50 == 1:\n print('\\n')\n print('iters:', ii, 'total_loss:', total_loss, 'loss_c:', content_loss, 'loss_s: ', style_loss)\n if (ii + 1) % opt.plot_every == 0:\n if os.path.exists(opt.debug_file):\n ipdb.set_trace()\n\n # visualization\n vis.plot('content_loss', content_meter.value()[0])\n vis.plot('style_loss', style_meter.value()[0])\n # denorm input/output, since we have applied (utils.normalize_batch)\n vis.img('output1', (y.data.cpu()[0]).clamp(min=0, max=1))\n vis.img('input1', (x.data.cpu()[0]).clamp(min=0, max=1))\n vis.img('decoder_1', (content_feats['decoder'][0][0].data.cpu()[0]).clamp(min=0, max=1))\n vis.img('decoder_2', (content_feats['decoder'][1][0].data.cpu()[0]).clamp(min=0, max=1))\n vis.img('decoder_3', (content_feats['decoder'][2][0].data.cpu()[0]).clamp(min=0, max=1))\n vis.img('decoder_4', (content_feats['decoder'][3][0].data.cpu()[0]).clamp(min=0, max=1))\n #save_image(content_feat.clamp_(0, 1), fname_output + \"decoder{:d}\".format(level), padding=0)\n\n if (ii) % 1000 == 0:\n if not os.path.exists(save_dir /'epoch_{:d}'.format(epoch)):\n os.makedirs(save_dir /'epoch_{:d}'.format(epoch))\n de_state_dict = network.decoder.state_dict()\n en_state_dict = network.encoder.state_dict()\n for key in de_state_dict.keys():\n de_state_dict[key] = de_state_dict[key].to(t.device('cpu'))\n t.save(de_state_dict, save_dir /'epoch_{:d}'.format(epoch)/\n 'decoder_iter_{:d}.pth.tar'.format(ii + 1))\n for key in en_state_dict.keys():\n en_state_dict[key] = en_state_dict[key].to(t.device('cpu'))\n t.save(en_state_dict, save_dir /'epoch_{:d}'.format(epoch)/\n 'encoder_iter_{:d}.pth.tar'.format(ii + 1))\n\n de_state_dict = network.decoder.state_dict()\n en_state_dict = network.encoder.state_dict()\n for key in de_state_dict.keys():\n de_state_dict[key] = de_state_dict[key].to(t.device('cpu'))\n t.save(de_state_dict, save_dir /\n 'epoch_decoder_iter_{:d}.pth.tar'.format(epoch + 1))\n for key in en_state_dict.keys():\n en_state_dict[key] = en_state_dict[key].to(t.device('cpu'))\n t.save(en_state_dict, save_dir /\n 'epoch_encoder_iter_{:d}.pth.tar'.format(epoch + 1))\n # save checkpoints\n vis.save([opt.env])\n t.save(network.state_dict(), 'checkpoints/epoch_%s_style.pth' % epoch)\n writer.close()\n\n\[email protected]_grad()\ndef stylize(**kwargs):\n \"\"\"\n perform style transfer\n \"\"\"\n opt = Config()\n\n for k_, v_ in kwargs.items():\n setattr(opt, k_, v_)\n device = t.device('cuda') if opt.use_gpu else t.device('cpu')\n\n # input image preprocess\n content_image = tv.datasets.folder.default_loader(opt.content_path)\n content_transform = tv.transforms.Compose([\n tv.transforms.ToTensor(),\n tv.transforms.Lambda(lambda x: x.mul(255))\n ])\n content_image = content_transform(content_image)\n content_image = content_image.unsqueeze(0).to(device).detach()\n\n # model setup\n style_model = TransformerNet().eval()\n style_model.load_state_dict(t.load(opt.model_path, map_location=lambda _s, _: _s))\n style_model.to(device)\n\n # style transfer and save output\n output = style_model(content_image)\n output_data = output.cpu().data[0]\n tv.utils.save_image(((output_data / 255)).clamp(min=0, max=1), opt.result_path)\n\n\nif __name__ == '__main__':\n import fire\n\n fire.Fire()\n train()"
]
| [
[
"torch.device",
"torch.no_grad",
"torch.cuda.is_available",
"torch.utils.data.DataLoader",
"torch.load"
]
]
|
ypxie/keras-1 | [
"f1ed8d63faa26ce6180faa685839aa32217211c6"
]
| [
"keras/backend/common.py"
]
| [
"import numpy as np\n\nfrom collections import defaultdict\n\n# the type of float to use throughout the session.\n_FLOATX = 'float32'\n_EPSILON = 10e-8\n_UID_PREFIXES = defaultdict(int)\n_IMAGE_DIM_ORDERING = 'tf'\n_LEGACY_WEIGHT_ORDERING = False\n\n\ndef epsilon():\n '''Returns the value of the fuzz\n factor used in numeric expressions.\n\n # Returns\n A float.\n\n # Example\n ```python\n >>> keras.backend.epsilon()\n 1e-08\n ```\n '''\n return _EPSILON\n\n\ndef set_epsilon(e):\n '''Sets the value of the fuzz\n factor used in numeric expressions.\n\n # Arguments\n e: float. New value of epsilon.\n\n # Example\n ```python\n >>> from keras import backend as K\n >>> K.epsilon()\n 1e-08\n >>> K.set_epsilon(1e-05)\n >>> K.epsilon()\n 1e-05\n ```\n '''\n global _EPSILON\n _EPSILON = e\n\n\ndef floatx():\n '''Returns the default float type, as a string\n (e.g. 'float16', 'float32', 'float64').\n\n # Returns\n String, the current default float type.\n\n # Example\n ```python\n >>> keras.backend.floatx()\n 'float32'\n ```\n '''\n return _FLOATX\n\n\ndef set_floatx(floatx):\n '''Sets the default float type.\n\n # Arguments\n String: 'float16', 'float32', or 'float64'.\n\n # Example\n ```python\n >>> from keras import backend as K\n >>> K.floatx()\n 'float32'\n >>> K.set_floatx('float16')\n >>> K.floatx()\n 'float16'\n ```\n '''\n global _FLOATX\n if floatx not in {'float16', 'float32', 'float64'}:\n raise ValueError('Unknown floatx type: ' + str(floatx))\n _FLOATX = str(floatx)\n\n\ndef cast_to_floatx(x):\n '''Cast a Numpy array to the default Keras float type.\n\n # Arguments\n x: Numpy array.\n\n # Returns\n The same Numpy array, cast to its new type.\n\n # Example\n ```python\n >>> from keras import backend as K\n >>> K.floatx()\n 'float32'\n >>> arr = numpy.array([1.0, 2.0], dtype='float64')\n >>> arr.dtype\n dtype('float64')\n >>> new_arr = K.cast_to_floatx(arr)\n >>> new_arr\n array([ 1., 2.], dtype=float32)\n >>> new_arr.dtype\n dtype('float32')\n ```\n '''\n return np.asarray(x, dtype=_FLOATX)\n\n\ndef image_dim_ordering():\n '''Returns the default image dimension ordering\n convention ('th' or 'tf').\n\n # Returns\n A string, either `'th'` or `'tf'`\n\n # Example\n ```python\n >>> keras.backend.image_dim_ordering()\n 'th'\n ```\n '''\n return _IMAGE_DIM_ORDERING\n\n\ndef set_image_dim_ordering(dim_ordering):\n '''Sets the value of the image dimension\n ordering convention ('th' or 'tf').\n\n # Arguments\n dim_ordering: string. `'th'` or `'tf'`.\n\n # Example\n ```python\n >>> from keras import backend as K\n >>> K.image_dim_ordering()\n 'th'\n >>> K.set_image_dim_ordering('tf')\n >>> K.image_dim_ordering()\n 'tf'\n ```\n '''\n global _IMAGE_DIM_ORDERING\n if dim_ordering not in {'tf', 'th'}:\n raise ValueError('Unknown dim_ordering:', dim_ordering)\n _IMAGE_DIM_ORDERING = str(dim_ordering)\n\n\ndef get_uid(prefix=''):\n '''Provides a unique UID given a string prefix.\n\n # Arguments\n prefix: string.\n\n # Returns\n An integer.\n\n # Example\n ```\n >>> keras.backend.get_uid('dense')\n >>> 1\n >>> keras.backend.get_uid('dense')\n >>> 2\n ```\n\n '''\n _UID_PREFIXES[prefix] += 1\n return _UID_PREFIXES[prefix]\n\n\ndef reset_uids():\n global _UID_PREFIXES\n _UID_PREFIXES = defaultdict(int)\n\n\ndef is_keras_tensor(x):\n '''Returns whether `x` is a Keras tensor.\n\n # Arguments\n x: a potential tensor.\n\n # Returns\n A boolean: whether the argument is a Keras tensor.\n\n # Examples\n ```python\n >>> from keras import backend as K\n >>> np_var = numpy.array([1, 2])\n >>> K.is_keras_tensor(np_var)\n False\n >>> keras_var = K.variable(np_var)\n >>> K.is_keras_tensor(keras_var) # A variable is not a Tensor.\n False\n >>> keras_placeholder = K.placeholder(shape=(2, 4, 5))\n >>> K.is_keras_tensor(keras_placeholder) # A placeholder is a Tensor.\n True\n ```\n '''\n if hasattr(x, '_keras_shape'):\n return True\n else:\n return False\n\n\ndef set_legacy_weight_ordering(value):\n global _LEGACY_WEIGHT_ORDERING\n assert value in {True, False}\n _LEGACY_WEIGHT_ORDERING = value\n\n\ndef legacy_weight_ordering():\n return _LEGACY_WEIGHT_ORDERING\n"
]
| [
[
"numpy.asarray"
]
]
|
hrichstein/phys_50733 | [
"a333bfa4dd5b0ca464bd861336bc2f32d8e72a2b"
]
| [
"rh_project/rk4_two_body.py"
]
| [
"import numpy as np\nimport matplotlib.pyplot as plt\n# from scipy.constants import G\n\n# Setting plotting parameters\nfrom matplotlib import rc,rcParams\nrc('text', usetex=True)\nrc('axes', linewidth=2)\nrc('font', weight='bold')\nrc('font', **{'family': 'serif', 'serif':['Computer Modern']})\n\ndef find_vel_init(M1, M2, A):\n\tperiod = np.sqrt(4 * np.pi**2 * A**3 / G / (M1 + M2)) # period in days\n\n\tv = 2 * np.pi * A / period # AU/day\n\n\treturn v\n\ndef accel(Mass, pos1, pos2):\n\t\"\"\"\n\tMass: float-like?\n\t\tsum of the mass of both stars\n\tpos1: array-like\n\t\t[x,y] position of first star\n\tpos2: array-like\n\t\t[x,y] position of second star\n\t\"\"\"\n\n\tr_sep = np.sqrt((pos1[0] - pos1[1])**2 + (pos2[0] - pos2[1])**2)\n\n\ta_x = -G * Mass / r_sep**3 * abs(pos1[0] - pos2[0])\n\ta_y = -G * Mass / r_sep**3 * abs(pos1[1] - pos2[1])\n\n\taccel_arr = np.array([a_x, a_y])\n\n\treturn accel_arr\n\n# Gm(x1-x2)/r^3; r is the distance separating everything (both the stars)\n\n# initial velocity only in one direction\n\ndef rk4(r1, r2, v1, v2, h):\n\t\"\"\"\n\tr: array-like\n\t\thas x,y components\n\tv: array-like\n\t\thas vx, vy components\n\th: float-like\n\t\ttime step\n\t\"\"\"\n\tx0_s1 = r1[0]\n\ty0_s1 = r1[1]\n\n\tx0_s2 = r2[0]\n\ty0_s2 = r2[1]\n\n\td_x0_s1 = v1[0]\n\td_y0_s1 = v1[1]\n\n\td_x0_s2 = v2[0]\n\td_y0_s2 = v2[1]\n\n\td_v0 = accel(Mass, r1, r2) # Same for both stars (velocity is what differs)\n\n\t# First set of RK4\n\tx1_s1 = x0_s1 + 0.5*(d_x0_s1)*h\n\ty1_s1 = y0_s1 + 0.5*(d_y0_s1)*h\n\n\tx1_s2 = x0_s2 + 0.5*(d_x0_s2)*h\n\ty1_s2 = y0_s2 + 0.5*(d_y0_s2)*h\n\n\td_x1_s1 = d_x0_s1 + 0.5*(d_v0[0])*h\n\td_y1_s1 = d_y0_s1 + 0.5*(d_v0[1])*h\n\n\td_x1_s2 = d_x0_s2 + 0.5*(d_v0[0])*h\n\td_y1_s2 = d_y0_s2 + 0.5*(d_v0[1])*h\n\n\tr1_new = np.array([x1_s1,y1_s1])\n\tr2_new = np.array([x1_s2,y1_s2])\n\n\td_v1 = accel(Mass, r1_new, r2_new)\n\n\t# Second\n\n\tx2_s1 = x0_s1 + 0.5*(d_x1_s1)*h\n\ty2_s1 = y0_s1 + 0.5*(d_y1_s1)*h\n\n\tx2_s2 = x0_s2 + 0.5*(d_x1_s2)*h\n\ty2_s2 = y0_s2 + 0.5*(d_y1_s2)*h\n\n\td_x2_s1 = d_x0_s1 + 0.5*(d_v1[0])*h\n\td_y2_s1 = d_y0_s1 + 0.5*(d_v1[1])*h\n\n\td_x2_s2 = d_x0_s2 + 0.5*(d_v1[0])*h\n\td_y2_s2 = d_y0_s2 + 0.5*(d_v1[1])*h\n\n\tr1_new = np.array([x2_s1,y2_s1])\n\tr2_new = np.array([x2_s2,y2_s2])\n\n\td_v2 = accel(Mass, r1_new, r2_new)\n\n\t# Third\n\n\tx3_s1 = x0_s1 + (d_x2_s1)*h\n\ty3_s1 = y0_s1 + (d_y2_s1)*h\n\n\tx3_s2 = x0_s2 + (d_x2_s2)*h\n\ty3_s2 = y0_s2 + (d_y2_s2)*h\n\n\td_x3_s1 = d_x0_s1 + (d_v2[0])*h\n\td_y3_s1 = d_y0_s1 + (d_v2[1])*h\n\n\td_x3_s2 = d_x0_s2 + (d_v2[0])*h\n\td_y3_s2 = d_y0_s2 + (d_v2[1])*h\n\n\tr1_new = np.array([x3_s1,y3_s1])\n\tr2_new = np.array([x3_s2,y3_s2])\n\n\td_v3 = accel(1, r1_new, r2_new)\n\n\t# Combining\n\n\txf_s1 = x0_s1 + h*(d_x0_s1 + 2*d_x1_s1 + 2*d_x2_s1 + d_x3_s1)/6\n\tyf_s1 = y0_s1 + h*(d_y0_s1 + 2*d_y1_s1 + 2*d_y2_s1 + d_y3_s1)/6\n\n\trf_s1 = np.array([xf_s1,yf_s1])\n\n\txf_s2 = x0_s2 + h*(d_x0_s2 + 2*d_x1_s2 + 2*d_x2_s2 + d_x3_s2)/6\n\tyf_s2 = y0_s2 + h*(d_y0_s2 + 2*d_y1_s2 + 2*d_y2_s2 + d_y3_s2)/6\n\n\trf_s2 = np.array([xf_s2,yf_s2])\n\n\td_xf_s1 = d_x0_s1 + h*(d_v0[0] + 2*d_v1[0] + 2*d_v2[0] + d_v3[0])/6\n\td_yf_s1 = d_y0_s1 + h*(d_v0[1] + 2*d_v1[1] + 2*d_v2[1] + d_v3[1])/6\n\n\tvf_s1 = np.array([d_xf_s1,d_yf_s1])\n\n\td_xf_s2 = d_x0_s2 + h*(d_v0[0] + 2*d_v1[0] + 2*d_v2[0] + d_v3[0])/6\n\td_yf_s2 = d_y0_s2 + h*(d_v0[1] + 2*d_v1[1] + 2*d_v2[1] + d_v3[1])/6\n\n\tvf_s2 = np.array([d_xf_s2,d_yf_s2])\n\n\tresults_arr = np.array([rf_s1, rf_s2, vf_s1, vf_s2])\n\n\treturn results_arr\n\nG = 4 * np.pi**2 # AU^3 yr^-2 M_sun^-1\n\nMass = 2 # Solar masses\nA = 0.2 # AU (sep dist)\n\na = 0\nb = 0.06 # years\nN = 100000\nh = (b-a) / N\n\ntpoints = np.arange(a,b,h)\t\n\n# Setting up arrays\n\nxpts_s1 = [[] for xx in range(len(tpoints))]\nypts_s1 = [[] for xx in range(len(tpoints))]\n\nxpts_s2 = [[] for xx in range(len(tpoints))]\nypts_s2 = [[] for xx in range(len(tpoints))]\n\n# Initial conditions\nr0_s1 = np.array([0,0.1])\nr0_s2 = np.array([0,-0.1])\n\nvx0 = find_vel_init(1, 1, A)\nvy0 = 0\n\nv0_s1 = np.array([vx0,0])\nv0_s2 = np.array([-vx0,0])\n\nparam_arr = np.array([r0_s1, r0_s2, v0_s1, v0_s2])\n\nfor tt in range(len(tpoints)):\n\txpts_s1[tt] = param_arr[0][0]\n\typts_s1[tt] = param_arr[0][1]\n\n\txpts_s2[tt] = param_arr[1][0]\n\typts_s2[tt] = param_arr[1][1]\n\n\tparam_arr = rk4(param_arr[0], param_arr[1], param_arr[2], param_arr[3], h)\n\nplt.plot(xpts_s1, ypts_s1)\nplt.plot(xpts_s2, ypts_s2)\n\nplt.show()\n"
]
| [
[
"numpy.array",
"matplotlib.pyplot.plot",
"matplotlib.rc",
"numpy.arange",
"numpy.sqrt",
"matplotlib.pyplot.show"
]
]
|
xsun28/CloudMerge | [
"c4211bac841b103c77d6f9c4af633102742298ac"
]
| [
"cloudmerge-hpc/mpi_merge.py"
]
| [
"#!/usr/bin/env python2\n# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Wed Dec 27 16:54:42 2017\n\n@author: Xiaobo\n\"\"\"\nimport numpy as np\nfrom mpi4py import MPI\nimport commands\nimport os\nimport sys\npath = os.path.dirname(os.path.realpath(__file__))\nsys.path.append(path)\n#sys.path.append('/Users/Xiaobo/git/CloudMerge/CloudMerge/cloudmerge-hpc')\n#sys.path.append('/home/ubuntu/cloudmerge/cloudmerge-hpc/')\nimport multiway_merge as mm\nimport argparse\n###############################################################################\ndef get_source(rank,size,rounds):\n divisor = np.power(2,rounds)\n new_rank = int(rank/divisor)\n new_size = int(size/divisor)\n if (new_rank%2 != 0) or (new_rank+1>=new_size):\n return []\n elif (new_rank+2+1>=new_size) and (new_rank+2<new_size):\n return [divisor*(new_rank+1),divisor*(new_rank+2)]\n else:\n return [divisor*(new_rank+1),]\n\n#------------------------------------------------------------------------------ \ndef get_dest(rank,size,rounds):\n SELF = -1\n divisor = np.power(2,rounds)\n new_rank = int(rank/divisor)\n new_size = int(size/divisor)\n if new_rank % 2 !=0:\n dest = divisor*(new_rank-1)\n return dest\n elif (new_rank + 1) >= new_size:\n dest = divisor*(new_rank-2)\n return dest if dest >=0 else 0 \n else:\n return SELF\n#------------------------------------------------------------------------------\ndef splits(filenum,size):\n assigned = 0\n sendcounts = np.zeros(size) \n disp = np.zeros(size)\n for i in range(size): \n nxt_sz = int((filenum-assigned)/(size-i))\n disp[i] = assigned\n sendcounts[i] = nxt_sz\n assigned = assigned + nxt_sz\n return tuple(sendcounts),tuple(disp)\n\n#------------------------------------------------------------------------------\ndef get_output_name(localname,rcvname):\n if rcvname is None:\n return localname\n start = localname.split('_')[0]\n end = rcvname[-1].split('_')[-1]\n return start+'_'+end\n\n\n###############################################################################\n\n\n \nparser = argparse.ArgumentParser(description='cloudmerge-hpc')\nparser.add_argument('-i',required=True,help='input file directory path',dest='input',metavar='/home/ubuntu/cloudmerge/input/')\nparser.add_argument('-o',required=True,help='output file directory path',dest='output',metavar='/home/ubuntu/cloudmerge/output/')\nparser.add_argument('-n',required=True,help='input file number',dest='filenum',metavar='10',type=int)\nparser.add_argument('-l',required=False,default='1',help='lower boundary of chrmosomes',dest='lower_chr',metavar='1')\nparser.add_argument('-u',required=False,default='M',help='upper boundary of chromosomes',dest='upper_chr',metavar='M')\nparser.add_argument('-g',required=False,default=9,help='genotype column number',dest='gtype_col',metavar='9',type=int)\nparser.add_argument('-f',required=False,default='PASS',help='filter value',dest='filter',metavar='PASS')\nargs = parser.parse_args()\n#args = parser.parse_args('-i abc -o def -n 10 -l 1 -u 26 -g 9 -f PASS'.split())\n#input_path = '/home/ubuntu/cloudmerge/input/'\n#output_path = '/home/ubuntu/cloudmerge/output/'\n#input_path = '/Users/Xiaobo/Desktop/input/'\n#output_path = '/Users/Xiaobo/Desktop/output/'\ninput_path = args.input\noutput_path = args.output\nfilenum = args.filenum\nlower_chr = args.lower_chr\nupper_chr = args.upper_chr\nqfilter = args.filter\ngenotype_col = args.gtype_col\ncomm = MPI.COMM_WORLD\nrank = comm.Get_rank()\nsize = comm.Get_size()\nhost = commands.getoutput(\"hostname\")\nrounds = 0\nsendcounts,disp = splits(filenum,size)\nif rank == 0:\n sendbuff = np.linspace(1,filenum,filenum)\n\nelse: \n sendbuff = None\n\nrcvbuff = np.zeros(int(sendcounts[rank])) \n \ncomm.Scatterv([sendbuff,sendcounts,disp,MPI.DOUBLE],rcvbuff,root=0)\n\n#local_input_files = map(lambda x: input_path+str(int(x))+'.bz2',rcvbuff)\n#for file in local_input_files:\n# print('unzipping files %s in rank %d' % (str(local_input_files),rank))\n# os.system('bunzip2 '+file)\n\nlocal_input_files = map(lambda x: input_path+str(int(x))+'.bz2',rcvbuff)\n#local_merged_files = \"_\".join(map(lambda x: str(int(x)),rcvbuff))\nlocal_merged_files = str(int(rcvbuff[0]))+'_'+str(int(rcvbuff[-1]))\nmerger = mm.multiway_merger(local_input_files, output_path+local_merged_files,lower_chr,upper_chr,qfilter,genotype_col,merge_type='vcf')\nmerger.start()\nprint('merged_files %s'%local_merged_files)\n\nwhile True:\n src = get_source(rank,size,rounds)\n# if len(src) == 0: #only when no source, we need a destination\n dest = get_dest(rank,size,rounds)\n rounds = rounds+1 \n if len(src) == 0:\n if rank > 0: \n comm.send(local_merged_files,dest=dest,tag=0)\n print('i am rank %d, host is %s, sent merged files is %s, source is %s, dest is %d' %(rank,host,local_merged_files,str(src),dest))\n break ## send the filename to dest process and quit\n elif len(src) == 1:\n local_files = [output_path+local_merged_files]\n rcv_merged_file = comm.recv(source=src[0],tag=0)\n local_files.extend([output_path+rcv_merged_file])\n# local_merged_files = '_'.join([local_merged_files,rcv_merged_file])\n local_merged_files = get_output_name(local_merged_files,[rcv_merged_file])\n print('i am rank %d, host is %s, local merged file is %s, src is %s, dest is %d' %(rank,host,local_merged_files,str(src),dest))\n else:\n local_files = [output_path+local_merged_files]\n rcv_merged_files = []\n for i,s in enumerate(src):\n print('i am rank %d, host is %s, src is %s, dest is %d' %(rank,host,s,dest))\n rcv_file = comm.recv(source=s,tag=0)\n local_files.extend([output_path+rcv_file])\n rcv_merged_files.extend([rcv_file])\n# local_merged_files = '_'.join([local_merged_files]+rcv_merged_files)\n local_merged_files = get_output_name(local_merged_files,rcv_merged_files)\n\n \n if rank == 0:\n src = get_source(rank,size,rounds)\n if len(src) == 0: #### the last merging step\n merger = mm.multiway_merger(local_files,output_path+local_merged_files,lower_chr,upper_chr,qfilter,genotype_col,False,merge_type='tped')\n merger.start()\n break;\n merger = mm.multiway_merger(local_files,output_path+local_merged_files,lower_chr,upper_chr,qfilter,genotype_col,merge_type='tped')\n merger.start()\n\n\n\n\n\n################################################################################ \n# if rank >0:\n# comm.send(local_merged_files,dest=dest,tag=0)\n# print('i am rank %d, host is %s, send local merged files is %s, source is %s, dest is %d' %(rank,host,local_merged_files,str(src),dest))\n \n \n \n#print('rank is %d, host is %s, data is %s' %(rank,host,str(rcvbuff))) \n# create numpy arrays to reduce\n\n#src = (np.arange(8) + rank*8).reshape(4,2)\n#dst = np.zeros_like(src)\n#\n#def myadd(xmem, ymem, dt):\n# x = np.frombuffer(xmem, dtype=src.dtype)\n# y = np.frombuffer(ymem, dtype=src.dtype)\n#\n# z = x + y\n#\n# print(\"Rank %d on host %s reducing %s (%s) and %s (%s), yielding %s\" % (rank, host, x, type(x), y, type(y), z))\n#\n# y[:] = z\n#\n#op = MPI.Op.Create(myadd)\n#\n#MPI.COMM_WORLD.Reduce(src, dst, op)\n#\n#if MPI.COMM_WORLD.rank == 0:\n# print(\"ANSWER: %s\" % dst)"
]
| [
[
"numpy.linspace",
"numpy.power",
"numpy.zeros"
]
]
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.