repo_name
stringlengths 6
130
| hexsha
list | file_path
list | code
list | apis
list |
|---|---|---|---|---|
zoeyuchao/onpolicy-release | [
"c2cb64e59c5b1f21cce022db76c378b396fd480e"
] | [
"onpolicy/envs/mpe/scenarios/simple_push.py"
] | [
"import numpy as np\nfrom onpolicy.envs.mpe.core import World, Agent, Landmark\nfrom onpolicy.envs.mpe.scenario import BaseScenario\nimport random\n\n#\n# # the non-ensemble version of <ensemble_push>\n#\n#\n\nclass Scenario(BaseScenario):\n def make_world(self, args):\n world = World()\n world.world_length = args.episode_length\n # set any world properties first\n world.dim_c = 2\n num_agents = args.num_agents#2\n num_adversaries = 1\n num_landmarks = args.num_landmarks#2\n # add agents\n world.agents = [Agent() for i in range(num_agents)]\n for i, agent in enumerate(world.agents):\n agent.name = 'agent %d' % i\n agent.collide = True\n agent.silent = True\n if i < num_adversaries:\n agent.adversary = True\n else:\n agent.adversary = False\n # agent.u_noise = 1e-1\n # agent.c_noise = 1e-1\n # add landmarks\n world.landmarks = [Landmark() for i in range(num_landmarks)]\n for i, landmark in enumerate(world.landmarks):\n landmark.name = 'landmark %d' % i\n landmark.collide = False\n landmark.movable = False\n # make initial conditions\n self.reset_world(world)\n return world\n\n def reset_world(self, world):\n # random properties for landmarks\n for i, landmark in enumerate(world.landmarks):\n landmark.color = np.array([0.1, 0.1, 0.1])\n landmark.color[i + 1] += 0.8\n landmark.index = i\n # set goal landmark\n goal = np.random.choice(world.landmarks)\n for i, agent in enumerate(world.agents):\n agent.goal_a = goal\n agent.color = np.array([0.25, 0.25, 0.25])\n if agent.adversary:\n agent.color = np.array([0.75, 0.25, 0.25])\n else:\n j = goal.index\n agent.color[j + 1] += 0.5\n # set random initial states\n for agent in world.agents:\n agent.state.p_pos = np.random.uniform(-1, +1, world.dim_p)\n agent.state.p_vel = np.zeros(world.dim_p)\n agent.state.c = np.zeros(world.dim_c)\n for i, landmark in enumerate(world.landmarks):\n landmark.state.p_pos = 0.8 * np.random.uniform(-1, +1, world.dim_p)\n landmark.state.p_vel = np.zeros(world.dim_p)\n\n def reward(self, agent, world):\n # Agents are rewarded based on minimum agent distance to each landmark\n return self.adversary_reward(agent, world) if agent.adversary else self.agent_reward(agent, world)\n\n def agent_reward(self, agent, world):\n # the distance to the goal\n return -np.sqrt(np.sum(np.square(agent.state.p_pos - agent.goal_a.state.p_pos)))\n\n def adversary_reward(self, agent, world):\n # keep the nearest good agents away from the goal\n agent_dist = [np.sqrt(np.sum(np.square(a.state.p_pos - a.goal_a.state.p_pos))) for a in world.agents if not a.adversary]\n pos_rew = min(agent_dist)\n #nearest_agent = world.good_agents[np.argmin(agent_dist)]\n #neg_rew = np.sqrt(np.sum(np.square(nearest_agent.state.p_pos - agent.state.p_pos)))\n neg_rew = np.sqrt(np.sum(np.square(agent.goal_a.state.p_pos - agent.state.p_pos)))\n #neg_rew = sum([np.sqrt(np.sum(np.square(a.state.p_pos - agent.state.p_pos))) for a in world.good_agents])\n return pos_rew - neg_rew\n \n def observation(self, agent, world):\n # get positions of all entities in this agent's reference frame\n entity_pos = []\n for entity in world.landmarks: # world.entities:\n entity_pos.append(entity.state.p_pos - agent.state.p_pos)\n # entity colors\n entity_color = []\n for entity in world.landmarks: # world.entities:\n entity_color.append(entity.color)\n # communication of all other agents\n comm = []\n other_pos = []\n for other in world.agents:\n if other is agent: continue\n comm.append(other.state.c)\n other_pos.append(other.state.p_pos - agent.state.p_pos)\n if not agent.adversary:\n return np.concatenate([agent.state.p_vel] + [agent.goal_a.state.p_pos - agent.state.p_pos] + [agent.color] + entity_pos + entity_color + other_pos)\n else:\n #other_pos = list(reversed(other_pos)) if random.uniform(0,1) > 0.5 else other_pos # randomize position of other agents in adversary network\n return np.concatenate([agent.state.p_vel] + entity_pos + other_pos)\n"
] | [
[
"numpy.concatenate",
"numpy.square",
"numpy.array",
"numpy.random.choice",
"numpy.zeros",
"numpy.random.uniform"
]
] |
ael-noblegas/pychron | [
"1a81e05d9fba43b797f335ceff6837c016633bcf",
"1a81e05d9fba43b797f335ceff6837c016633bcf"
] | [
"pychron/core/ui/qt/color_map_bar_editor.py",
"pychron/mv/focus/autofocus_manager.py"
] | [
"# ===============================================================================\n# Copyright 2012 Jake Ross\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ===============================================================================\n\n# ============= enthought library imports =======================\nfrom __future__ import absolute_import\nfrom chaco.data_range_1d import DataRange1D\nfrom chaco.default_colormaps import color_map_dict, color_map_name_dict\nfrom pyface.qt.QtGui import QPainter, QColor, QFrame\nfrom traits.api import Float, Int, Str\nfrom traitsui.basic_editor_factory import BasicEditorFactory\nfrom traitsui.qt4.editor import Editor\nfrom numpy import array\n\n# ============= local library imports ==========================\n# from matplotlib.cm import get_cmap\n\n\nclass Bar(QFrame):\n value = None\n low = 0\n high = 1\n color_scalar = 1\n colormap = 'jet'\n bar_width = 100\n scale = 'power'\n\n # def __init__(self, parent, ident=-1):\n # super(Bar, self).__init__()\n # self._cmap = get_cmap(self.colormap)\n\n def paintEvent(self, e):\n qp = QPainter()\n qp.begin(self)\n qp.setBrush(QColor(*self.value))\n qp.drawRect(0, 0, self.bar_width, 20)\n qp.end()\n\n def set_value(self, v):\n \"\"\"\n map v to users color scale\n use power law v=A*x**(1/cs)\n increase cs increases the rate of change at low values\n increase cs will make it easier to see small pertubations (more color change) at\n the low end.\n\n \"\"\"\n if self.scale == 'power':\n N = 1 / float(self.color_scalar)\n A = 1 / self.high ** N\n nv = A * v ** N\n else:\n nv = min(1, max(0, (v - self.low) / (self.high - self.low)))\n\n vs = self.cmap.map_screen(array([nv,]))[0][:3]\n self.value = [x * 255 for x in vs]\n self.update()\n\n\nclass _BarGaugeEditor(Editor):\n def init(self, parent):\n self.control = Bar()\n self.control.low = low = self.factory.low\n self.control.high = high = self.factory.high\n self.control.color_scalar = self.factory.color_scalar\n self.control.bar_width = self.factory.width\n self.control.scale = self.factory.scale\n\n # if self.factory.scale == 'power':\n # high = N = 1 / float(self.color_scalar)\n # A = 1 / self.high ** N\n self.control.cmap = color_map_name_dict[self.factory.colormap](DataRange1D(low_setting=0, high_setting=1))\n\n def update_editor(self):\n if self.control:\n self.control.set_value(self.value)\n\n\nclass BarGaugeEditor(BasicEditorFactory):\n klass = _BarGaugeEditor\n low = Float\n high = Float\n color_scalar = Int(1)\n scale = Str('power')\n colormap = Str('jet')\n width = Int(100)\n\n# ============= EOF =============================================\n",
"# ===============================================================================\n# Copyright 2011 Jake Ross\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ===============================================================================\n\n# =============enthought library imports=======================\nfrom __future__ import absolute_import\nfrom __future__ import print_function\nimport six.moves.cPickle as pickle\n\nfrom traits.api import Bool, Any, Instance, Button, Property, Event, on_trait_change\nfrom traitsui.api import View, Item, Handler, HGroup\n\n# ============= standard library imports ========================\n# from threading import Thread\nfrom threading import Event as TEvent\nfrom numpy import linspace, argmin, argmax, random, asarray\nimport time\nimport os\n# ============= local library imports ==========================\nfrom pychron.core.time_series.time_series import smooth\nfrom pychron.image.cv_wrapper import grayspace, crop, get_focus_measure\n# from pychron.image.cvwrapper import grayspace, get_focus_measure, crop, resize\nfrom scipy.ndimage.measurements import variance\nfrom scipy.ndimage.filters import generic_gradient_magnitude, sobel\nfrom scipy.ndimage import sum as ndsum\nfrom pychron.paths import paths\nfrom pychron.managers.manager import Manager\nfrom pychron.image.image import Image\n# from pychron.machine_vision.focus_parameters import FocusParameters\n# from pychron.image.image_editor import ImageEditor\nfrom pychron.graph.graph import Graph\nfrom pychron.mv.focus.focus_parameters import FocusParameters\nfrom pychron.core.ui.image_editor import ImageEditor\nfrom pychron.core.ui.gui import invoke_in_main_thread\nfrom pychron.core.ui.thread import Thread\n\n\nclass ConfigureHandler(Handler):\n def closed(self, info, isok):\n if isok:\n info.object.dump_parameters()\n\n\nclass AutoFocusManager(Manager):\n \"\"\"\n currently uses passive focus techniques\n see\n\n http://en.wikipedia.org/wiki/Autofocus\n\n \"\"\"\n\n video = Any\n laser_manager = Any\n stage_controller = Any\n canvas = Any\n parameters = Instance(FocusParameters)\n configure_button = Button('configure')\n\n autofocus_button = Event\n autofocus_label = Property(depends_on='autofocusing')\n autofocusing = Bool\n\n # threading event for cancel signal\n _evt_autofocusing = None\n\n image = Instance(Image, ())\n\n graph = None\n\n def dump_parameters(self):\n p = os.path.join(paths.hidden_dir, 'autofocus_configure')\n self.info('dumping parameters to {}'.format(p))\n with open(p, 'wb') as f:\n pickle.dump(self.parameters, f)\n\n def load_parameter(self):\n p = os.path.join(paths.hidden_dir, 'autofocus_configure')\n if os.path.isfile(p):\n with open(p, 'rb') as f:\n try:\n params = pickle.load(f)\n self.info('loading parameters from {}'.format(p))\n\n if not isinstance(params, FocusParameters):\n self.info('out of date parameters file. using default')\n params = FocusParameters()\n return params\n\n except Exception as e:\n print('autofocus load parameter', e)\n return FocusParameters()\n else:\n return FocusParameters()\n\n def passive_focus(self, block=False, **kw):\n\n self._evt_autofocusing = TEvent()\n self._evt_autofocusing.clear()\n# manager = self.laser_manager\n oper = self.parameters.operator\n self.info('passive focus. operator = {}'.format(oper))\n\n g = self.graph\n if not g:\n g = Graph(plotcontainer_dict=dict(padding=10),\n window_x=0.70,\n window_y=20,\n window_width=325,\n window_height=325,\n window_title='Autofocus'\n )\n self.graph = g\n\n g.clear()\n\n g.new_plot(padding=[40, 10, 10, 40],\n xtitle='Z (mm)',\n ytitle='Focus Measure ({})'.format(oper)\n )\n g.new_series()\n g.new_series()\n\n invoke_in_main_thread(self._open_graph)\n\n target = self._passive_focus\n self._passive_focus_thread = Thread(name='autofocus', target=target,\n args=(self._evt_autofocusing,\n\n ),\n kwargs=kw\n )\n self._passive_focus_thread.start()\n if block:\n# while 1:\n# if not self._passive_focus_thread.isRunning():\n# break\n# time.sleep(0.25)\n self._passive_focus_thread.join()\n\n def _open_graph(self):\n ui = self.graph.edit_traits()\n self.add_window(ui)\n\n def stop_focus(self):\n\n if self.stage_controller:\n self.stage_controller.stop()\n\n self.info('autofocusing stopped by user')\n\n def _passive_focus(self, stop_signal, set_zoom=True):\n '''\n sweep z looking for max focus measure\n FMgrad= roberts or sobel (sobel removes noise)\n FMvar = intensity variance\n '''\n\n self.autofocusing = True\n\n manager = self.laser_manager\n fstart = self.parameters.fstart\n fend = self.parameters.fend\n step_scalar = self.parameters.step_scalar\n zoom = self.parameters.zoom\n operator = self.parameters.operator\n\n steps = step_scalar * (max(fend, fstart) - min(fend, fstart)) + 1\n\n prev_zoom = None\n if set_zoom and \\\n manager is not None and \\\n zoom:\n motor = manager.get_motor('zoom')\n if motor:\n prev_zoom = motor.data_position\n self.info('setting zoom: {}'.format(zoom))\n manager.set_motor('zoom', zoom, block=True)\n time.sleep(1.5)\n\n args = self._do_focusing(fstart, fend, steps, operator)\n\n if manager is not None:\n if prev_zoom is not None:\n self.info('returning to previous zoom: {}'.format(prev_zoom))\n manager.set_motor('zoom', prev_zoom, block=True)\n\n if args:\n mi, fmi, ma, fma = args\n\n self.info('''passive focus results:Operator={}\nImageGradmin={} (z={})\nImageGradmax={}, (z={})'''.format(operator, mi, fmi, ma, fma))\n\n focus_pos = fma\n self.graph.add_vertical_rule(focus_pos)\n self.graph.redraw()\n# self.graph.add_vertical_rule(fma)\n\n self.info('calculated focus z= {}'.format(focus_pos))\n\n# if set_z:\n controller = self.stage_controller\n if controller is not None:\n if not stop_signal.isSet():\n controller.single_axis_move('z', focus_pos, block=True)\n controller._z_position = focus_pos\n controller.z_progress = focus_pos\n\n self.autofocusing = False\n\n def _cancel_sweep(self, vo):\n if self._evt_autofocusing.isSet():\n # return to original velocity\n self.autofocusing = False\n self._reset_velocity(vo)\n return True\n\n def _reset_velocity(self, vo):\n if self.stage_controller:\n pdict = dict(velocity=vo, key='z')\n self.stage_controller.set_single_axis_motion_parameters(pdict=pdict)\n\n def _do_focusing(self, start, end, steps, operator):\n screen_roi = self._get_roi()\n self._add_focus_area_rect(*screen_roi)\n\n src = self._load_source()\n src = asarray(src)\n h, w, _d = src.shape\n\n cx = w / 2.\n cy = h / 2.\n\n cw = self.parameters.crop_width\n ch = self.parameters.crop_height\n\n roi = cx, cy, cw, ch\n\n '''\n start the z in motion and take pictures as you go\n query stage_controller to get current z\n '''\n\n self.info('focus sweep start={} end={}'.format(start, end))\n # move to start position\n controller = self.stage_controller\n if controller:\n vo = controller.axes['z'].velocity\n if self._cancel_sweep(vo):\n return\n self.graph.set_x_limits(min(start, end), max(start, end), pad=2)\n # sweep 1 and velocity 1\n self._do_sweep(start, end, velocity=self.parameters.velocity_scalar1)\n fms, focussteps = self._collect_focus_measures(operator, roi)\n if not (fms and focussteps):\n return\n\n # reached end of sweep\n # calculate a nominal focal point\n args = self._calculate_nominal_focal_point(fms, focussteps)\n if not args:\n return\n nfocal = args[3]\n\n nwin = self.parameters.negative_window\n pwin = self.parameters.positive_window\n\n if self._cancel_sweep(vo):\n return\n nstart, nend = max(0, nfocal - nwin), nfocal + pwin\n# mi = min(min(nstart, nend), min(start, end))\n# ma = max(max(nstart, nend), max(start, end))\n# self.graph.set_x_limits(mi, ma, pad=2)\n time.sleep(1)\n # do a slow tight sweep around the nominal focal point\n self._do_sweep(nstart, nend, velocity=self.parameters.velocity_scalar2)\n fms, focussteps = self._collect_focus_measures(operator, roi, series=1)\n\n self._reset_velocity(vo)\n\n else:\n focussteps = linspace(0, 10, 11)\n fms = -(focussteps - 5) ** 2 + 10 + random.random(11)\n\n self.info('frames analyzed {}'.format(len(fms)))\n\n# self.canvas.markupcontainer.pop('croprect')\n return self._calculate_nominal_focal_point(fms, focussteps)\n\n def _do_sweep(self, start, end, velocity=None):\n controller = self.stage_controller\n controller.single_axis_move('z', start, block=True)\n# time.sleep(0.1)\n # explicitly check for motion\n# controller.block(axis='z')\n\n if velocity:\n vo = controller.axes['z'].velocity\n\n controller.set_single_axis_motion_parameters(pdict=dict(velocity=vo * velocity,\n key='z'))\n\n self.info('starting sweep from {}'.format(controller.z_progress))\n # pause before moving to end\n time.sleep(0.25)\n controller.single_axis_move('z', end, update=100, immediate=True)\n\n def _collect_focus_measures(self, operator, roi, series=0):\n controller = self.stage_controller\n focussteps = []\n fms = []\n if controller.timer:\n p = controller.timer.get_interval()\n self.debug('controller timer period {}'.format(p))\n pz = controller.z_progress\n\n while 1:\n src = self._load_source()\n x = controller.z_progress\n if x != pz:\n y = self._calculate_focus_measure(src, operator, roi)\n self.graph.add_datum((x, y), series=series)\n\n focussteps.append(x)\n fms.append(y)\n\n pz = x\n\n if not (controller.timer.isActive() and \\\n not self._evt_autofocusing.isSet()):\n break\n time.sleep(p)\n\n self.debug('sweep finished')\n\n\n return fms, focussteps\n\n def _calculate_nominal_focal_point(self, fms, focussteps):\n if fms:\n sfms = smooth(fms)\n if sfms is not None:\n\n self.graph.new_series(focussteps, sfms)\n self.graph.redraw()\n\n fmi = focussteps[argmin(sfms)]\n fma = focussteps[argmax(sfms)]\n\n mi = min(sfms)\n ma = max(sfms)\n\n return mi, fmi, ma, fma\n\n def _calculate_focus_measure(self, src, operator, roi):\n '''\n see\n IMPLEMENTATION OF A PASSIVE AUTOMATIC FOCUSING ALGORITHM\n FOR DIGITAL STILL CAMERA\n DOI 10.1109/30.468047\n and\n http://cybertron.cg.tu-berlin.de/pdci10/frankencam/#autofocus\n '''\n\n # need to resize to 640,480. this is the space the roi is in\n# s = resize(grayspace(pychron), 640, 480)\n src = grayspace(src)\n v = crop(src, *roi)\n\n di = dict(var=lambda x:variance(x),\n laplace=lambda x: get_focus_measure(x, 'laplace'),\n sobel=lambda x: ndsum(generic_gradient_magnitude(x, sobel, mode='nearest'))\n )\n\n func = di[operator]\n return func(v)\n\n def image_view(self):\n v = View(Item('image', show_label=False, editor=ImageEditor(),\n width=640,\n height=480,\n style='custom'))\n return v\n\n def traits_view(self):\n v = View(\n HGroup(self._button_factory('autofocus_button', 'autofocus_label'),\n Item('configure_button', show_label=False),\n show_border=True,\n label='Autofocus'\n )\n )\n return v\n\n def configure_view(self):\n v = View(Item('parameters', style='custom', show_label=False),\n handler=ConfigureHandler,\n buttons=['OK', 'Cancel'],\n kind='livemodal',\n title='Configure Autofocus',\n x=0.80,\n y=0.05\n )\n return v\n\n def _load_source(self):\n src = self.video.get_frame()\n return src\n# if pychron:\n# return Image.new_frame(pychron)\n# self.image.load(pychron)\n\n# return self.image.source_frame\n\n def _get_roi(self):\n w = self.parameters.crop_width\n h = self.parameters.crop_height\n\n cx, cy = self.canvas.get_center_rect_position(w, h)\n\n\n# cw, ch = self.canvas.outer_bounds\n# print w, h, cw, ch\n# cx = cw / 2. - w / 2.\n# cy = ch / 2. - h / 2.\n# cx = (cw - w) / 2.\n# cy = (ch - h) / 2.\n# cx = (640 * self.canvas.scaling - w) / 2\n# cy = (480 * self.canvas.scaling - h) / 2\n roi = cx, cy, w, h\n\n return roi\n\n def _add_focus_area_rect(self, cx, cy, w, h):\n# pl = self.canvas.padding_left\n# pb = self.canvas.padding_bottom\n\n self.canvas.remove_item('croprect')\n self.canvas.add_markup_rect(cx, cy, w, h, identifier='croprect')\n\n def _autofocus_button_fired(self):\n if not self.autofocusing:\n self.autofocusing = True\n\n self.passive_focus()\n else:\n self.autofocusing = False\n self._evt_autofocusing.set()\n self.stop_focus()\n\n def _configure_button_fired(self):\n self._crop_rect_update()\n self.edit_traits(view='configure_view', kind='livemodal')\n\n self.canvas.remove_item('croprect')\n# try:\n# self.canvas.markupcontainer.pop('croprect')\n# except KeyError:\n# pass\n\n @on_trait_change('parameters:[_crop_width,_crop_height]')\n def _crop_rect_update(self):\n roi = self._get_roi()\n self._add_focus_area_rect(*roi)\n\n def _get_autofocus_label(self):\n return 'Autofocus' if not self.autofocusing else 'Stop'\n\n\n def _parameters_default(self):\n return self.load_parameter()\n\n def _autofocusing_changed(self, new):\n if not new:\n self.canvas.remove_item('croprect')\n# ===============================================================================\n# Deprecated\n# ===============================================================================\n# ============= EOF =====================================\n\n"
] | [
[
"numpy.array"
],
[
"numpy.asarray",
"numpy.argmin",
"scipy.ndimage.filters.generic_gradient_magnitude",
"scipy.ndimage.measurements.variance",
"numpy.argmax",
"numpy.random.random",
"numpy.linspace"
]
] |
awinawin1/prediksi | [
"b3d552555f775d7b6a1b22077146443fe09bbf5d"
] | [
"public/code/simpleCropPredictSpektogram.py"
] | [
"# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Sat May 15 00:21:05 2021\n\n@author: marina\n\"\"\"\nimport os\nimport shutil\nimport pyedflib\nimport numpy as np\nimport pandas as pd\nimport sys\nimport mne \nfrom pywt import wavedec\nfrom sklearn.preprocessing import LabelEncoder\nimport matplotlib.pyplot as plt\nfrom scipy import signal\nfrom keras.models import Sequential\n #importing layers\nfrom keras.layers import Conv2D,Flatten,Dense,MaxPooling2D \nfrom tensorflow.keras.optimizers import SGD\n# pathDataSet = \"D:\\\\Kuliah\\Tugas Akhir\\chb-mit-scalp-eeg-database-1.0.0\\\\chb07\\\\\"\npathDataSet = \"/Applications/XAMPP/xamppfiles/htdocs/prediksi/storage/app/public/uploadedSpektogram/\"\npathSaveData = \"/Applications/XAMPP/xamppfiles/htdocs/prediksi/storage/app/public/uploadedSpektogram/spektogram/\"\n\n\ndef data_load(FILE, selected_channels=[]): \n fullNm = pathDataSet + FILE\n # fullNm = FILE\n f = pyedflib.EdfReader(fullNm )\n n = f.signals_in_file\n signal_labels = f.getSignalLabels()\n channel_freq = f.getSampleFrequencies()\n\n sigbufs = np.zeros((n, f.getNSamples()[0]))\n for i in np.arange(n):\n sigbufs[i, :] = f.readSignal(i)\n f.close()\n \n # and load the data into a DataFrame\n df_signals = pd.DataFrame(sigbufs)\n df_signals = df_signals.transpose()\n df_signals.columns = signal_labels\n df_signals = df_signals.loc[:,~df_signals.columns.duplicated()]\n df_signals = df_signals[selected_channels].astype('float32') \n return df_signals,channel_freq[0]\n\ndef mne_object(data, freq, events = None):\n info = mne.create_info(ch_names=list(data.columns), \n sfreq=freq, \n ch_types=['eeg']*data.shape[-1])\n data_T = data.transpose()\n raw = mne.io.RawArray(data_T, info,verbose=False)\n if events:\n start_times = np.array(events[::2])\n end_times = np.array(events[1::2])\n anno_length = end_times-start_times\n event_name = np.array(['Ictal']*len(anno_length))\n raw.set_annotations(mne.Annotations(start_times,\n anno_length,\n event_name))\n return raw\n\ndef loadAndFiltering(FILE,channel_keeps):\n raw_data, freq = data_load(FILE, channel_keeps)\n if len(raw_data) ==0:\n print(\"no data \")\n return raw_data\n mne_data = mne_object(raw_data, freq)\n raw=mne_data.copy()\n return raw\n\ndef extract_windows(array, start, max_time, sub_window_size,\n stride_size): \n sub_windows = (\n start + \n np.expand_dims(np.arange(sub_window_size), 0) +\n np.expand_dims(np.arange(max_time + 1- sub_window_size-start, step=stride_size), 0).T\n ) \n return array[:,sub_windows]\n\n\ndef Crop(raw): \n cropS = 3\n strides = 1\n \n tMin=0\n tMax=raw.get_data().shape[1]#18*256*cropS \n\n\n sub_window_size,stride_size = 256*cropS,256*strides\n cropData = extract_windows(raw.get_data(), tMin, tMax , sub_window_size,stride_size)\n cropData = cropData.reshape(cropData.shape[1],cropData.shape[0],cropData.shape[2])\n \n return cropData\n\n# def create_modelCNN(input_shape, num_class,flatten=False):\n# from tensorflow.keras.models import Sequential\n# from tensorflow.keras.layers import Dense\n# from tensorflow.keras.backend import clear_session\n# from tensorflow.keras.optimizers import Adam\n \n# from tensorflow.keras.layers import Conv1D#, Input\n# from tensorflow.keras.layers import MaxPooling1D\n# from tensorflow.keras.layers import GlobalAveragePooling1D#, GlobalMaxPooling1D\n# from keras.layers import Activation,Flatten, Dropout\n \n# clear_session()\n# model = Sequential()\n# def add_conv_block(model, num_filters, input_shape=None):\n# if input_shape:\n# model.add(Conv1D(num_filters, kernel_size=3, activation='relu', padding='same', input_shape=input_shape))\n# else:\n# model.add(Conv1D(num_filters, kernel_size=3, activation='relu', padding='same'))\n# return model\n# model = add_conv_block(model, 128, input_shape=input_shape[1:])\n# model = add_conv_block(model, 128)\n# model.add(Dropout(0.3)) \n# model.add(MaxPooling1D(pool_size=3, # size of the window\n# strides=2, # factor to downsample\n# padding='same'))\n# model.add(Dropout(0.1))\n# for i in range(2):\n# model.add(Conv1D(filters=256,kernel_size=3,padding=\"same\",activation='relu'))\n# model.add(Dropout(0.1))\n# if flatten:\n# model.add(Flatten())\n# else:\n# model.add(GlobalAveragePooling1D())\n# model.add(Dense(units=128,activation='relu'))\n# model.add(Dropout(0.1))\n# model.add(Dense(num_class))\n# model.add(Activation('softmax'))\n# model.compile(optimizer=Adam(0.0001), \n# loss='categorical_crossentropy', \n# metrics=['accuracy'])\n# return model\n\ndef modelCNN2(input_shape,nb_classes):\n model = Sequential()\n model.add(Conv2D(32, (3, 3), activation='relu', padding='same', input_shape=input_shape))\n model.add(Conv2D(32, (3, 3), activation='relu', padding='same'))\n model.add(MaxPooling2D((2, 2)))\n model.add(Conv2D(64, (3, 3), activation='relu', padding='same'))\n model.add(Conv2D(64, (3, 3), activation='relu', padding='same'))\n model.add(MaxPooling2D((2, 2)))\n model.add(Conv2D(128, (3, 3), activation='relu', padding='same'))\n model.add(Conv2D(128, (3, 3), activation='relu', padding='same'))\n model.add(MaxPooling2D((2, 2)))\n model.add(Flatten())\n model.add(Dense(128, activation='relu'))\n model.add(Dense(nb_classes, activation='softmax'))\n\t# compile model\n opt = SGD(lr=0.001, momentum=0.9)\n model.compile(optimizer=opt, loss='categorical_crossentropy', metrics=['accuracy'])\n return model\n\ndef plotSpektogram(x,fs,nmFile=''):\n f, t, Sxx = signal.spectrogram(x, fs)\n cut=10\n imgAll=[]\n for i,sinyal in enumerate(Sxx):\n img = plt.pcolormesh(t, f[:cut], sinyal[:cut], shading='gouraud')\n imgAll.append([(r, g, b) for r, g, b, a in img.to_rgba(img.get_array())])\n # print(nmFile)\n # if nmFile !='':\n #(18, 30, 3)\n # print(\"masuk sini\")\n # plt.savefig(nmFile)\n # plt.show()\n # plt.imsave(nmFile, imgAll)\n \n # imgAll = np.array(imgAll)# .reshape(-1,3)\n imgAll = np.array(imgAll).ravel()\n #(18, 30, 3)\n return imgAll \n \nif __name__ == '__main__':\n FILE=sys.argv[1]\n # FILE = 'D:\\\\Kuliah\\Tugas Akhir\\chb-mit-scalp-eeg-database-1.0.0\\\\chb24\\\\chb24_22.edf'\n # FILE = 'chb07_12.edf'\n FILE = FILE.replace(\"'\",\"\")\n dir_path = \"/Applications/XAMPP/xamppfiles/htdocs/prediksi/storage/app/public/fitur3Kelas30DetikImg/\"\n # if(os.path.isdir(dir_path+FILE)):\n # shutil.rmtree(dir_path+FILE)\n # os.mkdir(\"/Applications/XAMPP/xamppfiles/htdocs/prediksi/storage/app/public/fitur3Kelas30DetikImg/\"+FILE,0o777)\n loaded = np.load(\"/Applications/XAMPP/xamppfiles/htdocs/prediksi/storage/app/public/spektogram/channel_keeps.npz\")\n selected_channels =loaded['channel_keeps'] \n segmen=[]\n raw = loadAndFiltering(FILE,selected_channels)\n \n cropData = Crop(raw) \n numCH = cropData[0].shape[0]\n oneData = cropData[0]\n oneData = plotSpektogram(oneData,256)\n \n oneData = oneData.reshape(1,numCH,-1, 3)\n KELAS = 3\n bntk_input = (18, 30, 3)\n model = modelCNN2(bntk_input,KELAS)\n # model = modelCNN2(oneData.shape,KELAS)#,False) \n nmModel = '/Applications/XAMPP/xamppfiles/htdocs/prediksi/storage/app/public/modelCNNSpektrogram_3.h5'\n\n model.load_weights(nmModel) \n cnt=0 \n \n for idx in range(cropData.shape[0]): \n numCH = cropData[idx].shape[0]\n oneData = cropData[idx]\n nmFile = \"/Applications/XAMPP/xamppfiles/htdocs/prediksi/storage/app/public/fitur3Kelas30DetikImg/%s/%s_%d.png\"%(FILE,FILE,idx)\n # nmFile = dir+\"%s_%s.png\"%(FILE,idx)\n oneData = plotSpektogram(oneData,256,nmFile)\n oneData = oneData.reshape(1,numCH,-1, 3)\n yPred = model.predict(oneData)\n yPred = np.argmax(yPred,axis=1)\n if yPred[0] == 0:\n hasil = \"Normal\"\n elif yPred[0] == 1:\n hasil = \"Inter\" \n else:\n hasil = \"Ictal\"\n # break\n segmen.append(hasil) \n # print(\"segment=%d prediksi=%s <br>\"%(idx,hasil))\n cnt+=1\n if cnt>1000:\n break\n saveHistory = open(pathSaveData+FILE+\".txt\",\"w\")\n saveHistory.write(str(segmen))\n saveHistory.close()\n print(segmen)\n \n \n \n \n\n"
] | [
[
"tensorflow.keras.optimizers.SGD",
"scipy.signal.spectrogram",
"numpy.array",
"matplotlib.pyplot.pcolormesh",
"pandas.DataFrame",
"numpy.load",
"numpy.arange",
"numpy.argmax"
]
] |
Aympab/BigDataHadoopSparkDaskCourse | [
"42f9e0475cbd7c5db240ccc6dc00c19b9006012a"
] | [
"TPs/TP4/test_flower.py"
] | [
"import pyspark\nfrom pyspark import SparkContext\nfrom pyspark.sql import Row\nfrom pyspark.sql import SQLContext\nfrom pyspark import SparkFiles\nimport os\nimport pandas as pd\n\nsc =SparkContext()\nsqlContext = SQLContext(sc)\n\n\ndata_dir=\"/work/irlin355_1/gratienj/ParallelProgrammingCourse/BigDataHadoopSpark/data\"\nfile = os.path.join(data_dir,\"iris.csv\")\npanda_df = pd.read_csv(file)\n\nsqlContext = SQLContext(sc)\n#df = sqlContext.read.csv(SparkFiles.get(\"iris.csv\"), header=True, inferSchema= True)\t\ndf=sqlContext.createDataFrame(panda_df)\ndf.printSchema()\ndf.show(5, truncate = False)\ndf.select('petal_width','variety').show(5)\n\ndf.groupBy(\"variety\").count().sort(\"count\",ascending=True).show()\n\ndf.describe().show()\n"
] | [
[
"pandas.read_csv"
]
] |
owenshen24/acme | [
"71434dffd3449236f9b8aaf7a53ceab515e75a2a"
] | [
"acme/agents/actors_tf2_test.py"
] | [
"# python3\n# Copyright 2018 DeepMind Technologies Limited. All rights reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n\"\"\"Tests for actors_tf2.\"\"\"\n\nfrom absl.testing import absltest\n\nfrom acme import environment_loop\nfrom acme import specs\nfrom acme.agents import actors_tf2\nfrom acme.testing import fakes\n\nimport dm_env\nimport numpy as np\nimport sonnet as snt\nimport tensorflow as tf\n\n\ndef _make_fake_env() -> dm_env.Environment:\n env_spec = specs.EnvironmentSpec(\n observations=specs.Array(shape=(10, 5), dtype=np.float32),\n actions=specs.DiscreteArray(num_values=3),\n rewards=specs.Array(shape=(), dtype=np.float32),\n discounts=specs.BoundedArray(\n shape=(), dtype=np.float32, minimum=0., maximum=1.),\n )\n return fakes.Environment(env_spec, episode_length=10)\n\n\nclass ActorTest(absltest.TestCase):\n\n def test_feedforward(self):\n environment = _make_fake_env()\n env_spec = specs.make_environment_spec(environment)\n\n network = snt.Sequential([\n snt.Flatten(),\n snt.Linear(env_spec.actions.num_values),\n lambda x: tf.argmax(x, axis=-1, output_type=env_spec.actions.dtype),\n ])\n\n actor = actors_tf2.FeedForwardActor(network)\n loop = environment_loop.EnvironmentLoop(environment, actor)\n loop.run(20)\n\n def test_recurrent(self):\n environment = _make_fake_env()\n env_spec = specs.make_environment_spec(environment)\n\n network = snt.DeepRNN([\n snt.Flatten(),\n snt.Linear(env_spec.actions.num_values),\n lambda x: tf.argmax(x, axis=-1, output_type=env_spec.actions.dtype),\n ])\n\n actor = actors_tf2.RecurrentActor(network)\n loop = environment_loop.EnvironmentLoop(environment, actor)\n loop.run(20)\n\n\nif __name__ == '__main__':\n absltest.main()\n"
] | [
[
"tensorflow.argmax"
]
] |
prasadph/ga-learner-dsmp-repo | [
"ac1cc9d96250718f2842592e643c885d54ab2903"
] | [
"NLP/code.py"
] | [
"# --------------\n# import packages\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\n\nimport seaborn as sns\nimport re\nfrom nltk.corpus import stopwords\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer\nfrom sklearn.naive_bayes import MultinomialNB\nfrom sklearn.multiclass import OneVsRestClassifier\nfrom sklearn.linear_model import LogisticRegression\nfrom sklearn.metrics import accuracy_score ,confusion_matrix\n\n\n# Code starts here\n\n# load data\nnews = pd.read_csv(path)\n\n# subset data\nnews = news[[\"TITLE\",\"CATEGORY\"]]\n# distribution of classes\ndist = news.CATEGORY.value_counts()\n\n# display class distribution\nprint(dist)\n\n# display data\nprint(news.head())\n\n# Code ends here\n\n\n# --------------\n# Code starts here\n\n# stopwords \n\nstop = set(stopwords.words('english'))\n# retain only alphabets\nnews.TITLE = news.TITLE.apply(lambda x:re.sub(\"[^a-zA-Z]\", \" \",x))\n\n# convert to lowercase and tokenize\nnews.TITLE = news.TITLE.apply(lambda row:row.lower().split())\n\n# remove stopwords\nnews.TITLE = news.TITLE.apply(lambda row:[i for i in row if i not in stop] )\n\n# join list elements\nnews.TITLE = news.TITLE.apply(lambda x: ' '.join(x))\n\n# split into training and test sets\nX_train, X_test, y_train, y_test = train_test_split(news['TITLE'], news['CATEGORY'], test_size=0.2, random_state=3)\n\n# Code ends here\n\n\n# --------------\n# Code starts here\n\n# initialize count vectorizer\ncount_vectorizer = CountVectorizer()\n# initialize tfidf vectorizer\ntfidf_vectorizer = TfidfVectorizer(ngram_range=(1,3))\n# fit and transform with count vectorizer\nX_train_count = count_vectorizer.fit_transform(X_train)\nX_test_count = count_vectorizer.transform(X_test)\n\n# fit and transform with tfidf vectorizer\nX_train_tfidf = tfidf_vectorizer.fit_transform(X_train)\nX_test_tfidf = tfidf_vectorizer.transform(X_test)\n\n# Code ends here\n\n\n# --------------\n# Code starts here\n\n# initialize multinomial naive bayes\nnb_1 = MultinomialNB()\nnb_2 = MultinomialNB() \n# fit on count vectorizer training data\nnb_1.fit(X_train_count, y_train)\n# fit on tfidf vectorizer training data\nnb_2.fit(X_train_tfidf, y_train)\n\n# accuracy with count vectorizer\nacc_count_nb = accuracy_score(nb_1.predict(X_test_count), y_test)\n\n# accuracy with tfidf vectorizer\nacc_tfidf_nb = accuracy_score(nb_2.predict(X_test_tfidf), y_test)\n\n# display accuracies\nprint(acc_count_nb)\nprint(acc_tfidf_nb)\n\n# Code ends here\n\n\n# --------------\nimport warnings\nwarnings.filterwarnings('ignore')\n\n# initialize logistic regression\nlogreg_1 = OneVsRestClassifier(LogisticRegression(random_state=10))\nlogreg_2 = OneVsRestClassifier(LogisticRegression(random_state=10))\n# fit on count vectorizer training data\nlogreg_1.fit(X_train_count, y_train)\n\n# fit on tfidf vectorizer training data\nlogreg_2.fit(X_train_tfidf, y_train)\n\n# accuracy with count vectorizer\nacc_count_logreg = accuracy_score(logreg_1.predict(X_test_count), y_test)\n# accuracy with tfidf vectorizer\nacc_tfidf_logreg = accuracy_score(logreg_2.predict(X_test_tfidf), y_test)\n\n# display accuracies\nprint(acc_count_logreg)\nprint(acc_tfidf_logreg)\n# Code ends here\n\n\n"
] | [
[
"sklearn.naive_bayes.MultinomialNB",
"sklearn.linear_model.LogisticRegression",
"sklearn.feature_extraction.text.CountVectorizer",
"sklearn.feature_extraction.text.TfidfVectorizer",
"sklearn.model_selection.train_test_split",
"pandas.read_csv"
]
] |
okdshin/onnx | [
"27b40225ea98f6412ae2879ed67211d49564af2a",
"27b40225ea98f6412ae2879ed67211d49564af2a"
] | [
"onnx/backend/test/case/node/xor.py",
"onnx/backend/test/case/node/flatten.py"
] | [
"from __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\nfrom __future__ import unicode_literals\n\nimport numpy as np\n\nimport onnx\nfrom ..base import Base\nfrom . import expect\n\n\nclass Xor(Base):\n\n @staticmethod\n def export():\n node = onnx.helper.make_node(\n 'Xor',\n inputs=['x', 'y'],\n outputs=['xor'],\n )\n\n # 2d\n x = (np.random.randn(3, 4) > 0).astype(np.bool)\n y = (np.random.randn(3, 4) > 0).astype(np.bool)\n z = np.logical_xor(x, y)\n expect(node, inputs=[x, y], outputs=[z],\n name='test_xor2d')\n\n # 3d\n x = (np.random.randn(3, 4, 5) > 0).astype(np.bool)\n y = (np.random.randn(3, 4, 5) > 0).astype(np.bool)\n z = np.logical_xor(x, y)\n expect(node, inputs=[x, y], outputs=[z],\n name='test_xor3d')\n\n # 4d\n x = (np.random.randn(3, 4, 5, 6) > 0).astype(np.bool)\n y = (np.random.randn(3, 4, 5, 6) > 0).astype(np.bool)\n z = np.logical_xor(x, y)\n expect(node, inputs=[x, y], outputs=[z],\n name='test_xor4d')\n\n @staticmethod\n def export_xor_broadcast():\n node = onnx.helper.make_node(\n 'Xor',\n inputs=['x', 'y'],\n outputs=['xor'],\n broadcast=1,\n )\n\n #3d vs 1d\n x = (np.random.randn(3, 4, 5) > 0).astype(np.bool)\n y = (np.random.randn(5) > 0).astype(np.bool)\n z = np.logical_xor(x, y)\n expect(node, inputs=[x, y], outputs=[z],\n name='test_xor_bcast3v1d')\n\n #3d vs 2d\n x = (np.random.randn(3, 4, 5) > 0).astype(np.bool)\n y = (np.random.randn(4, 5) > 0).astype(np.bool)\n z = np.logical_xor(x, y)\n expect(node, inputs=[x, y], outputs=[z],\n name='test_xor_bcast3v2d')\n\n #4d vs 2d\n x = (np.random.randn(3, 4, 5, 6) > 0).astype(np.bool)\n y = (np.random.randn(5, 6) > 0).astype(np.bool)\n z = np.logical_xor(x, y)\n expect(node, inputs=[x, y], outputs=[z],\n name='test_xor_bcast4v2d')\n\n #4d vs 3d\n x = (np.random.randn(3, 4, 5, 6) > 0).astype(np.bool)\n y = (np.random.randn(4, 5, 6) > 0).astype(np.bool)\n z = np.logical_xor(x, y)\n expect(node, inputs=[x, y], outputs=[z],\n name='test_xor_bcast4v3d')\n\n @staticmethod\n def export_xor_axis():\n x = (np.random.randn(5, 5, 5, 5) > 0).astype(np.bool)\n y = (np.random.randn(5) > 0).astype(np.bool)\n\n node = onnx.helper.make_node(\n 'Xor',\n inputs=['x', 'y'],\n outputs=['xor'],\n broadcast=1,\n axis=0,\n )\n\n z = np.logical_xor(x, y[:, np.newaxis, np.newaxis, np.newaxis])\n expect(node, inputs=[x, y], outputs=[z],\n name='test_xor_axis0')\n\n node = onnx.helper.make_node(\n 'Xor',\n inputs=['x', 'y'],\n outputs=['xor'],\n broadcast=1,\n axis=1,\n )\n\n z = np.logical_xor(x, y[:, np.newaxis, np.newaxis,])\n expect(node, inputs=[x, y], outputs=[z],\n name='test_xor_axis1')\n\n node = onnx.helper.make_node(\n 'Xor',\n inputs=['x', 'y'],\n outputs=['xor'],\n broadcast=1,\n axis=2,\n )\n\n z = np.logical_xor(x, y[:, np.newaxis,])\n expect(node, inputs=[x, y], outputs=[z],\n name='test_xor_axis2')\n\n node = onnx.helper.make_node(\n 'Xor',\n inputs=['x', 'y'],\n outputs=['xor'],\n broadcast=1,\n axis=3,\n )\n\n z = np.logical_xor(x, y)\n expect(node, inputs=[x, y], outputs=[z],\n name='test_xor_axis3')",
"from __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\nfrom __future__ import unicode_literals\n\nimport numpy as np\n\nimport onnx\nfrom ..base import Base\nfrom . import expect\n\n\nclass Flatten(Base):\n\n @staticmethod\n def export():\n shape = (2, 3, 4, 5)\n a = np.random.random_sample(shape).astype(np.float32)\n\n for i in range(len(shape)):\n node = onnx.helper.make_node(\n 'Flatten',\n inputs=['a'],\n outputs=['b'],\n axis=i,\n )\n\n new_shape = (1, -1) if i == 0 else (np.prod(shape[0:i]).astype(int), -1)\n b= np.reshape(a, new_shape)\n expect(node, inputs=[a], outputs=[b],\n name='test_flatten_axis' + str(i))\n\n @staticmethod\n def export_flatten_with_default_axis():\n node = onnx.helper.make_node(\n 'Flatten',\n inputs=['a'],\n outputs=['b'], # Default value for axis: axis=1\n )\n \n shape = (5, 4, 3, 2)\n a = np.random.random_sample(shape).astype(np.float32)\n new_shape = (5, 24)\n b= np.reshape(a, new_shape)\n expect(node, inputs=[a], outputs=[b],\n name='test_flatten_default_axis')"
] | [
[
"numpy.logical_xor",
"numpy.random.randn"
],
[
"numpy.prod",
"numpy.reshape",
"numpy.random.random_sample"
]
] |
GAA-UAM/scikit-fda | [
"a9953a3104195ce9796397d094b17b1b90fd090f"
] | [
"skfda/_utils/_utils.py"
] | [
"\"\"\"Module with generic methods.\"\"\"\n\nfrom __future__ import annotations\n\nimport functools\nimport numbers\nfrom typing import (\n TYPE_CHECKING,\n Any,\n Callable,\n Iterable,\n List,\n Optional,\n Sequence,\n Tuple,\n TypeVar,\n Union,\n cast,\n overload,\n)\n\nimport numpy as np\nimport scipy.integrate\nfrom numpy import ndarray\nfrom pandas.api.indexers import check_array_indexer\nfrom sklearn.base import clone\nfrom sklearn.preprocessing import LabelEncoder\nfrom sklearn.utils.multiclass import check_classification_targets\nfrom typing_extensions import Literal, Protocol\n\nfrom ..representation._typing import (\n ArrayLike,\n DomainRange,\n DomainRangeLike,\n GridPoints,\n GridPointsLike,\n)\nfrom ..representation.extrapolation import ExtrapolationLike\n\nRandomStateLike = Optional[Union[int, np.random.RandomState]]\n\nif TYPE_CHECKING:\n from ..exploratory.depth import Depth\n from ..representation import FData, FDataGrid\n from ..representation.basis import Basis\n T = TypeVar(\"T\", bound=FData)\n\n\ndef check_is_univariate(fd: FData) -> None:\n \"\"\"Check if an FData is univariate and raises an error.\n\n Args:\n fd: Functional object to check if is univariate.\n\n Raises:\n ValueError: If it is not univariate, i.e., `fd.dim_domain != 1` or\n `fd.dim_codomain != 1`.\n\n \"\"\"\n if fd.dim_domain != 1 or fd.dim_codomain != 1:\n domain_str = (\n \"\" if fd.dim_domain == 1\n else f\"(currently is {fd.dim_domain}) \"\n )\n\n codomain_str = (\n \"\" if fd.dim_codomain == 1\n else f\"(currently is {fd.dim_codomain})\"\n )\n\n raise ValueError(\n f\"The functional data must be univariate, i.e., \"\n f\"with dim_domain=1 {domain_str}\"\n f\"and dim_codomain=1 {codomain_str}\",\n )\n\n\ndef _check_compatible_fdata(fdata1: FData, fdata2: FData) -> None:\n \"\"\"Check that fdata is compatible.\"\"\"\n if (fdata1.dim_domain != fdata2.dim_domain):\n raise ValueError(\n f\"Functional data has incompatible domain dimensions: \"\n f\"{fdata1.dim_domain} != {fdata2.dim_domain}\",\n )\n\n if (fdata1.dim_codomain != fdata2.dim_codomain):\n raise ValueError(\n f\"Functional data has incompatible codomain dimensions: \"\n f\"{fdata1.dim_codomain} != {fdata2.dim_codomain}\",\n )\n\n\ndef _to_grid(\n X: FData,\n y: FData,\n eval_points: Optional[np.ndarray] = None,\n) -> Tuple[FDataGrid, FDataGrid]:\n \"\"\"Transform a pair of FDatas in grids to perform calculations.\"\"\"\n from .. import FDataGrid\n x_is_grid = isinstance(X, FDataGrid)\n y_is_grid = isinstance(y, FDataGrid)\n\n if eval_points is not None:\n X = X.to_grid(eval_points)\n y = y.to_grid(eval_points)\n elif x_is_grid and not y_is_grid:\n y = y.to_grid(X.grid_points[0])\n elif not x_is_grid and y_is_grid:\n X = X.to_grid(y.grid_points[0])\n elif not x_is_grid and not y_is_grid:\n X = X.to_grid()\n y = y.to_grid()\n\n return X, y\n\n\ndef _to_grid_points(grid_points_like: GridPointsLike) -> GridPoints:\n \"\"\"Convert to grid points.\n\n If the original list is one-dimensional (e.g. [1, 2, 3]), return list to\n array (in this case [array([1, 2, 3])]).\n\n If the original list is two-dimensional (e.g. [[1, 2, 3], [4, 5]]), return\n a list containing other one-dimensional arrays (in this case\n [array([1, 2, 3]), array([4, 5])]).\n\n In any other case the behaviour is unespecified.\n\n \"\"\"\n unidimensional = False\n\n if not isinstance(grid_points_like, Iterable):\n grid_points_like = [grid_points_like]\n\n if not isinstance(grid_points_like[0], Iterable):\n unidimensional = True\n\n if unidimensional:\n return (_int_to_real(np.asarray(grid_points_like)),)\n\n return tuple(_int_to_real(np.asarray(i)) for i in grid_points_like)\n\n\ndef _to_domain_range(sequence: DomainRangeLike) -> DomainRange:\n \"\"\"Convert sequence to a proper domain range.\"\"\"\n seq_aux = cast(\n Sequence[Sequence[float]],\n (sequence,) if isinstance(sequence[0], numbers.Real) else sequence,\n )\n\n tuple_aux = tuple(tuple(s) for s in seq_aux)\n\n if not all(len(s) == 2 and s[0] <= s[1] for s in tuple_aux):\n raise ValueError(\n \"Domain intervals should have 2 bounds for \"\n \"dimension: (lower, upper).\",\n )\n\n return cast(DomainRange, tuple_aux)\n\n\ndef _to_array_maybe_ragged(\n array: Iterable[ArrayLike],\n *,\n row_shape: Optional[Sequence[int]] = None,\n) -> np.ndarray:\n \"\"\"\n Convert to an array where each element may or may not be of equal length.\n\n If each element is of equal length the array is multidimensional.\n Otherwise it is a ragged array.\n\n \"\"\"\n def convert_row(row: ArrayLike) -> np.ndarray:\n r = np.array(row)\n\n if row_shape is not None:\n r = r.reshape(row_shape)\n\n return r\n\n array_list = [convert_row(a) for a in array]\n shapes = [a.shape for a in array_list]\n\n if all(s == shapes[0] for s in shapes):\n return np.array(array_list)\n\n res = np.empty(len(array_list), dtype=np.object_)\n\n for i, a in enumerate(array_list):\n res[i] = a\n\n return res\n\n\n@overload\ndef _cartesian_product(\n axes: Sequence[np.ndarray],\n *,\n flatten: bool = True,\n return_shape: Literal[False] = False,\n) -> np.ndarray:\n pass\n\n\n@overload\ndef _cartesian_product(\n axes: Sequence[np.ndarray],\n *,\n flatten: bool = True,\n return_shape: Literal[True],\n) -> Tuple[np.ndarray, Tuple[int, ...]]:\n pass\n\n\ndef _cartesian_product( # noqa: WPS234\n axes: Sequence[np.ndarray],\n *,\n flatten: bool = True,\n return_shape: bool = False,\n) -> Union[np.ndarray, Tuple[np.ndarray, Tuple[int, ...]]]:\n \"\"\"\n Compute the cartesian product of the axes.\n\n Computes the cartesian product of the axes and returns a numpy array of\n 1 dimension with all the possible combinations, for an arbitrary number of\n dimensions.\n\n Args:\n axes: List with axes.\n flatten: Whether to return the flatten array or keep one dimension per\n axis.\n return_shape: If ``True`` return the shape of the array before\n flattening.\n\n Returns:\n Numpy 2-D array with all the possible combinations.\n The entry (i,j) represent the j-th coordinate of the i-th point.\n If ``return_shape`` is ``True`` returns also the shape of the array\n before flattening.\n\n Examples:\n >>> from skfda._utils import _cartesian_product\n >>> axes = [[0,1],[2,3]]\n >>> _cartesian_product(axes)\n array([[0, 2],\n [0, 3],\n [1, 2],\n [1, 3]])\n\n >>> axes = [[0,1],[2,3],[4]]\n >>> _cartesian_product(axes)\n array([[0, 2, 4],\n [0, 3, 4],\n [1, 2, 4],\n [1, 3, 4]])\n\n >>> axes = [[0,1]]\n >>> _cartesian_product(axes)\n array([[0],\n [1]])\n \"\"\"\n cartesian = np.stack(np.meshgrid(*axes, indexing='ij'), -1)\n\n shape = cartesian.shape\n\n if flatten:\n cartesian = cartesian.reshape(-1, len(axes))\n\n if return_shape:\n return cartesian, shape\n\n return cartesian\n\n\ndef _same_domain(fd: Union[Basis, FData], fd2: Union[Basis, FData]) -> bool:\n \"\"\"Check if the domain range of two objects is the same.\"\"\"\n return np.array_equal(fd.domain_range, fd2.domain_range)\n\n\n@overload\ndef _reshape_eval_points(\n eval_points: ArrayLike,\n *,\n aligned: Literal[True],\n n_samples: int,\n dim_domain: int,\n) -> np.ndarray:\n pass\n\n\n@overload\ndef _reshape_eval_points(\n eval_points: Sequence[ArrayLike],\n *,\n aligned: Literal[True],\n n_samples: int,\n dim_domain: int,\n) -> np.ndarray:\n pass\n\n\n@overload\ndef _reshape_eval_points(\n eval_points: Union[ArrayLike, Sequence[ArrayLike]],\n *,\n aligned: bool,\n n_samples: int,\n dim_domain: int,\n) -> np.ndarray:\n pass\n\n\ndef _reshape_eval_points(\n eval_points: Union[ArrayLike, Iterable[ArrayLike]],\n *,\n aligned: bool,\n n_samples: int,\n dim_domain: int,\n) -> np.ndarray:\n \"\"\"Convert and reshape the eval_points to ndarray.\n\n Args:\n eval_points: Evaluation points to be reshaped.\n aligned: Boolean flag. True if all the samples\n will be evaluated at the same evaluation_points.\n n_samples: Number of observations.\n dim_domain: Dimension of the domain.\n\n Returns:\n Numpy array with the eval_points, if\n evaluation_aligned is True with shape `number of evaluation points`\n x `dim_domain`. If the points are not aligned the shape of the\n points will be `n_samples` x `number of evaluation points`\n x `dim_domain`.\n\n \"\"\"\n if aligned:\n eval_points = np.asarray(eval_points)\n else:\n eval_points = cast(Iterable[ArrayLike], eval_points)\n\n eval_points = _to_array_maybe_ragged(\n eval_points,\n row_shape=(-1, dim_domain),\n )\n\n # Case evaluation of a single value, i.e., f(0)\n # Only allowed for aligned evaluation\n if aligned and (\n eval_points.shape == (dim_domain,)\n or (eval_points.ndim == 0 and dim_domain == 1)\n ):\n eval_points = np.array([eval_points])\n\n if aligned: # Samples evaluated at same eval points\n eval_points = eval_points.reshape(\n (eval_points.shape[0], dim_domain),\n )\n\n else: # Different eval_points for each sample\n\n if eval_points.shape[0] != n_samples:\n raise ValueError(\n f\"eval_points should be a list \"\n f\"of length {n_samples} with the \"\n f\"evaluation points for each sample.\",\n )\n\n return eval_points\n\n\ndef _one_grid_to_points(\n axes: GridPointsLike,\n *,\n dim_domain: int,\n) -> Tuple[np.ndarray, Tuple[int, ...]]:\n \"\"\"\n Convert a list of ndarrays, one per domain dimension, in the points.\n\n Returns also the shape containing the information of how each point\n is formed.\n \"\"\"\n axes = _to_grid_points(axes)\n\n if len(axes) != dim_domain:\n raise ValueError(\n f\"Length of axes should be {dim_domain}\",\n )\n\n cartesian, shape = _cartesian_product(axes, return_shape=True)\n\n # Drop domain size dimension, as it is not needed to reshape the output\n shape = shape[:-1]\n\n return cartesian, shape\n\n\nclass EvaluateMethod(Protocol):\n \"\"\"Evaluation method.\"\"\"\n\n def __call__(\n self,\n __eval_points: np.ndarray, # noqa: WPS112\n extrapolation: Optional[ExtrapolationLike],\n aligned: bool,\n ) -> np.ndarray:\n \"\"\"Evaluate a function.\"\"\"\n pass\n\n\n@overload\ndef _evaluate_grid(\n axes: GridPointsLike,\n *,\n evaluate_method: EvaluateMethod,\n n_samples: int,\n dim_domain: int,\n dim_codomain: int,\n extrapolation: Optional[ExtrapolationLike] = None,\n aligned: Literal[True] = True,\n) -> np.ndarray:\n pass\n\n\n@overload\ndef _evaluate_grid(\n axes: Iterable[GridPointsLike],\n *,\n evaluate_method: EvaluateMethod,\n n_samples: int,\n dim_domain: int,\n dim_codomain: int,\n extrapolation: Optional[ExtrapolationLike] = None,\n aligned: Literal[False],\n) -> np.ndarray:\n pass\n\n\ndef _evaluate_grid( # noqa: WPS234\n axes: Union[GridPointsLike, Iterable[GridPointsLike]],\n *,\n evaluate_method: EvaluateMethod,\n n_samples: int,\n dim_domain: int,\n dim_codomain: int,\n extrapolation: Optional[ExtrapolationLike] = None,\n aligned: bool = True,\n) -> np.ndarray:\n \"\"\"\n Evaluate the functional object in the cartesian grid.\n\n This method is called internally by :meth:`evaluate` when the argument\n `grid` is True.\n\n Evaluates the functional object in the grid generated by the cartesian\n product of the axes. The length of the list of axes should be equal\n than the domain dimension of the object.\n\n If the list of axes has lengths :math:`n_1, n_2, ..., n_m`, where\n :math:`m` is equal than the dimension of the domain, the result of the\n evaluation in the grid will be a matrix with :math:`m+1` dimensions and\n shape :math:`n_{samples} x n_1 x n_2 x ... x n_m`.\n\n If `aligned` is false each sample is evaluated in a\n different grid, and the list of axes should contain a list of axes for\n each sample.\n\n If the domain dimension is 1, the result of the behaviour of the\n evaluation will be the same than :meth:`evaluate` without the grid\n option, but with worst performance.\n\n Args:\n axes: List of axes to generated the grid where the\n object will be evaluated.\n evaluate_method: Function used to evaluate the functional object.\n n_samples: Number of samples.\n dim_domain: Domain dimension.\n dim_codomain: Codomain dimension.\n extrapolation: Controls the\n extrapolation mode for elements outside the domain range. By\n default it is used the mode defined during the instance of the\n object.\n aligned: If False evaluates each sample\n in a different grid.\n evaluate_method: method to use to evaluate the points\n n_samples: number of samples\n dim_domain: dimension of the domain\n dim_codomain: dimensions of the codomain\n\n Returns:\n Numpy array with dim_domain + 1 dimensions with\n the result of the evaluation.\n\n Raises:\n ValueError: If there are a different number of axes than the domain\n dimension.\n\n \"\"\"\n # Compute intersection points and resulting shapes\n if aligned:\n\n axes = cast(GridPointsLike, axes)\n\n eval_points, shape = _one_grid_to_points(axes, dim_domain=dim_domain)\n\n else:\n\n axes_per_sample = cast(Iterable[GridPointsLike], axes)\n\n axes_per_sample = list(axes_per_sample)\n\n eval_points_tuple, shape_tuple = zip(\n *[\n _one_grid_to_points(a, dim_domain=dim_domain)\n for a in axes_per_sample\n ],\n )\n\n if len(eval_points_tuple) != n_samples:\n raise ValueError(\n \"Should be provided a list of axis per sample\",\n )\n\n eval_points = _to_array_maybe_ragged(eval_points_tuple)\n\n # Evaluate the points\n evaluated = evaluate_method(\n eval_points,\n extrapolation=extrapolation,\n aligned=aligned,\n )\n\n # Reshape the result\n if aligned:\n\n res = evaluated.reshape(\n [n_samples] + list(shape) + [dim_codomain],\n )\n\n else:\n\n res = _to_array_maybe_ragged([\n r.reshape(list(s) + [dim_codomain])\n for r, s in zip(evaluated, shape_tuple)\n ])\n\n return res\n\n\ndef nquad_vec(\n func: Callable[[np.ndarray], np.ndarray],\n ranges: Sequence[Tuple[float, float]],\n) -> np.ndarray:\n \"\"\"Perform multiple integration of vector valued functions.\"\"\"\n initial_depth = len(ranges) - 1\n\n def integrate(*args: Any, depth: int) -> np.ndarray: # noqa: WPS430\n\n if depth == 0:\n f = functools.partial(func, *args)\n else:\n f = functools.partial(integrate, *args, depth=depth - 1)\n\n return scipy.integrate.quad_vec(f, *ranges[initial_depth - depth])[0]\n\n return integrate(depth=initial_depth)\n\n\ndef _map_in_batches(\n function: Callable[..., np.ndarray],\n arguments: Tuple[Union[FData, np.ndarray], ...],\n indexes: Tuple[np.ndarray, ...],\n memory_per_batch: Optional[int] = None,\n **kwargs: Any,\n) -> np.ndarray:\n \"\"\"\n Map a function over samples of FData or ndarray tuples efficiently.\n\n This function prevents a large set of indexes to use all available\n memory and hang the PC.\n\n \"\"\"\n if memory_per_batch is None:\n # 256MB is not too big\n memory_per_batch = 256 * 1024 * 1024 # noqa: WPS432\n\n memory_per_element = sum(a.nbytes // len(a) for a in arguments)\n n_elements_per_batch_allowed = memory_per_batch // memory_per_element\n if n_elements_per_batch_allowed < 1:\n raise ValueError(\"Too few memory allowed for the operation\")\n\n n_indexes = len(indexes[0])\n\n assert all(n_indexes == len(i) for i in indexes)\n\n batches: List[np.ndarray] = []\n\n for pos in range(0, n_indexes, n_elements_per_batch_allowed):\n batch_args = tuple(\n a[i[pos:pos + n_elements_per_batch_allowed]]\n for a, i in zip(arguments, indexes)\n )\n\n batches.append(function(*batch_args, **kwargs))\n\n return np.concatenate(batches, axis=0)\n\n\ndef _pairwise_symmetric(\n function: Callable[..., np.ndarray],\n arg1: Union[FData, np.ndarray],\n arg2: Optional[Union[FData, np.ndarray]] = None,\n memory_per_batch: Optional[int] = None,\n **kwargs: Any,\n) -> np.ndarray:\n \"\"\"Compute pairwise a commutative function.\"\"\"\n dim1 = len(arg1)\n if arg2 is None or arg2 is arg1:\n indices = np.triu_indices(dim1)\n\n matrix = np.empty((dim1, dim1))\n\n triang_vec = _map_in_batches(\n function,\n (arg1, arg1),\n indices,\n memory_per_batch=memory_per_batch,\n **kwargs,\n )\n\n # Set upper matrix\n matrix[indices] = triang_vec\n\n # Set lower matrix\n matrix[(indices[1], indices[0])] = triang_vec\n\n return matrix\n\n dim2 = len(arg2)\n indices = np.indices((dim1, dim2))\n\n vec = _map_in_batches(\n function,\n (arg1, arg2),\n (indices[0].ravel(), indices[1].ravel()),\n memory_per_batch=memory_per_batch,\n **kwargs,\n )\n\n return vec.reshape((dim1, dim2))\n\n\ndef _int_to_real(array: np.ndarray) -> np.ndarray:\n \"\"\"Convert integer arrays to floating point.\"\"\"\n return array + 0.0\n\n\ndef _check_array_key(array: np.ndarray, key: Any) -> Any:\n \"\"\"Check a getitem key.\"\"\"\n key = check_array_indexer(array, key)\n if isinstance(key, tuple):\n non_ellipsis = [i for i in key if i is not Ellipsis]\n if len(non_ellipsis) > 1:\n raise KeyError(key)\n key = non_ellipsis[0]\n\n if isinstance(key, numbers.Integral): # To accept also numpy ints\n key = int(key)\n key = range(len(array))[key]\n\n return slice(key, key + 1)\n\n return key\n\n\ndef _check_estimator(estimator):\n from sklearn.utils.estimator_checks import (\n check_get_params_invariance,\n check_set_params,\n )\n\n name = estimator.__name__\n instance = estimator()\n check_get_params_invariance(name, instance)\n check_set_params(name, instance)\n\n\ndef _classifier_get_classes(y: ndarray) -> Tuple[ndarray, ndarray]:\n\n check_classification_targets(y)\n\n le = LabelEncoder()\n y_ind = le.fit_transform(y)\n\n classes = le.classes_\n\n if classes.size < 2:\n raise ValueError(\n f'The number of classes has to be greater than'\n f'one; got {classes.size} class',\n )\n return classes, y_ind\n\n\ndef _classifier_get_depth_methods(\n classes: ndarray,\n X: T,\n y_ind: ndarray,\n depth_methods: Sequence[Depth[T]],\n) -> Sequence[Depth[T]]:\n return [\n clone(depth_method).fit(X[y_ind == cur_class])\n for cur_class in range(classes.size)\n for depth_method in depth_methods\n ]\n\n\ndef _classifier_fit_depth_methods(\n X: T,\n y: ndarray,\n depth_methods: Sequence[Depth[T]],\n) -> Tuple[ndarray, Sequence[Depth[T]]]:\n classes, y_ind = _classifier_get_classes(y)\n\n class_depth_methods_ = _classifier_get_depth_methods(\n classes, X, y_ind, depth_methods,\n )\n\n return classes, class_depth_methods_\n\n\n_DependenceMeasure = Callable[[np.ndarray, np.ndarray], np.ndarray]\n\n\ndef _compute_dependence(\n X: np.ndarray,\n y: np.ndarray,\n *,\n dependence_measure: _DependenceMeasure,\n) -> np.ndarray:\n \"\"\"\n Compute dependence between points and target.\n\n Computes the dependence of each point in each trajectory in X with the\n corresponding class label in Y.\n\n \"\"\"\n from dcor import rowwise\n\n # Move n_samples to the end\n # The shape is now input_shape + n_samples + n_output\n X = np.moveaxis(X, 0, -2)\n\n input_shape = X.shape[:-2]\n\n # Join input in a list for rowwise\n X = X.reshape(-1, X.shape[-2], X.shape[-1])\n\n if y.ndim == 1:\n y = np.atleast_2d(y).T\n Y = np.array([y] * len(X))\n\n dependence_results = rowwise(dependence_measure, X, Y)\n\n return dependence_results.reshape(input_shape)\n"
] | [
[
"numpy.concatenate",
"sklearn.utils.estimator_checks.check_set_params",
"sklearn.preprocessing.LabelEncoder",
"numpy.array_equal",
"numpy.array",
"numpy.asarray",
"numpy.triu_indices",
"numpy.empty",
"sklearn.utils.multiclass.check_classification_targets",
"sklearn.base.clone",
"sklearn.utils.estimator_checks.check_get_params_invariance",
"pandas.api.indexers.check_array_indexer",
"numpy.moveaxis",
"numpy.indices",
"numpy.meshgrid",
"numpy.atleast_2d"
]
] |
tombackstrom/mdct | [
"f59e708f9a7f65ee672dbf44e6f164e79c82d83a"
] | [
"tests/test_windows.py"
] | [
"import pytest\nimport numpy\nimport mdct.windows\n\n\ndef test_kbd():\n M = 100\n w = mdct.windows.kaiser_derived(M, beta=4.)\n\n assert numpy.allclose(w[:M//2] ** 2 + w[-M//2:] ** 2, 1.)\n\n with pytest.raises(ValueError):\n mdct.windows.kaiser_derived(M + 1, beta=4.)\n\n assert numpy.allclose(\n mdct.windows.kaiser_derived(2, beta=numpy.pi/2)[:1],\n [numpy.sqrt(2)/2])\n\n assert numpy.allclose(\n mdct.windows.kaiser_derived(4, beta=numpy.pi/2)[:2],\n [0.518562710536, 0.855039598640])\n\n assert numpy.allclose(\n mdct.windows.kaiser_derived(6, beta=numpy.pi/2)[:3],\n [0.436168993154, 0.707106781187, 0.899864772847])\n"
] | [
[
"numpy.allclose",
"numpy.sqrt"
]
] |
dpetrini/nova | [
"00b7637901420f68c7d805c13ccd4c39d514efb1"
] | [
"trainer.py"
] | [
"from matplotlib.pyplot import show\nimport torch\nfrom torch.autograd import Variable\nfrom torch.cuda.amp import GradScaler, autocast\nimport numpy as np\nfrom sklearn.metrics import roc_auc_score\n\nfrom callbacks.cb_handler import CallbackHandler\nfrom callbacks.cb_base import BaseCB\nfrom callbacks.cb_lr_patch_clf import LR_SchedCB_patch\nfrom callbacks.cb_lr_full_clf import LR_SchedCB_full\nfrom callbacks.cb_lr_2views_clf import LR_SchedCB_2views\nfrom callbacks.cb_lr_w_cyc_cos import LR_SchedCB_W_Cyc_Cos\nfrom callbacks.cb_lr_w_cos import LR_SchedCB_W_Cos\nfrom callbacks.cb_auc import AUC_CB\n\n# from parallel import DataParallelModel, DataParallelCriterion\nfrom util.util import show_auc, calc_auc_desv\n\nparallel = False\n\n#APAGAR\nimport cv2\n\n# Accuracy\ndef acc(y_hat, labels):\n \"\"\" Default accuracy \"\"\"\n\n # para parallel\n if len(y_hat) > 1 and parallel:\n y_hat = torch.cat(y_hat)\n\n return (torch.argmax(y_hat, dim=1) == labels).float().sum()\n\n\nclass Trainer():\n \"\"\"\n Many possible configurations for Trainer\n config = {\n 'num_epochs': NUM_EPOCHS,\n 'batch_size': MINI_BATCH,\n 'name': 'example',\n 'title': 'Cats & Dogs Classifier',\n 'save_last': True, # optional: Save last model (default=False)\n 'save_best': True, # optional: Save best models (ACC, {AUC}) (default=True)\n 'stable_metric: N # optional: extend epochs number to wait N epochs with no metric change (ex.AUC)\n 'save_checkpoints': N, # Save checkpoint each N epochs\n 'features': ['auc'], # optional: features like auc stats or some scheduler (if none default:optim)\n 'save_path': folder, # if want to save artifacts in other place (eg.cloud)\n 'show_plots': False, # if want to show plots\n 'make_plots': False, # if want to disable plots\n 'cv_k': (number), # interactio number if using Cross Validation\n }\n \"\"\"\n\n def __init__(self, model, train_dataloader, val_dataloader,\n loss_criterion, optimizer, optimizer_args,\n device, config):\n self.model = model\n self.device = device\n self.loss_criterion = loss_criterion\n\n # parts of config are only retrieved in callbacks\n self.epochs = int(config['num_epochs']) if 'num_epochs' in config else 10\n self.mini_batch = int(config['batch_size']) if 'batch_size' in config else 1\n self.first_epoch = int(config['start_epoch']) if 'start_epoch' in config else 1\n self.stable_metric = int(config['stable_metric']) if 'stable_metric' in config else False\n self.name = config['name'] if 'name' in config else 'default'\n self.title = config['title'] if 'title' in config else 'Classifier'\n self.features = config['features'] if 'features' in config else []\n self.make_plots = config['make_plots'] if 'make_plots' in config else True\n\n if train_dataloader:\n self.train_dataloader = train_dataloader\n else:\n return\n\n self.train_dataloader = train_dataloader\n self.val_dataloader = val_dataloader\n self.optimizer = optimizer\n self.optimizer_args = optimizer_args\n\n print(self.title)\n\n # Load Callbacks for this session\n callbacks = [BaseCB(self.name, self.title, config)]\n for feat in self.features:\n if feat == 'auc':\n callbacks.append(AUC_CB(self.name, config))\n if feat == 'lr_step_full':\n callbacks.append(LR_SchedCB_full())\n if feat == 'lr_step_patch':\n callbacks.append(LR_SchedCB_patch())\n if feat == 'lr_step_2views':\n callbacks.append(LR_SchedCB_2views())\n if feat == 'lr_warmup_cos':\n callbacks.append(LR_SchedCB_W_Cos())\n if feat == 'lr_warmup_cyc_cos':\n callbacks.append(LR_SchedCB_W_Cyc_Cos())\n if feat == 'LR_SchedCB_W_Cos':\n callbacks.append(LR_SchedCB_W_Cos())\n self.cb = CallbackHandler(callbacks)\n\n\n def train_and_validate(self, **kwargs):\n \"\"\"\n Main train and validate function that runs main loop (fit).\n Receives all parameters and feed callback system.\n Loop through epochs and executes pytorch forward, loss,\n backpropagation and optimization (grads calc).\n Returns the model trained.\n \"\"\"\n\n calc_acc = kwargs.get('accuracy') if kwargs.get('accuracy') else acc\n input_dict = kwargs.get('input_dict') if kwargs.get('input_dict') else []\n\n if not self.cb.begin_train_val(self.epochs, self.model, self.train_dataloader,\n self.val_dataloader, self.mini_batch, self.optimizer):\n return\n\n self.cb.update_loss(self.loss_criterion, calc_acc)\n\n device = self.device\n\n for epoch in range(self.first_epoch, self.epochs+1):\n self.model.train()\n train_loss, train_acc = 0.0, 0.0\n val_loss, val_acc = 0.0, 0.0\n\n if not self.cb.begin_epoch(epoch): return # noqa: E701\n\n optim = self.cb.update_LR(epoch, self.model, self.optimizer, self.optimizer_args)\n if optim: self.optimizer = optim\n\n # Train loop\n for _, (inputs, labels) in enumerate(self.train_dataloader):\n\n if isinstance(inputs, dict):\n for key in input_dict:\n inputs[key] = inputs[key].to(device)\n else:\n inputs = Variable(inputs.to(device))\n\n labels = Variable(labels.to(device))\n\n # inserting MIXUP handling\n res = self.cb.begin_batch(inputs, labels)\n if res: inputs, labels, self.loss_criterion, calc_acc = res\n\n self.optimizer.zero_grad() # clean existing gradients\n outputs = self.model(inputs) # forward pass\n loss = self.loss_criterion(outputs, labels) # compute loss\n if parallel:\n loss = loss.mean() # list in this case\n loss.backward() # backprop the gradients\n self.optimizer.step() # update parameters\n train_loss += loss.item() * labels.size(0) # inputs.size(0) == mini_batch size\n train_acc += calc_acc(outputs, labels).item()\n\n self.cb.after_step(labels.size(0), labels, outputs)\n\n # validation - no gradient tracking needed\n with torch.no_grad():\n self.model.eval()\n self.cb.begin_val()\n\n # validation loop\n for _, (inputs, labels) in enumerate(self.val_dataloader):\n\n if isinstance(inputs, dict):\n for key in input_dict:\n inputs[key] = inputs[key].to(device)\n else:\n inputs = Variable(inputs.to(device))\n\n labels = Variable(labels.to(device))\n\n outputs = self.model(inputs) # forward pass\n loss = self.loss_criterion(outputs, labels) # compute loss\n if parallel:\n loss = loss.mean()\n val_loss += loss.item() * labels.size(0) # inputs.size(0) == mini_batch size\n val_acc += calc_acc(outputs, labels).item()\n\n self.cb.after_step_val(labels.size(0), labels, outputs)\n\n self.cb.after_epoch(self.model, train_acc, train_loss, val_acc, val_loss)\n\n self.cb.after_train_val()\n\n return self.model\n\n def train_and_validate_amp(self, **kwargs):\n \"\"\"\n Mixed precision (automatic) version for train_and_validate.\n Uses FP16 and FP32 in main loop with pytorch Automatic Mixed Precision.\n In simple tests: use 75% of memory in 66% of time. Less memory and faster.\n Sometimes it just don't work and get worse, like for resnest...\n \"\"\"\n\n assert torch.__version__ >= '1.6.0', \"[Mixed precision] Please use PyTorch 1.6.0+\"\n\n print('Using AMP')\n\n calc_acc = kwargs.get('accuracy') if kwargs.get('accuracy') else acc\n input_dict = kwargs.get('input_dict') if kwargs.get('input_dict') else []\n\n if not self.cb.begin_train_val(self.epochs, self.model, self.train_dataloader,\n self.val_dataloader, self.mini_batch, self.optimizer):\n return\n\n # Creates a GradScaler once at the beginning of training.\n scaler = GradScaler()\n\n device = self.device\n\n # for epoch in range(self.first_epoch, self.epochs+1):\n epoch = self.first_epoch # suport for \"wait N epochs after best metric\"\n last_epoch = self.epochs\n while epoch <= last_epoch:\n self.model.train()\n train_loss, train_acc = 0.0, 0.0\n val_loss, val_acc = 0.0, 0.0\n\n if not self.cb.begin_epoch(epoch): return # noqa: E701\n\n optim = self.cb.update_LR(epoch, self.model, self.optimizer, self.optimizer_args)\n if optim: self.optimizer = optim\n\n # Train loop\n for _, (inputs, labels) in enumerate(self.train_dataloader):\n\n if isinstance(inputs, dict):\n for key in input_dict:\n inputs[key] = inputs[key].to(device)\n else:\n inputs = Variable(inputs.to(device))\n\n labels = Variable(labels.to(device))\n\n self.optimizer.zero_grad() # clean existing gradients\n # Runs the forward pass with autocasting.\n with autocast():\n outputs = self.model(inputs) # forward pass\n loss = self.loss_criterion(outputs, labels) # compute loss\n if parallel:\n loss = loss.mean() # list in this case\n scaler.scale(loss).backward() # backward() on scaled loss for scaled gradients. \n scaler.step(self.optimizer) # update parameters\n scaler.update() # Updates the scale for next iteration.\n\n train_loss += loss.item() * labels.size(0) # == mini_batch size\n train_acc += calc_acc(outputs, labels).item()\n\n self.cb.after_step(labels.size(0), labels, outputs)\n\n # validation - no gradient tracking needed\n with torch.no_grad():\n self.model.eval()\n\n # validation loop\n for _, (inputs, labels) in enumerate(self.val_dataloader):\n\n if isinstance(inputs, dict):\n for key in input_dict:\n inputs[key] = inputs[key].to(device)\n else:\n inputs = Variable(inputs.to(device))\n\n labels = Variable(labels.to(device))\n\n outputs = self.model(inputs) # forward pass\n loss = self.loss_criterion(outputs, labels) # compute loss\n if parallel:\n loss = loss.mean()\n val_loss += loss.item() * labels.size(0) # == mini_batch size\n val_acc += calc_acc(outputs, labels).item()\n\n self.cb.after_step_val(labels.size(0), labels, outputs)\n\n self.cb.after_epoch(self.model, train_acc, train_loss, val_acc, val_loss)\n\n epoch += 1\n # print('-', self.cb.best_metric_epoch[self.cb.metric_name[-1]], last_epoch)\n # Is use stable metric - will stop training earlier, after \n # stable_metric epochs without validation metric (to be selected) improve\n # last_epoch = self.epochs if not self.stable_metric else max(self.epochs, self.cb.best_metric_epoch[self.cb.metric_name[-1]] + self.stable_metric)\n # for metric in self.cb.metric_name:\n # print(metric)\n last_epoch = self.epochs if not self.stable_metric else min(self.epochs, self.cb.best_metric_epoch[self.cb.metric_name[-1]] + self.stable_metric)\n\n self.cb.after_train_val()\n\n values = [self.cb.best_metric, self.cb.best_metric_epoch, self.cb.elapsed_mins, \n self.cb.metric_name, self.cb.loss_plot, self.cb.metric_plot, \n self.cb.best_model_file]\n\n return values\n\n\n def run_test(self, test_dataloader, model_type, **kwargs):\n \"\"\" Run test from test_dataloader according to model_type.\n if model_type = 'normal' : use last saved model\n if model_type = 'best' : use best model\n Uses: loss function from Trainer\n Input: test_dataloader\n \"\"\"\n calc_acc = kwargs.get('accuracy') if kwargs.get('accuracy') else acc\n quiet = kwargs.get('quiet') if kwargs.get('quiet') else False\n\n if model_type == 'normal':\n model = self.cb.last_model\n elif model_type == 'best':\n model = self.cb.best_model\n elif model_type == 'bootstrap':\n model = self.model\n\n test_acc, test_loss = 0., 0.\n batch_val_counter = 0\n device = self.device\n\n with torch.no_grad():\n model.eval()\n\n # validation loop\n for _, (inputs, labels) in enumerate(test_dataloader):\n\n if isinstance(inputs, dict):\n for key in ['CC', 'MLO']:\n inputs[key] = inputs[key].to(device)\n labels = Variable(labels.to(device))\n else:\n inputs = Variable(inputs.to(device))\n labels = Variable(labels.to(device))\n\n outputs = model(inputs) # forward pass\n loss = self.loss_criterion(outputs, labels) # compute loss\n if parallel:\n loss = loss.mean()\n test_loss += loss.item() * labels.size(0)\n test_acc += calc_acc(outputs, labels).item()\n\n batch_val_counter += labels.size(0)\n\n # Find average test loss and test accuracy\n avg_test_loss = test_loss/batch_val_counter\n avg_test_acc = test_acc/batch_val_counter\n\n if not quiet:\n print(f'Model: {model_type} - Test accuracy : {avg_test_acc:.5f}' +\n f' Test loss : {avg_test_loss:.5f}')\n\n return avg_test_acc \n\n\n def run_test_auc(self, test_dataloader, model_type, **kwargs):\n \"\"\" Run test from test_dataloader, calculating AUC and ROC curve\n According to model_type:\n if model_type = 'normal' : use last saved model\n if model_type = 'best' : use best model\n If we are running test iunference only can pass model through kwargs.\n Uses: loss function from Trainer\n Input: test_dataloader\n \"\"\"\n calc_acc = kwargs.get('accuracy') if kwargs.get('accuracy') else acc\n model = kwargs.get('model') if kwargs.get('model') else None\n show_results = kwargs.get('show_results') if kwargs.get('show_results') else False\n m_positive = kwargs.get('m') if kwargs.get('m') else False\n n_negative = kwargs.get('n') if kwargs.get('n') else False\n\n if model is None:\n if model_type == 'normal':\n model = self.cb.last_model\n elif model_type == 'best':\n model = self.cb.best_model\n elif model_type == 'test':\n model = self.model\n elif model_type == 'bootstrap':\n model = self.model\n\n test_acc, test_loss = 0., 0.\n batch_val_counter = 0\n y_hat_auc, label_auc = [], []\n device = self.device\n\n with torch.no_grad():\n model.eval()\n\n # validation loop\n for _, (inputs, labels) in enumerate(test_dataloader):\n if isinstance(inputs, dict):\n for key in ['CC', 'MLO']:\n inputs[key] = inputs[key].to(device)\n labels = Variable(labels.to(device))\n else:\n inputs = Variable(inputs.to(device))\n labels = Variable(labels.to(device))\n outputs = model(inputs) # forward pass\n loss = self.loss_criterion(outputs, labels) # compute loss\n test_loss += loss.item() * labels.size(0)\n\n # calculate acc\n test_acc += calc_acc(outputs, labels).item()\n batch_val_counter += labels.size(0)\n\n # Store auc for malignant\n label_auc = np.append(label_auc, labels.cpu().detach().numpy())\n y_hat_auc = np.append(y_hat_auc, torch.softmax(outputs, dim=1)[:, 1].cpu().detach().numpy())\n\n # enter show result mode\n if self.mini_batch == 1 and show_results:\n print(f'{labels.item()} {torch.softmax(outputs, dim=1)[:, 1].item():.3f}')\n\n # Find average test loss and test accuracy\n avg_test_loss = test_loss/batch_val_counter\n avg_test_acc = test_acc/batch_val_counter\n\n print(f\"Model: {model_type} - Test accuracy : {avg_test_acc:.3f}\" +\n f\" Test loss : {avg_test_loss:.4f}\", end='')\n\n # calculate AUC TEST\n auc_mal_val = roc_auc_score(label_auc.ravel(), y_hat_auc.ravel())\n # print(f' AUC Malignant: {auc_mal_val:.4f}', end='')\n if m_positive and n_negative:\n auc_final = f'{auc_mal_val:.4f}±{calc_auc_desv(m_positive, n_negative, auc_mal_val):.4f}'\n # print(f'±{calc_auc_desv(m_positive, n_negative, auc_mal_val):.4f}')\n print(f' AUC Malignant: {auc_final}')\n else:\n auc_final = f'{auc_mal_val:.4f}'\n print(f' AUC Malignant: {auc_final}')\n # print()\n\n if self.make_plots:\n show_auc(label_auc, y_hat_auc, self.title, show_plt=False)\n \n # return auc_mal_val\n return auc_final\n\n\n # Not fully tested yet (2021-05)\n # it seems to be working - maybe integrate in single function as above\n # and use kwargs to indicate that it is test-data- aug?\n def run_test_data_aug_auc(self, test_dataloader, model_type, **kwargs):\n \"\"\" Run test from test_dataloader, calculating AUC and ROC curve\n --> Using test-data augmentation: rotation 0°, 90°, 180°, 270°\n --> All rotated sample will be infered and AUC will consider all.\n According to model_type:\n if model_type = 'normal' : use last saved model\n if model_type = 'best' : use best model\n If we are running test iunference only can pass model through kwargs.\n Uses: loss function from Trainer\n Input: test_dataloader\n \"\"\"\n calc_acc = kwargs.get('accuracy') if kwargs.get('accuracy') else acc\n model = kwargs.get('model') if kwargs.get('model') else None\n\n if model is None:\n if model_type == 'normal':\n model = self.cb.last_model\n elif model_type == 'best':\n model = self.cb.best_model\n elif model_type == 'test':\n model = self.model\n\n test_acc, test_loss = 0., 0.\n batch_val_counter = 0\n y_hat_auc, label_auc = [], []\n device = self.device\n\n with torch.no_grad():\n model.eval()\n\n # validation loop\n for _, (inputs, labels) in enumerate(test_dataloader):\n for rot in range(0,4):\n \n # print(rot, inputs.shape)\n inputs = torch.rot90(inputs, rot, [2, 3])\n # inputs = Variable(inputs.to(device))\n # labels = Variable(labels.to(device))\n # print(counter, rot, inputs.shape)\n\n inputs = Variable(inputs.to(device))\n labels = Variable(labels.to(device))\n\n # img = inputs.cpu().detach().numpy()\n # img = img.transpose(0,2,3,1)\n # print(img[0, :, :, 0:3].shape)\n # cv2.imwrite('thrash/test-aug_'+str(rot)+'.png', img[0, :, :, 0:3]*65535)\n\n outputs = model(inputs) # forward pass\n loss = self.loss_criterion(outputs, labels) # compute loss\n test_loss += loss.item() * labels.size(0)\n\n # calculate acc\n test_acc += calc_acc(outputs, labels).item()\n batch_val_counter += labels.size(0)\n\n # Store auc for malignant\n label_auc = np.append(label_auc, labels.cpu().detach().numpy())\n y_hat_auc = np.append(y_hat_auc, torch.softmax(outputs, dim=1)[:, 1].cpu().detach().numpy())\n\n # enter show result mode\n if self.mini_batch == 1:\n print(f'{labels.item()} {torch.softmax(outputs, dim=1)[:, 1].item():.3f}')\n\n print('batch_val_counter ', batch_val_counter)\n\n # Find average test loss and test accuracy\n avg_test_loss = test_loss/batch_val_counter\n avg_test_acc = test_acc/batch_val_counter\n\n print(f\"Model: {model_type} - Test accuracy : {avg_test_acc:.3f}\" +\n f\" Test loss : {avg_test_loss:.4f}\", end='')\n\n # calculate AUC TEST\n auc_mal_val = roc_auc_score(label_auc.ravel(), y_hat_auc.ravel())\n print(f' AUC Malignant: {auc_mal_val:.4f}')\n\n if self.make_plots:\n show_auc(label_auc, y_hat_auc, self.title, show_plt=False)\n \n return auc_mal_val\n"
] | [
[
"torch.cat",
"torch.cuda.amp.autocast",
"torch.no_grad",
"torch.rot90",
"torch.softmax",
"torch.cuda.amp.GradScaler",
"torch.argmax"
]
] |
QDaria/pennylane | [
"5a28983fc7bd950cde8a4014e54261fef4b54293",
"5a28983fc7bd950cde8a4014e54261fef4b54293"
] | [
"tests/templates/test_subroutines/test_qmc.py",
"pennylane/ops/qubit/arithmetic_ops.py"
] | [
"# Copyright 2018-2021 Xanadu Quantum Technologies Inc.\n\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n\n# http://www.apache.org/licenses/LICENSE-2.0\n\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\nimport numpy as np\nimport pytest\nfrom scipy.stats import norm\n\nimport pennylane as qml\nfrom pennylane.templates.subroutines.qmc import (\n QuantumMonteCarlo,\n _make_V,\n _make_Z,\n func_to_unitary,\n make_Q,\n probs_to_unitary,\n)\nfrom pennylane.wires import Wires\n\n\nclass TestProbsToUnitary:\n \"\"\"Tests for the probs_to_unitary function\"\"\"\n\n def test_invalid_distribution_sum_to_not_one(self):\n \"\"\"Test if a ValueError is raised when a distribution that does not sum to one is input\"\"\"\n p = np.ones(4)\n with pytest.raises(ValueError, match=\"A valid probability distribution of non-negative\"):\n probs_to_unitary(p)\n\n def test_invalid_distribution_negative(self):\n \"\"\"Test if a ValueError is raised when a distribution with a negative value is input\"\"\"\n p = [2, 0, 0, -1]\n with pytest.raises(ValueError, match=\"A valid probability distribution of non-negative\"):\n probs_to_unitary(p)\n\n ps = [\n [0.46085261032920616, 0.5391473896707938],\n [0.2111821738452515, 0.4235979103670337, 0.36521991578771484],\n [0.3167916924190049, 0.2651843704361695, 0.1871934980886578, 0.23083043905616774],\n [0.8123242419241959, 0.07990911578859018, 0.07983919018902215, 0.027927452098191852],\n ]\n\n @pytest.mark.parametrize(\"p\", ps)\n def test_fixed_examples(self, p):\n \"\"\"Test if the correct unitary is returned for fixed input examples. A correct unitary has\n its first column equal to the square root of the distribution and satisfies\n U @ U.T = U.T @ U = I.\"\"\"\n unitary = probs_to_unitary(p)\n assert np.allclose(np.sqrt(p), unitary[:, 0])\n assert np.allclose(unitary @ unitary.T, np.eye(len(unitary)))\n assert np.allclose(unitary.T @ unitary, np.eye(len(unitary)))\n\n\nclass TestFuncToUnitary:\n \"\"\"Tests for the func_to_unitary function\"\"\"\n\n def test_not_bounded_func(self):\n \"\"\"Test if a ValueError is raised if a function that evaluates outside of the [0, 1]\n interval is provided\"\"\"\n func = lambda i: np.sin(i)\n\n with pytest.raises(ValueError, match=\"func must be bounded within the interval\"):\n func_to_unitary(func, 8)\n\n def test_example(self):\n \"\"\"Test for a fixed example if the returned unitary maps input states to the\n expected output state as well as if the unitary satisfies U @ U.T = U.T @ U = I.\"\"\"\n M = 8\n func = lambda i: np.sin(i) ** 2\n\n r = func_to_unitary(func, M)\n\n for i in range(M):\n # The control qubit is the last qubit, so we have to look at every other term\n # using [::2].\n output_state = r[::2][i]\n output_0 = output_state[::2]\n output_1 = output_state[1::2]\n assert np.allclose(output_0[i], np.sqrt(1 - func(i)))\n assert np.allclose(output_1[i], np.sqrt(func(i)))\n\n assert np.allclose(r @ r.T, np.eye(2 * M))\n assert np.allclose(r.T @ r, np.eye(2 * M))\n\n def test_example_with_pl(self):\n \"\"\"Test for a fixed example if the returned unitary behaves as expected\n when used within a PennyLane circuit, i.e., so that the probability of the final control\n wire encodes the function.\"\"\"\n wires = 3\n M = 2**wires\n func = lambda i: np.sin(i) ** 2\n\n r = func_to_unitary(func, M)\n\n dev = qml.device(\"default.qubit\", wires=(wires + 1))\n\n @qml.qnode(dev)\n def apply_r(input_state):\n qml.QubitStateVector(input_state, wires=range(wires))\n qml.QubitUnitary(r, wires=range(wires + 1))\n return qml.probs(wires)\n\n for i, state in enumerate(np.eye(M)):\n p = apply_r(state)[1]\n assert np.allclose(p, func(i))\n\n\ndef test_V():\n \"\"\"Test for the _make_V function\"\"\"\n dim = 4\n\n V_expected = -np.eye(dim)\n V_expected[1, 1] = V_expected[3, 3] = 1\n V = _make_V(dim)\n\n assert np.allclose(V, V_expected)\n\n\ndef test_Z():\n \"\"\"Test for the _make_Z function\"\"\"\n dim = 4\n\n Z_expected = -np.eye(dim)\n Z_expected[0, 0] = 1\n Z = _make_Z(dim)\n\n assert np.allclose(Z, Z_expected)\n\n\ndef test_Q():\n \"\"\"Test for the make_Q function using a fixed example\"\"\"\n\n A = np.array(\n [\n [0.85358423 - 0.32239299j, -0.12753659 + 0.38883306j],\n [0.39148136 - 0.11915985j, 0.34064316 - 0.84646648j],\n ]\n )\n R = np.array(\n [\n [\n 0.45885289 + 0.03972856j,\n 0.2798685 - 0.05981098j,\n 0.64514642 - 0.51555038j,\n 0.11015177 - 0.10877695j,\n ],\n [\n 0.19407005 - 0.35483005j,\n 0.29756077 + 0.80153453j,\n -0.19147104 + 0.0507968j,\n 0.15553799 - 0.20493631j,\n ],\n [\n 0.35083011 - 0.20807392j,\n -0.27602911 - 0.13934692j,\n 0.11874165 + 0.34532609j,\n -0.45945242 - 0.62734969j,\n ],\n [\n -0.11379919 - 0.66706921j,\n -0.21120956 - 0.2165113j,\n 0.30133006 + 0.23367271j,\n 0.54593491 + 0.08446372j,\n ],\n ]\n )\n\n Q_expected = np.array(\n [\n [\n -0.46513201 - 1.38777878e-17j,\n -0.13035515 - 2.23341802e-01j,\n -0.74047856 + 7.08652160e-02j,\n -0.0990036 - 3.91977176e-01j,\n ],\n [\n 0.13035515 - 2.23341802e-01j,\n 0.46494302 + 0.00000000e00j,\n 0.05507901 - 1.19182067e-01j,\n -0.80370146 - 2.31904873e-01j,\n ],\n [\n -0.74047856 - 7.08652160e-02j,\n -0.05507901 - 1.19182067e-01j,\n 0.62233412 - 2.77555756e-17j,\n -0.0310774 - 2.02894077e-01j,\n ],\n [\n 0.0990036 - 3.91977176e-01j,\n -0.80370146 + 2.31904873e-01j,\n 0.0310774 - 2.02894077e-01j,\n -0.30774091 + 2.77555756e-17j,\n ],\n ]\n )\n\n Q = make_Q(A, R)\n\n assert np.allclose(Q, Q_expected)\n\n\nclass TestQuantumMonteCarlo:\n \"\"\"Tests for the QuantumMonteCarlo template\"\"\"\n\n @staticmethod\n def func(i):\n return np.sin(i) ** 2\n\n def test_non_flat(self):\n \"\"\"Test if a ValueError is raised when a non-flat array is input\"\"\"\n p = np.ones((4, 1)) / 4\n with pytest.raises(ValueError, match=\"The probability distribution must be specified as a\"):\n QuantumMonteCarlo(p, self.func, range(3), range(3, 5))\n\n def test_wrong_size_p(self):\n \"\"\"Test if a ValueError is raised when a probability distribution is passed whose length\n cannot be mapped to qubits\"\"\"\n p = np.ones(5) / 5\n with pytest.raises(ValueError, match=\"The probability distribution must have a length\"):\n QuantumMonteCarlo(p, self.func, range(3), range(3, 5))\n\n def test_unexpected_target_wires_number(self):\n \"\"\"Test if a ValueError is raised when the number of target wires is incompatible with the\n expected number of target wires inferred from the length of the input probability\n distribution\"\"\"\n p = np.ones(4) / 4\n with pytest.raises(\n ValueError,\n match=\"The probability distribution of dimension 4 requires\" \" 3 target wires\",\n ):\n QuantumMonteCarlo(p, self.func, range(4), range(4, 6))\n\n def test_expected_circuit(self):\n \"\"\"Test if the circuit applied when using the QMC template is the same as the expected\n circuit for a fixed example\"\"\"\n p = np.ones(4) / 4\n target_wires, estimation_wires = Wires(range(3)), Wires(range(3, 5))\n\n op = QuantumMonteCarlo(p, self.func, target_wires, estimation_wires)\n tape = op.expand()\n\n # Do expansion in two steps to avoid also decomposing the first QubitUnitary\n queue_before_qpe = tape.operations[:2]\n\n # 2-qubit decomposition has 10 operations, and after is a 3-qubit gate so start at 11\n queue_after_qpe = tape.expand().operations[11:]\n\n A = probs_to_unitary(p)\n R = func_to_unitary(self.func, 4)\n\n assert len(queue_before_qpe) == 2\n assert queue_before_qpe[0].name == \"QubitUnitary\"\n assert queue_before_qpe[1].name == \"QubitUnitary\"\n assert np.allclose(queue_before_qpe[0].matrix, A)\n assert np.allclose(queue_before_qpe[1].matrix, R)\n assert queue_before_qpe[0].wires == target_wires[:-1]\n assert queue_before_qpe[1].wires == target_wires\n\n Q = make_Q(A, R)\n\n with qml.tape.QuantumTape() as qpe_tape:\n qml.QuantumPhaseEstimation(Q, target_wires, estimation_wires)\n\n qpe_tape = qpe_tape.expand()\n\n assert len(queue_after_qpe) == len(qpe_tape.operations)\n assert all(o1.name == o2.name for o1, o2 in zip(queue_after_qpe, qpe_tape.operations))\n assert all(\n np.allclose(o1.matrix, o2.matrix)\n for o1, o2 in zip(queue_after_qpe, qpe_tape.operations)\n )\n assert all(o1.wires == o2.wires for o1, o2 in zip(queue_after_qpe, qpe_tape.operations))\n\n def test_expected_value(self):\n \"\"\"Test that the QuantumMonteCarlo template can correctly estimate the expectation value\n following the example in the usage details\"\"\"\n m = 5\n M = 2**m\n\n xmax = np.pi\n xs = np.linspace(-xmax, xmax, M)\n\n probs = np.array([norm().pdf(x) for x in xs])\n probs /= np.sum(probs)\n\n func = lambda i: np.cos(xs[i]) ** 2\n\n estimates = []\n\n for n in range(4, 11):\n N = 2**n\n\n target_wires = range(m + 1)\n estimation_wires = range(m + 1, n + m + 1)\n\n dev = qml.device(\"default.qubit\", wires=(n + m + 1))\n\n @qml.qnode(dev)\n def circuit():\n qml.QuantumMonteCarlo(\n probs, func, target_wires=target_wires, estimation_wires=estimation_wires\n )\n return qml.probs(estimation_wires)\n\n phase_estimated = np.argmax(circuit()[: int(N / 2)]) / N\n mu_estimated = (1 - np.cos(np.pi * phase_estimated)) / 2\n estimates.append(mu_estimated)\n\n exact = 0.432332358381693654\n\n # Check that the error is monotonically decreasing\n for i in range(len(estimates) - 1):\n err1 = np.abs(estimates[i] - exact)\n err2 = np.abs(estimates[i + 1] - exact)\n assert err1 >= err2\n\n assert np.allclose(estimates[-1], exact, rtol=1e-3)\n\n def test_expected_value_custom_wires(self):\n \"\"\"Test that the QuantumMonteCarlo template can correctly estimate the expectation value\n following the example in the usage details when the wires have custom labels\"\"\"\n m = 5\n M = 2**m\n\n xmax = np.pi\n xs = np.linspace(-xmax, xmax, M)\n\n probs = np.array([norm().pdf(x) for x in xs])\n probs /= np.sum(probs)\n\n func = lambda i: np.cos(xs[i]) ** 2\n\n n = 10\n N = 2**n\n\n target_wires = [0, \"a\", -1.1, -10, \"bbb\", 1000]\n estimation_wires = [\"bob\", -3, 42, \"penny\", \"lane\", 247, \"straw\", \"berry\", 5.5, 6.6]\n\n dev = qml.device(\"default.qubit\", wires=target_wires + estimation_wires)\n\n @qml.qnode(dev)\n def circuit():\n qml.QuantumMonteCarlo(\n probs, func, target_wires=target_wires, estimation_wires=estimation_wires\n )\n return qml.probs(estimation_wires)\n\n phase_estimated = np.argmax(circuit()[: int(N / 2)]) / N\n mu_estimated = (1 - np.cos(np.pi * phase_estimated)) / 2\n\n exact = 0.432332358381693654\n assert np.allclose(mu_estimated, exact, rtol=1e-3)\n\n def test_id(self):\n \"\"\"Tests that the id attribute can be set.\"\"\"\n xs = np.linspace(-np.pi, np.pi, 2**5)\n probs = np.array([norm().pdf(x) for x in xs])\n probs /= np.sum(probs)\n func = lambda i: np.cos(xs[i]) ** 2\n\n target_wires = [0, \"a\", -1.1, -10, \"bbb\", 1000]\n estimation_wires = [\"bob\", -3, 42, \"penny\", \"lane\", 247, \"straw\", \"berry\", 5.5, 6.6]\n\n template = qml.QuantumMonteCarlo(\n probs, func, target_wires=target_wires, estimation_wires=estimation_wires, id=\"a\"\n )\n\n assert template.id == \"a\"\n",
"# Copyright 2018-2021 Xanadu Quantum Technologies Inc.\n\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n\n# http://www.apache.org/licenses/LICENSE-2.0\n\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\"\"\"\nThis submodule contains the discrete-variable quantum operations that perform\narithmetic operations on their input states.\n\"\"\"\n# pylint:disable=abstract-method,arguments-differ,protected-access\nimport numpy as np\n\nimport pennylane as qml\nfrom pennylane.operation import Operation\n\n\nclass QubitCarry(Operation):\n r\"\"\"QubitCarry(wires)\n Apply the ``QubitCarry`` operation to four input wires.\n\n This operation performs the transformation:\n\n .. math::\n |a\\rangle |b\\rangle |c\\rangle |d\\rangle \\rightarrow |a\\rangle |b\\rangle |b\\oplus c\\rangle |bc \\oplus d\\oplus (b\\oplus c)a\\rangle\n\n .. figure:: ../../_static/ops/QubitCarry.svg\n :align: center\n :width: 60%\n :target: javascript:void(0);\n\n See `here <https://arxiv.org/abs/quant-ph/0008033v1>`__ for more information.\n\n .. note::\n The first wire should be used to input a carry bit from previous operations. The final wire\n holds the carry bit of this operation and the input state on this wire should be\n :math:`|0\\rangle`.\n\n **Details:**\n\n * Number of wires: 4\n * Number of parameters: 0\n\n Args:\n wires (Sequence[int]): the wires the operation acts on\n\n **Example**\n\n The ``QubitCarry`` operation maps the state :math:`|0110\\rangle` to :math:`|0101\\rangle`, where\n the last qubit denotes the carry value:\n\n .. code-block::\n\n input_bitstring = (0, 1, 1, 0)\n\n @qml.qnode(dev)\n def circuit(basis_state):\n qml.BasisState(basis_state, wires=[0, 1, 2, 3])\n qml.QubitCarry(wires=[0, 1, 2, 3])\n return qml.probs(wires=[0, 1, 2, 3])\n\n probs = circuit(input_bitstring)\n probs_indx = np.argwhere(probs == 1).flatten()[0]\n bitstrings = list(itertools.product(range(2), repeat=4))\n output_bitstring = bitstrings[probs_indx]\n\n The output bitstring is\n\n >>> output_bitstring\n (0, 1, 0, 1)\n\n The action of ``QubitCarry`` is to add wires ``1`` and ``2``. The modulo-two result is output\n in wire ``2`` with a carry value output in wire ``3``. In this case, :math:`1 \\oplus 1 = 0` with\n a carry, so we have:\n\n >>> bc_sum = output_bitstring[2]\n >>> bc_sum\n 0\n >>> carry = output_bitstring[3]\n >>> carry\n 1\n \"\"\"\n num_wires = 4\n num_params = 0\n _mat = np.array(\n [\n [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n [0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0],\n [0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n [0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0],\n [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0],\n [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0],\n [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],\n [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],\n [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],\n [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],\n [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0],\n ]\n )\n\n @classmethod\n def _matrix(cls, *params):\n return QubitCarry._mat\n\n @staticmethod\n def decomposition(wires):\n decomp_ops = [\n qml.Toffoli(wires=wires[1:]),\n qml.CNOT(wires=[wires[1], wires[2]]),\n qml.Toffoli(wires=[wires[0], wires[2], wires[3]]),\n ]\n return decomp_ops\n\n\nclass QubitSum(Operation):\n r\"\"\"QubitSum(wires)\n Apply a ``QubitSum`` operation on three input wires.\n\n This operation performs the transformation:\n\n .. math::\n |a\\rangle |b\\rangle |c\\rangle \\rightarrow |a\\rangle |b\\rangle |a\\oplus b\\oplus c\\rangle\n\n\n .. figure:: ../../_static/ops/QubitSum.svg\n :align: center\n :width: 40%\n :target: javascript:void(0);\n\n See `here <https://arxiv.org/abs/quant-ph/0008033v1>`__ for more information.\n\n **Details:**\n\n * Number of wires: 3\n * Number of parameters: 0\n\n Args:\n wires (Sequence[int]): the wires the operation acts on\n\n **Example**\n\n The ``QubitSum`` operation maps the state :math:`|010\\rangle` to :math:`|011\\rangle`, with the\n final wire holding the modulo-two sum of the first two wires:\n\n .. code-block::\n\n input_bitstring = (0, 1, 0)\n\n @qml.qnode(dev)\n def circuit(basis_state):\n qml.BasisState(basis_state, wires = [0, 1, 2])\n qml.QubitSum(wires=[0, 1, 2])\n return qml.probs(wires=[0, 1, 2])\n\n probs = circuit(input_bitstring)\n probs_indx = np.argwhere(probs == 1).flatten()[0]\n bitstrings = list(itertools.product(range(2), repeat=3))\n output_bitstring = bitstrings[probs_indx]\n\n The output bitstring is\n\n >>> output_bitstring\n (0, 1, 1)\n\n The action of ``QubitSum`` is to add wires ``0``, ``1``, and ``2``. The modulo-two result is\n output in wire ``2``. In this case, :math:`0 \\oplus 1 \\oplus 0 = 1`, so we have:\n\n >>> abc_sum = output_bitstring[2]\n >>> abc_sum\n 1\n \"\"\"\n num_wires = 3\n num_params = 0\n _mat = np.array(\n [\n [1, 0, 0, 0, 0, 0, 0, 0],\n [0, 1, 0, 0, 0, 0, 0, 0],\n [0, 0, 0, 1, 0, 0, 0, 0],\n [0, 0, 1, 0, 0, 0, 0, 0],\n [0, 0, 0, 0, 0, 1, 0, 0],\n [0, 0, 0, 0, 1, 0, 0, 0],\n [0, 0, 0, 0, 0, 0, 1, 0],\n [0, 0, 0, 0, 0, 0, 0, 1],\n ]\n )\n\n def label(self, decimals=None, base_label=None):\n return super().label(decimals=decimals, base_label=base_label or \"Σ\")\n\n @classmethod\n def _matrix(cls, *params):\n return QubitSum._mat\n\n @staticmethod\n def decomposition(wires):\n decomp_ops = [\n qml.CNOT(wires=[wires[1], wires[2]]),\n qml.CNOT(wires=[wires[0], wires[2]]),\n ]\n return decomp_ops\n\n def adjoint(self):\n return QubitSum(wires=self.wires)\n"
] | [
[
"numpy.array",
"numpy.sin",
"scipy.stats.norm",
"numpy.sum",
"numpy.ones",
"numpy.eye",
"numpy.allclose",
"numpy.sqrt",
"numpy.abs",
"numpy.cos",
"numpy.linspace"
],
[
"numpy.array"
]
] |
kgizdov/hep_ml | [
"114ac9e896c3a601761092760a7b315f448d59c6"
] | [
"tests/test_nnet.py"
] | [
"from __future__ import division, print_function\n\nimport numpy\nfrom sklearn.linear_model.logistic import LogisticRegression\nfrom sklearn.metrics import roc_auc_score, mean_squared_error, log_loss\nfrom sklearn.base import clone\nfrom sklearn.datasets import make_blobs\n\nfrom hep_ml import nnet\nfrom hep_ml.commonutils import generate_sample\nfrom hep_ml.nnet import MLPRegressor\nfrom hep_ml.preprocessing import BinTransformer, IronTransformer\n\n__author__ = 'Alex Rogozhnikov'\n\nnn_types = [\n nnet.SimpleNeuralNetwork,\n nnet.MLPClassifier,\n nnet.SoftmaxNeuralNetwork,\n nnet.RBFNeuralNetwork,\n nnet.PairwiseNeuralNetwork,\n nnet.PairwiseSoftplusNeuralNetwork,\n]\n\n\n# TODO test pipelines, bagging and boosting\n\ndef check_single_classification_network(neural_network, n_samples=200, n_features=7, distance=0.8, retry_attempts=3):\n X, y = generate_sample(n_samples=n_samples, n_features=n_features, distance=distance)\n # each combination is tried 3 times. before raising exception\n\n for retry_attempt in range(retry_attempts):\n # to initial state\n neural_network = clone(neural_network)\n neural_network.set_params(random_state=42 + retry_attempt)\n print(neural_network)\n neural_network.fit(X, y)\n quality = roc_auc_score(y, neural_network.predict_proba(X)[:, 1])\n # checking that computations don't fail\n computed_loss = neural_network.compute_loss(X, y, sample_weight=y * 0 + 1)\n if quality > 0.8:\n break\n else:\n print('attempt {} : {}'.format(retry_attempt, quality))\n if retry_attempt == retry_attempts - 1:\n raise RuntimeError('quality of model is too low: {} {}'.format(quality, neural_network))\n\n\ndef test_classification_nnets():\n \"\"\"\n checking combinations of losses, nn_types, trainers, most of them are used once during tests.\n \"\"\"\n attempts = max(len(nnet.losses), len(nnet.trainers), len(nn_types))\n losses_shift = numpy.random.randint(10)\n trainers_shift = numpy.random.randint(10)\n for combination in range(attempts):\n loss = list(nnet.losses.keys())[(combination + losses_shift) % len(nnet.losses)]\n trainer = list(nnet.trainers.keys())[(combination + trainers_shift) % len(nnet.trainers)]\n\n nn_type = nn_types[combination % len(nn_types)]\n neural_network = nn_type(layers=[5], loss=loss, trainer=trainer, epochs=200)\n yield check_single_classification_network, neural_network\n\n\ndef test_regression_nnets():\n from sklearn.datasets import make_regression\n X, y = make_regression(n_samples=300, n_features=20, n_informative=10, bias=5)\n print(y[:20])\n\n original_mse = mean_squared_error(y, y * 0 + y.mean())\n for loss in ['mse_loss', 'smooth_huber_loss']:\n reg = MLPRegressor(layers=(5,), loss=loss)\n reg.fit(X, y)\n p = reg.predict(X)\n print(numpy.sort(abs(p))[-10:])\n mse = mean_squared_error(y, p)\n assert mse < original_mse * 0.3\n\n # fitting a constant\n y[:] = 100.\n for loss in ['mse_loss', 'smooth_huber_loss']:\n reg = MLPRegressor(layers=(1,), loss=loss, epochs=300)\n reg.fit(X, y)\n print(mean_squared_error(y, reg.predict(X)))\n assert mean_squared_error(y, reg.predict(X)) < 5., \"doesn't fit constant\"\n\n\ndef compare_nnets_quality(n_samples=200, n_features=7, distance=0.8):\n X, y = generate_sample(n_samples=n_samples, n_features=n_features, distance=distance)\n # checking all possible combinations\n for loss in ['log_loss']: # nnet.losses:\n for NNType in nn_types:\n for trainer in nnet.trainers:\n nn = NNType(layers=[5], loss=loss, trainer=trainer, epochs=100, random_state=42)\n nn.fit(X, y)\n print(roc_auc_score(y, nn.predict_proba(X)[:, 1]), nn)\n\n lr = LogisticRegression().fit(X, y)\n print(roc_auc_score(y, lr.predict_proba(X)[:, 1]), lr)\n\n\ndef test_network_with_scaler(n_samples=200, n_features=15, distance=0.5):\n X, y = generate_sample(n_samples=n_samples, n_features=n_features, distance=distance)\n for scaler in [BinTransformer(max_bins=16), IronTransformer()]:\n clf = nnet.SimpleNeuralNetwork(scaler=scaler, epochs=300)\n clf.fit(X, y)\n\n p = clf.predict_proba(X)\n assert roc_auc_score(y, p[:, 1]) > 0.8, 'quality is too low for model: {}'.format(clf)\n\n\ndef test_adaptive_methods(n_samples=200, n_features=15, distance=0.5):\n X, y = generate_sample(n_samples=n_samples, n_features=n_features, distance=distance)\n for trainer in ['sgd', 'adadelta']:\n clf = nnet.SimpleNeuralNetwork(trainer=trainer, trainer_parameters={'batch': 1})\n clf.fit(X, y)\n assert roc_auc_score(y, clf.predict_proba(X)[:, 1]) > 0.8, 'quality is too low for model: {}'.format(clf)\n\n\ndef test_reproducibility(n_samples=200, n_features=15, distance=0.5):\n X, y = generate_sample(n_samples=n_samples, n_features=n_features, distance=distance)\n for trainer in nnet.trainers.keys():\n clf1 = nnet.MLPClassifier(trainer=trainer, random_state=42).fit(X, y)\n clf2 = nnet.MLPClassifier(trainer=trainer, random_state=42).fit(X, y)\n assert numpy.allclose(clf1.predict_proba(X), clf2.predict_proba(X))\n\n\ndef test_multiclassification(n_samples=200, n_features=10):\n for n_classes in [2, 3, 4]:\n X, y = make_blobs(n_samples=n_samples, centers=n_classes, n_features=n_features)\n losses = []\n for n_epochs in [1, 10, 100]:\n clf = nnet.MLPMultiClassifier(epochs=n_epochs).fit(X, y)\n loss1 = log_loss(y, clf.predict_proba(X))\n loss2 = clf.compute_loss(X, y)\n assert numpy.allclose(loss1, loss2), 'computed losses are different'\n losses.append(loss1)\n\n assert losses[0] > losses[-1], 'loss is not decreasing'\n"
] | [
[
"sklearn.metrics.mean_squared_error",
"sklearn.datasets.make_blobs",
"numpy.allclose",
"sklearn.linear_model.logistic.LogisticRegression",
"numpy.random.randint",
"sklearn.datasets.make_regression",
"sklearn.base.clone",
"sklearn.metrics.roc_auc_score"
]
] |
jopetty/transd-dev | [
"0078dfd8a049f5b97a7b3be6e883821e4994d4c0"
] | [
"src/models/modules/rnn_decoder.py"
] | [
"import random\nfrom typing import Dict\n\nimport torch\nfrom torch import Tensor, nn\nfrom torch.nn import functional as F\n\n\nclass RNNDecoder(nn.Module):\n @property\n def max_gen_length(self) -> int:\n return self.hparams[\"dec_max_gen_length\"]\n\n @property\n def EOS_idx(self) -> int:\n return self.hparams[\"dec_EOS_idx\"]\n\n def __init__(self, hparams: dict) -> None:\n super().__init__()\n\n self.hparams = hparams\n\n self.embedding = nn.Embedding(\n hparams[\"dec_vocab_size\"], hparams[\"dec_embedding_size\"]\n )\n self.unit = nn.RNN(\n hparams[\"dec_embedding_size\"],\n hparams[\"dec_hidden_size\"],\n num_layers=hparams[\"dec_num_layers\"],\n batch_first=True,\n )\n self.output = nn.Linear(hparams[\"dec_hidden_size\"], hparams[\"dec_vocab_size\"])\n\n def forward_step(self, step_input: Dict[str, Tensor]) -> Dict[str, Tensor]:\n\n # Unsqueeze if only one batch is present\n no_squeeze = lambda a: a.unsqueeze(0) if a.shape == 2 else a\n\n # print(\"Step Input\")\n # for key in step_input:\n # print(f\"{key}: {step_input[key].shape}\")\n\n h = no_squeeze(step_input[\"h\"])\n unit_input = no_squeeze(F.relu(self.embedding(step_input[\"x\"])))\n _, state = self.unit(unit_input, h)\n y = self.output(no_squeeze(state[-1, :, :]))\n\n # print(f\"h: {h.shape}\")\n # print(f\"unit_input: {unit_input.shape}\")\n # print(f\"unk: {unk.shape}\")\n # print(f\"state: {state.shape}\")\n # print(f\"state[-1]: {state[-1].shape}\")\n # print(f\"y: {y.shape}\")\n\n return {\"y\": y, \"h\": state}\n\n def get_step_input(self, dec_input: Dict[str, Tensor]) -> Dict[str, Tensor]:\n\n if \"h\" in dec_input:\n h = dec_input[\"h\"]\n elif \"encoder_last_state\" in dec_input:\n h = torch.transpose(dec_input[\"encoder_last_state\"], 0, 1)\n else:\n raise ValueError(\n f\"You must provide a hidden input in dec_input '{dec_input}'\"\n )\n\n if \"x\" in dec_input:\n x = dec_input[\"x\"]\n elif \"transform\" in dec_input:\n # print(\"No x found\")\n # print(dec_input[\"transform\"][:, 1:-1].shape)\n x = dec_input[\"transform\"][:, 1:-1]\n else:\n raise ValueError(\n f\"You must provide a step input in dec_input '{dec_input}'\"\n )\n\n step_input = {\"x\": x, \"h\": h}\n\n if \"encoder_output\" in dec_input:\n step_input[\"encoder_output\"] = dec_input[\"encoder_output\"]\n\n return step_input\n\n def forward(self, dec_input: Dict[str, Tensor], tf_ratio) -> Dict[str, Tensor]:\n\n is_teacher_forcing = random.random() < tf_ratio\n\n batch_size: int = dec_input[\"encoder_output\"].shape[0]\n hidden_size: int = self.output.in_features\n vocab_size: int = self.output.out_features\n gen_length = (\n dec_input[\"target\"][0].shape[0]\n if is_teacher_forcing\n else self.max_gen_length\n )\n\n dec_step_input = self.get_step_input(dec_input)\n\n has_finished = torch.zeros(batch_size, dtype=torch.bool)\n dec_output = torch.zeros(gen_length, batch_size, vocab_size)\n dec_hidden = torch.zeros(gen_length, batch_size, hidden_size)\n\n for i in range(gen_length):\n\n # print(f\"STEP {i} (tf={is_teacher_forcing})\")\n\n step_result = self.forward_step(dec_step_input)\n step_prediction = step_result[\"y\"].argmax(dim=-1)\n\n # for key in step_result:\n # print(f\"step_result[{key}]: {step_result[key].shape}\")\n # print(\"dec_hidden: \", dec_hidden.shape)\n\n dec_output[i] = step_result[\"y\"]\n dec_hidden[i] = step_result[\"h\"]\n\n has_finished[step_prediction == self.EOS_idx] = True\n if all(has_finished):\n break\n else:\n x = dec_input[\"target\"][:, i] if is_teacher_forcing else step_prediction\n step_result[\"x\"] = x.unsqueeze(-1)\n step_result[\"encoder_output\"] = dec_input[\"encoder_output\"]\n\n dec_step_input = self.get_step_input(step_result)\n\n output = {\n \"logits\": torch.transpose(dec_output, 0, 1),\n \"predictions\": torch.transpose(dec_output, 0, 1).argmax(dim=-1),\n \"decoder_hiddens\": dec_hidden,\n }\n\n return output\n"
] | [
[
"torch.nn.Linear",
"torch.zeros",
"torch.nn.RNN",
"torch.transpose",
"torch.nn.Embedding"
]
] |
continue-nature/google-research | [
"7011fe008efc4f11592ace842dbd4c9dffd46c29"
] | [
"capsule_em/norb/norb_record.py"
] | [
"# coding=utf-8\n# Copyright 2020 The Google Research 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\"\"\"Input utility functions for norb.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\n\nimport os.path\nimport numpy as np\nimport tensorflow.compat.v1 as tf\n\n\ndef _read_and_decode(filename_queue, image_pixel=96, distort=0):\n \"\"\"Read a norb tf record file.\"\"\"\n reader = tf.TFRecordReader()\n _, serialized_example = reader.read(filename_queue)\n features = tf.parse_single_example(\n serialized_example,\n # Defaults are not specified since both keys are required.\n features={\n 'image_raw': tf.FixedLenFeature([], tf.string),\n 'label': tf.FixedLenFeature([], tf.int64),\n 'height': tf.FixedLenFeature([], tf.int64),\n 'width': tf.FixedLenFeature([], tf.int64),\n 'depth': tf.FixedLenFeature([], tf.int64),\n 'meta': tf.FixedLenFeature([4], tf.int64),\n })\n\n # Convert from a scalar string tensor (whose single string has\n # length image_pixels) to a uint8 tensor with shape\n # [image_pixels].\n image = tf.decode_raw(features['image_raw'], tf.uint8)\n height = tf.cast(features['height'], tf.int32)\n depth = tf.cast(features['depth'], tf.int32)\n image = tf.reshape(image, tf.stack([depth, height, height]))\n image = tf.transpose(image, [1, 2, 0])\n image = tf.cast(image, tf.float32)\n print(image.get_shape()[0].value)\n if image_pixel < 96:\n print('image resizing to {}'.format(image_pixel))\n image = tf.image.resize_images(image, [image_pixel, image_pixel])\n orig_images = image\n\n if image_pixel == 48:\n new_dim = 32\n elif image_pixel == 32:\n new_dim = 22\n if distort == 1:\n image = tf.image.random_brightness(image, max_delta=63)\n image = tf.image.random_contrast(image, lower=0.2, upper=1.8)\n image = tf.random_crop(image, tf.stack([new_dim, new_dim, depth]))\n # 0.26179938779 is 15 degress in radians\n image = tf.image.per_image_standardization(image)\n image_pixel = new_dim\n elif distort == 2:\n image = tf.image.resize_image_with_crop_or_pad(image, new_dim, new_dim)\n image = tf.image.per_image_standardization(image)\n image_pixel = new_dim\n else:\n image = image * (1.0 / 255.0)\n image = tf.div(\n tf.subtract(image, tf.reduce_min(image)),\n tf.subtract(tf.reduce_max(image), tf.reduce_min(image)))\n\n # Convert label from a scalar uint8 tensor to an int32 scalar.\n label = tf.cast(features['label'], tf.int32)\n\n return image, label, image_pixel, orig_images\n\n\nbxs_m2 = [[1, 1], [1, -1], [-1, 1], [-1, -1]]\n\n\ndef inputs(train_dir,\n batch_size,\n split,\n multi,\n image_pixel=96,\n distort=False,\n patching=False):\n \"\"\"Reads input data num_epochs times.\"\"\"\n if multi:\n filename = os.path.join(train_dir, '{}duo-az.tfrecords'.format(split))\n else:\n filename = os.path.join(train_dir, '{}.tfrecords'.format(split))\n\n with tf.name_scope('input'):\n filename_queue = tf.train.string_input_producer([filename])\n\n if distort:\n d = 1 + (split == 'test')\n else:\n d = 0\n\n # Even when reading in multiple threads, share the filename\n # queue.\n image, label, dim, orig_image = _read_and_decode(\n filename_queue, image_pixel=image_pixel, distort=d)\n orig_image.set_shape([48, 48, 1 + multi])\n image.set_shape([dim, dim, 1 + multi])\n image = tf.transpose(image, [2, 0, 1])\n\n if split == 'train':\n images, sparse_labels = tf.train.shuffle_batch(\n [image, label],\n batch_size=batch_size,\n num_threads=2,\n capacity=2000 + 3 * batch_size,\n # Ensures a minimum amount of shuffling of examples.\n min_after_dequeue=2000)\n else:\n images, sparse_labels, orig_images = tf.train.batch(\n [image, label, orig_image],\n batch_size=batch_size,\n num_threads=1,\n capacity=1000 + 3 * batch_size)\n if patching:\n t_images = tf.tile(orig_images, [4, 1, 1, 1])\n c_images = tf.image.extract_glimpse(\n t_images, [32, 32], bxs_m2, centered=True, normalized=False)\n c2images = tf.image.extract_glimpse(\n t_images, [32, 32],\n 2 * np.array(bxs_m2),\n centered=True,\n normalized=False)\n c3images = tf.image.extract_glimpse(\n t_images, [32, 32],\n 3 * np.array(bxs_m2),\n centered=True,\n normalized=False)\n c_images = tf.map_fn(tf.image.per_image_standardization, c_images)\n c2images = tf.map_fn(tf.image.per_image_standardization, c2images)\n c3images = tf.map_fn(tf.image.per_image_standardization, c3images)\n c_images = tf.transpose(c_images, [0, 3, 1, 2])\n c2images = tf.transpose(c2images, [0, 3, 1, 2])\n c3images = tf.transpose(c3images, [0, 3, 1, 2])\n # cc_images = tf.concat([images, m_images, c_images], axis=0)\n # cc_labels = tf.tile(sparse_labels, [9])\n cc_images = tf.concat([images, c_images, c2images, c3images], axis=0)\n cc_labels = tf.tile(sparse_labels, [13])\n features = {\n 'images': images,\n 'labels': tf.one_hot(sparse_labels, 5),\n 'recons_image': images,\n 'recons_label': sparse_labels,\n 'height': dim,\n 'depth': 1 + multi,\n 'num_classes': 5,\n 'cc_images': cc_images,\n 'cc_recons_label': cc_labels,\n 'cc_labels': tf.one_hot(cc_labels, 5),\n }\n\n return features\n"
] | [
[
"tensorflow.compat.v1.map_fn",
"tensorflow.compat.v1.transpose",
"tensorflow.compat.v1.tile",
"tensorflow.compat.v1.reduce_min",
"tensorflow.compat.v1.image.random_brightness",
"tensorflow.compat.v1.train.shuffle_batch",
"tensorflow.compat.v1.name_scope",
"tensorflow.compat.v1.stack",
"tensorflow.compat.v1.train.batch",
"tensorflow.compat.v1.image.random_contrast",
"tensorflow.compat.v1.image.resize_image_with_crop_or_pad",
"tensorflow.compat.v1.FixedLenFeature",
"tensorflow.compat.v1.cast",
"numpy.array",
"tensorflow.compat.v1.decode_raw",
"tensorflow.compat.v1.image.resize_images",
"tensorflow.compat.v1.train.string_input_producer",
"tensorflow.compat.v1.reduce_max",
"tensorflow.compat.v1.TFRecordReader",
"tensorflow.compat.v1.one_hot",
"tensorflow.compat.v1.image.extract_glimpse",
"tensorflow.compat.v1.concat",
"tensorflow.compat.v1.image.per_image_standardization"
]
] |
haowen-xu/ml-essentials | [
"ca44186be37887461205227c32995f1485b4ff41"
] | [
"mltk/data/loaders.py"
] | [
"\"\"\"\nSimple dataset loaders.\n\nFor more datasets and more comprehensive loaders, you may turn to dedicated\nlibraries like `fuel`.\n\"\"\"\n\nimport gzip\nimport hashlib\nimport os\nimport pickle\nfrom typing import *\n\nimport idx2numpy\nimport numpy as np\n\nfrom ..typing_ import *\nfrom ..utils import CacheDir, validate_enum_arg\n\n__all__ = ['load_mnist', 'load_fashion_mnist', 'load_cifar10', 'load_cifar100']\n\n_MNIST_LIKE_FILE_NAMES = {\n 'train_x': 'train-images-idx3-ubyte.gz',\n 'train_y': 'train-labels-idx1-ubyte.gz',\n 'test_x': 't10k-images-idx3-ubyte.gz',\n 'test_y': 't10k-labels-idx1-ubyte.gz',\n}\n_MNIST_URI_PREFIX = 'http://yann.lecun.com/exdb/mnist/'\n_MNIST_FILE_MD5 = {\n 'train_x': 'f68b3c2dcbeaaa9fbdd348bbdeb94873',\n 'train_y': 'd53e105ee54ea40749a09fcbcd1e9432',\n 'test_x': '9fb629c4189551a2d022fa330f9573f3',\n 'test_y': 'ec29112dd5afa0611ce80d1b7f02629c',\n}\n_FASHION_MNIST_URI_PREFIX = 'http://fashion-mnist.s3-website.eu-central-1.' \\\n 'amazonaws.com/'\n_FASHION_MNIST_FILE_MD5 = {\n 'train_x': '8d4fb7e6c68d591d4c3dfef9ec88bf0d',\n 'train_y': '25c81989df183df01b3e8a0aad5dffbe',\n 'test_x': 'bef4ecab320f06d8554ea6380940ec79',\n 'test_y': 'bb300cfdad3c16e7a12a480ee83cd310',\n}\n\n_CIFAR_10_URI = 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz'\n_CIFAR_10_MD5 = 'c58f30108f718f92721af3b95e74349a'\n_CIFAR_10_CONTENT_DIR = 'cifar-10-batches-py'\n_CIFAR_100_URI = 'https://www.cs.toronto.edu/~kriz/cifar-100-python.tar.gz'\n_CIFAR_100_MD5 = 'eb9058c3a382ffc7106e4002c42a8d85'\n_CIFAR_100_CONTENT_DIR = 'cifar-100-python'\n\n\ndef _validate_x_shape(shape, default_shape):\n shape = tuple(int(v) for v in shape)\n default_shape = tuple(int(v) for v in default_shape)\n value_size = int(np.prod(default_shape))\n\n if np.prod(shape) != value_size:\n raise ValueError(f'`x_shape` does not product to {value_size}: {shape}')\n return shape\n\n\ndef load_mnist_like(uri_prefix: str,\n file_md5: Dict[str, str],\n cache_name: str,\n x_shape: Sequence[int] = (28, 28),\n x_dtype: ArrayDType = np.uint8,\n y_dtype: ArrayDType = np.int32\n ) -> Tuple[XYArrayTuple, XYArrayTuple]:\n \"\"\"\n Load an MNIST-like dataset as NumPy arrays.\n\n Args:\n uri_prefix: Common prefix of the URIs in `remote_files`.\n file_md5: The remote file MD5 hash sums, a dict of\n `{'train_x': ..., 'train_y': ..., 'test_x': ..., 'test_y': ...}`,\n where each value is the md5 sum.\n cache_name: Name of the cache directory.\n x_shape: Reshape each digit into this shape.\n x_dtype: Cast each digit into this data type.\n y_dtype: Cast each label into this data type.\n\n Returns:\n The ``(train_x, train_y), (test_x, test_y)`` arrays.\n \"\"\"\n\n def _fetch_array(array_name):\n uri = uri_prefix + _MNIST_LIKE_FILE_NAMES[array_name]\n md5 = file_md5[array_name]\n path = CacheDir(cache_name).download(\n uri, hasher=hashlib.md5(), expected_hash=md5)\n with gzip.open(path, 'rb') as f:\n return idx2numpy.convert_from_file(f)\n\n # check arguments\n x_shape = _validate_x_shape(x_shape, (28, 28))\n\n # load data\n train_x = _fetch_array('train_x').astype(x_dtype)\n train_y = _fetch_array('train_y').astype(y_dtype)\n test_x = _fetch_array('test_x').astype(x_dtype)\n test_y = _fetch_array('test_y').astype(y_dtype)\n\n assert(len(train_x) == len(train_y) == 60000)\n assert(len(test_x) == len(test_y) == 10000)\n\n # change shape\n train_x = train_x.reshape([len(train_x)] + list(x_shape))\n test_x = test_x.reshape([len(test_x)] + list(x_shape))\n\n return (train_x, train_y), (test_x, test_y)\n\n\ndef load_mnist(x_shape: Sequence[int] = (28, 28),\n x_dtype: ArrayDType = np.uint8,\n y_dtype: ArrayDType = np.int32\n ) -> Tuple[XYArrayTuple, XYArrayTuple]:\n \"\"\"\n Load an MNIST dataset as NumPy arrays.\n\n Args:\n x_shape: Reshape each digit into this shape.\n x_dtype: Cast each digit into this data type.\n y_dtype: Cast each label into this data type.\n\n Returns:\n The ``(train_x, train_y), (test_x, test_y)`` arrays.\n \"\"\"\n return load_mnist_like(\n _MNIST_URI_PREFIX, _MNIST_FILE_MD5, 'mnist', x_shape, x_dtype, y_dtype)\n\n\ndef load_fashion_mnist(x_shape: Sequence[int] = (28, 28),\n x_dtype: ArrayDType = np.uint8,\n y_dtype: ArrayDType = np.int32\n ) -> Tuple[XYArrayTuple, XYArrayTuple]:\n \"\"\"\n Load an MNIST dataset as NumPy arrays.\n\n Args:\n x_shape: Reshape each digit into this shape.\n x_dtype: Cast each digit into this data type.\n y_dtype: Cast each label into this data type.\n\n Returns:\n The ``(train_x, train_y), (test_x, test_y)`` arrays.\n \"\"\"\n return load_mnist_like(\n _FASHION_MNIST_URI_PREFIX, _FASHION_MNIST_FILE_MD5, 'fashion_mnist',\n x_shape, x_dtype, y_dtype)\n\n\ndef _cifar_load_batch(path, x_shape, x_dtype, y_dtype, expected_batch_label,\n labels_key='labels'):\n # load from file\n with open(path, 'rb') as f:\n d = {\n k.decode('utf-8'): v\n for k, v in pickle.load(f, encoding='bytes').items()\n }\n d['batch_label'] = d['batch_label'].decode('utf-8')\n assert(d['batch_label'] == expected_batch_label)\n\n data = np.asarray(d['data'], dtype=x_dtype)\n labels = np.asarray(d[labels_key], dtype=y_dtype)\n\n # change shape\n data = data.reshape((data.shape[0], 3, 32, 32))\n data = np.transpose(data, (0, 2, 3, 1))\n if x_shape:\n data = data.reshape([data.shape[0]] + list(x_shape))\n\n return data, labels\n\n\ndef load_cifar10(x_shape: Sequence[int] = (32, 32, 3),\n x_dtype: ArrayDType = np.float32,\n y_dtype: ArrayDType = np.int32) -> Tuple[XYArrayTuple, XYArrayTuple]:\n \"\"\"\n Load the CIFAR-10 dataset as NumPy arrays.\n\n Args:\n x_shape: Reshape each digit into this shape.\n x_dtype: Cast each digit into this data type.\n y_dtype: Cast each label into this data type.\n\n Returns:\n The ``(train_x, train_y), (test_x, test_y)`` arrays.\n \"\"\"\n # check the arguments\n x_shape = _validate_x_shape(x_shape, (32, 32, 3))\n\n # fetch data\n path = CacheDir('cifar').download_and_extract(\n _CIFAR_10_URI, hasher=hashlib.md5(), expected_hash=_CIFAR_10_MD5)\n data_dir = os.path.join(path, _CIFAR_10_CONTENT_DIR)\n\n # load the data\n train_num = 50000\n train_x = np.zeros((train_num,) + x_shape, dtype=x_dtype)\n train_y = np.zeros((train_num,), dtype=y_dtype)\n\n for i in range(1, 6):\n path = os.path.join(data_dir, 'data_batch_{}'.format(i))\n x, y = _cifar_load_batch(\n path, x_shape=x_shape, x_dtype=x_dtype, y_dtype=y_dtype,\n expected_batch_label='training batch {} of 5'.format(i)\n )\n (train_x[(i - 1) * 10000: i * 10000, ...],\n train_y[(i - 1) * 10000: i * 10000]) = x, y\n\n path = os.path.join(data_dir, 'test_batch')\n test_x, test_y = _cifar_load_batch(\n path, x_shape=x_shape, x_dtype=x_dtype, y_dtype=y_dtype,\n expected_batch_label='testing batch 1 of 1'\n )\n assert(len(test_x) == len(test_y) == 10000)\n\n return (train_x, train_y), (test_x, test_y)\n\n\ndef load_cifar100(label_mode: str = 'fine',\n x_shape: Sequence[int] = (32, 32, 3),\n x_dtype: ArrayDType = np.float32,\n y_dtype: ArrayDType = np.int32) -> Tuple[XYArrayTuple, XYArrayTuple]:\n \"\"\"\n Load the CIFAR-100 dataset as NumPy arrays.\n\n Args:\n label_mode: One of {\"fine\", \"coarse\"}.\n x_shape: Reshape each digit into this shape.\n x_dtype: Cast each digit into this data type.\n y_dtype: Cast each label into this data type.\n\n Returns:\n The ``(train_x, train_y), (test_x, test_y)`` arrays.\n \"\"\"\n # check the arguments\n label_mode = validate_enum_arg('label_mode', label_mode, ('fine', 'coarse'))\n x_shape = _validate_x_shape(x_shape, (32, 32, 3))\n\n # fetch data\n path = CacheDir('cifar').download_and_extract(\n _CIFAR_100_URI, hasher=hashlib.md5(), expected_hash=_CIFAR_100_MD5)\n data_dir = os.path.join(path, _CIFAR_100_CONTENT_DIR)\n\n # load the data\n path = os.path.join(data_dir, 'train')\n train_x, train_y = _cifar_load_batch(\n path, x_shape=x_shape, x_dtype=x_dtype, y_dtype=y_dtype,\n expected_batch_label='training batch 1 of 1',\n labels_key='{}_labels'.format(label_mode)\n )\n assert(len(train_x) == len(train_y) == 50000)\n\n path = os.path.join(data_dir, 'test')\n test_x, test_y = _cifar_load_batch(\n path, x_shape=x_shape, x_dtype=x_dtype, y_dtype=y_dtype,\n expected_batch_label='testing batch 1 of 1',\n labels_key='{}_labels'.format(label_mode)\n )\n assert(len(test_x) == len(test_y) == 10000)\n\n return (train_x, train_y), (test_x, test_y)\n"
] | [
[
"numpy.prod",
"numpy.transpose",
"numpy.asarray",
"numpy.zeros"
]
] |
fxia22/gibson_demos | [
"5f8d253694b23b41c53959774203ba5787578b74"
] | [
"igibson/test/test_motion_planning.py"
] | [
"import igibson\nfrom igibson.envs.igibson_env import iGibsonEnv\nfrom time import time\nimport os\nfrom igibson.utils.assets_utils import download_assets, download_demo_data\nfrom igibson.utils.motion_planning_wrapper import MotionPlanningWrapper\nimport numpy as np\nimport matplotlib.pyplot as plt\n\ndef test_occupancy_grid():\n print(\"Test env\")\n download_assets()\n download_demo_data()\n config_filename = os.path.join(igibson.root_path, 'test', 'test_house_occupancy_grid.yaml')\n \n nav_env = iGibsonEnv(config_file=config_filename, mode='headless')\n nav_env.reset()\n nav_env.robots[0].set_position_orientation([0,0,0],[0,0,0,1])\n nav_env.simulator.step()\n\n action = nav_env.action_space.sample()\n ts = nav_env.step(action)\n assert np.sum(ts[0]['occupancy_grid'] == 0) > 0\n assert np.sum(ts[0]['occupancy_grid'] == 1) > 0\n plt.imshow(ts[0]['occupancy_grid'][:,:,0])\n plt.colorbar()\n plt.savefig('occupancy_grid.png')\n nav_env.clean()\n\n\ndef test_base_planning():\n print(\"Test env\")\n download_assets()\n download_demo_data()\n config_filename = os.path.join(igibson.root_path, 'test', 'test_house_occupancy_grid.yaml')\n\n nav_env = iGibsonEnv(config_file=config_filename, mode='headless')\n motion_planner = MotionPlanningWrapper(nav_env)\n state = nav_env.reset()\n nav_env.robots[0].set_position_orientation([0,0,0],[0,0,0,1])\n nav_env.simulator.step()\n plan = None\n itr = 0\n while plan is None and itr < 10:\n plan = motion_planner.plan_base_motion([0.5,0,0])\n print(plan)\n itr += 1\n motion_planner.dry_run_base_plan(plan)\n\n assert len(plan) > 0 \n nav_env.clean()\n\n"
] | [
[
"matplotlib.pyplot.savefig",
"matplotlib.pyplot.colorbar",
"numpy.sum",
"matplotlib.pyplot.imshow"
]
] |
adityabasu1/Event-Extraction-NLP | [
"98faa88d36f09330ebce6fc180ab2f087776f2e1"
] | [
"Joint_Event_Extraction.py"
] | [
"import sys\nimport os\nimport numpy as np\nimport random\n\nfrom collections import OrderedDict\nimport pickle\nimport datetime\nfrom tqdm import tqdm\nfrom recordclass import recordclass\nimport math\nimport torch\nimport torch.autograd as autograd\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport torch.optim as optim\nimport json\n\n# Helper funcs\ndef custom_print(*msg):\n for i in range(0, len(msg)):\n if i == len(msg) - 1:\n print(msg[i])\n logger.write(str(msg[i]) + '\\n')\n else:\n print(msg[i], ' ', end='')\n logger.write(str(msg[i]))\n\n\ndef load_word_embedding(embed_file, vocab):\n custom_print('vocab length:', len(vocab))\n embed_vocab = OrderedDict()\n rev_embed_vocab = OrderedDict()\n embed_matrix = list()\n\n embed_vocab['<PAD>'] = 0\n rev_embed_vocab[0] = '<PAD>'\n embed_matrix.append(np.zeros(word_embed_dim, dtype=np.float32))\n\n embed_vocab['<UNK>'] = 1\n rev_embed_vocab[1] = '<UNK>'\n embed_matrix.append(np.random.uniform(-0.25, 0.25, word_embed_dim))\n\n embed_vocab['<SOS>'] = 2\n rev_embed_vocab[2] = '<SOS>'\n embed_matrix.append(np.random.uniform(-0.25, 0.25, word_embed_dim))\n\n embed_vocab['<EOS>'] = 3\n rev_embed_vocab[3] = '<EOS>'\n embed_matrix.append(np.random.uniform(-0.25, 0.25, word_embed_dim))\n\n word_idx = 4\n with open(embed_file, \"r\") as f:\n for line in f:\n parts = line.split()\n if len(parts) < word_embed_dim + 1:\n continue\n word = parts[0]\n if word in vocab and vocab[word] >= word_min_freq:\n vec = [np.float32(val) for val in parts[1:]]\n embed_matrix.append(vec)\n embed_vocab[word] = word_idx\n rev_embed_vocab[word_idx] = word\n word_idx += 1\n\n for word in vocab:\n if word not in embed_vocab and vocab[word] >= word_min_freq:\n embed_matrix.append(np.random.uniform(-0.25, 0.25, word_embed_dim))\n embed_vocab[word] = word_idx\n rev_embed_vocab[word_idx] = word\n word_idx += 1\n\n custom_print('embed dictionary length:', len(embed_vocab))\n return embed_vocab, rev_embed_vocab, np.array(embed_matrix, dtype=np.float32)\n\n\ndef build_vocab(data, events, arguments, roles, vocab_file, embed_file):\n vocab = OrderedDict()\n char_v = OrderedDict()\n char_v['<PAD>'] = 0\n char_v['<UNK>'] = 1\n char_v[';'] = 2\n char_v['|'] = 3\n char_idx = 4\n for d in data:\n for word in d.SrcWords:\n if word not in vocab:\n vocab[word] = 1\n else:\n vocab[word] += 1\n\n for c in word:\n if c not in char_v:\n char_v[c] = char_idx\n char_idx += 1\n\n for event in events:\n vocab[event] = word_min_freq\n for argument in arguments:\n vocab[argument] = word_min_freq\n for role in roles:\n vocab[role] = word_min_freq\n\n vocab[';'] = word_min_freq\n vocab['|'] = word_min_freq\n\n word_v, rev_word_v, embed_matrix = load_word_embedding(embed_file, vocab)\n output = open(vocab_file, 'wb')\n pickle.dump([word_v, char_v], output)\n output.close()\n return word_v, rev_word_v, char_v, embed_matrix\n\n\ndef load_vocab(vocab_file):\n with open(vocab_file, 'rb') as f:\n word_v, char_v = pickle.load(f)\n return word_v, char_v\n\ndef get_adj_mat(amat):\n K = 5\n adj_mat = np.zeros((len(amat), len(amat)), np.float32)\n for i in range(len(amat)):\n for j in range(len(amat)):\n if 0 <= amat[i][j] <= K:\n adj_mat[i][j] = 1.0 / math.pow(2, amat[i][j])\n else:\n adj_mat[i][j] = 0\n return adj_mat\n\n\n\ndef get_data(src_lines, trg_lines, datatype):\n samples = []\n uid = 1\n src_len = -1\n trg_len = -1\n for i in range(0, len(src_lines)):\n src_line = src_lines[i].strip()\n trg_line = trg_lines[i].strip()\n src_words = src_line.split()\n\n if datatype == 1:\n tuples = trg_line.strip().split('|')\n random.shuffle(tuples)\n new_trg_line = ' | '.join(tuples)\n assert len(trg_line.split()) == len(new_trg_line.split())\n trg_line = new_trg_line\n\n trg_words = list()\n trg_words.append('<SOS>')\n trg_words += trg_line.split()\n trg_words.append('<EOS>')\n\n if datatype == 1 and (len(src_words) > max_src_len or len(trg_words) > max_trg_len + 1):\n continue\n if len(src_words) > src_len:\n src_len = len(src_words)\n if len(trg_words) > trg_len:\n trg_len = len(trg_words)\n \n sample = Sample(Id=uid, SrcLen=len(src_words), SrcWords=src_words, TrgLen=len(trg_words),\n TrgWords=trg_words) #c\n samples.append(sample)\n \n uid += 1\n print(src_len)\n print(trg_len)\n return samples\n\n\ndef read_data(src_file, trg_file, datatype):\n reader = open(src_file)\n src_lines = reader.readlines()\n reader.close()\n\n reader = open(trg_file)\n trg_lines = reader.readlines()\n reader.close()\n\n # tot_len = 100\n # src_lines = src_lines[0:min(tot_len, len(src_lines))]\n # trg_lines = trg_lines[0:min(tot_len, len(trg_lines))]\n # adj_lines = adj_lines[0:min(tot_len, len(adj_lines))]\n\n data = get_data(src_lines, trg_lines, datatype)\n return data\n\n\n#event_lines, argument_lines, roles_lines\n\n# to add option for less detailed checks\n\ndef check_event_trigger(ref_string, pred_string):\n return (ref_string == pred_string)\n pass\n\ndef check_event_type(ref_string, pred_string, event_lines):\n if granular_mode == 0:\n if pred_string in event_lines:\n return (ref_string == pred_string)\n else:\n # print(\"invalid prediction\")\n return False\n pass\n\n if granular_mode == 1:\n pred_token = pred_string.split(\":\")[0]\n ref_token = ref_string.split(\":\")[0]\n return (pred_token == ref_token)\n pass\n\n\ndef check_event_argument(ref_string, pred_string):\n return (ref_string == pred_string)\n pass\n\ndef check_argument_type(ref_string, pred_string, argument_lines):\n if granular_mode == 0:\n if pred_string in argument_lines:\n return (ref_string == pred_string)\n else:\n # print(\"invalid prediction\")\n return False\n pass\n\n if granular_mode == 1:\n pred_token = pred_string.split(\":\")[0]\n ref_token = ref_string.split(\":\")[0]\n return (pred_token == ref_token)\n pass\n\ndef check_argument_role(ref_string, pred_string, roles_lines):\n if pred_string in roles_lines:\n return (ref_string == pred_string)\n else:\n # print(\"invalid prediction\")\n return False\n pass\n\ndef calculate_f1(ref_lines, pred_lines, event_lines, argument_lines, roles_lines):\n\n list_of_tracking_metrics = ['predicted_tuples',\n 'ground_truth_tuples',\n 'correct_predictions',\n 'events_count',\n 'correct_events',\n 'correct_event_type',\n 'correct_arguments',\n 'correct_argment_types',\n 'correct_argument_roles'\n ]\n\n metric_counts = dict.fromkeys(list_of_tracking_metrics, 0)\n \n\n for i in range(0, min(len(ref_lines), len(pred_lines))):\n \n ref_line = ref_lines[i].strip()\n pred_line = pred_lines[i].strip()\n\n ref_tuples = ref_line.split('|')\n pred_tuples = pred_line.split('|')\n\n # find a way to compare multiple tuples\n\n # correct - t1 | t2 | t3\n # pred - p1 | p2\n # postives = 3 [number of ground truths minus nones]\n # predicted_pos = 2 [number of preds minus nones]\n # TP = correct preds \n # TP + FP = predicted\n # TP + FN = positives \n # Precision = correct / predicted_pos \n # Recall = correct / positives\n # f = pr/p+r\n\n # handling repeated predictions \n # set_of_preds = set()\n # for pred_tuple in pred_tuples:\n # set_of_preds.add(pred_tuple.strip())\n # pred_tuples = list(set_of_preds)\n\n for pred_tuple in pred_tuples:\n pred_strings = pred_tuple.split(';')\n if(len(pred_strings) < 3):\n continue\n\n\n # in the case of no argument detection, we only calculate the event trigger scores\n if(pred_strings[2].strip().lower()) == 'none':\n max_matches = 0\n part_matches = []\n\n for ref_tuple in ref_tuples:\n # ssss\n ev1, ev2 = cal_f1_for_pair(ref_tuple, pred_tuple, event_lines)\n\n pair_score = ev1+ev2\n\n if pair_score > max_matches:\n max_matches = pair_score\n part_matches = (ev1, ev2)\n pass\n pass\n\n metric_counts['events_count'] += 1\n if ev1 == 1:\n metric_counts['correct_events'] += 1\n if ev2 == 1:\n metric_counts['correct_event_type'] += 1\n\n continue\n \n max_matches = 0\n part_matches = cal_f1_for_tuple(ref_tuples[0], pred_tuple, event_lines, argument_lines, roles_lines)\n\n for ref_tuple in ref_tuples:\n res = cal_f1_for_tuple(ref_tuple, pred_tuple, event_lines, argument_lines, roles_lines)\n\n tuple_score = sum(res)\n\n if tuple_score >= max_matches:\n max_matches = tuple_score\n part_matches = res\n pass\n pass\n\n metric_counts['predicted_tuples'] += 1\n metric_counts['events_count'] += 1\n\n if max_matches >= 4:\n metric_counts['correct_predictions'] += 1\n if part_matches[0] == 1:\n metric_counts['correct_events'] += 1\n if part_matches[1] == 1:\n metric_counts['correct_event_type'] += 1\n if part_matches[2] == 1:\n metric_counts['correct_arguments'] += 1\n if part_matches[3] == 1:\n metric_counts['correct_argment_types'] += 1\n if part_matches[4] == 1:\n metric_counts['correct_argument_roles'] += 1\n pass\n \n for ref_tuple in ref_tuples:\n if(ref_tuple.split(';')[2].strip().lower()) != 'none':\n metric_counts['ground_truth_tuples'] += 1\n\n pass\n \n print(metric_counts)\n\n precision = float(metric_counts['correct_predictions'] / (metric_counts['predicted_tuples'] + 1e-08))\n recall = float(metric_counts['correct_predictions'] / (metric_counts['ground_truth_tuples'] + 1e-08))\n f1 = 2 * precision * recall / (precision + recall + 1e-08)\n precision = round(precision, 3)\n recall = round(recall, 3)\n f1 = round(f1, 3)\n\n print(\"Partwise Results\")\n \n event_acc = metric_counts['correct_events']/ (metric_counts['events_count'] + 1e-08)\n evtype_acc = metric_counts['correct_event_type']/ (metric_counts['events_count'] + 1e-08)\n argument_acc = metric_counts['correct_arguments']/ (metric_counts['predicted_tuples'] + 1e-08)\n argtype_acc = metric_counts['correct_argment_types']/ (metric_counts['predicted_tuples'] + 1e-08)\n role_acc = metric_counts['correct_argument_roles']/ (metric_counts['predicted_tuples'] + 1e-08)\n\n\n print(f'Event Trigger Word Accuracy: {event_acc}')\n print(f'Event Type Accuracy: {evtype_acc}')\n print(f'Argument Identification Accuracy: {argument_acc}')\n print(f'Argument Type Accuracy: {argtype_acc}')\n print(f'Argument Role Accuracy: {role_acc}')\n\n print(f'Macro f-score: {f1}')\n\n targ_file = os.path.join(trg_data_folder, 'Results_logger.txt')\n\n f = open(targ_file, \"a\")\n\n f.write(f'Event Trigger Word Accuracy: {event_acc}')\n f.write(\"\\n\")\n f.write(f'Event Type Accuracy: {evtype_acc}')\n f.write(\"\\n\")\n f.write(f'Argument Identification Accuracy: {argument_acc}')\n f.write(\"\\n\")\n f.write(f'Argument Type Accuracy: {argtype_acc}')\n f.write(\"\\n\")\n f.write(f'Argument Role Accuracy: {role_acc}')\n f.write(\"\\n\")\n\n f.write(f'Macro f-score: {f1}')\n f.write(\"\\n\")\n\n f.close()\n\n\n return f1\n\ndef cal_f1_for_pair(ref_tuple: str ,\n pred_tuple: str,\n event_lines: list\n ) -> list:\n \n ref_strings = ref_tuple.split(';')\n pred_strings = pred_tuple.split(';')\n\n ev1 = int( check_event_trigger(ref_strings[0].strip(), pred_strings[0].strip()) )\n ev2 = int( check_event_type(ref_strings[1].strip(), pred_strings[1].strip(), event_lines) )\n\n return ev1, ev2\n\ndef cal_f1_for_tuple(ref_tuple: str ,\n pred_tuple: str,\n event_lines: list,\n argument_lines: list,\n roles_lines: list\n ) -> list:\n\n ref_strings = ref_tuple.split(';')\n pred_strings = pred_tuple.split(';')\n\n if (len (pred_strings) != 5 ):\n if (len (pred_strings) >= 2 ):\n ev1 = int( check_event_trigger(ref_strings[0].strip(), pred_strings[0].strip()) )\n ev2 = int( check_event_type(ref_strings[1].strip(), pred_strings[1].strip(), event_lines) )\n return [ev1, ev2, 0, 0, 0]\n return list([0,0,0,0,0])\n\n ev1 = int( check_event_trigger(ref_strings[0].strip(), pred_strings[0].strip()) )\n ev2 = int( check_event_type(ref_strings[1].strip(), pred_strings[1].strip(), event_lines) )\n ev3 = int( check_event_argument(ref_strings[2].strip(), pred_strings[2].strip()) )\n ev4 = int( check_argument_type(ref_strings[3].strip(), pred_strings[3].strip(), argument_lines) )\n ev5 = int( check_argument_role(ref_strings[4].strip(), pred_strings[4].strip(), roles_lines) )\n\n ret = [ev1, ev2, ev3, ev4, ev5]\n \n return ret\n\n\n\ndef get_model(model_id):\n if model_id == 1:\n return SeqToSeqModel()\n\ndef write_test_res(data, preds, attns, outfile):\n writer = open(outfile, 'w')\n for i in range(0, len(data)):\n pred_words = get_pred_words(preds[i], attns[i], data[i].SrcWords)[:-1]\n writer.write(' '.join(pred_words) + '\\n')\n writer.close()\n\n\ndef set_random_seeds(seed):\n random.seed(seed)\n np.random.seed(seed)\n torch.manual_seed(seed)\n if n_gpu > 1:\n torch.cuda.manual_seed_all(seed)\n\ndef get_max_len(sample_batch):\n src_max_len = len(sample_batch[0].SrcWords)\n for idx in range(1, len(sample_batch)):\n if len(sample_batch[idx].SrcWords) > src_max_len:\n src_max_len = len(sample_batch[idx].SrcWords)\n\n trg_max_len = len(sample_batch[0].TrgWords)\n for idx in range(1, len(sample_batch)):\n if len(sample_batch[idx].TrgWords) > trg_max_len:\n trg_max_len = len(sample_batch[idx].TrgWords)\n\n return src_max_len, trg_max_len\n\ndef get_words_index_seq(words, max_len):\n seq = list()\n for word in words:\n if word in word_vocab:\n seq.append(word_vocab[word])\n else:\n seq.append(word_vocab['<UNK>'])\n pad_len = max_len - len(words)\n for i in range(0, pad_len):\n seq.append(word_vocab['<PAD>'])\n return seq\n\n\ndef get_target_words_index_seq(words, max_len):\n seq = list()\n for word in words:\n if word in word_vocab:\n seq.append(word_vocab[word])\n else:\n seq.append(word_vocab['<UNK>'])\n pad_len = max_len - len(words)\n for i in range(0, pad_len):\n seq.append(word_vocab['<EOS>'])\n return seq\n\n\ndef get_padded_mask(cur_len, max_len):\n mask_seq = list()\n for i in range(0, cur_len):\n mask_seq.append(0)\n pad_len = max_len - cur_len\n for i in range(0, pad_len):\n mask_seq.append(1)\n return mask_seq\n\n\ndef get_target_vocab_mask(src_words):\n mask = []\n for i in range(0, len(word_vocab)):\n mask.append(1)\n for word in src_words:\n if word in word_vocab:\n mask[word_vocab[word]] = 0\n # events, arguments, roles\n for event in events:\n mask[word_vocab[event]] = 0\n for argument in arguments:\n mask[word_vocab[argument]] = 0\n for role in roles:\n mask[word_vocab[role]] = 0\n\n mask[word_vocab['<UNK>']] = 0\n mask[word_vocab['<EOS>']] = 0\n mask[word_vocab[';']] = 0\n mask[word_vocab['|']] = 0\n return mask\n\n\ndef get_rel_mask(trg_words, max_len):\n mask_seq = list()\n for word in trg_words:\n mask_seq.append(0)\n # if word in relations:\n # mask_seq.append(0)\n # else:\n # mask_seq.append(1)\n pad_len = max_len - len(trg_words)\n for i in range(0, pad_len):\n mask_seq.append(1)\n return mask_seq\n\n\ndef get_char_seq(words, max_len):\n char_seq = list()\n for i in range(0, conv_filter_size - 1):\n char_seq.append(char_vocab['<PAD>'])\n for word in words:\n for c in word[0:min(len(word), max_word_len)]:\n if c in char_vocab:\n char_seq.append(char_vocab[c])\n else:\n char_seq.append(char_vocab['<UNK>'])\n pad_len = max_word_len - len(word)\n for i in range(0, pad_len):\n char_seq.append(char_vocab['<PAD>'])\n for i in range(0, conv_filter_size - 1):\n char_seq.append(char_vocab['<PAD>'])\n\n pad_len = max_len - len(words)\n for i in range(0, pad_len):\n for i in range(0, max_word_len + conv_filter_size - 1):\n char_seq.append(char_vocab['<PAD>'])\n return char_seq\n\n\n\ndef get_relations(file_name):\n rels = []\n reader = open(file_name)\n lines = reader.readlines()\n reader.close()\n for line in lines:\n rels.append(line.strip())\n return rels\n\ndef get_batch_data(cur_samples, is_training=False):\n \"\"\"\n Returns the training samples and labels as numpy array\n \"\"\"\n batch_src_max_len, batch_trg_max_len = get_max_len(cur_samples)\n src_words_list = list()\n src_words_mask_list = list()\n src_char_seq = list()\n\n trg_words_list = list()\n trg_vocab_mask = list()\n adj_lst = []\n\n target = list()\n cnt = 0\n for sample in cur_samples:\n src_words_list.append(get_words_index_seq(sample.SrcWords, batch_src_max_len))\n src_words_mask_list.append(get_padded_mask(sample.SrcLen, batch_src_max_len))\n src_char_seq.append(get_char_seq(sample.SrcWords, batch_src_max_len))\n trg_vocab_mask.append(get_target_vocab_mask(sample.SrcWords))\n\n # cur_masked_adj = np.zeros((batch_src_max_len, batch_src_max_len), dtype=np.float32)\n # cur_masked_adj[:len(sample.SrcWords), :len(sample.SrcWords)] = sample.AdjMat\n # adj_lst.append(cur_masked_adj)\n\n if is_training:\n padded_trg_words = get_words_index_seq(sample.TrgWords, batch_trg_max_len)\n trg_words_list.append(padded_trg_words)\n target.append(padded_trg_words[1:])\n else:\n trg_words_list.append(get_words_index_seq(['<SOS>'], 1))\n cnt += 1\n\n return {'src_words': np.array(src_words_list, dtype=np.float32),\n 'src_chars': np.array(src_char_seq),\n 'src_words_mask': np.array(src_words_mask_list),\n 'adj': np.array(adj_lst),\n 'trg_vocab_mask': np.array(trg_vocab_mask),\n 'trg_words': np.array(trg_words_list, dtype=np.int32),\n 'target': np.array(target)}\n\ndef shuffle_data(data):\n custom_print(len(data))\n data.sort(key=lambda x: x.SrcLen)\n num_batch = int(len(data) / batch_size)\n rand_idx = random.sample(range(num_batch), num_batch)\n new_data = []\n for idx in rand_idx:\n new_data += data[batch_size * idx: batch_size * (idx + 1)]\n if len(new_data) < len(data):\n new_data += data[num_batch * batch_size:]\n return new_data\n\n\ndef get_pred_words(preds, attns, src_words):\n pred_words = []\n for i in range(0, max_trg_len):\n word_idx = preds[i]\n if word_vocab['<EOS>'] == word_idx:\n pred_words.append('<EOS>')\n break\n elif att_type != 'None' and copy_on and word_vocab['<UNK>'] == word_idx:\n word_idx = attns[i]\n pred_words.append(src_words[word_idx])\n else:\n pred_words.append(rev_word_vocab[word_idx])\n return pred_words\n\n\nclass WordEmbeddings(nn.Module):\n def __init__(self, vocab_size, embed_dim, pre_trained_embed_matrix, drop_out_rate):\n super(WordEmbeddings, self).__init__()\n self.embeddings = nn.Embedding(vocab_size, embed_dim, padding_idx=0)\n self.embeddings.weight.data.copy_(torch.from_numpy(pre_trained_embed_matrix))\n self.dropout = nn.Dropout(drop_out_rate)\n\n def forward(self, words_seq):\n word_embeds = self.embeddings(words_seq)\n word_embeds = self.dropout(word_embeds)\n return word_embeds\n\n def weight(self):\n return self.embeddings.weight\n\n# Potentially use a pretrained BERT - 509\nclass CharEmbeddings(nn.Module):\n def __init__(self, vocab_size, embed_dim, drop_out_rate):\n super(CharEmbeddings, self).__init__()\n\n # Layers\n self.embeddings = nn.Embedding(vocab_size, embed_dim, padding_idx=0)\n self.dropout = nn.Dropout(drop_out_rate)\n\n def forward(self, words_seq):\n char_embeds = self.embeddings(words_seq)\n char_embeds = self.dropout(char_embeds)\n return char_embeds\n\n\n# DONT CHANGE CLASSES\n# 543\nclass Encoder(nn.Module):\n def __init__(self, input_dim, hidden_dim, layers, is_bidirectional, drop_out_rate):\n super(Encoder, self).__init__()\n self.input_dim = input_dim\n self.hidden_dim = hidden_dim\n self.layers = layers\n self.is_bidirectional = is_bidirectional\n self.drop_rate = drop_out_rate\n self.char_embeddings = CharEmbeddings(len(char_vocab), char_embed_dim, drop_rate)\n # Remove In case we want to BERT \n\n self.lstm = nn.LSTM(self.input_dim, self.hidden_dim, self.layers, batch_first=True,\n bidirectional=self.is_bidirectional)\n self.dropout = nn.Dropout(self.drop_rate)\n self.conv1d = nn.Conv1d(char_embed_dim, char_feature_size, conv_filter_size)\n self.max_pool = nn.MaxPool1d(max_word_len + conv_filter_size - 1, max_word_len + conv_filter_size - 1)\n\n def forward(self, words_input, char_seq, adj, is_training=False):\n char_embeds = self.char_embeddings(char_seq)\n char_embeds = char_embeds.permute(0, 2, 1)\n\n char_feature = torch.tanh(self.max_pool(self.conv1d(char_embeds)))\n char_feature = char_feature.permute(0, 2, 1)\n\n words_input = torch.cat((words_input, char_feature), -1)\n\n outputs, hc = self.lstm(words_input)\n outputs = self.dropout(outputs)\n \n return outputs\n\n\n# 597\nclass Attention(nn.Module):\n def __init__(self, input_dim):\n super(Attention, self).__init__()\n self.input_dim = input_dim\n self.linear_ctx = nn.Linear(self.input_dim, self.input_dim, bias=False)\n self.linear_query = nn.Linear(self.input_dim, self.input_dim, bias=True)\n self.v = nn.Linear(self.input_dim, 1)\n\n def forward(self, s_prev, enc_hs, src_mask):\n uh = self.linear_ctx(enc_hs)\n wq = self.linear_query(s_prev)\n wquh = torch.tanh(wq + uh)\n attn_weights = self.v(wquh).squeeze()\n attn_weights.data.masked_fill_(src_mask.data, -float('inf'))\n attn_weights = F.softmax(attn_weights, dim=-1)\n ctx = torch.bmm(attn_weights.unsqueeze(1), enc_hs).squeeze()\n return ctx, attn_weights\n\n# 617\nclass NGram_Attention(nn.Module):\n def __init__(self, input_dim, N):\n super(NGram_Attention, self).__init__()\n self.input_dim = input_dim\n self.layers = N\n self.V_layers = nn.ModuleList()\n self.W_layers = nn.ModuleList()\n for i in range(N):\n self.V_layers.append(nn.Linear(input_dim, input_dim))\n self.W_layers.append(nn.Linear(input_dim, input_dim))\n\n def forward(self, s_prev, enc_hs, src_mask):\n att = torch.bmm(s_prev.unsqueeze(1), self.V_layers[0](enc_hs).transpose(1, 2)).squeeze()\n att.data.masked_fill_(src_mask.data, -float('inf'))\n att = F.softmax(att, dim=-1)\n ctx = self.W_layers[0](torch.bmm(att.unsqueeze(1), enc_hs).squeeze())\n for i in range(1, self.layers):\n enc_hs_ngram = torch.nn.AvgPool1d(i+1, 1)(enc_hs.transpose(1, 2)).transpose(1, 2)\n n_mask = src_mask.unsqueeze(1).float()\n n_mask = torch.nn.AvgPool1d(i+1, 1)(n_mask).squeeze()\n n_mask[n_mask > 0] = 1\n n_mask = n_mask.byte()\n n_att = torch.bmm(s_prev.unsqueeze(1), self.V_layers[i](enc_hs_ngram).transpose(1, 2)).squeeze()\n n_att.data.masked_fill_(n_mask.data, -float('inf'))\n n_att = F.softmax(n_att, dim=-1)\n ctx += self.W_layers[i](torch.bmm(n_att.unsqueeze(1), enc_hs_ngram).squeeze())\n return ctx, att\n\n# 588\ndef mean_over_time(x, mask):\n x.data.masked_fill_(mask.unsqueeze(2).data, 0)\n x = torch.sum(x, dim=1)\n time_steps = torch.sum(mask.eq(0), dim=1, keepdim=True).float()\n x /= time_steps\n return x\n\n# 645\nclass Decoder(nn.Module):\n def __init__(self, input_dim, hidden_dim, layers, drop_out_rate, max_length):\n super(Decoder, self).__init__()\n \n self.input_dim = input_dim\n self.hidden_dim = hidden_dim\n self.layers = layers\n self.drop_rate = drop_out_rate\n self.max_length = max_length\n\n if att_type == 'None':\n self.lstm = nn.LSTMCell(2 * self.input_dim, self.hidden_dim, self.layers)\n elif att_type == 'Unigram':\n self.attention = Attention(input_dim)\n self.lstm = nn.LSTMCell(2 * self.input_dim, self.hidden_dim, self.layers)\n else:\n self.attention = NGram_Attention(input_dim, 3)\n self.lstm = nn.LSTMCell(3 * self.input_dim, self.hidden_dim, self.layers)\n\n self.dropout = nn.Dropout(self.drop_rate)\n self.ent_out = nn.Linear(self.input_dim, len(word_vocab))\n\n def forward(self, y_prev, h_prev, enc_hs, src_word_embeds, src_mask, is_training=False):\n src_time_steps = enc_hs.size()[1]\n if att_type == 'None':\n ctx = mean_over_time(enc_hs, src_mask)\n attn_weights = torch.zeros(src_mask.size()).cuda()\n elif att_type == 'Unigram':\n s_prev = h_prev[0]\n s_prev = s_prev.unsqueeze(1)\n s_prev = s_prev.repeat(1, src_time_steps, 1)\n ctx, attn_weights = self.attention(s_prev, enc_hs, src_mask)\n else:\n last_index = src_mask.size()[1] - torch.sum(src_mask, dim=-1).long() - 1\n last_index = last_index.unsqueeze(1).unsqueeze(1).repeat(1, 1, enc_hs.size()[-1])\n enc_last = torch.gather(enc_hs, 1, last_index).squeeze()\n ctx, attn_weights = self.attention(enc_last, src_word_embeds, src_mask)\n ctx = torch.cat((enc_last, ctx), -1)\n\n y_prev = y_prev.squeeze()\n s_cur = torch.cat((y_prev, ctx), 1)\n hidden, cell_state = self.lstm(s_cur, h_prev)\n hidden = self.dropout(hidden)\n output = self.ent_out(hidden)\n return output, (hidden, cell_state), attn_weights\n\n# 690\n\nclass SeqToSeqModel(nn.Module):\n def __init__(self):\n super(SeqToSeqModel, self).__init__()\n self.word_embeddings = WordEmbeddings(len(word_vocab), word_embed_dim, word_embed_matrix, drop_rate)\n self.encoder = Encoder(enc_inp_size, int(enc_hidden_size/2), layers, True, drop_rate)\n self.decoder = Decoder(dec_inp_size, dec_hidden_size, layers, drop_rate, max_trg_len)\n\n def forward(self, src_words_seq, src_chars_seq, src_mask, trg_words_seq, trg_vocab_mask, adj, is_training=False):\n src_word_embeds = self.word_embeddings(src_words_seq)\n trg_word_embeds = self.word_embeddings(trg_words_seq)\n\n batch_len = src_word_embeds.size()[0]\n \n if is_training:\n time_steps = trg_word_embeds.size()[1] - 1\n else:\n time_steps = max_trg_len\n\n encoder_output = self.encoder(src_word_embeds, src_chars_seq, adj, is_training)\n\n h0 = autograd.Variable(torch.FloatTensor(torch.zeros(batch_len, word_embed_dim)))\n h0 = h0.cuda()\n c0 = autograd.Variable(torch.FloatTensor(torch.zeros(batch_len, word_embed_dim)))\n c0 = c0.cuda()\n dec_hid = (h0, c0)\n\n if is_training:\n dec_inp = trg_word_embeds[:, 0, :]\n dec_out, dec_hid, dec_attn = self.decoder(dec_inp, dec_hid, encoder_output, src_word_embeds,\n src_mask, is_training) \n dec_out = dec_out.view(-1, len(word_vocab))\n dec_out = F.log_softmax(dec_out, dim=-1)\n dec_out = dec_out.unsqueeze(1)\n\n for t in range(1, time_steps):\n dec_inp = trg_word_embeds[:, t, :]\n cur_dec_out, dec_hid, dec_attn = self.decoder(dec_inp, dec_hid, encoder_output, src_word_embeds,\n src_mask, is_training)\n cur_dec_out = cur_dec_out.view(-1, len(word_vocab))\n dec_out = torch.cat((dec_out, F.log_softmax(cur_dec_out, dim=-1).unsqueeze(1)), 1)\n else:\n dec_inp = trg_word_embeds[:, 0, :]\n dec_out, dec_hid, dec_attn = self.decoder(dec_inp, dec_hid, encoder_output, src_word_embeds,\n src_mask, is_training)\n dec_out = dec_out.view(-1, len(word_vocab))\n if copy_on:\n dec_out.data.masked_fill_(trg_vocab_mask.data, -float('inf'))\n dec_out = F.log_softmax(dec_out, dim=-1)\n topv, topi = dec_out.topk(1)\n dec_out_v, dec_out_i = dec_out.topk(1)\n dec_attn_v, dec_attn_i = dec_attn.topk(1)\n\n for t in range(1, time_steps):\n dec_inp = self.word_embeddings(topi.squeeze().detach())\n cur_dec_out, dec_hid, cur_dec_attn = self.decoder(dec_inp, dec_hid, encoder_output, src_word_embeds,\n src_mask, is_training)\n cur_dec_out = cur_dec_out.view(-1, len(word_vocab))\n if copy_on:\n cur_dec_out.data.masked_fill_(trg_vocab_mask.data, -float('inf'))\n cur_dec_out = F.log_softmax(cur_dec_out, dim=-1)\n topv, topi = cur_dec_out.topk(1)\n cur_dec_out_v, cur_dec_out_i = cur_dec_out.topk(1)\n dec_out_i = torch.cat((dec_out_i, cur_dec_out_i), 1)\n cur_dec_attn_v, cur_dec_attn_i = cur_dec_attn.topk(1)\n dec_attn_i = torch.cat((dec_attn_i, cur_dec_attn_i), 1)\n\n if is_training:\n dec_out = dec_out.view(-1, len(word_vocab))\n return dec_out\n else:\n return dec_out_i, dec_attn_i\n\ndef predict(samples, model, model_id):\n pred_batch_size = batch_size\n batch_count = math.ceil(len(samples) / pred_batch_size)\n move_last_batch = False\n if len(samples) - batch_size * (batch_count - 1) == 1:\n move_last_batch = True\n batch_count -= 1\n \n preds = list()\n attns = list()\n \n model.eval()\n \n set_random_seeds(random_seed)\n \n start_time = datetime.datetime.now()\n \n for batch_idx in tqdm(range(0, batch_count)):\n batch_start = batch_idx * pred_batch_size\n batch_end = min(len(samples), batch_start + pred_batch_size)\n if batch_idx == batch_count - 1 and move_last_batch:\n batch_end = len(samples)\n\n cur_batch = samples[batch_start:batch_end]\n cur_samples_input = get_batch_data(cur_batch, False)\n\n src_words_seq = torch.from_numpy(cur_samples_input['src_words'].astype('long'))\n src_words_mask = torch.from_numpy(cur_samples_input['src_words_mask'].astype('uint8'))\n trg_vocab_mask = torch.from_numpy(cur_samples_input['trg_vocab_mask'].astype('uint8'))\n trg_words_seq = torch.from_numpy(cur_samples_input['trg_words'].astype('long'))\n adj = torch.from_numpy(cur_samples_input['adj'].astype('float32'))\n src_chars_seq = torch.from_numpy(cur_samples_input['src_chars'].astype('long'))\n\n if torch.cuda.is_available():\n src_words_seq = src_words_seq.cuda()\n src_words_mask = src_words_mask.cuda()\n trg_vocab_mask = trg_vocab_mask.cuda()\n trg_words_seq = trg_words_seq.cuda()\n adj = adj.cuda()\n src_chars_seq = src_chars_seq.cuda()\n\n src_words_seq = autograd.Variable(src_words_seq)\n src_words_mask = autograd.Variable(src_words_mask)\n trg_vocab_mask = autograd.Variable(trg_vocab_mask)\n adj = autograd.Variable(adj)\n src_chars_seq = autograd.Variable(src_chars_seq)\n\n trg_words_seq = autograd.Variable(trg_words_seq)\n with torch.no_grad():\n outputs = model(src_words_seq, src_chars_seq, src_words_mask, trg_words_seq, trg_vocab_mask, adj,False)\n\n preds += list(outputs[0].data.cpu().numpy())\n attns += list(outputs[1].data.cpu().numpy())\n model.zero_grad()\n end_time = datetime.datetime.now()\n custom_print('Prediction time:', end_time - start_time)\n return preds, attns\n\ndef train_model(model_id, train_samples, dev_samples, best_model_file):\n train_size = len(train_samples)\n batch_count = int(math.ceil(train_size/batch_size))\n move_last_batch = False\n \n if len(train_samples) - batch_size * (batch_count - 1) == 1:\n move_last_batch = True\n batch_count -= 1\n \n custom_print(batch_count)\n\n # model = get_model(model_id)\n model = SeqToSeqModel()\n\n pytorch_total_params = sum(p.numel() for p in model.parameters() if p.requires_grad)\n custom_print('Parameters size:', pytorch_total_params)\n\n custom_print(model)\n\n if torch.cuda.is_available():\n model.cuda()\n if n_gpu > 1:\n model = torch.nn.DataParallel(model)\n\n criterion = nn.NLLLoss(ignore_index=0)\n optimizer = optim.Adam(model.parameters())\n\n custom_print(optimizer)\n\n best_dev_acc = -1.0\n best_epoch_idx = -1\n best_epoch_seed = -1\n\n for epoch_idx in range(0, num_epoch):\n model.train()\n model.zero_grad()\n\n custom_print('Epoch:', epoch_idx + 1)\n cur_seed = random_seed + epoch_idx + 1\n set_random_seeds(cur_seed)\n\n cur_shuffled_train_data = shuffle_data(train_samples)\n\n start_time = datetime.datetime.now()\n train_loss_val = 0.0\n\n for batch_idx in tqdm(range(0, batch_count)):\n batch_start = batch_idx * batch_size\n batch_end = min(len(cur_shuffled_train_data), batch_start + batch_size)\n\n if batch_idx == batch_count - 1 and move_last_batch:\n batch_end = len(cur_shuffled_train_data)\n\n cur_batch = cur_shuffled_train_data[batch_start:batch_end]\n cur_samples_input = get_batch_data(cur_batch, True)\n\n # np arrays to tensors\n src_words_seq = torch.from_numpy(cur_samples_input['src_words'].astype('long'))\n src_words_mask = torch.from_numpy(cur_samples_input['src_words_mask'].astype('uint8'))\n trg_vocab_mask = torch.from_numpy(cur_samples_input['trg_vocab_mask'].astype('uint8'))\n trg_words_seq = torch.from_numpy(cur_samples_input['trg_words'].astype('long'))\n adj = torch.from_numpy(cur_samples_input['adj'].astype('float32'))\n src_chars_seq = torch.from_numpy(cur_samples_input['src_chars'].astype('long'))\n\n target = torch.from_numpy(cur_samples_input['target'].astype('long'))\n\n if torch.cuda.is_available():\n src_words_seq = src_words_seq.cuda()\n src_words_mask = src_words_mask.cuda()\n trg_vocab_mask = trg_vocab_mask.cuda()\n trg_words_seq = trg_words_seq.cuda()\n adj = adj.cuda()\n src_chars_seq = src_chars_seq.cuda()\n\n target = target.cuda()\n\n src_words_seq = autograd.Variable(src_words_seq)\n src_words_mask = autograd.Variable(src_words_mask)\n trg_vocab_mask = autograd.Variable(trg_vocab_mask)\n trg_words_seq = autograd.Variable(trg_words_seq)\n adj = autograd.Variable(adj)\n src_chars_seq = autograd.Variable(src_chars_seq)\n\n target = autograd.Variable(target)\n\n outputs = model(src_words_seq, src_chars_seq, src_words_mask, trg_words_seq, trg_vocab_mask, adj, True)\n\n target = target.view(-1, 1).squeeze()\n loss = criterion(outputs, target)\n loss.backward()\n torch.nn.utils.clip_grad_norm_(model.parameters(), 10.0)\n\n if (batch_idx + 1) % update_freq == 0:\n optimizer.step()\n model.zero_grad()\n\n train_loss_val += loss.item()\n\n train_loss_val /= batch_count\n end_time = datetime.datetime.now()\n custom_print('Training loss:', train_loss_val)\n custom_print('Training time:', end_time - start_time)\n\n custom_print('\\nDev Results\\n')\n set_random_seeds(random_seed)\n dev_preds, dev_attns = predict(dev_samples, model, model_id)\n \n write_test_res(dev_samples, dev_preds, dev_attns, os.path.join(trg_data_folder, 'dev.out'))\n\n ref_lines = open(trg_dev_file).read().splitlines()\n pred_lines = open(os.path.join(trg_data_folder, 'dev.out')).read().splitlines()\n event_lines = open(events_file).read().splitlines()\n argument_lines = open(arguments_file).read().splitlines()\n roles_lines = open(roles_file).read().splitlines()\n\n dev_acc = calculate_f1(ref_lines, pred_lines, event_lines, argument_lines, roles_lines)\n\n\n # pred_pos, gt_pos, correct_pos = get_F1(dev_samples, dev_preds, dev_attns)\n # custom_print(pred_pos, '\\t', gt_pos, '\\t', correct_pos)\n # p = float(correct_pos) / (pred_pos + 1e-8)\n # r = float(correct_pos) / (gt_pos + 1e-8)\n # dev_acc = (2 * p * r) / (p + r + 1e-8)\n # custom_print('F1:', dev_acc)\n\n if dev_acc >= best_dev_acc:\n best_epoch_idx = epoch_idx + 1\n best_epoch_seed = cur_seed\n custom_print('model saved......')\n best_dev_acc = dev_acc\n torch.save(model.state_dict(), best_model_file)\n\n custom_print('\\n\\n')\n if epoch_idx + 1 - best_epoch_idx >= early_stop_cnt:\n break\n\n custom_print('*******')\n custom_print('Best Epoch:', best_epoch_idx)\n custom_print('Best Epoch Seed:', best_epoch_seed)\n\n\nif __name__ == \"__main__\":\n \n os.environ['CUDA_VISIBLE_DEVICES'] = sys.argv[1]\n random_seed = int(sys.argv[2])\n src_data_folder = sys.argv[3]\n trg_data_folder = sys.argv[4]\n job_mode = sys.argv[5]\n embedding_type = sys.argv[6]\n granular_mode = 1\n\n n_gpu = torch.cuda.device_count()\n set_random_seeds(random_seed)\n\n\n if not os.path.exists(trg_data_folder):\n os.mkdir(trg_data_folder)\n model_name = 1\n\n #Tunable Hyperparameters\n\n batch_size = 32\n num_epoch = 30\n max_src_len = 100\n max_trg_len = 50\n\n if embedding_type == 'w2v':\n embedding_file = os.path.join(src_data_folder, 'w2v.txt')\n else:\n embedding_file = os.path.join(src_data_folder, 'Bert_embeddings.txt')\n\n update_freq = 1\n enc_type = ['LSTM', 'GCN', 'LSTM-GCN'][0]\n att_type = ['None', 'Unigram', 'N-Gram-Enc'][1]\n\n copy_on = True\n\n gcn_num_layers = 3\n\n if embedding_type == 'w2v':\n word_embed_dim = 300\n else:\n word_embed_dim = 768\n \n word_min_freq = 2\n char_embed_dim = 50\n char_feature_size = 50\n conv_filter_size = 3\n max_word_len = 10\n\n enc_inp_size = word_embed_dim + char_feature_size\n enc_hidden_size = word_embed_dim\n dec_inp_size = enc_hidden_size\n dec_hidden_size = dec_inp_size\n\n drop_rate = 0.3\n layers = 1\n early_stop_cnt = 20\n sample_cnt = 0\n Sample = recordclass(\"Sample\", \"Id SrcLen SrcWords TrgLen TrgWords\")\n\n events_file = os.path.join(src_data_folder, 'event_types.txt')\n arguments_file = os.path.join(src_data_folder, 'arguments.txt')\n roles_file = os.path.join(src_data_folder, 'roles.txt')\n\n events = get_relations(events_file)\n arguments = get_relations(arguments_file)\n roles = get_relations(roles_file)\n\n\n # train a model\n if job_mode == 'train':\n logger = open(os.path.join(trg_data_folder, 'training.log'), 'w')\n custom_print(sys.argv)\n custom_print(max_src_len, max_trg_len, drop_rate, layers)\n custom_print('loading data......')\n model_file_name = os.path.join(trg_data_folder, 'model.h5py')\n src_train_file = os.path.join(src_data_folder, 'train.sent')\n trg_train_file = os.path.join(src_data_folder, 'train.tup')\n train_data = read_data(src_train_file, trg_train_file, 1)\n\n src_dev_file = os.path.join(src_data_folder, 'dev.sent')\n trg_dev_file = os.path.join(src_data_folder, 'dev.tup')\n dev_data = read_data(src_dev_file, trg_dev_file, 2)\n\n custom_print('Training data size:', len(train_data))\n custom_print('Development data size:', len(dev_data))\n\n custom_print(\"preparing vocabulary......\")\n save_vocab = os.path.join(trg_data_folder, 'vocab.pkl')\n word_vocab, rev_word_vocab, char_vocab, word_embed_matrix = build_vocab(train_data, events, arguments, roles, save_vocab,\n embedding_file)\n\n custom_print(\"Training started......\")\n train_model(model_name, train_data, dev_data, model_file_name)\n logger.close()\n\n if job_mode == 'test':\n logger = open(os.path.join(trg_data_folder, 'test.log'), 'w')\n custom_print(sys.argv)\n custom_print(\"loading word vectors......\")\n vocab_file_name = os.path.join(trg_data_folder, 'vocab.pkl')\n word_vocab, char_vocab = load_vocab(vocab_file_name)\n\n rev_word_vocab = OrderedDict()\n for word in word_vocab:\n idx = word_vocab[word]\n rev_word_vocab[idx] = word\n\n word_embed_matrix = np.zeros((len(word_vocab), word_embed_dim), dtype=np.float32)\n custom_print('vocab size:', len(word_vocab))\n\n src_test_file = os.path.join(src_data_folder, 'test.sent')\n trg_test_file = os.path.join(src_data_folder, 'test.tup')\n test_data = read_data(src_test_file, trg_test_file, 3)\n\n custom_print('Test data size:', len(test_data))\n\n custom_print('seed:', random_seed)\n model_file = os.path.join(trg_data_folder, 'model.h5py')\n\n best_model = get_model(model_name)\n custom_print(best_model)\n if torch.cuda.is_available():\n best_model.cuda()\n if n_gpu > 1:\n best_model = torch.nn.DataParallel(best_model)\n best_model.load_state_dict(torch.load(model_file))\n\n custom_print('\\nTest Results\\n')\n set_random_seeds(random_seed)\n test_preds, test_attns = predict(test_data, best_model, model_name)\n\n custom_print('Copy On')\n write_test_res(test_data, test_preds, test_attns, os.path.join(trg_data_folder, 'test.out'))\n\n # ref_lines = open(trg_test_file).readlines()\n # pred_lines = open(os.path.join(trg_data_folder, 'test.out')).readlines()\n # event_lines = open(events_file).readlines()\n # argument_lines = open(arguments_file).readlines()\n # roles_lines = open(roles_file).readlines()\n\n ref_lines = open(trg_test_file).read().splitlines()\n pred_lines = open(os.path.join(trg_data_folder, 'test.out')).read().splitlines()\n event_lines = open(events_file).read().splitlines()\n argument_lines = open(arguments_file).read().splitlines()\n roles_lines = open(roles_file).read().splitlines()\n\n mode = 1\n custom_print('Overall F1')\n # custom_print(cal_f1(ref_lines, pred_lines, event_lines, argument_lines, roles_lines, mode))\n calculate_f1(ref_lines, pred_lines, event_lines, argument_lines, roles_lines)\n\n copy_on = False\n custom_print('Copy Off')\n set_random_seeds(random_seed)\n test_preds, test_attns = predict(test_data, best_model, model_name)\n write_test_res(test_data, test_preds, test_attns, os.path.join(trg_data_folder, 'test_without_copy.out'))\n\n # ref_lines = open(trg_test_file).readlines()\n # pred_lines = open(os.path.join(trg_data_folder, 'test_without_copy.out')).readlines()\n # event_lines = open(events_file).readlines()\n # argument_lines = open(arguments_file).readlines()\n # roles_lines = open(roles_file).readlines()\n\n ref_lines = open(trg_test_file).read().splitlines()\n pred_lines = open(os.path.join(trg_data_folder, 'test_without_copy.out')).read().splitlines()\n event_lines = open(events_file).read().splitlines()\n argument_lines = open(arguments_file).read().splitlines()\n roles_lines = open(roles_file).read().splitlines()\n\n mode = 1\n custom_print('Overall F1')\n # custom_print(cal_f1(ref_lines, pred_lines, event_lines, argument_lines, roles_lines, mode))\n calculate_f1(ref_lines, pred_lines, event_lines, argument_lines, roles_lines)\n logger.close()\n\n\n\n\n"
] | [
[
"torch.nn.Linear",
"torch.cat",
"torch.nn.LSTM",
"torch.nn.ModuleList",
"torch.cuda.is_available",
"torch.load",
"torch.nn.MaxPool1d",
"torch.nn.DataParallel",
"torch.sum",
"torch.nn.AvgPool1d",
"torch.nn.Conv1d",
"torch.autograd.Variable",
"torch.gather",
"torch.manual_seed",
"torch.zeros",
"numpy.array",
"torch.cuda.manual_seed_all",
"torch.nn.LSTMCell",
"numpy.zeros",
"torch.cuda.device_count",
"torch.nn.functional.log_softmax",
"numpy.float32",
"torch.nn.functional.softmax",
"torch.nn.NLLLoss",
"torch.nn.Dropout",
"numpy.random.seed",
"torch.no_grad",
"torch.from_numpy",
"numpy.random.uniform",
"torch.tanh",
"torch.nn.Embedding"
]
] |
samellem/autodp | [
"fd14fed07e0bb67fca5f7e82bbdab6cf60b339d3"
] | [
"test/unit_test_fdp_to_approxdp_conversion.py"
] | [
"from autodp.mechanism_zoo import GaussianMechanism\nfrom autodp.dp_bank import get_eps_ana_gaussian\n\nimport numpy as np\n\nfrom absl.testing import absltest\nfrom absl.testing import parameterized\n\nparams = [0.05, 0.1, 0.2, 0.5, 1.0, 2.0, 5.0, 10.0]\n\n\ndef _fdp_conversion(sigma):\n\n delta_list = [0,1e-8, 1e-6, 1e-4, 1e-2, 0.3, 0.5, 1]\n\n # f-DP implementation\n gm3 = GaussianMechanism(sigma, name='GM3', RDP_off=True, approxDP_off=True, fdp_off=False)\n\n # direct approxdp implementation\n agm = lambda x: get_eps_ana_gaussian(sigma, x)\n\n eps_direct = np.array([agm(delta) for delta in delta_list])\n\n # the fdp is converted by numerical methods from privacy profile.\n eps_converted = np.array([gm3.get_approxDP(delta) for delta in delta_list])\n max_diff = eps_direct - eps_converted\n\n rel_diff = max_diff / (eps_direct+1e-10)\n\n if np.isinf(eps_direct[0]) and np.isinf(eps_converted[0]):\n rel_diff[0] = 0\n return rel_diff\n\n\n_fdp_conversion(1.0)\n\nclass Test_approxDP2fDP_Conversion(parameterized.TestCase):\n\n @parameterized.parameters(p for p in params)\n def test_fdp_conversion(self, sigma):\n max_diff = _fdp_conversion(sigma)\n self.assertSequenceAlmostEqual(max_diff, np.zeros_like(max_diff), places=2)\n\n\nif __name__ == '__main__':\n absltest.main()\n\n"
] | [
[
"numpy.isinf",
"numpy.zeros_like"
]
] |
GautamV234/pyro | [
"d5474ebc6101b330bf9060a3731830d4b6a585d5"
] | [
"pyro/contrib/gp/models/gpr.py"
] | [
"# Copyright (c) 2017-2019 Uber Technologies, Inc.\n# SPDX-License-Identifier: Apache-2.0\n\nimport torch\nimport torch.distributions as torchdist\nfrom torch.distributions import constraints\n\nimport pyro\nimport pyro.distributions as dist\nfrom pyro.contrib.gp.models.model import GPModel\nfrom pyro.contrib.gp.util import conditional\nfrom pyro.nn.module import PyroParam, pyro_method\nfrom pyro.util import warn_if_nan\n\n\nclass GPRegression(GPModel):\n r\"\"\"\n Gaussian Process Regression model.\n\n The core of a Gaussian Process is a covariance function :math:`k` which governs\n the similarity between input points. Given :math:`k`, we can establish a\n distribution over functions :math:`f` by a multivarite normal distribution\n\n .. math:: p(f(X)) = \\mathcal{N}(0, k(X, X)),\n\n where :math:`X` is any set of input points and :math:`k(X, X)` is a covariance\n matrix whose entries are outputs :math:`k(x, z)` of :math:`k` over input pairs\n :math:`(x, z)`. This distribution is usually denoted by\n\n .. math:: f \\sim \\mathcal{GP}(0, k).\n\n .. note:: Generally, beside a covariance matrix :math:`k`, a Gaussian Process can\n also be specified by a mean function :math:`m` (which is a zero-value function\n by default). In that case, its distribution will be\n\n .. math:: p(f(X)) = \\mathcal{N}(m(X), k(X, X)).\n\n Given inputs :math:`X` and their noisy observations :math:`y`, the Gaussian Process\n Regression model takes the form\n\n .. math::\n f &\\sim \\mathcal{GP}(0, k(X, X)),\\\\\n y & \\sim f + \\epsilon,\n\n where :math:`\\epsilon` is Gaussian noise.\n\n .. note:: This model has :math:`\\mathcal{O}(N^3)` complexity for training,\n :math:`\\mathcal{O}(N^3)` complexity for testing. Here, :math:`N` is the number\n of train inputs.\n\n Reference:\n\n [1] `Gaussian Processes for Machine Learning`,\n Carl E. Rasmussen, Christopher K. I. Williams\n\n :param torch.Tensor X: A input data for training. Its first dimension is the number\n of data points.\n :param torch.Tensor y: An output data for training. Its last dimension is the\n number of data points.\n :param ~pyro.contrib.gp.kernels.kernel.Kernel kernel: A Pyro kernel object, which\n is the covariance function :math:`k`.\n :param torch.Tensor noise: Variance of Gaussian noise of this model.\n :param callable mean_function: An optional mean function :math:`m` of this Gaussian\n process. By default, we use zero mean.\n :param float jitter: A small positive term which is added into the diagonal part of\n a covariance matrix to help stablize its Cholesky decomposition.\n \"\"\"\n\n def __init__(self, X, y, kernel, noise=None, mean_function=None, jitter=1e-6):\n assert isinstance(\n X, torch.Tensor\n ), \"X needs to be a torch Tensor instead of a {}\".format(type(X))\n if y is not None:\n assert isinstance(\n y, torch.Tensor\n ), \"y needs to be a torch Tensor instead of a {}\".format(type(y))\n super().__init__(X, y, kernel, mean_function, jitter)\n\n noise = self.X.new_tensor(1.0) if noise is None else noise\n self.noise = PyroParam(noise, constraints.positive)\n\n @pyro_method\n def model(self):\n self.set_mode(\"model\")\n\n N = self.X.size(0)\n Kff = self.kernel(self.X)\n Kff.view(-1)[:: N + 1] += self.jitter + self.noise # add noise to diagonal\n Lff = torch.linalg.cholesky(Kff)\n\n zero_loc = self.X.new_zeros(self.X.size(0))\n f_loc = zero_loc + self.mean_function(self.X)\n if self.y is None:\n f_var = Lff.pow(2).sum(dim=-1)\n return f_loc, f_var\n else:\n return pyro.sample(\n self._pyro_get_fullname(\"y\"),\n dist.MultivariateNormal(f_loc, scale_tril=Lff)\n .expand_by(self.y.shape[:-1])\n .to_event(self.y.dim() - 1),\n obs=self.y,\n )\n\n @pyro_method\n def guide(self):\n self.set_mode(\"guide\")\n self._load_pyro_samples()\n\n def forward(self, Xnew, full_cov=False, noiseless=True):\n r\"\"\"\n Computes the mean and covariance matrix (or variance) of Gaussian Process\n posterior on a test input data :math:`X_{new}`:\n\n .. math:: p(f^* \\mid X_{new}, X, y, k, \\epsilon) = \\mathcal{N}(loc, cov).\n\n .. note:: The noise parameter ``noise`` (:math:`\\epsilon`) together with\n kernel's parameters have been learned from a training procedure (MCMC or\n SVI).\n\n :param torch.Tensor Xnew: A input data for testing. Note that\n ``Xnew.shape[1:]`` must be the same as ``self.X.shape[1:]``.\n :param bool full_cov: A flag to decide if we want to predict full covariance\n matrix or just variance.\n :param bool noiseless: A flag to decide if we want to include noise in the\n prediction output or not.\n :returns: loc and covariance matrix (or variance) of :math:`p(f^*(X_{new}))`\n :rtype: tuple(torch.Tensor, torch.Tensor)\n \"\"\"\n self._check_Xnew_shape(Xnew)\n self.set_mode(\"guide\")\n\n N = self.X.size(0)\n Kff = self.kernel(self.X).contiguous()\n Kff.view(-1)[:: N + 1] += self.jitter + self.noise # add noise to the diagonal\n Lff = torch.linalg.cholesky(Kff)\n\n y_residual = self.y - self.mean_function(self.X)\n loc, cov = conditional(\n Xnew,\n self.X,\n self.kernel,\n y_residual,\n None,\n Lff,\n full_cov,\n jitter=self.jitter,\n )\n\n if full_cov and not noiseless:\n M = Xnew.size(0)\n cov = cov.contiguous()\n cov.view(-1, M * M)[:, :: M + 1] += self.noise # add noise to the diagonal\n if not full_cov and not noiseless:\n cov = cov + self.noise\n\n return loc + self.mean_function(Xnew), cov\n\n def iter_sample(self, noiseless=True):\n r\"\"\"\n Iteratively constructs a sample from the Gaussian Process posterior.\n\n Recall that at test input points :math:`X_{new}`, the posterior is\n multivariate Gaussian distributed with mean and covariance matrix\n given by :func:`forward`.\n\n This method samples lazily from this multivariate Gaussian. The advantage\n of this approach is that later query points can depend upon earlier ones.\n Particularly useful when the querying is to be done by an optimisation\n routine.\n\n .. note:: The noise parameter ``noise`` (:math:`\\epsilon`) together with\n kernel's parameters have been learned from a training procedure (MCMC or\n SVI).\n\n :param bool noiseless: A flag to decide if we want to add sampling noise\n to the samples beyond the noise inherent in the GP posterior.\n :returns: sampler\n :rtype: function\n \"\"\"\n noise = self.noise.detach()\n X = self.X.clone().detach()\n y = self.y.clone().detach()\n N = X.size(0)\n Kff = self.kernel(X).contiguous()\n Kff.view(-1)[:: N + 1] += noise # add noise to the diagonal\n\n outside_vars = {\"X\": X, \"y\": y, \"N\": N, \"Kff\": Kff}\n\n def sample_next(xnew, outside_vars):\n \"\"\"Repeatedly samples from the Gaussian process posterior,\n conditioning on previously sampled values.\n \"\"\"\n warn_if_nan(xnew)\n\n # Variables from outer scope\n X, y, Kff = outside_vars[\"X\"], outside_vars[\"y\"], outside_vars[\"Kff\"]\n\n # Compute Cholesky decomposition of kernel matrix\n Lff = torch.linalg.cholesky(Kff)\n y_residual = y - self.mean_function(X)\n\n # Compute conditional mean and variance\n loc, cov = conditional(\n xnew, X, self.kernel, y_residual, None, Lff, False, jitter=self.jitter\n )\n if not noiseless:\n cov = cov + noise\n\n ynew = torchdist.Normal(\n loc + self.mean_function(xnew), cov.sqrt()\n ).rsample()\n\n # Update kernel matrix\n N = outside_vars[\"N\"]\n Kffnew = Kff.new_empty(N + 1, N + 1)\n Kffnew[:N, :N] = Kff\n cross = self.kernel(X, xnew).squeeze()\n end = self.kernel(xnew, xnew).squeeze()\n Kffnew[N, :N] = cross\n Kffnew[:N, N] = cross\n # No noise, just jitter for numerical stability\n Kffnew[N, N] = end + self.jitter\n # Heuristic to avoid adding degenerate points\n if Kffnew.logdet() > -15.0:\n outside_vars[\"Kff\"] = Kffnew\n outside_vars[\"N\"] += 1\n outside_vars[\"X\"] = torch.cat((X, xnew))\n outside_vars[\"y\"] = torch.cat((y, ynew))\n\n return ynew\n\n return lambda xnew: sample_next(xnew, outside_vars)\n"
] | [
[
"torch.cat",
"torch.linalg.cholesky"
]
] |
aphearin/c3dev | [
"d36d083c9eb688640670dbe066bf299777a78ba7"
] | [
"c3dev/galmocks/data_loaders/load_tng_data.py"
] | [
"\"\"\"\n\"\"\"\nfrom collections import OrderedDict\nimport numpy as np\nfrom halotools.utils import sliding_conditional_percentile\nfrom astropy.table import Table\nfrom ..utils.galprops import compute_lg_ssfr\n\n\nSANDY_SCRATCH_PATH = \"/global/cscratch1/sd/sihany/TNG300-1/output\"\nBEBOP = \"/lcrc/project/halotools/C3EMC/TNG300-1\"\nNERSC = \"/global/cfs/cdirs/desi/users/aphearin/C3EMC/TNG300-1\"\nTNG_LBOX = 205.0\n\n\ndef load_tng_subhalos(drn=NERSC, snapNum=55):\n import illustris_python as il\n\n subhalos = il.groupcat.loadSubhalos(drn, snapNum)\n return subhalos\n\n\ndef load_tng_host_halos(drn=NERSC, snapNum=55):\n import illustris_python as il\n\n host_halos = il.groupcat.loadHalos(drn, snapNum)\n return host_halos\n\n\ndef get_value_added_tng_data(subs, hosts):\n hosts[\"halo_id\"] = np.arange(len(hosts[\"GroupMass\"])).astype(int)\n\n host_keys_to_keep = [\"halo_id\", \"GroupFirstSub\", \"GroupPos\", \"GroupVel\"]\n tng_hosts = Table(OrderedDict([(key, hosts[key]) for key in host_keys_to_keep]))\n tng_hosts.rename_column(\"GroupPos\", \"pos\")\n tng_hosts.rename_column(\"GroupVel\", \"vel\")\n tng_hosts[\"logmh\"] = np.log10(hosts[\"GroupMass\"]) + 10\n tng_hosts[\"pos\"] = tng_hosts[\"pos\"] / 1000\n\n tng = Table()\n tng[\"host_halo_logmh\"] = tng_hosts[\"logmh\"][subs[\"SubhaloGrNr\"]]\n tng[\"host_halo_pos\"] = tng_hosts[\"pos\"][subs[\"SubhaloGrNr\"]]\n tng[\"host_halo_vel\"] = tng_hosts[\"vel\"][subs[\"SubhaloGrNr\"]]\n\n tng[\"subhalo_pos\"] = subs[\"SubhaloPos\"] / 1000\n tng[\"subhalo_vel\"] = subs[\"SubhaloVel\"]\n tng[\"subhalo_mass\"] = subs[\"SubhaloMass\"] * 1e10\n tng[\"subhalo_vmax\"] = subs[\"SubhaloVmax\"]\n tng[\"subhalo_vdisp\"] = subs[\"SubhaloVelDisp\"]\n\n tng[\"stellar_metallicity\"] = subs[\"SubhaloStarMetallicity\"]\n tng[\"subhalo_mgas\"] = subs[\"SubhaloMassType\"][:, 0] * 1e10\n tng[\"subhalo_dm\"] = subs[\"SubhaloMassType\"][:, 1] * 1e10\n tng[\"mstar\"] = subs[\"SubhaloMassType\"][:, 4] * 1e10\n tng[\"sfr\"] = subs[\"SubhaloSFR\"]\n tng[\"lgssfr\"] = compute_lg_ssfr(tng[\"mstar\"], tng[\"sfr\"])\n\n tng[\"host_halo_index\"] = subs[\"SubhaloGrNr\"]\n\n subhalo_id = np.arange(len(subs[\"SubhaloGrNr\"])).astype(int)\n subhalo_cen_id = subhalo_id[tng_hosts[\"GroupFirstSub\"]]\n tng[\"is_central\"] = subhalo_cen_id == subhalo_id\n\n # Broadcast properties of the central subhalo to each host\n tng_hosts[\"central_subhalo_vmax\"] = subs[\"SubhaloVmax\"][tng_hosts[\"GroupFirstSub\"]]\n tng_hosts[\"central_subhalo_vdisp\"] = subs[\"SubhaloVelDisp\"][\n tng_hosts[\"GroupFirstSub\"]\n ]\n\n # Broadcast properties of the central subhalo to each group member\n tng[\"host_halo_vmax\"] = tng_hosts[\"central_subhalo_vmax\"][subs[\"SubhaloGrNr\"]]\n tng[\"host_halo_vdisp\"] = tng_hosts[\"central_subhalo_vdisp\"][subs[\"SubhaloGrNr\"]]\n\n tng_hosts[\"p_vmax\"] = sliding_conditional_percentile(\n tng_hosts[\"logmh\"], tng_hosts[\"central_subhalo_vmax\"], 101\n )\n tng_hosts[\"p_vdisp\"] = sliding_conditional_percentile(\n tng_hosts[\"logmh\"], tng_hosts[\"central_subhalo_vdisp\"], 101\n )\n tng[\"host_halo_p_vmax\"] = tng_hosts[\"p_vmax\"][subs[\"SubhaloGrNr\"]]\n tng[\"host_halo_p_vdisp\"] = tng_hosts[\"p_vdisp\"][subs[\"SubhaloGrNr\"]]\n\n return tng, tng_hosts\n"
] | [
[
"numpy.log10"
]
] |
yurivict/incubator-mxnet | [
"3d38dbde744954854015919d4faf56ac1aea16de"
] | [
"python/mxnet/model.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\n# pylint: disable=fixme, invalid-name, too-many-arguments, too-many-locals, too-many-lines\n# pylint: disable=too-many-branches, too-many-statements\n\"\"\"MXNet model module\"\"\"\nfrom __future__ import absolute_import, print_function\n\nimport os\nimport time\nimport logging\nimport warnings\nfrom collections import namedtuple\nimport numpy as np\n\nfrom . import io\nfrom . import ndarray as nd\nfrom . import symbol as sym\nfrom . import optimizer as opt\nfrom . import metric\nfrom . import kvstore as kvs\nfrom .context import Context, cpu\nfrom .initializer import Uniform\nfrom .optimizer import get_updater\nfrom .executor_manager import DataParallelExecutorManager, _check_arguments, _load_data\nfrom .io import DataDesc\nfrom .base import mx_real_t\n\nBASE_ESTIMATOR = object\n\ntry:\n from sklearn.base import BaseEstimator\n BASE_ESTIMATOR = BaseEstimator\nexcept ImportError:\n SKLEARN_INSTALLED = False\n\n# Parameter to pass to batch_end_callback\nBatchEndParam = namedtuple('BatchEndParams',\n ['epoch',\n 'nbatch',\n 'eval_metric',\n 'locals'])\n\ndef _create_sparse_kvstore(kvstore):\n \"\"\"Create kvstore assuming some parameters' storage types are row_sparse.\n\n Parameters\n ----------\n kvstore : KVStore or str\n The kvstore.\n\n Returns\n -------\n kvstore : KVStore\n update_on_kvstore : bool. Always True.\n \"\"\"\n # always update on kvstore\n update_on_kvstore = True\n if isinstance(kvstore, kvs.KVStore):\n kv = kvstore\n elif isinstance(kvstore, str):\n kv = kvs.create(kvstore)\n else:\n raise TypeError(\"Cannot create '%s' KVStore with row_sparse parameters. \"\n \"The type must be KVStore or str.\" % kvstore)\n return (kv, update_on_kvstore)\n\ndef _create_kvstore(kvstore, num_device, arg_params):\n \"\"\"Create kvstore\n This function select and create a proper kvstore if given the kvstore type.\n\n Parameters\n ----------\n kvstore : KVStore or str\n The kvstore.\n num_device : int\n The number of devices\n arg_params : dict of str to `NDArray`.\n Model parameter, dict of name to `NDArray` of net's weights.\n \"\"\"\n update_on_kvstore = bool(int(os.getenv('MXNET_UPDATE_ON_KVSTORE', \"1\")))\n if kvstore is None:\n kv = None\n elif isinstance(kvstore, kvs.KVStore):\n kv = kvstore\n elif isinstance(kvstore, str):\n # create kvstore using the string type\n if num_device == 1 and 'dist' not in kvstore:\n # no need to use kv for single device and single machine\n kv = None\n else:\n kv = kvs.create(kvstore)\n if kvstore == 'local':\n # automatically select a proper local\n max_size = max(np.prod(param.shape) for param in\n arg_params.values())\n if max_size > 1024 * 1024 * 16:\n update_on_kvstore = False\n else:\n raise TypeError('kvstore must be KVStore, str or None')\n\n if kv is None:\n update_on_kvstore = False\n\n return (kv, update_on_kvstore)\n\ndef _initialize_kvstore(kvstore, param_arrays, arg_params, param_names, update_on_kvstore):\n \"\"\"Initialize kvstore\"\"\"\n for idx, param_on_devs in enumerate(param_arrays):\n name = param_names[idx]\n kvstore.init(name, arg_params[name])\n\n if update_on_kvstore:\n kvstore.pull(name, param_on_devs, priority=-idx)\n\ndef _update_params_on_kvstore_nccl(param_arrays, grad_arrays, kvstore, param_names):\n \"\"\"Perform update of param_arrays from grad_arrays on NCCL kvstore.\"\"\"\n valid_indices = [index for index, grad_list in\n enumerate(grad_arrays) if grad_list[0] is not None]\n valid_grad_arrays = [grad_arrays[i] for i in valid_indices]\n valid_param_arrays = [param_arrays[i] for i in valid_indices]\n valid_param_names = [param_names[i] for i in valid_indices]\n size = len(valid_grad_arrays)\n start = 0\n # Use aggregation by default only with NCCL\n default_batch = '16'\n batch = int(os.getenv('MXNET_UPDATE_AGGREGATION_SIZE', default_batch))\n while start < size:\n end = start + batch if start + batch < size else size\n # push gradient, priority is negative index\n kvstore.push(valid_param_names[start:end], valid_grad_arrays[start:end], priority=-start)\n # pull back the weights\n kvstore.pull(valid_param_names[start:end], valid_param_arrays[start:end], priority=-start)\n start = end\n\ndef _update_params_on_kvstore(param_arrays, grad_arrays, kvstore, param_names):\n \"\"\"Perform update of param_arrays from grad_arrays on kvstore.\"\"\"\n for index, pair in enumerate(zip(param_arrays, grad_arrays)):\n arg_list, grad_list = pair\n if grad_list[0] is None:\n continue\n name = param_names[index]\n # push gradient, priority is negative index\n kvstore.push(name, grad_list, priority=-index)\n # pull back the weights\n kvstore.pull(name, arg_list, priority=-index)\n\ndef _update_params(param_arrays, grad_arrays, updater, num_device,\n kvstore=None, param_names=None):\n \"\"\"Perform update of param_arrays from grad_arrays not on kvstore.\"\"\"\n updates = [[] for _ in range(num_device)]\n for i, pair in enumerate(zip(param_arrays, grad_arrays)):\n arg_list, grad_list = pair\n if grad_list[0] is None:\n continue\n index = i\n if kvstore:\n name = param_names[index]\n # push gradient, priority is negative index\n kvstore.push(name, grad_list, priority=-index)\n # pull back the sum gradients, to the same locations.\n kvstore.pull(name, grad_list, priority=-index)\n for k, p in enumerate(zip(arg_list, grad_list)):\n # faked an index here, to make optimizer create diff\n # state for the same index but on diff devs, TODO(mli)\n # use a better solution later\n w, g = p\n updates[k].append((index*num_device+k, g, w))\n for dev_updates in updates:\n # update params if param_arrays and grad_arrays are not empty\n if dev_updates:\n i, w, g = zip(*dev_updates)\n updater(i, w, g)\n\n\ndef _multiple_callbacks(callbacks, *args, **kwargs):\n \"\"\"Sends args and kwargs to any configured callbacks.\n This handles the cases where the 'callbacks' variable\n is ``None``, a single function, or a list.\n \"\"\"\n if isinstance(callbacks, list):\n for cb in callbacks:\n cb(*args, **kwargs)\n return\n if callbacks:\n callbacks(*args, **kwargs)\n\n\ndef _train_multi_device(symbol, ctx, arg_names, param_names, aux_names,\n arg_params, aux_params,\n begin_epoch, end_epoch, epoch_size, optimizer,\n kvstore, update_on_kvstore,\n train_data, eval_data=None, eval_metric=None,\n epoch_end_callback=None, batch_end_callback=None,\n logger=None, work_load_list=None, monitor=None,\n eval_end_callback=None,\n eval_batch_end_callback=None, sym_gen=None):\n \"\"\"Internal training function on multiple devices.\n This function will also work for single device as well.\n\n Parameters\n ----------\n symbol : Symbol\n The network configuration.\n ctx : list of Context\n The training devices.\n arg_names: list of str\n Name of all arguments of the network.\n param_names: list of str\n Name of all trainable parameters of the network.\n aux_names: list of str\n Name of all auxiliary states of the network.\n arg_params : dict of str to NDArray\n Model parameter, dict of name to NDArray of net's weights.\n aux_params : dict of str to NDArray\n Model parameter, dict of name to NDArray of net's auxiliary states.\n begin_epoch : int\n The begining training epoch.\n end_epoch : int\n The end training epoch.\n epoch_size : int, optional\n Number of batches in a epoch. In default, it is set to\n ``ceil(num_train_examples / batch_size)``.\n optimizer : Optimizer\n The optimization algorithm\n train_data : DataIter\n Training data iterator.\n eval_data : DataIter\n Validation data iterator.\n eval_metric : EvalMetric\n An evaluation function or a list of evaluation functions.\n epoch_end_callback : callable(epoch, symbol, arg_params, aux_states)\n A callback that is invoked at end of each epoch.\n This can be used to checkpoint model each epoch.\n batch_end_callback : callable(BatchEndParams)\n A callback that is invoked at end of each batch.\n This can be used to measure speed, get result from evaluation metric. etc.\n kvstore : KVStore\n The KVStore.\n update_on_kvstore : bool\n Whether or not perform weight updating on kvstore.\n logger : logging logger\n When not specified, default logger will be used.\n work_load_list : list of float or int, optional\n The list of work load for different devices,\n in the same order as ``ctx``.\n monitor : Monitor, optional\n Monitor installed to executor,\n for monitoring outputs, weights, and gradients for debugging.\n Notes\n -----\n - This function will inplace update the NDArrays in `arg_params` and `aux_states`.\n \"\"\"\n if logger is None:\n logger = logging\n executor_manager = DataParallelExecutorManager(symbol=symbol,\n sym_gen=sym_gen,\n ctx=ctx,\n train_data=train_data,\n param_names=param_names,\n arg_names=arg_names,\n aux_names=aux_names,\n work_load_list=work_load_list,\n logger=logger)\n if monitor:\n executor_manager.install_monitor(monitor)\n\n executor_manager.set_params(arg_params, aux_params)\n\n if not update_on_kvstore:\n updater = get_updater(optimizer)\n else:\n kvstore.set_optimizer(optimizer)\n\n if kvstore:\n _initialize_kvstore(kvstore=kvstore,\n param_arrays=executor_manager.param_arrays,\n arg_params=arg_params,\n param_names=executor_manager.param_names,\n update_on_kvstore=update_on_kvstore)\n\n # Now start training\n train_data.reset()\n for epoch in range(begin_epoch, end_epoch):\n # Training phase\n tic = time.time()\n eval_metric.reset()\n nbatch = 0\n # Iterate over training data.\n while True:\n do_reset = True\n for data_batch in train_data:\n executor_manager.load_data_batch(data_batch)\n\n if monitor is not None:\n monitor.tic()\n\n executor_manager.forward(is_train=True)\n executor_manager.backward()\n\n if update_on_kvstore:\n if 'nccl' in kvstore.type:\n _update_params_on_kvstore_nccl(executor_manager.param_arrays,\n executor_manager.grad_arrays,\n kvstore, executor_manager.param_names)\n else:\n _update_params_on_kvstore(executor_manager.param_arrays,\n executor_manager.grad_arrays,\n kvstore, executor_manager.param_names)\n else:\n _update_params(executor_manager.param_arrays,\n executor_manager.grad_arrays,\n updater=updater,\n num_device=len(ctx),\n kvstore=kvstore,\n param_names=executor_manager.param_names)\n\n if monitor is not None:\n monitor.toc_print()\n\n # evaluate at end, so we can lazy copy\n executor_manager.update_metric(eval_metric, data_batch.label)\n\n nbatch += 1\n # batch callback (for print purpose)\n if batch_end_callback is not None:\n batch_end_params = BatchEndParam(epoch=epoch,\n nbatch=nbatch,\n eval_metric=eval_metric,\n locals=locals())\n _multiple_callbacks(batch_end_callback, batch_end_params)\n\n # this epoch is done possibly earlier\n if epoch_size is not None and nbatch >= epoch_size:\n do_reset = False\n break\n\n if do_reset:\n logger.info('Epoch[%d] Resetting Data Iterator', epoch)\n train_data.reset()\n\n # this epoch is done\n if epoch_size is None or nbatch >= epoch_size:\n break\n\n toc = time.time()\n logger.info('Epoch[%d] Time cost=%.3f', epoch, (toc - tic))\n\n if epoch_end_callback or epoch + 1 == end_epoch:\n executor_manager.copy_to(arg_params, aux_params)\n\n _multiple_callbacks(epoch_end_callback, epoch, symbol, arg_params, aux_params)\n\n # evaluation\n if eval_data:\n eval_metric.reset()\n eval_data.reset()\n total_num_batch = 0\n for i, eval_batch in enumerate(eval_data):\n executor_manager.load_data_batch(eval_batch)\n executor_manager.forward(is_train=False)\n executor_manager.update_metric(eval_metric, eval_batch.label)\n if eval_batch_end_callback is not None:\n batch_end_params = BatchEndParam(epoch=epoch,\n nbatch=i,\n eval_metric=eval_metric,\n locals=locals())\n _multiple_callbacks(eval_batch_end_callback, batch_end_params)\n total_num_batch += 1\n if eval_end_callback is not None:\n eval_end_params = BatchEndParam(epoch=epoch,\n nbatch=total_num_batch,\n eval_metric=eval_metric,\n locals=locals())\n _multiple_callbacks(eval_end_callback, eval_end_params)\n eval_data.reset()\n # end of all epochs\n\n\ndef save_checkpoint(prefix, epoch, symbol, arg_params, aux_params, remove_amp_cast=True):\n \"\"\"Checkpoint the model data into file.\n\n Parameters\n ----------\n prefix : str\n Prefix of model name.\n epoch : int\n The epoch number of the model.\n symbol : Symbol\n The input Symbol.\n arg_params : dict of str to NDArray\n Model parameter, dict of name to NDArray of net's weights.\n aux_params : dict of str to NDArray\n Model parameter, dict of name to NDArray of net's auxiliary states.\n remove_amp_cast : bool, optional\n Whether to remove the amp_cast and amp_multicast operators, before saving the model.\n Notes\n -----\n - ``prefix-symbol.json`` will be saved for symbol.\n - ``prefix-epoch.params`` will be saved for parameters.\n \"\"\"\n if symbol is not None:\n symbol.save('%s-symbol.json' % prefix, remove_amp_cast=remove_amp_cast)\n\n save_dict = {('arg:%s' % k) : v.as_in_context(cpu()) for k, v in arg_params.items()}\n save_dict.update({('aux:%s' % k) : v.as_in_context(cpu()) for k, v in aux_params.items()})\n param_name = '%s-%04d.params' % (prefix, epoch)\n nd.save(param_name, save_dict)\n logging.info('Saved checkpoint to \\\"%s\\\"', param_name)\n\n\ndef load_params(prefix, epoch):\n \"\"\"Load params from a file\n \"\"\"\n save_dict = nd.load(\"%s-%04d.params\" % (prefix, epoch))\n arg_params = {}\n aux_params = {}\n if not save_dict:\n logging.warning(\"Params file '%s' is empty\", '%s-%04d.params' % (prefix, epoch))\n return (arg_params, aux_params)\n for k, v in save_dict.items():\n tp, name = k.split(\":\", 1)\n if tp == \"arg\":\n arg_params[name] = v\n if tp == \"aux\":\n aux_params[name] = v\n return (arg_params, aux_params)\n\ndef load_checkpoint(prefix, epoch):\n \"\"\"Load model checkpoint from file.\n\n Parameters\n ----------\n prefix : str\n Prefix of model name.\n epoch : int\n Epoch number of model we would like to load.\n\n Returns\n -------\n symbol : Symbol\n The symbol configuration of computation network.\n arg_params : dict of str to NDArray\n Model parameter, dict of name to NDArray of net's weights.\n aux_params : dict of str to NDArray\n Model parameter, dict of name to NDArray of net's auxiliary states.\n\n Notes\n -----\n - Symbol will be loaded from ``prefix-symbol.json``.\n - Parameters will be loaded from ``prefix-epoch.params``.\n \"\"\"\n symbol = sym.load('%s-symbol.json' % prefix)\n arg_params, aux_params = load_params(prefix, epoch)\n return (symbol, arg_params, aux_params)\n\nfrom .callback import LogValidationMetricsCallback # pylint: disable=wrong-import-position\n\nclass FeedForward(BASE_ESTIMATOR):\n \"\"\"Model class of MXNet for training and predicting feedforward nets.\n This class is designed for a single-data single output supervised network.\n\n Parameters\n ----------\n symbol : Symbol\n The symbol configuration of computation network.\n ctx : Context or list of Context, optional\n The device context of training and prediction.\n To use multi GPU training, pass in a list of gpu contexts.\n num_epoch : int, optional\n Training parameter, number of training epochs(epochs).\n epoch_size : int, optional\n Number of batches in a epoch. In default, it is set to\n ``ceil(num_train_examples / batch_size)``.\n optimizer : str or Optimizer, optional\n Training parameter, name or optimizer object for training.\n initializer : initializer function, optional\n Training parameter, the initialization scheme used.\n numpy_batch_size : int, optional\n The batch size of training data.\n Only needed when input array is numpy.\n arg_params : dict of str to NDArray, optional\n Model parameter, dict of name to NDArray of net's weights.\n aux_params : dict of str to NDArray, optional\n Model parameter, dict of name to NDArray of net's auxiliary states.\n allow_extra_params : boolean, optional\n Whether allow extra parameters that are not needed by symbol\n to be passed by aux_params and ``arg_params``.\n If this is True, no error will be thrown when ``aux_params`` and ``arg_params``\n contain more parameters than needed.\n begin_epoch : int, optional\n The begining training epoch.\n kwargs : dict\n The additional keyword arguments passed to optimizer.\n \"\"\"\n def __init__(self, symbol, ctx=None,\n num_epoch=None, epoch_size=None, optimizer='sgd',\n initializer=Uniform(0.01),\n numpy_batch_size=128,\n arg_params=None, aux_params=None,\n allow_extra_params=False,\n begin_epoch=0,\n **kwargs):\n warnings.warn(\n '\\033[91mmxnet.model.FeedForward has been deprecated. ' + \\\n 'Please use mxnet.mod.Module instead.\\033[0m',\n DeprecationWarning, stacklevel=2)\n\n if isinstance(symbol, sym.Symbol):\n self.symbol = symbol\n self.sym_gen = None\n else:\n assert(callable(symbol))\n self.symbol = None\n self.sym_gen = symbol\n\n # model parameters\n self.arg_params = arg_params\n self.aux_params = aux_params\n self.allow_extra_params = allow_extra_params\n\n self.argument_checked = False\n if self.sym_gen is None:\n self._check_arguments()\n\n # basic configuration\n if ctx is None:\n ctx = [cpu()]\n elif isinstance(ctx, Context):\n ctx = [ctx]\n self.ctx = ctx\n # training parameters\n self.num_epoch = num_epoch\n self.epoch_size = epoch_size\n self.kwargs = kwargs.copy()\n self.optimizer = optimizer\n self.initializer = initializer\n self.numpy_batch_size = numpy_batch_size\n # internal helper state\n self._pred_exec = None\n self.begin_epoch = begin_epoch\n\n def _check_arguments(self):\n \"\"\"verify the argument of the default symbol and user provided parameters\"\"\"\n if self.argument_checked:\n return\n\n assert(self.symbol is not None)\n self.argument_checked = True\n\n # check if symbol contain duplicated names.\n _check_arguments(self.symbol)\n # rematch parameters to delete useless ones\n if self.allow_extra_params:\n if self.arg_params:\n arg_names = set(self.symbol.list_arguments())\n self.arg_params = {k : v for k, v in self.arg_params.items()\n if k in arg_names}\n if self.aux_params:\n aux_names = set(self.symbol.list_auxiliary_states())\n self.aux_params = {k : v for k, v in self.aux_params.items()\n if k in aux_names}\n\n\n @staticmethod\n def _is_data_arg(name):\n \"\"\"Check if name is a data argument.\"\"\"\n return name.endswith('data') or name.endswith('label')\n\n def _init_params(self, inputs, overwrite=False):\n \"\"\"Initialize weight parameters and auxiliary states.\"\"\"\n inputs = [x if isinstance(x, DataDesc) else DataDesc(*x) for x in inputs]\n input_shapes = {item.name: item.shape for item in inputs}\n arg_shapes, _, aux_shapes = self.symbol.infer_shape(**input_shapes)\n assert arg_shapes is not None\n input_dtypes = {item.name: item.dtype for item in inputs}\n arg_dtypes, _, aux_dtypes = self.symbol.infer_type(**input_dtypes)\n assert arg_dtypes is not None\n\n arg_names = self.symbol.list_arguments()\n input_names = input_shapes.keys()\n param_names = [key for key in arg_names if key not in input_names]\n aux_names = self.symbol.list_auxiliary_states()\n\n param_name_attrs = [x for x in zip(arg_names, arg_shapes, arg_dtypes)\n if x[0] in param_names]\n arg_params = {k : nd.zeros(shape=s, dtype=t)\n for k, s, t in param_name_attrs}\n aux_name_attrs = [x for x in zip(aux_names, aux_shapes, aux_dtypes)\n if x[0] in aux_names]\n aux_params = {k : nd.zeros(shape=s, dtype=t)\n for k, s, t in aux_name_attrs}\n\n for k, v in arg_params.items():\n if self.arg_params and k in self.arg_params and (not overwrite):\n arg_params[k][:] = self.arg_params[k][:]\n else:\n self.initializer(k, v)\n\n for k, v in aux_params.items():\n if self.aux_params and k in self.aux_params and (not overwrite):\n aux_params[k][:] = self.aux_params[k][:]\n else:\n self.initializer(k, v)\n\n self.arg_params = arg_params\n self.aux_params = aux_params\n return (arg_names, list(param_names), aux_names)\n\n def __getstate__(self):\n this = self.__dict__.copy()\n this['_pred_exec'] = None\n return this\n\n def __setstate__(self, state):\n self.__dict__.update(state)\n\n def _init_predictor(self, input_shapes, type_dict=None):\n \"\"\"Initialize the predictor module for running prediction.\"\"\"\n shapes = {name: self.arg_params[name].shape for name in self.arg_params}\n shapes.update(dict(input_shapes))\n if self._pred_exec is not None:\n arg_shapes, _, _ = self.symbol.infer_shape(**shapes)\n assert arg_shapes is not None, \"Incomplete input shapes\"\n pred_shapes = [x.shape for x in self._pred_exec.arg_arrays]\n if arg_shapes == pred_shapes:\n return\n # for now only use the first device\n pred_exec = self.symbol.simple_bind(\n self.ctx[0], grad_req='null', type_dict=type_dict, **shapes)\n pred_exec.copy_params_from(self.arg_params, self.aux_params)\n\n _check_arguments(self.symbol)\n self._pred_exec = pred_exec\n\n def _init_iter(self, X, y, is_train):\n \"\"\"Initialize the iterator given input.\"\"\"\n if isinstance(X, (np.ndarray, nd.NDArray)):\n if y is None:\n if is_train:\n raise ValueError('y must be specified when X is numpy.ndarray')\n y = np.zeros(X.shape[0])\n if not isinstance(y, (np.ndarray, nd.NDArray)):\n raise TypeError('y must be ndarray when X is numpy.ndarray')\n if X.shape[0] != y.shape[0]:\n raise ValueError(\"The numbers of data points and labels not equal\")\n if y.ndim == 2 and y.shape[1] == 1:\n y = y.flatten()\n if y.ndim != 1:\n raise ValueError(\"Label must be 1D or 2D (with 2nd dimension being 1)\")\n if is_train:\n return io.NDArrayIter(X, y, min(X.shape[0], self.numpy_batch_size),\n shuffle=is_train, last_batch_handle='roll_over')\n else:\n return io.NDArrayIter(X, y, min(X.shape[0], self.numpy_batch_size), shuffle=False)\n if not isinstance(X, io.DataIter):\n raise TypeError('X must be DataIter, NDArray or numpy.ndarray')\n return X\n\n def _init_eval_iter(self, eval_data):\n \"\"\"Initialize the iterator given eval_data.\"\"\"\n if eval_data is None:\n return eval_data\n if isinstance(eval_data, (tuple, list)) and len(eval_data) == 2:\n if eval_data[0] is not None:\n if eval_data[1] is None and isinstance(eval_data[0], io.DataIter):\n return eval_data[0]\n input_data = (np.array(eval_data[0]) if isinstance(eval_data[0], list)\n else eval_data[0])\n input_label = (np.array(eval_data[1]) if isinstance(eval_data[1], list)\n else eval_data[1])\n return self._init_iter(input_data, input_label, is_train=True)\n else:\n raise ValueError(\"Eval data is NONE\")\n if not isinstance(eval_data, io.DataIter):\n raise TypeError('Eval data must be DataIter, or ' \\\n 'NDArray/numpy.ndarray/list pair (i.e. tuple/list of length 2)')\n return eval_data\n\n def predict(self, X, num_batch=None, return_data=False, reset=True):\n \"\"\"Run the prediction, always only use one device.\n\n Parameters\n ----------\n X : mxnet.DataIter\n num_batch : int or None\n The number of batch to run. Go though all batches if ``None``.\n Returns\n -------\n y : numpy.ndarray or a list of numpy.ndarray if the network has multiple outputs.\n The predicted value of the output.\n \"\"\"\n X = self._init_iter(X, None, is_train=False)\n\n if reset:\n X.reset()\n data_shapes = X.provide_data\n data_names = [x[0] for x in data_shapes]\n type_dict = dict((key, value.dtype) for (key, value) in self.arg_params.items())\n for x in X.provide_data:\n if isinstance(x, DataDesc):\n type_dict[x.name] = x.dtype\n else:\n type_dict[x[0]] = mx_real_t\n\n self._init_predictor(data_shapes, type_dict)\n batch_size = X.batch_size\n data_arrays = [self._pred_exec.arg_dict[name] for name in data_names]\n output_list = [[] for _ in range(len(self._pred_exec.outputs))]\n if return_data:\n data_list = [[] for _ in X.provide_data]\n label_list = [[] for _ in X.provide_label]\n\n i = 0\n for batch in X:\n\n _load_data(batch, data_arrays)\n self._pred_exec.forward(is_train=False)\n padded = batch.pad\n real_size = batch_size - padded\n\n for o_list, o_nd in zip(output_list, self._pred_exec.outputs):\n o_list.append(o_nd[0:real_size].asnumpy())\n\n if return_data:\n for j, x in enumerate(batch.data):\n data_list[j].append(x[0:real_size].asnumpy())\n for j, x in enumerate(batch.label):\n label_list[j].append(x[0:real_size].asnumpy())\n i += 1\n if num_batch is not None and i == num_batch:\n break\n\n outputs = [np.concatenate(x) for x in output_list]\n if len(outputs) == 1:\n outputs = outputs[0]\n\n if return_data:\n data = [np.concatenate(x) for x in data_list]\n label = [np.concatenate(x) for x in label_list]\n if len(data) == 1:\n data = data[0]\n if len(label) == 1:\n label = label[0]\n return outputs, data, label\n else:\n return outputs\n\n def score(self, X, eval_metric='acc', num_batch=None, batch_end_callback=None, reset=True):\n \"\"\"Run the model given an input and calculate the score\n as assessed by an evaluation metric.\n\n Parameters\n ----------\n X : mxnet.DataIter\n eval_metric : metric.metric\n The metric for calculating score.\n num_batch : int or None\n The number of batches to run. Go though all batches if ``None``.\n Returns\n -------\n s : float\n The final score.\n \"\"\"\n # setup metric\n if not isinstance(eval_metric, metric.EvalMetric):\n eval_metric = metric.create(eval_metric)\n\n X = self._init_iter(X, None, is_train=False)\n if reset:\n X.reset()\n\n data_shapes = X.provide_data\n data_names = [x[0] for x in data_shapes]\n type_dict = dict((key, value.dtype) for (key, value) in self.arg_params.items())\n for x in X.provide_data:\n if isinstance(x, DataDesc):\n type_dict[x.name] = x.dtype\n else:\n type_dict[x[0]] = mx_real_t\n\n self._init_predictor(data_shapes, type_dict)\n data_arrays = [self._pred_exec.arg_dict[name] for name in data_names]\n\n for i, batch in enumerate(X):\n if num_batch is not None and i == num_batch:\n break\n _load_data(batch, data_arrays)\n self._pred_exec.forward(is_train=False)\n eval_metric.update(batch.label, self._pred_exec.outputs)\n\n if batch_end_callback is not None:\n batch_end_params = BatchEndParam(epoch=0,\n nbatch=i,\n eval_metric=eval_metric,\n locals=locals())\n _multiple_callbacks(batch_end_callback, batch_end_params)\n return eval_metric.get()[1]\n\n def fit(self, X, y=None, eval_data=None, eval_metric='acc',\n epoch_end_callback=None, batch_end_callback=None, kvstore='local', logger=None,\n work_load_list=None, monitor=None, eval_end_callback=LogValidationMetricsCallback(),\n eval_batch_end_callback=None):\n \"\"\"Fit the model.\n\n Parameters\n ----------\n X : DataIter, or numpy.ndarray/NDArray\n Training data. If `X` is a `DataIter`, the name or (if name not available)\n the position of its outputs should match the corresponding variable\n names defined in the symbolic graph.\n y : numpy.ndarray/NDArray, optional\n Training set label.\n If X is ``numpy.ndarray`` or `NDArray`, `y` is required to be set.\n While y can be 1D or 2D (with 2nd dimension as 1), its first dimension must be\n the same as `X`, i.e. the number of data points and labels should be equal.\n eval_data : DataIter or numpy.ndarray/list/NDArray pair\n If eval_data is numpy.ndarray/list/NDArray pair,\n it should be ``(valid_data, valid_label)``.\n eval_metric : metric.EvalMetric or str or callable\n The evaluation metric. This could be the name of evaluation metric\n or a custom evaluation function that returns statistics\n based on a minibatch.\n epoch_end_callback : callable(epoch, symbol, arg_params, aux_states)\n A callback that is invoked at end of each epoch.\n This can be used to checkpoint model each epoch.\n batch_end_callback: callable(epoch)\n A callback that is invoked at end of each batch for purposes of printing.\n kvstore: KVStore or str, optional\n The KVStore or a string kvstore type: 'local', 'dist_sync', 'dist_async'\n In default uses 'local', often no need to change for single machiine.\n logger : logging logger, optional\n When not specified, default logger will be used.\n work_load_list : float or int, optional\n The list of work load for different devices,\n in the same order as `ctx`.\n\n Note\n ----\n KVStore behavior\n - 'local', multi-devices on a single machine, will automatically choose best type.\n - 'dist_sync', multiple machines communicating via BSP.\n - 'dist_async', multiple machines with asynchronous communication.\n \"\"\"\n\n data = self._init_iter(X, y, is_train=True)\n eval_data = self._init_eval_iter(eval_data)\n\n if self.sym_gen:\n self.symbol = self.sym_gen(data.default_bucket_key) # pylint: disable=no-member\n self._check_arguments()\n self.kwargs[\"sym\"] = self.symbol\n\n arg_names, param_names, aux_names = \\\n self._init_params(data.provide_data+data.provide_label)\n\n # setup metric\n if not isinstance(eval_metric, metric.EvalMetric):\n eval_metric = metric.create(eval_metric)\n\n # create kvstore\n (kvstore, update_on_kvstore) = _create_kvstore(\n kvstore, len(self.ctx), self.arg_params)\n\n param_idx2name = {}\n if update_on_kvstore:\n param_idx2name.update(enumerate(param_names))\n else:\n for i, n in enumerate(param_names):\n for k in range(len(self.ctx)):\n param_idx2name[i*len(self.ctx)+k] = n\n self.kwargs[\"param_idx2name\"] = param_idx2name\n\n # init optmizer\n if isinstance(self.optimizer, str):\n batch_size = data.batch_size\n if kvstore and 'dist' in kvstore.type and '_async' not in kvstore.type:\n batch_size *= kvstore.num_workers\n optimizer = opt.create(self.optimizer,\n rescale_grad=(1.0/batch_size),\n **(self.kwargs))\n elif isinstance(self.optimizer, opt.Optimizer):\n if not optimizer.idx2name:\n optimizer.idx2name = param_idx2name.copy()\n optimizer = self.optimizer\n\n # do training\n _train_multi_device(self.symbol, self.ctx, arg_names, param_names, aux_names,\n self.arg_params, self.aux_params,\n begin_epoch=self.begin_epoch, end_epoch=self.num_epoch,\n epoch_size=self.epoch_size,\n optimizer=optimizer,\n train_data=data, eval_data=eval_data,\n eval_metric=eval_metric,\n epoch_end_callback=epoch_end_callback,\n batch_end_callback=batch_end_callback,\n kvstore=kvstore, update_on_kvstore=update_on_kvstore,\n logger=logger, work_load_list=work_load_list, monitor=monitor,\n eval_end_callback=eval_end_callback,\n eval_batch_end_callback=eval_batch_end_callback,\n sym_gen=self.sym_gen)\n\n\n def save(self, prefix, epoch=None, remove_amp_cast=True):\n \"\"\"Checkpoint the model checkpoint into file.\n You can also use `pickle` to do the job if you only work on Python.\n The advantage of `load` and `save` (as compared to `pickle`) is that\n the resulting file can be loaded from other MXNet language bindings.\n One can also directly `load`/`save` from/to cloud storage(S3, HDFS)\n\n Parameters\n ----------\n prefix : str\n Prefix of model name.\n remove_amp_cast : bool, optional\n Whether to remove the amp_cast and amp_multicast operators, before saving the model.\n\n Notes\n -----\n - ``prefix-symbol.json`` will be saved for symbol.\n - ``prefix-epoch.params`` will be saved for parameters.\n \"\"\"\n if epoch is None:\n epoch = self.num_epoch\n assert epoch is not None\n save_checkpoint(prefix, epoch, self.symbol, self.arg_params, self.aux_params, remove_amp_cast=remove_amp_cast)\n\n @staticmethod\n def load(prefix, epoch, ctx=None, **kwargs):\n \"\"\"Load model checkpoint from file.\n\n Parameters\n ----------\n prefix : str\n Prefix of model name.\n epoch : int\n epoch number of model we would like to load.\n ctx : Context or list of Context, optional\n The device context of training and prediction.\n kwargs : dict\n Other parameters for model, including `num_epoch`, optimizer and `numpy_batch_size`.\n\n Returns\n -------\n model : FeedForward\n The loaded model that can be used for prediction.\n\n Notes\n -----\n - ``prefix-symbol.json`` will be saved for symbol.\n - ``prefix-epoch.params`` will be saved for parameters.\n \"\"\"\n symbol, arg_params, aux_params = load_checkpoint(prefix, epoch)\n return FeedForward(symbol, ctx=ctx,\n arg_params=arg_params, aux_params=aux_params,\n begin_epoch=epoch,\n **kwargs)\n\n @staticmethod\n def create(symbol, X, y=None, ctx=None,\n num_epoch=None, epoch_size=None, optimizer='sgd', initializer=Uniform(0.01),\n eval_data=None, eval_metric='acc',\n epoch_end_callback=None, batch_end_callback=None,\n kvstore='local', logger=None, work_load_list=None,\n eval_end_callback=LogValidationMetricsCallback(),\n eval_batch_end_callback=None, **kwargs):\n \"\"\"Functional style to create a model.\n This function is more consistent with functional\n languages such as R, where mutation is not allowed.\n\n Parameters\n ----------\n symbol : Symbol\n The symbol configuration of a computation network.\n X : DataIter\n Training data.\n y : numpy.ndarray, optional\n If `X` is a ``numpy.ndarray``, `y` must be set.\n ctx : Context or list of Context, optional\n The device context of training and prediction.\n To use multi-GPU training, pass in a list of GPU contexts.\n num_epoch : int, optional\n The number of training epochs(epochs).\n epoch_size : int, optional\n Number of batches in a epoch. In default, it is set to\n ``ceil(num_train_examples / batch_size)``.\n optimizer : str or Optimizer, optional\n The name of the chosen optimizer, or an optimizer object, used for training.\n initializer : initializer function, optional\n The initialization scheme used.\n eval_data : DataIter or numpy.ndarray pair\n If `eval_set` is ``numpy.ndarray`` pair, it should\n be (`valid_data`, `valid_label`).\n eval_metric : metric.EvalMetric or str or callable\n The evaluation metric. Can be the name of an evaluation metric\n or a custom evaluation function that returns statistics\n based on a minibatch.\n epoch_end_callback : callable(epoch, symbol, arg_params, aux_states)\n A callback that is invoked at end of each epoch.\n This can be used to checkpoint model each epoch.\n batch_end_callback: callable(epoch)\n A callback that is invoked at end of each batch for print purposes.\n kvstore: KVStore or str, optional\n The KVStore or a string kvstore type: 'local', 'dist_sync', 'dis_async'.\n Defaults to 'local', often no need to change for single machine.\n logger : logging logger, optional\n When not specified, default logger will be used.\n work_load_list : list of float or int, optional\n The list of work load for different devices,\n in the same order as `ctx`.\n \"\"\"\n model = FeedForward(symbol, ctx=ctx, num_epoch=num_epoch,\n epoch_size=epoch_size,\n optimizer=optimizer, initializer=initializer, **kwargs)\n model.fit(X, y, eval_data=eval_data, eval_metric=eval_metric,\n epoch_end_callback=epoch_end_callback,\n batch_end_callback=batch_end_callback,\n kvstore=kvstore,\n logger=logger,\n work_load_list=work_load_list,\n eval_end_callback=eval_end_callback,\n eval_batch_end_callback=eval_batch_end_callback)\n return model\n"
] | [
[
"numpy.concatenate",
"numpy.array",
"numpy.prod",
"numpy.zeros"
]
] |
feiwu77777/Face-detection-and-tracking | [
"1135d2d93d5b667110551dc7e4b985b5861eb380"
] | [
"eval_tiny_one_image.py"
] | [
"# -*- coding: utf-8 -*-\r\n\"\"\"\r\nCreated on Mon Dec 10 15:49:15 2018\r\n\r\n@author: fei.wu\r\n\"\"\"\r\n\r\n# -*- coding: utf-8 -*-\r\nfrom __future__ import absolute_import\r\nfrom __future__ import division\r\nfrom __future__ import print_function\r\n\r\nimport tensorflow as tf\r\nimport tiny_face_model\r\nimport util\r\nimport cv2\r\nimport numpy as np\r\nimport matplotlib.pyplot as plt\r\nimport pickle\r\nimport pylab as pl\r\nfrom scipy.special import expit\r\n\r\nMAX_INPUT_DIM = 5000.0\r\n\r\ndef overlay_bounding_boxes(raw_img, refined_bboxes, lw):\r\n \"\"\"Overlay bounding boxes of face on images.\r\n Args:\r\n raw_img:\r\n A target image.\r\n refined_bboxes:\r\n Bounding boxes of detected faces.\r\n lw: \r\n Line width of bounding boxes. If zero specified,\r\n this is determined based on confidence of each detection.\r\n Returns:\r\n None.\r\n \"\"\"\r\n\r\n # Overlay bounding boxes on an image with the color based on the confidence.\r\n for r in refined_bboxes:\r\n _score = expit(r[4])\r\n cm_idx = int(np.ceil(_score * 255))\r\n rect_color = [int(np.ceil(x * 255)) for x in util.cm_data[cm_idx]] # parula\r\n _lw = lw\r\n if lw == 0: # line width of each bounding box is adaptively determined.\r\n bw, bh = r[2] - r[0] + 1, r[3] - r[0] + 1\r\n _lw = 1 if min(bw, bh) <= 20 else max(2, min(3, min(bh / 20, bw / 20)))\r\n _lw = int(np.ceil(_lw * _score))\r\n\r\n _r = [int(x) for x in r[:4]]\r\n cv2.rectangle(raw_img, (_r[0], _r[1]), (_r[2], _r[3]), rect_color, _lw)\r\n\r\n\r\ndef evaluate(weight_file_path, frame, prob_thresh=0.5, nms_thresh=0.1, lw=3, display=False):\r\n \"\"\"Detect faces in images.\r\n Args:\r\n prob_thresh:\r\n The threshold of detection confidence.\r\n nms_thresh:\r\n The overlap threshold of non maximum suppression\r\n weight_file_path: \r\n A pretrained weight file in the pickle format \r\n generated by matconvnet_hr101_to_tf.py.\r\n data_dir: \r\n A directory which contains images.\r\n output_dir: \r\n A directory into which images with detected faces are output.\r\n lw: \r\n Line width of bounding boxes. If zero specified,\r\n this is determined based on confidence of each detection.\r\n display:\r\n Display tiny face images on window.\r\n Returns:\r\n None.\r\n \"\"\"\r\n\r\n # placeholder of input images. Currently batch size of one is supported.\r\n x = tf.placeholder(tf.float32, [1, None, None, 3]) # n, h, w, c\r\n\r\n # Create the tiny face model which weights are loaded from a pretrained model.\r\n model = tiny_face_model.Model(weight_file_path)\r\n score_final = model.tiny_face(x)\r\n\r\n # Load an average image and clusters(reference boxes of templates).\r\n with open(weight_file_path, \"rb\") as f:\r\n _, mat_params_dict = pickle.load(f)\r\n\r\n average_image = model.get_data_by_key(\"average_image\")\r\n clusters = model.get_data_by_key(\"clusters\")\r\n clusters_h = clusters[:, 3] - clusters[:, 1] + 1\r\n clusters_w = clusters[:, 2] - clusters[:, 0] + 1\r\n normal_idx = np.where(clusters[:, 4] == 1)\r\n\r\n # main\r\n with tf.Session() as sess:\r\n sess.run(tf.global_variables_initializer())\r\n raw_img = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\r\n raw_img_f = raw_img.astype(np.float32)\r\n \r\n def _calc_scales():\r\n raw_h, raw_w = raw_img.shape[0], raw_img.shape[1]\r\n min_scale = min(np.floor(np.log2(np.max(clusters_w[normal_idx] / raw_w))),\r\n np.floor(np.log2(np.max(clusters_h[normal_idx] / raw_h))))\r\n max_scale = min(1.0, -np.log2(max(raw_h, raw_w) / MAX_INPUT_DIM))\r\n scales_down = pl.frange(min_scale, 0, 1.)\r\n scales_up = pl.frange(0.5, max_scale, 0.5)\r\n scales_pow = np.hstack((scales_down, scales_up))\r\n scales = np.power(2.0, scales_pow)\r\n return scales\r\n \r\n scales = _calc_scales()\r\n\r\n # initialize output\r\n bboxes = np.empty(shape=(0, 5))\r\n \r\n # process input at different scales\r\n for s in scales:\r\n img = cv2.resize(raw_img_f, (0, 0), fx=s, fy=s, interpolation=cv2.INTER_LINEAR)\r\n img = img - average_image\r\n img = img[np.newaxis, :]\r\n \r\n # we don't run every template on every scale ids of templates to ignore\r\n tids = list(range(4, 12)) + ([] if s <= 1.0 else list(range(18, 25)))\r\n ignoredTids = list(set(range(0, clusters.shape[0])) - set(tids))\r\n \r\n # run through the net\r\n score_final_tf = sess.run(score_final, feed_dict={x: img})\r\n \r\n # collect scores\r\n score_cls_tf, score_reg_tf = score_final_tf[:, :, :, :25], score_final_tf[:, :, :, 25:125]\r\n prob_cls_tf = expit(score_cls_tf)\r\n prob_cls_tf[0, :, :, ignoredTids] = 0.0\r\n \r\n def _calc_bounding_boxes():\r\n # threshold for detection\r\n _, fy, fx, fc = np.where(prob_cls_tf > prob_thresh)\r\n \r\n # interpret heatmap into bounding boxes\r\n cy = fy * 8 - 1\r\n cx = fx * 8 - 1\r\n ch = clusters[fc, 3] - clusters[fc, 1] + 1\r\n cw = clusters[fc, 2] - clusters[fc, 0] + 1\r\n \r\n # extract bounding box refinement\r\n Nt = clusters.shape[0]\r\n tx = score_reg_tf[0, :, :, 0:Nt]\r\n ty = score_reg_tf[0, :, :, Nt:2*Nt]\r\n tw = score_reg_tf[0, :, :, 2*Nt:3*Nt]\r\n th = score_reg_tf[0, :, :, 3*Nt:4*Nt]\r\n \r\n # refine bounding boxes\r\n dcx = cw * tx[fy, fx, fc]\r\n dcy = ch * ty[fy, fx, fc]\r\n rcx = cx + dcx\r\n rcy = cy + dcy\r\n rcw = cw * np.exp(tw[fy, fx, fc])\r\n rch = ch * np.exp(th[fy, fx, fc])\r\n \r\n scores = score_cls_tf[0, fy, fx, fc]\r\n tmp_bboxes = np.vstack((rcx - rcw / 2, rcy - rch / 2, rcx + rcw / 2, rcy + rch / 2))\r\n tmp_bboxes = np.vstack((tmp_bboxes / s, scores))\r\n tmp_bboxes = tmp_bboxes.transpose()\r\n return tmp_bboxes\r\n \r\n tmp_bboxes = _calc_bounding_boxes()\r\n bboxes = np.vstack((bboxes, tmp_bboxes)) # <class 'tuple'>: (5265, 5) \r\n \r\n # non maximum suppression\r\n # refind_idx = util.nms(bboxes, nms_thresh)\r\n refind_idx = tf.image.non_max_suppression(tf.convert_to_tensor(bboxes[:, :4], dtype=tf.float32),\r\n tf.convert_to_tensor(bboxes[:, 4], dtype=tf.float32),\r\n max_output_size=bboxes.shape[0], iou_threshold=nms_thresh)\r\n refind_idx = sess.run(refind_idx)\r\n refined_bboxes = bboxes[refind_idx]\r\n overlay_bounding_boxes(raw_img, refined_bboxes, lw)\r\n if display:\r\n # plt.axis('off')\r\n plt.imshow(raw_img)\r\n plt.show() \r\n return refined_bboxes\r\n\r\n\r\ndef main(frame):\r\n print(\"Searching faces...\")\r\n with tf.Graph().as_default():\r\n faces = evaluate(\r\n weight_file_path= \"weights.pckl\", frame = frame,\r\n prob_thresh=0.7, nms_thresh=0.1, #non max suppression threshold,\r\n lw=2, display= False)\r\n return faces\r\n\r\n"
] | [
[
"numpy.max",
"numpy.ceil",
"tensorflow.convert_to_tensor",
"numpy.empty",
"tensorflow.Graph",
"tensorflow.Session",
"scipy.special.expit",
"numpy.exp",
"numpy.where",
"tensorflow.placeholder",
"numpy.power",
"matplotlib.pyplot.show",
"numpy.hstack",
"tensorflow.global_variables_initializer",
"numpy.vstack",
"matplotlib.pyplot.imshow"
]
] |
valanm22/pytorch-lightning | [
"5d190eabd28671a6222741f5dd9ee3f214e519b1",
"5d190eabd28671a6222741f5dd9ee3f214e519b1"
] | [
"pytorch_lightning/trainer/trainer.py",
"tests/deprecated_api/test_remove_1-8.py"
] | [
"# Copyright The PyTorch Lightning team.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\"\"\"Trainer to automate the training.\"\"\"\nimport inspect\nimport logging\nimport math\nimport os\nimport traceback\nimport warnings\nfrom argparse import ArgumentParser, Namespace\nfrom copy import deepcopy\nfrom datetime import timedelta\nfrom pathlib import Path\nfrom typing import Any, Callable, cast, Dict, Iterable, List, Optional, Tuple, Type, Union\nfrom weakref import proxy\n\nimport torch\nfrom packaging.version import Version\nfrom torch.optim import Optimizer\nfrom torch.utils.data import DataLoader\n\nimport pytorch_lightning as pl\nfrom pytorch_lightning.accelerators import Accelerator, GPUAccelerator, IPUAccelerator, TPUAccelerator\nfrom pytorch_lightning.callbacks import Callback, EarlyStopping, ModelCheckpoint, ProgressBarBase\nfrom pytorch_lightning.callbacks.prediction_writer import BasePredictionWriter\nfrom pytorch_lightning.core.datamodule import LightningDataModule\nfrom pytorch_lightning.core.optimizer import LightningOptimizer\nfrom pytorch_lightning.loggers import LightningLoggerBase\nfrom pytorch_lightning.loggers.base import DummyLogger, LoggerCollection\nfrom pytorch_lightning.loggers.tensorboard import TensorBoardLogger\nfrom pytorch_lightning.loops import PredictionLoop, TrainingEpochLoop\nfrom pytorch_lightning.loops.dataloader.evaluation_loop import EvaluationLoop\nfrom pytorch_lightning.loops.fit_loop import FitLoop\nfrom pytorch_lightning.loops.utilities import _parse_loop_limits, _reset_progress\nfrom pytorch_lightning.plugins import (\n ApexMixedPrecisionPlugin,\n NativeMixedPrecisionPlugin,\n PLUGIN_INPUT,\n PrecisionPlugin,\n)\nfrom pytorch_lightning.plugins.environments.slurm_environment import SLURMEnvironment\nfrom pytorch_lightning.profiler import (\n AdvancedProfiler,\n BaseProfiler,\n PassThroughProfiler,\n PyTorchProfiler,\n SimpleProfiler,\n XLAProfiler,\n)\nfrom pytorch_lightning.strategies import ParallelStrategy, Strategy\nfrom pytorch_lightning.strategies.ddp_spawn import DDPSpawnStrategy\nfrom pytorch_lightning.trainer.callback_hook import TrainerCallbackHookMixin\nfrom pytorch_lightning.trainer.configuration_validator import verify_loop_configurations\nfrom pytorch_lightning.trainer.connectors.accelerator_connector import AcceleratorConnector\nfrom pytorch_lightning.trainer.connectors.callback_connector import CallbackConnector\nfrom pytorch_lightning.trainer.connectors.checkpoint_connector import CheckpointConnector\nfrom pytorch_lightning.trainer.connectors.data_connector import DataConnector\nfrom pytorch_lightning.trainer.connectors.logger_connector import LoggerConnector\nfrom pytorch_lightning.trainer.connectors.logger_connector.result import _ResultCollection\nfrom pytorch_lightning.trainer.connectors.signal_connector import SignalConnector\nfrom pytorch_lightning.trainer.data_loading import TrainerDataLoadingMixin\nfrom pytorch_lightning.trainer.optimizers import TrainerOptimizersMixin\nfrom pytorch_lightning.trainer.states import RunningStage, TrainerFn, TrainerState, TrainerStatus\nfrom pytorch_lightning.trainer.supporters import CombinedLoader\nfrom pytorch_lightning.tuner.lr_finder import _LRFinder\nfrom pytorch_lightning.tuner.tuning import Tuner\nfrom pytorch_lightning.utilities import (\n _IPU_AVAILABLE,\n _TPU_AVAILABLE,\n AMPType,\n device_parser,\n GradClipAlgorithmType,\n parsing,\n)\nfrom pytorch_lightning.utilities.apply_func import apply_to_collection\nfrom pytorch_lightning.utilities.argparse import (\n _defaults_from_env_vars,\n add_argparse_args,\n from_argparse_args,\n parse_argparser,\n parse_env_variables,\n)\nfrom pytorch_lightning.utilities.auto_restart import _add_capture_metadata_collate\nfrom pytorch_lightning.utilities.cloud_io import get_filesystem\nfrom pytorch_lightning.utilities.data import _auto_add_worker_init_fn, has_len_all_ranks\nfrom pytorch_lightning.utilities.distributed import distributed_available\nfrom pytorch_lightning.utilities.exceptions import ExitGracefullyException, MisconfigurationException\nfrom pytorch_lightning.utilities.imports import _fault_tolerant_training\nfrom pytorch_lightning.utilities.meta import is_on_meta_device, materialize_module\nfrom pytorch_lightning.utilities.model_helpers import is_overridden\nfrom pytorch_lightning.utilities.rank_zero import rank_zero_deprecation, rank_zero_info, rank_zero_warn\nfrom pytorch_lightning.utilities.seed import isolate_rng\nfrom pytorch_lightning.utilities.signature_utils import is_param_in_hook_signature\nfrom pytorch_lightning.utilities.types import (\n _EVALUATE_OUTPUT,\n _PATH,\n _PREDICT_OUTPUT,\n EVAL_DATALOADERS,\n LRSchedulerConfig,\n STEP_OUTPUT,\n TRAIN_DATALOADERS,\n)\nfrom pytorch_lightning.utilities.warnings import PossibleUserWarning\n\nlog = logging.getLogger(__name__)\n# warnings to ignore in trainer\nwarnings.filterwarnings(\n \"ignore\", message=\"torch.distributed.reduce_op is deprecated, please use torch.distributed.ReduceOp instead\"\n)\n\n\nclass Trainer(\n TrainerCallbackHookMixin, # TODO: Remove in v1.8\n TrainerOptimizersMixin, # TODO: Remove in v1.8\n TrainerDataLoadingMixin, # TODO: Remove in v1.8\n):\n @_defaults_from_env_vars\n def __init__(\n self,\n logger: Union[LightningLoggerBase, Iterable[LightningLoggerBase], bool] = True,\n checkpoint_callback: Optional[bool] = None,\n enable_checkpointing: bool = True,\n callbacks: Optional[Union[List[Callback], Callback]] = None,\n default_root_dir: Optional[str] = None,\n gradient_clip_val: Optional[Union[int, float]] = None,\n gradient_clip_algorithm: Optional[str] = None,\n process_position: int = 0,\n num_nodes: int = 1,\n num_processes: Optional[int] = None,\n devices: Optional[Union[List[int], str, int]] = None,\n gpus: Optional[Union[List[int], str, int]] = None,\n auto_select_gpus: bool = False,\n tpu_cores: Optional[Union[List[int], str, int]] = None,\n ipus: Optional[int] = None,\n log_gpu_memory: Optional[str] = None, # TODO: Remove in 1.7\n progress_bar_refresh_rate: Optional[int] = None, # TODO: remove in v1.7\n enable_progress_bar: bool = True,\n overfit_batches: Union[int, float] = 0.0,\n track_grad_norm: Union[int, float, str] = -1,\n check_val_every_n_epoch: int = 1,\n fast_dev_run: Union[int, bool] = False,\n accumulate_grad_batches: Optional[Union[int, Dict[int, int]]] = None,\n max_epochs: Optional[int] = None,\n min_epochs: Optional[int] = None,\n max_steps: int = -1,\n min_steps: Optional[int] = None,\n max_time: Optional[Union[str, timedelta, Dict[str, int]]] = None,\n limit_train_batches: Optional[Union[int, float]] = None,\n limit_val_batches: Optional[Union[int, float]] = None,\n limit_test_batches: Optional[Union[int, float]] = None,\n limit_predict_batches: Optional[Union[int, float]] = None,\n val_check_interval: Optional[Union[int, float]] = None,\n flush_logs_every_n_steps: Optional[int] = None,\n log_every_n_steps: int = 50,\n accelerator: Optional[Union[str, Accelerator]] = None,\n strategy: Optional[Union[str, Strategy]] = None,\n sync_batchnorm: bool = False,\n precision: Union[int, str] = 32,\n enable_model_summary: bool = True,\n weights_summary: Optional[str] = \"top\",\n weights_save_path: Optional[str] = None, # TODO: Remove in 1.8\n num_sanity_val_steps: int = 2,\n resume_from_checkpoint: Optional[Union[Path, str]] = None,\n profiler: Optional[Union[BaseProfiler, str]] = None,\n benchmark: Optional[bool] = None,\n deterministic: bool = False,\n reload_dataloaders_every_n_epochs: int = 0,\n auto_lr_find: Union[bool, str] = False,\n replace_sampler_ddp: bool = True,\n detect_anomaly: bool = False,\n auto_scale_batch_size: Union[str, bool] = False,\n prepare_data_per_node: Optional[bool] = None,\n plugins: Optional[Union[PLUGIN_INPUT, List[PLUGIN_INPUT]]] = None,\n amp_backend: str = \"native\",\n amp_level: Optional[str] = None,\n move_metrics_to_cpu: bool = False,\n multiple_trainloader_mode: str = \"max_size_cycle\",\n stochastic_weight_avg: bool = False,\n terminate_on_nan: Optional[bool] = None,\n ) -> None:\n r\"\"\"\n Customize every aspect of training via flags.\n\n Args:\n\n accelerator: Supports passing different accelerator types (\"cpu\", \"gpu\", \"tpu\", \"ipu\", \"auto\")\n as well as custom accelerator instances.\n\n .. deprecated:: v1.5\n Passing training strategies (e.g., 'ddp') to ``accelerator`` has been deprecated in v1.5.0\n and will be removed in v1.7.0. Please use the ``strategy`` argument instead.\n\n accumulate_grad_batches: Accumulates grads every k batches or as set up in the dict.\n Default: ``None``.\n\n amp_backend: The mixed precision backend to use (\"native\" or \"apex\").\n Default: ``'native''``.\n\n amp_level: The optimization level to use (O1, O2, etc...). By default it will be set to \"O2\"\n if ``amp_backend`` is set to \"apex\".\n\n auto_lr_find: If set to True, will make trainer.tune() run a learning rate finder,\n trying to optimize initial learning for faster convergence. trainer.tune() method will\n set the suggested learning rate in self.lr or self.learning_rate in the LightningModule.\n To use a different key set a string instead of True with the key name.\n Default: ``False``.\n\n auto_scale_batch_size: If set to True, will `initially` run a batch size\n finder trying to find the largest batch size that fits into memory.\n The result will be stored in self.batch_size in the LightningModule.\n Additionally, can be set to either `power` that estimates the batch size through\n a power search or `binsearch` that estimates the batch size through a binary search.\n Default: ``False``.\n\n auto_select_gpus: If enabled and ``gpus`` is an integer, pick available\n gpus automatically. This is especially useful when\n GPUs are configured to be in \"exclusive mode\", such\n that only one process at a time can access them.\n Default: ``False``.\n\n benchmark: Sets ``torch.backends.cudnn.benchmark``.\n Defaults to ``True`` if :paramref:`~pytorch_lightning.trainer.trainer.Trainer.deterministic`\n is ``False``. Overwrite to manually set a different value. Default: ``None``.\n\n callbacks: Add a callback or list of callbacks.\n Default: ``None``.\n\n checkpoint_callback: If ``True``, enable checkpointing.\n Default: ``None``.\n\n .. deprecated:: v1.5\n ``checkpoint_callback`` has been deprecated in v1.5 and will be removed in v1.7.\n Please consider using ``enable_checkpointing`` instead.\n\n enable_checkpointing: If ``True``, enable checkpointing.\n It will configure a default ModelCheckpoint callback if there is no user-defined ModelCheckpoint in\n :paramref:`~pytorch_lightning.trainer.trainer.Trainer.callbacks`.\n Default: ``True``.\n\n check_val_every_n_epoch: Check val every n train epochs.\n Default: ``1``.\n\n\n default_root_dir: Default path for logs and weights when no logger/ckpt_callback passed.\n Default: ``os.getcwd()``.\n Can be remote file paths such as `s3://mybucket/path` or 'hdfs://path/'\n\n detect_anomaly: Enable anomaly detection for the autograd engine.\n Default: ``False``.\n\n deterministic: If ``True``, sets whether PyTorch operations must use deterministic algorithms.\n Default: ``False``.\n\n devices: Will be mapped to either `gpus`, `tpu_cores`, `num_processes` or `ipus`,\n based on the accelerator type.\n\n fast_dev_run: Runs n if set to ``n`` (int) else 1 if set to ``True`` batch(es)\n of train, val and test to find any bugs (ie: a sort of unit test).\n Default: ``False``.\n\n flush_logs_every_n_steps: How often to flush logs to disk (defaults to every 100 steps).\n\n .. deprecated:: v1.5\n ``flush_logs_every_n_steps`` has been deprecated in v1.5 and will be removed in v1.7.\n Please configure flushing directly in the logger instead.\n\n gpus: Number of GPUs to train on (int) or which GPUs to train on (list or str) applied per node\n Default: ``None``.\n\n gradient_clip_val: The value at which to clip gradients. Passing ``gradient_clip_val=None`` disables\n gradient clipping. If using Automatic Mixed Precision (AMP), the gradients will be unscaled before.\n Default: ``None``.\n\n gradient_clip_algorithm: The gradient clipping algorithm to use. Pass ``gradient_clip_algorithm=\"value\"``\n to clip by value, and ``gradient_clip_algorithm=\"norm\"`` to clip by norm. By default it will\n be set to ``\"norm\"``.\n\n limit_train_batches: How much of training dataset to check (float = fraction, int = num_batches).\n Default: ``1.0``.\n\n limit_val_batches: How much of validation dataset to check (float = fraction, int = num_batches).\n Default: ``1.0``.\n\n limit_test_batches: How much of test dataset to check (float = fraction, int = num_batches).\n Default: ``1.0``.\n\n limit_predict_batches: How much of prediction dataset to check (float = fraction, int = num_batches).\n Default: ``1.0``.\n\n logger: Logger (or iterable collection of loggers) for experiment tracking. A ``True`` value uses\n the default ``TensorBoardLogger``. ``False`` will disable logging. If multiple loggers are\n provided and the `save_dir` property of that logger is not set, local files (checkpoints,\n profiler traces, etc.) are saved in ``default_root_dir`` rather than in the ``log_dir`` of any\n of the individual loggers.\n Default: ``True``.\n\n log_gpu_memory: None, 'min_max', 'all'. Might slow performance.\n\n .. deprecated:: v1.5\n Deprecated in v1.5.0 and will be removed in v1.7.0\n Please use the ``DeviceStatsMonitor`` callback directly instead.\n\n log_every_n_steps: How often to log within steps.\n Default: ``50``.\n\n prepare_data_per_node: If True, each LOCAL_RANK=0 will call prepare data.\n Otherwise only NODE_RANK=0, LOCAL_RANK=0 will prepare data\n\n .. deprecated:: v1.5\n Deprecated in v1.5.0 and will be removed in v1.7.0\n Please set ``prepare_data_per_node`` in ``LightningDataModule`` and/or\n ``LightningModule`` directly instead.\n\n process_position: Orders the progress bar when running multiple models on same machine.\n\n .. deprecated:: v1.5\n ``process_position`` has been deprecated in v1.5 and will be removed in v1.7.\n Please pass :class:`~pytorch_lightning.callbacks.progress.TQDMProgressBar` with ``process_position``\n directly to the Trainer's ``callbacks`` argument instead.\n\n progress_bar_refresh_rate: How often to refresh progress bar (in steps). Value ``0`` disables progress bar.\n Ignored when a custom progress bar is passed to :paramref:`~Trainer.callbacks`. Default: None, means\n a suitable value will be chosen based on the environment (terminal, Google COLAB, etc.).\n\n .. deprecated:: v1.5\n ``progress_bar_refresh_rate`` has been deprecated in v1.5 and will be removed in v1.7.\n Please pass :class:`~pytorch_lightning.callbacks.progress.TQDMProgressBar` with ``refresh_rate``\n directly to the Trainer's ``callbacks`` argument instead. To disable the progress bar,\n pass ``enable_progress_bar = False`` to the Trainer.\n\n enable_progress_bar: Whether to enable to progress bar by default.\n Default: ``False``.\n\n profiler: To profile individual steps during training and assist in identifying bottlenecks.\n Default: ``None``.\n\n overfit_batches: Overfit a fraction of training data (float) or a set number of batches (int).\n Default: ``0.0``.\n\n plugins: Plugins allow modification of core behavior like ddp and amp, and enable custom lightning plugins.\n Default: ``None``.\n\n precision: Double precision (64), full precision (32), half precision (16) or bfloat16 precision (bf16).\n Can be used on CPU, GPU, TPUs or IPUs.\n Default: ``32``.\n\n max_epochs: Stop training once this number of epochs is reached. Disabled by default (None).\n If both max_epochs and max_steps are not specified, defaults to ``max_epochs = 1000``.\n To enable infinite training, set ``max_epochs = -1``.\n\n min_epochs: Force training for at least these many epochs. Disabled by default (None).\n\n max_steps: Stop training after this number of steps. Disabled by default (-1). If ``max_steps = -1``\n and ``max_epochs = None``, will default to ``max_epochs = 1000``. To enable infinite training, set\n ``max_epochs`` to ``-1``.\n\n min_steps: Force training for at least these number of steps. Disabled by default (``None``).\n\n max_time: Stop training after this amount of time has passed. Disabled by default (``None``).\n The time duration can be specified in the format DD:HH:MM:SS (days, hours, minutes seconds), as a\n :class:`datetime.timedelta`, or a dictionary with keys that will be passed to\n :class:`datetime.timedelta`.\n\n num_nodes: Number of GPU nodes for distributed training.\n Default: ``1``.\n\n num_processes: Number of processes for distributed training with ``accelerator=\"cpu\"``.\n Default: ``1``.\n\n num_sanity_val_steps: Sanity check runs n validation batches before starting the training routine.\n Set it to `-1` to run all batches in all validation dataloaders.\n Default: ``2``.\n\n reload_dataloaders_every_n_epochs: Set to a non-negative integer to reload dataloaders every n epochs.\n Default: ``0``.\n\n replace_sampler_ddp: Explicitly enables or disables sampler replacement. If not specified this\n will toggled automatically when DDP is used. By default it will add ``shuffle=True`` for\n train sampler and ``shuffle=False`` for val/test sampler. If you want to customize it,\n you can set ``replace_sampler_ddp=False`` and add your own distributed sampler.\n\n resume_from_checkpoint: Path/URL of the checkpoint from which training is resumed. If there is\n no checkpoint file at the path, an exception is raised. If resuming from mid-epoch checkpoint,\n training will start from the beginning of the next epoch.\n\n .. deprecated:: v1.5\n ``resume_from_checkpoint`` is deprecated in v1.5 and will be removed in v2.0.\n Please pass the path to ``Trainer.fit(..., ckpt_path=...)`` instead.\n\n strategy: Supports different training strategies with aliases\n as well custom training type plugins.\n Default: ``None``.\n\n sync_batchnorm: Synchronize batch norm layers between process groups/whole world.\n Default: ``False``.\n\n terminate_on_nan: If set to True, will terminate training (by raising a `ValueError`) at the\n end of each training batch, if any of the parameters or the loss are NaN or +/-inf.\n\n .. deprecated:: v1.5\n Trainer argument ``terminate_on_nan`` was deprecated in v1.5 and will be removed in 1.7.\n Please use ``detect_anomaly`` instead.\n\n detect_anomaly: Enable anomaly detection for the autograd engine.\n Default: ``False``.\n\n tpu_cores: How many TPU cores to train on (1 or 8) / Single TPU to train on (1)\n Default: ``None``.\n\n ipus: How many IPUs to train on.\n Default: ``None``.\n\n track_grad_norm: -1 no tracking. Otherwise tracks that p-norm. May be set to 'inf' infinity-norm. If using\n Automatic Mixed Precision (AMP), the gradients will be unscaled before logging them.\n Default: ``-1``.\n\n val_check_interval: How often to check the validation set. Pass a ``float`` in the range [0.0, 1.0] to check\n after a fraction of the training epoch. Pass an ``int`` to check after a fixed number of training\n batches.\n Default: ``1.0``.\n\n enable_model_summary: Whether to enable model summarization by default.\n Default: ``True``.\n\n weights_summary: Prints a summary of the weights when training begins.\n\n .. deprecated:: v1.5\n ``weights_summary`` has been deprecated in v1.5 and will be removed in v1.7.\n To disable the summary, pass ``enable_model_summary = False`` to the Trainer.\n To customize the summary, pass :class:`~pytorch_lightning.callbacks.model_summary.ModelSummary`\n directly to the Trainer's ``callbacks`` argument.\n\n weights_save_path: Where to save weights if specified. Will override default_root_dir\n for checkpoints only. Use this if for whatever reason you need the checkpoints\n stored in a different place than the logs written in `default_root_dir`.\n Can be remote file paths such as `s3://mybucket/path` or 'hdfs://path/'\n Defaults to `default_root_dir`.\n\n .. deprecated:: v1.6\n ``weights_save_path`` has been deprecated in v1.6 and will be removed in v1.8. Please pass\n ``dirpath`` directly to the :class:`~pytorch_lightning.callbacks.model_checkpoint.ModelCheckpoint`\n callback.\n\n move_metrics_to_cpu: Whether to force internal logged metrics to be moved to cpu.\n This can save some gpu memory, but can make training slower. Use with attention.\n Default: ``False``.\n\n multiple_trainloader_mode: How to loop over the datasets when there are multiple train loaders.\n In 'max_size_cycle' mode, the trainer ends one epoch when the largest dataset is traversed,\n and smaller datasets reload when running out of their data. In 'min_size' mode, all the datasets\n reload when reaching the minimum length of datasets.\n Default: ``\"max_size_cycle\"``.\n\n stochastic_weight_avg: Whether to use `Stochastic Weight Averaging (SWA)\n <https://pytorch.org/blog/pytorch-1.6-now-includes-stochastic-weight-averaging/>`_.\n Default: ``False``.\n\n .. deprecated:: v1.5\n ``stochastic_weight_avg`` has been deprecated in v1.5 and will be removed in v1.7.\n Please pass :class:`~pytorch_lightning.callbacks.stochastic_weight_avg.StochasticWeightAveraging`\n directly to the Trainer's ``callbacks`` argument instead.\n \"\"\"\n super().__init__()\n Trainer._log_api_event(\"init\")\n log.detail(f\"{self.__class__.__name__}: Initializing trainer with parameters: {locals()}\")\n self.state = TrainerState()\n\n gpu_ids, tpu_cores = self._parse_devices(gpus, auto_select_gpus, tpu_cores)\n\n # init connectors\n self._data_connector = DataConnector(self, multiple_trainloader_mode)\n\n self._accelerator_connector = AcceleratorConnector(\n num_processes=num_processes,\n devices=devices,\n tpu_cores=tpu_cores,\n ipus=ipus,\n accelerator=accelerator,\n strategy=strategy,\n gpus=gpus,\n gpu_ids=gpu_ids,\n num_nodes=num_nodes,\n sync_batchnorm=sync_batchnorm,\n benchmark=benchmark,\n replace_sampler_ddp=replace_sampler_ddp,\n deterministic=deterministic,\n precision=precision,\n amp_type=amp_backend,\n amp_level=amp_level,\n plugins=plugins,\n )\n self._logger_connector = LoggerConnector(self, log_gpu_memory)\n self._callback_connector = CallbackConnector(self)\n self._checkpoint_connector = CheckpointConnector(self, resume_from_checkpoint)\n self._signal_connector = SignalConnector(self)\n self.tuner = Tuner(self)\n\n min_steps, max_steps, min_epochs, max_epochs, max_time = _parse_loop_limits(\n min_steps, max_steps, min_epochs, max_epochs, max_time\n )\n fit_loop = FitLoop(min_epochs=min_epochs, max_epochs=max_epochs)\n training_epoch_loop = TrainingEpochLoop(min_steps=min_steps, max_steps=max_steps)\n fit_loop.connect(epoch_loop=training_epoch_loop)\n\n # default .fit() loop\n self.fit_loop = fit_loop\n\n # default .validate() loop\n self.validate_loop = EvaluationLoop()\n\n # default .test() loop\n self.test_loop = EvaluationLoop()\n\n # default .predict() loop\n self.predict_loop = PredictionLoop()\n\n # set when a checkpoint is loaded via `Trainer.{fit,validate,test,predict}`.\n self._ckpt_path: Optional[str] = None\n\n # .validate(), predict() and .test() set these when they load a checkpoint. They will be removed in favor of\n # the unified read-only `Trainer.ckpt_path` attribute in v1.8\n self._validated_ckpt_path: Optional[str] = None # TODO: remove in v1.8\n self._tested_ckpt_path: Optional[str] = None # TODO: remove in v1.8\n self._predicted_ckpt_path: Optional[str] = None # TODO: remove in v1.8\n\n # todo: remove in v1.7\n self._weights_summary: Optional[str] = None\n\n # init callbacks\n # Declare attributes to be set in _callback_connector on_trainer_init\n self._callback_connector.on_trainer_init(\n callbacks,\n checkpoint_callback,\n enable_checkpointing,\n enable_progress_bar,\n progress_bar_refresh_rate,\n process_position,\n default_root_dir,\n weights_save_path,\n enable_model_summary,\n weights_summary,\n stochastic_weight_avg,\n max_time,\n accumulate_grad_batches,\n )\n\n # hook\n self._call_callback_hooks(\"on_init_start\")\n\n # init data flags\n self.check_val_every_n_epoch: int\n self._data_connector.on_trainer_init(\n check_val_every_n_epoch,\n reload_dataloaders_every_n_epochs,\n prepare_data_per_node,\n )\n\n if terminate_on_nan is not None:\n rank_zero_deprecation(\n \"Trainer argument `terminate_on_nan` was deprecated in v1.5 and will be removed in 1.7.\"\n \" Please use `Trainer(detect_anomaly=True)` instead.\"\n )\n if not isinstance(terminate_on_nan, bool):\n raise TypeError(f\"`terminate_on_nan` should be a bool, got {terminate_on_nan}.\")\n\n # gradient clipping\n if gradient_clip_val is not None and not isinstance(gradient_clip_val, (int, float)):\n raise TypeError(f\"`gradient_clip_val` should be an int or a float. Got {gradient_clip_val}.\")\n\n if gradient_clip_algorithm is not None and not GradClipAlgorithmType.supported_type(\n gradient_clip_algorithm.lower()\n ):\n raise MisconfigurationException(\n f\"`gradient_clip_algorithm` {gradient_clip_algorithm} is invalid. \"\n f\"Allowed algorithms: {GradClipAlgorithmType.supported_types()}.\"\n )\n\n # gradient norm tracking\n if track_grad_norm != -1 and not (\n (isinstance(track_grad_norm, (int, float)) or track_grad_norm == \"inf\") and float(track_grad_norm) > 0\n ):\n raise MisconfigurationException(\n f\"`track_grad_norm` must be a positive number or 'inf' (infinity norm). Got {track_grad_norm}.\"\n )\n\n self._terminate_on_nan = terminate_on_nan\n self.gradient_clip_val: Union[int, float] = gradient_clip_val\n self.gradient_clip_algorithm = (\n GradClipAlgorithmType(gradient_clip_algorithm.lower())\n if gradient_clip_algorithm is not None\n else gradient_clip_algorithm\n )\n self.track_grad_norm: float = float(track_grad_norm)\n\n self._detect_anomaly: bool = detect_anomaly\n self._setup_on_init(num_sanity_val_steps)\n\n # configure tuner\n self.tuner.on_trainer_init(auto_lr_find, auto_scale_batch_size)\n\n # configure profiler\n self.__init_profiler(profiler)\n\n # init logger flags\n self._loggers: List[LightningLoggerBase]\n self._logger_connector.on_trainer_init(logger, flush_logs_every_n_steps, log_every_n_steps, move_metrics_to_cpu)\n\n # init debugging flags\n self.val_check_interval: Union[int, float]\n self._init_debugging_flags(\n limit_train_batches,\n limit_val_batches,\n limit_test_batches,\n limit_predict_batches,\n val_check_interval,\n overfit_batches,\n fast_dev_run,\n )\n\n # Callback system\n self._call_callback_hooks(\"on_init_end\")\n\n def _init_debugging_flags(\n self,\n limit_train_batches: Optional[Union[int, float]],\n limit_val_batches: Optional[Union[int, float]],\n limit_test_batches: Optional[Union[int, float]],\n limit_predict_batches: Optional[Union[int, float]],\n val_check_interval: Optional[Union[int, float]],\n overfit_batches: Union[int, float],\n fast_dev_run: Union[int, bool],\n ) -> None:\n if isinstance(fast_dev_run, int) and (fast_dev_run < 0):\n raise MisconfigurationException(\n f\"fast_dev_run={fast_dev_run} is not a valid configuration. It should be >= 0.\"\n )\n\n self.fast_dev_run = fast_dev_run\n\n # set fast_dev_run=True when it is 1, used while logging\n if fast_dev_run == 1:\n self.fast_dev_run = True\n\n if fast_dev_run:\n num_batches = int(fast_dev_run)\n limit_train_batches = num_batches\n limit_val_batches = num_batches\n limit_test_batches = num_batches\n limit_predict_batches = num_batches\n self.fit_loop.max_steps = num_batches\n self.num_sanity_val_steps = 0\n self.fit_loop.max_epochs = 1\n val_check_interval = 1.0\n self.check_val_every_n_epoch = 1\n self.loggers = [DummyLogger()] if self.loggers else []\n\n rank_zero_info(\n \"Running in fast_dev_run mode: will run a full train,\"\n f\" val, test and prediction loop using {num_batches} batch(es).\"\n )\n\n self.limit_train_batches = _determine_batch_limits(limit_train_batches, \"limit_train_batches\")\n self.limit_val_batches = _determine_batch_limits(limit_val_batches, \"limit_val_batches\")\n self.limit_test_batches = _determine_batch_limits(limit_test_batches, \"limit_test_batches\")\n self.limit_predict_batches = _determine_batch_limits(limit_predict_batches, \"limit_predict_batches\")\n self.val_check_interval = _determine_batch_limits(val_check_interval, \"val_check_interval\")\n self.overfit_batches = _determine_batch_limits(overfit_batches, \"overfit_batches\")\n self._determine_data_use_amount(self.overfit_batches)\n\n def _determine_data_use_amount(self, overfit_batches: float) -> None:\n \"\"\"Use less data for debugging purposes.\"\"\"\n if overfit_batches > 0:\n self.limit_train_batches = overfit_batches\n self.limit_val_batches = 0\n\n def _setup_on_init(self, num_sanity_val_steps: int) -> None:\n self._log_device_info()\n\n self.should_stop = False\n self.state = TrainerState()\n self.num_training_batches = float(\"inf\")\n self.train_dataloader = None\n\n if num_sanity_val_steps == -1:\n self.num_sanity_val_steps = float(\"inf\")\n else:\n self.num_sanity_val_steps = num_sanity_val_steps\n\n self.num_sanity_val_batches = []\n self.num_test_batches = []\n self.num_val_batches = []\n self.test_dataloaders = None\n self.val_dataloaders = None\n self._last_train_dl_reload_epoch = float(\"-inf\")\n self._last_val_dl_reload_epoch = float(\"-inf\")\n\n self.num_predict_batches = []\n\n def _call_and_handle_interrupt(self, trainer_fn: Callable, *args: Any, **kwargs: Any) -> Any:\n r\"\"\"\n Error handling, intended to be used only for main trainer function entry points (fit, validate, test, predict)\n as all errors should funnel through them\n\n Args:\n trainer_fn: one of (fit, validate, test, predict)\n *args: positional arguments to be passed to the `trainer_fn`\n **kwargs: keyword arguments to be passed to `trainer_fn`\n \"\"\"\n try:\n if self.strategy.launcher is not None:\n return self.strategy.launcher.launch(trainer_fn, *args, trainer=self, **kwargs)\n else:\n return trainer_fn(*args, **kwargs)\n # TODO: treat KeyboardInterrupt as BaseException (delete the code below) in v1.7\n except KeyboardInterrupt as exception:\n rank_zero_warn(\"Detected KeyboardInterrupt, attempting graceful shutdown...\")\n # user could press Ctrl+c many times... only shutdown once\n if not self.interrupted:\n self.state.status = TrainerStatus.INTERRUPTED\n self._call_callback_hooks(\"on_keyboard_interrupt\")\n self._call_callback_hooks(\"on_exception\", exception)\n except BaseException as exception:\n self.state.status = TrainerStatus.INTERRUPTED\n if distributed_available() and self.world_size > 1:\n # try syncing remaining processes, kill otherwise\n self.strategy.reconciliate_processes(traceback.format_exc())\n self._call_callback_hooks(\"on_exception\", exception)\n self._teardown()\n # teardown might access the stage so we reset it after\n self.state.stage = None\n raise\n\n def fit(\n self,\n model: \"pl.LightningModule\",\n train_dataloaders: Optional[Union[TRAIN_DATALOADERS, LightningDataModule]] = None,\n val_dataloaders: Optional[EVAL_DATALOADERS] = None,\n datamodule: Optional[LightningDataModule] = None,\n ckpt_path: Optional[str] = None,\n ) -> None:\n r\"\"\"\n Runs the full optimization routine.\n\n Args:\n model: Model to fit.\n\n train_dataloaders: A collection of :class:`torch.utils.data.DataLoader` or a\n :class:`~pytorch_lightning.core.datamodule.LightningDataModule` specifying training samples.\n In the case of multiple dataloaders, please see this :ref:`section <multiple-dataloaders>`.\n\n val_dataloaders: A :class:`torch.utils.data.DataLoader` or a sequence of them specifying validation samples.\n\n ckpt_path: Path/URL of the checkpoint from which training is resumed. If there is\n no checkpoint file at the path, an exception is raised. If resuming from mid-epoch checkpoint,\n training will start from the beginning of the next epoch.\n\n datamodule: An instance of :class:`~pytorch_lightning.core.datamodule.LightningDataModule`.\n \"\"\"\n self.strategy.model = model\n self._call_and_handle_interrupt(\n self._fit_impl, model, train_dataloaders, val_dataloaders, datamodule, ckpt_path\n )\n\n def _fit_impl(\n self,\n model: \"pl.LightningModule\",\n train_dataloaders: Optional[Union[TRAIN_DATALOADERS, LightningDataModule]] = None,\n val_dataloaders: Optional[EVAL_DATALOADERS] = None,\n datamodule: Optional[LightningDataModule] = None,\n ckpt_path: Optional[str] = None,\n ) -> None:\n Trainer._log_api_event(\"fit\")\n log.detail(f\"{self.__class__.__name__}: trainer fit stage\")\n\n self.state.fn = TrainerFn.FITTING\n self.state.status = TrainerStatus.RUNNING\n self.training = True\n self._last_train_dl_reload_epoch = float(\"-inf\")\n self._last_val_dl_reload_epoch = float(\"-inf\")\n\n # if a datamodule comes in as the second arg, then fix it for the user\n if isinstance(train_dataloaders, LightningDataModule):\n datamodule = train_dataloaders\n train_dataloaders = None\n # If you supply a datamodule you can't supply train_dataloader or val_dataloaders\n if (train_dataloaders is not None or val_dataloaders is not None) and datamodule is not None:\n raise MisconfigurationException(\n \"You cannot pass `train_dataloader` or `val_dataloaders` to `trainer.fit(datamodule=...)`\"\n )\n\n # links data to the trainer\n self._data_connector.attach_data(\n model, train_dataloaders=train_dataloaders, val_dataloaders=val_dataloaders, datamodule=datamodule\n )\n\n # TODO: ckpt_path only in v2.0\n ckpt_path = ckpt_path or self.resume_from_checkpoint\n self._ckpt_path = self.__set_ckpt_path(\n ckpt_path, model_provided=True, model_connected=self.lightning_module is not None\n )\n results = self._run(model, ckpt_path=self.ckpt_path)\n\n assert self.state.stopped\n self.training = False\n return results\n\n def validate(\n self,\n model: Optional[\"pl.LightningModule\"] = None,\n dataloaders: Optional[Union[EVAL_DATALOADERS, LightningDataModule]] = None,\n ckpt_path: Optional[str] = None,\n verbose: bool = True,\n datamodule: Optional[LightningDataModule] = None,\n ) -> _EVALUATE_OUTPUT:\n r\"\"\"\n Perform one evaluation epoch over the validation set.\n\n Args:\n model: The model to validate.\n\n dataloaders: A :class:`torch.utils.data.DataLoader` or a sequence of them,\n or a :class:`~pytorch_lightning.core.datamodule.LightningDataModule` specifying validation samples.\n\n ckpt_path: Either ``best`` or path to the checkpoint you wish to validate.\n If ``None`` and the model instance was passed, use the current weights.\n Otherwise, the best model checkpoint from the previous ``trainer.fit`` call will be loaded\n if a checkpoint callback is configured.\n\n verbose: If True, prints the validation results.\n\n datamodule: An instance of :class:`~pytorch_lightning.core.datamodule.LightningDataModule`.\n\n Returns:\n List of dictionaries with metrics logged during the validation phase, e.g., in model- or callback hooks\n like :meth:`~pytorch_lightning.core.lightning.LightningModule.validation_step`,\n :meth:`~pytorch_lightning.core.lightning.LightningModule.validation_epoch_end`, etc.\n The length of the list corresponds to the number of validation dataloaders used.\n \"\"\"\n self.strategy.model = model or self.lightning_module\n return self._call_and_handle_interrupt(self._validate_impl, model, dataloaders, ckpt_path, verbose, datamodule)\n\n def _validate_impl(\n self,\n model: Optional[\"pl.LightningModule\"] = None,\n dataloaders: Optional[Union[EVAL_DATALOADERS, LightningDataModule]] = None,\n ckpt_path: Optional[str] = None,\n verbose: bool = True,\n datamodule: Optional[LightningDataModule] = None,\n ) -> _EVALUATE_OUTPUT:\n # --------------------\n # SETUP HOOK\n # --------------------\n Trainer._log_api_event(\"validate\")\n log.detail(f\"{self.__class__.__name__}: trainer validate stage\")\n\n self.state.fn = TrainerFn.VALIDATING\n self.state.status = TrainerStatus.RUNNING\n self.validating = True\n\n # if a datamodule comes in as the second arg, then fix it for the user\n if isinstance(dataloaders, LightningDataModule):\n datamodule = dataloaders\n dataloaders = None\n # If you supply a datamodule you can't supply val_dataloaders\n if dataloaders is not None and datamodule:\n raise MisconfigurationException(\"You cannot pass both `trainer.validate(dataloaders=..., datamodule=...)`\")\n\n model_provided = model is not None\n model = model or self.lightning_module\n if model is None:\n raise MisconfigurationException(\n \"`model` must be provided to `trainer.validate()` when it hasn't been passed in a previous run\"\n )\n\n self.validate_loop.verbose = verbose\n\n # links data to the trainer\n self._data_connector.attach_data(model, val_dataloaders=dataloaders, datamodule=datamodule)\n\n self._ckpt_path = self.__set_ckpt_path(\n ckpt_path, model_provided=model_provided, model_connected=self.lightning_module is not None\n )\n\n self._validated_ckpt_path = self.ckpt_path # TODO: remove in v1.8\n\n # run validate\n results = self._run(model, ckpt_path=self.ckpt_path)\n\n assert self.state.stopped\n self.validating = False\n\n return results\n\n def test(\n self,\n model: Optional[\"pl.LightningModule\"] = None,\n dataloaders: Optional[Union[EVAL_DATALOADERS, LightningDataModule]] = None,\n ckpt_path: Optional[str] = None,\n verbose: bool = True,\n datamodule: Optional[LightningDataModule] = None,\n ) -> _EVALUATE_OUTPUT:\n r\"\"\"\n Perform one evaluation epoch over the test set.\n It's separated from fit to make sure you never run on your test set until you want to.\n\n Args:\n model: The model to test.\n\n dataloaders: A :class:`torch.utils.data.DataLoader` or a sequence of them,\n or a :class:`~pytorch_lightning.core.datamodule.LightningDataModule` specifying test samples.\n\n ckpt_path: Either ``best`` or path to the checkpoint you wish to test.\n If ``None`` and the model instance was passed, use the current weights.\n Otherwise, the best model checkpoint from the previous ``trainer.fit`` call will be loaded\n if a checkpoint callback is configured.\n\n verbose: If True, prints the test results.\n\n datamodule: An instance of :class:`~pytorch_lightning.core.datamodule.LightningDataModule`.\n\n Returns:\n List of dictionaries with metrics logged during the test phase, e.g., in model- or callback hooks\n like :meth:`~pytorch_lightning.core.lightning.LightningModule.test_step`,\n :meth:`~pytorch_lightning.core.lightning.LightningModule.test_epoch_end`, etc.\n The length of the list corresponds to the number of test dataloaders used.\n \"\"\"\n self.strategy.model = model or self.lightning_module\n return self._call_and_handle_interrupt(self._test_impl, model, dataloaders, ckpt_path, verbose, datamodule)\n\n def _test_impl(\n self,\n model: Optional[\"pl.LightningModule\"] = None,\n dataloaders: Optional[Union[EVAL_DATALOADERS, LightningDataModule]] = None,\n ckpt_path: Optional[str] = None,\n verbose: bool = True,\n datamodule: Optional[LightningDataModule] = None,\n ) -> _EVALUATE_OUTPUT:\n # --------------------\n # SETUP HOOK\n # --------------------\n Trainer._log_api_event(\"test\")\n log.detail(f\"{self.__class__.__name__}: trainer test stage\")\n\n self.state.fn = TrainerFn.TESTING\n self.state.status = TrainerStatus.RUNNING\n self.testing = True\n\n # if a datamodule comes in as the second arg, then fix it for the user\n if isinstance(dataloaders, LightningDataModule):\n datamodule = dataloaders\n dataloaders = None\n # If you supply a datamodule you can't supply test_dataloaders\n if dataloaders is not None and datamodule:\n raise MisconfigurationException(\"You cannot pass both `trainer.test(dataloaders=..., datamodule=...)`\")\n\n model_provided = model is not None\n model = model or self.lightning_module\n if model is None:\n raise MisconfigurationException(\n \"`model` must be provided to `trainer.test()` when it hasn't been passed in a previous run\"\n )\n\n self.test_loop.verbose = verbose\n\n # links data to the trainer\n self._data_connector.attach_data(model, test_dataloaders=dataloaders, datamodule=datamodule)\n\n self._ckpt_path = self.__set_ckpt_path(\n ckpt_path, model_provided=model_provided, model_connected=self.lightning_module is not None\n )\n\n self._tested_ckpt_path = self.ckpt_path # TODO: remove in v1.8\n\n # run test\n results = self._run(model, ckpt_path=self.ckpt_path)\n\n assert self.state.stopped\n self.testing = False\n\n return results\n\n def predict(\n self,\n model: Optional[\"pl.LightningModule\"] = None,\n dataloaders: Optional[Union[EVAL_DATALOADERS, LightningDataModule]] = None,\n datamodule: Optional[LightningDataModule] = None,\n return_predictions: Optional[bool] = None,\n ckpt_path: Optional[str] = None,\n ) -> Optional[_PREDICT_OUTPUT]:\n r\"\"\"\n Run inference on your data.\n This will call the model forward function to compute predictions. Useful to perform distributed\n and batched predictions. Logging is disabled in the predict hooks.\n\n Args:\n model: The model to predict with.\n\n dataloaders: A :class:`torch.utils.data.DataLoader` or a sequence of them,\n or a :class:`~pytorch_lightning.core.datamodule.LightningDataModule` specifying prediction samples.\n\n datamodule: The datamodule with a predict_dataloader method that returns one or more dataloaders.\n\n return_predictions: Whether to return predictions.\n ``True`` by default except when an accelerator that spawns processes is used (not supported).\n\n ckpt_path: Either ``best`` or path to the checkpoint you wish to predict.\n If ``None`` and the model instance was passed, use the current weights.\n Otherwise, the best model checkpoint from the previous ``trainer.fit`` call will be loaded\n if a checkpoint callback is configured.\n\n Returns:\n Returns a list of dictionaries, one for each provided dataloader containing their respective predictions.\n \"\"\"\n self.strategy.model = model or self.lightning_module\n return self._call_and_handle_interrupt(\n self._predict_impl, model, dataloaders, datamodule, return_predictions, ckpt_path\n )\n\n def _predict_impl(\n self,\n model: Optional[\"pl.LightningModule\"] = None,\n dataloaders: Optional[Union[EVAL_DATALOADERS, LightningDataModule]] = None,\n datamodule: Optional[LightningDataModule] = None,\n return_predictions: Optional[bool] = None,\n ckpt_path: Optional[str] = None,\n ) -> Optional[_PREDICT_OUTPUT]:\n # --------------------\n # SETUP HOOK\n # --------------------\n Trainer._log_api_event(\"predict\")\n log.detail(f\"{self.__class__.__name__}: trainer predict stage\")\n\n self.state.fn = TrainerFn.PREDICTING\n self.state.status = TrainerStatus.RUNNING\n self.predicting = True\n\n self.predict_loop.return_predictions = return_predictions\n\n # if a datamodule comes in as the second arg, then fix it for the user\n if isinstance(dataloaders, LightningDataModule):\n datamodule = dataloaders\n dataloaders = None\n if dataloaders is not None and datamodule:\n raise MisconfigurationException(\"You cannot pass both `trainer.predict(dataloaders=..., datamodule=...)`\")\n\n model_provided = model is not None\n model = model or self.lightning_module\n if model is None:\n raise MisconfigurationException(\n \"`model` must be provided to `trainer.predict()` when it hasn't been passed in a previous run\"\n )\n\n # links data to the trainer\n self._data_connector.attach_data(model, predict_dataloaders=dataloaders, datamodule=datamodule)\n\n self._ckpt_path = self.__set_ckpt_path(\n ckpt_path, model_provided=model_provided, model_connected=self.lightning_module is not None\n )\n\n self._predicted_ckpt_path = self.ckpt_path # TODO: remove in v1.8\n\n results = self._run(model, ckpt_path=self.ckpt_path)\n\n assert self.state.stopped\n self.predicting = False\n\n return results\n\n def tune(\n self,\n model: \"pl.LightningModule\",\n train_dataloaders: Optional[Union[TRAIN_DATALOADERS, LightningDataModule]] = None,\n val_dataloaders: Optional[EVAL_DATALOADERS] = None,\n datamodule: Optional[LightningDataModule] = None,\n scale_batch_size_kwargs: Optional[Dict[str, Any]] = None,\n lr_find_kwargs: Optional[Dict[str, Any]] = None,\n ) -> Dict[str, Optional[Union[int, _LRFinder]]]:\n r\"\"\"\n Runs routines to tune hyperparameters before training.\n\n Args:\n model: Model to tune.\n\n train_dataloaders: A collection of :class:`torch.utils.data.DataLoader` or a\n :class:`~pytorch_lightning.core.datamodule.LightningDataModule` specifying training samples.\n In the case of multiple dataloaders, please see this :ref:`section <multiple-dataloaders>`.\n\n val_dataloaders: A :class:`torch.utils.data.DataLoader` or a sequence of them specifying validation samples.\n\n datamodule: An instance of :class:`~pytorch_lightning.core.datamodule.LightningDataModule`.\n\n scale_batch_size_kwargs: Arguments for :func:`~pytorch_lightning.tuner.batch_size_scaling.scale_batch_size`\n\n lr_find_kwargs: Arguments for :func:`~pytorch_lightning.tuner.lr_finder.lr_find`\n \"\"\"\n Trainer._log_api_event(\"tune\")\n\n self.state.fn = TrainerFn.TUNING\n self.state.status = TrainerStatus.RUNNING\n self.tuning = True\n\n # if a datamodule comes in as the second arg, then fix it for the user\n if isinstance(train_dataloaders, LightningDataModule):\n datamodule = train_dataloaders\n train_dataloaders = None\n # If you supply a datamodule you can't supply train_dataloader or val_dataloaders\n if (train_dataloaders is not None or val_dataloaders is not None) and datamodule is not None:\n raise MisconfigurationException(\n \"You cannot pass `train_dataloader` or `val_dataloaders` to `trainer.tune(datamodule=...)`\"\n )\n\n # links data to the trainer\n self._data_connector.attach_data(\n model, train_dataloaders=train_dataloaders, val_dataloaders=val_dataloaders, datamodule=datamodule\n )\n\n with isolate_rng():\n result = self.tuner._tune(\n model, scale_batch_size_kwargs=scale_batch_size_kwargs, lr_find_kwargs=lr_find_kwargs\n )\n\n assert self.state.stopped\n self.tuning = False\n\n return result\n\n def _restore_modules_and_callbacks(self, checkpoint_path: Optional[_PATH] = None) -> None:\n # restore modules after setup\n self._checkpoint_connector.resume_start(checkpoint_path)\n self._checkpoint_connector.restore_model()\n self._checkpoint_connector.restore_datamodule()\n if self.state.fn == TrainerFn.FITTING:\n # restore callback states\n self._checkpoint_connector.restore_callbacks()\n\n def _run(\n self, model: \"pl.LightningModule\", ckpt_path: Optional[str] = None\n ) -> Optional[Union[_EVALUATE_OUTPUT, _PREDICT_OUTPUT]]:\n # clean hparams\n if hasattr(model, \"hparams\"):\n parsing.clean_namespace(model.hparams)\n\n # attach model to the training type plugin\n self.strategy.connect(model)\n\n self._callback_connector._attach_model_callbacks()\n self._callback_connector._attach_model_logging_functions()\n\n verify_loop_configurations(self)\n\n # hook\n log.detail(f\"{self.__class__.__name__}: preparing data\")\n self._data_connector.prepare_data()\n\n # ----------------------------\n # SET UP TRAINING\n # ----------------------------\n self._call_callback_hooks(\"on_before_accelerator_backend_setup\")\n log.detail(f\"{self.__class__.__name__}: setting up strategy environment\")\n self.strategy.setup_environment()\n self.__setup_profiler()\n\n self._call_setup_hook() # allow user to setup lightning_module in accelerator environment\n\n # check if we should delay restoring checkpoint till later\n if not self.strategy.restore_checkpoint_after_setup:\n log.detail(f\"{self.__class__.__name__}: restoring module and callbacks from checkpoint path: {ckpt_path}\")\n self._restore_modules_and_callbacks(ckpt_path)\n\n log.detail(f\"{self.__class__.__name__}: configuring sharded model\")\n self._call_configure_sharded_model() # allow user to setup in model sharded environment\n\n # ----------------------------\n # INSPECT THE CORE LOOPS\n # ----------------------------\n fr\"\"\"\n Lightning internal flow looks like this:\n {Trainer.fit} or {Trainer.test} or {Trainer.predict} ||\n | ||\n spawn processes ||\n {self.strategy.setup_environment} ||\n | ||\n setup accelerator ||\n and strategy || LIGHTNING\n | ||\n {self._run_stage} || FLOW\n | ||\n {self._run_train} || DIRECTION\n or {self._run_evaluate} ||\n or {self._run_predict} ||\n | ||\n results \\/\n This is used to guide readers to the core loops: train, test, predict.\n {self._run_predict} is the simplest to understand, use `Go to Definition` to read it :)\n \"\"\"\n\n # ----------------------------\n # TRAIN\n # ----------------------------\n\n # reset logger connector\n self._logger_connector.reset_results()\n self._logger_connector.reset_metrics()\n\n # strategy will configure model and move it to the device\n self.strategy.setup(self)\n\n # hook\n if self.state.fn == TrainerFn.FITTING:\n self._call_callback_hooks(\"on_fit_start\")\n self._call_lightning_module_hook(\"on_fit_start\")\n\n self._log_hyperparams()\n\n if self.strategy.restore_checkpoint_after_setup:\n log.detail(f\"{self.__class__.__name__}: restoring module and callbacks from checkpoint path: {ckpt_path}\")\n self._restore_modules_and_callbacks(ckpt_path)\n\n # restore optimizers, etc.\n log.detail(f\"{self.__class__.__name__}: restoring training state\")\n self._checkpoint_connector.restore_training_state()\n\n self._checkpoint_connector.resume_end()\n\n results = self._run_stage()\n\n log.detail(f\"{self.__class__.__name__}: trainer tearing down\")\n self._teardown()\n\n # ----------------------------\n # POST-Training CLEAN UP\n # ----------------------------\n # hook\n if self.state.fn == TrainerFn.FITTING:\n self._call_callback_hooks(\"on_fit_end\")\n self._call_lightning_module_hook(\"on_fit_end\")\n\n log.detail(f\"{self.__class__.__name__}: calling teardown hooks\")\n self._call_teardown_hook()\n\n self.state.status = TrainerStatus.FINISHED\n self.state.stage = None\n\n return results\n\n def _log_hyperparams(self) -> None:\n if not self.loggers:\n return\n # log hyper-parameters\n hparams_initial = None\n\n # save exp to get started (this is where the first experiment logs are written)\n datamodule_log_hyperparams = self.datamodule._log_hyperparams if self.datamodule is not None else False\n\n if self.lightning_module._log_hyperparams and datamodule_log_hyperparams:\n datamodule_hparams = self.datamodule.hparams_initial\n lightning_hparams = self.lightning_module.hparams_initial\n inconsistent_keys = []\n for key in lightning_hparams.keys() & datamodule_hparams.keys():\n lm_val, dm_val = lightning_hparams[key], datamodule_hparams[key]\n if type(lm_val) != type(dm_val):\n inconsistent_keys.append(key)\n elif isinstance(lm_val, torch.Tensor) and id(lm_val) != id(dm_val):\n inconsistent_keys.append(key)\n elif lm_val != dm_val:\n inconsistent_keys.append(key)\n if inconsistent_keys:\n raise MisconfigurationException(\n f\"Error while merging hparams: the keys {inconsistent_keys} are present \"\n \"in both the LightningModule's and LightningDataModule's hparams \"\n \"but have different values.\"\n )\n hparams_initial = {**lightning_hparams, **datamodule_hparams}\n elif self.lightning_module._log_hyperparams:\n hparams_initial = self.lightning_module.hparams_initial\n elif datamodule_log_hyperparams:\n hparams_initial = self.datamodule.hparams_initial\n\n for logger in self.loggers:\n if hparams_initial is not None:\n logger.log_hyperparams(hparams_initial)\n logger.log_graph(self.lightning_module)\n logger.save()\n\n def _teardown(self):\n \"\"\"This is the Trainer's internal teardown, unrelated to the `teardown` hooks in LightningModule and\n Callback; those are handled by :meth:`_call_teardown_hook`.\"\"\"\n self.strategy.post_dispatch(self)\n self.strategy.teardown()\n loop = self._active_loop\n # loop should never be `None` here but it can because we don't know the trainer stage with `ddp_spawn`\n if loop is not None:\n loop.teardown()\n self._logger_connector.teardown()\n self._signal_connector.teardown()\n\n def run_stage(self) -> None:\n rank_zero_deprecation(\n \"`Trainer.run_stage` is deprecated in v1.6 and will be removed in v1.8. Use\"\n \" `Trainer.{fit,validate,test,predict}` instead.\"\n )\n return self._run_stage()\n\n def _run_stage(self):\n self.strategy.barrier(\"run-stage\")\n self.strategy.dispatch(self)\n\n if self.evaluating:\n return self._run_evaluate()\n if self.predicting:\n return self._run_predict()\n return self._run_train()\n\n def _pre_training_routine(self):\n # wait for all to join if on distributed\n self.strategy.barrier(\"setup_training\")\n\n # register signals\n self._signal_connector.register_signal_handlers()\n\n # --------------------------\n # Pre-train\n # --------------------------\n self._call_callback_hooks(\"on_pretrain_routine_start\")\n self._call_lightning_module_hook(\"on_pretrain_routine_start\")\n\n self._call_callback_hooks(\"on_pretrain_routine_end\")\n self._call_lightning_module_hook(\"on_pretrain_routine_end\")\n\n def _run_train(self) -> None:\n self._pre_training_routine()\n\n with isolate_rng():\n self._run_sanity_check()\n\n # enable train mode\n self.model.train()\n torch.set_grad_enabled(True)\n\n self.fit_loop.trainer = self\n with torch.autograd.set_detect_anomaly(self._detect_anomaly):\n self.fit_loop.run()\n\n def _run_evaluate(self) -> _EVALUATE_OUTPUT:\n assert self.evaluating\n\n # reload dataloaders\n self._evaluation_loop._reload_evaluation_dataloaders()\n\n # reset trainer on this loop and all child loops in case user connected a custom loop\n self._evaluation_loop.trainer = self\n\n with self.profiler.profile(f\"run_{self.state.stage}_evaluation\"), torch.no_grad():\n eval_loop_results = self._evaluation_loop.run()\n\n # remove the tensors from the eval results\n for result in eval_loop_results:\n if isinstance(result, dict):\n for k, v in result.items():\n if isinstance(v, torch.Tensor):\n result[k] = v.cpu().item()\n\n return eval_loop_results\n\n def _run_predict(self) -> Optional[_PREDICT_OUTPUT]:\n self.reset_predict_dataloader(self.lightning_module)\n # reset trainer on this loop and all child loops in case user connected a custom loop\n self.predict_loop.trainer = self\n with torch.no_grad():\n return self.predict_loop.run()\n\n def _run_sanity_check(self) -> None:\n val_loop = self.fit_loop.epoch_loop.val_loop\n\n should_sanity_check = (\n self.enable_validation\n and self.num_sanity_val_steps > 0\n # do not sanity check if restarting because it would mess up the loaded state\n and not val_loop.restarting\n )\n\n # run tiny validation (if validation defined)\n # to make sure program won't crash during val\n if should_sanity_check:\n stage = self.state.stage\n self.sanity_checking = True\n\n # reset logger connector\n self._logger_connector.reset_results()\n self._logger_connector.reset_metrics()\n\n self._call_callback_hooks(\"on_sanity_check_start\")\n\n # reload dataloaders\n val_loop._reload_evaluation_dataloaders()\n self.num_sanity_val_batches = [\n min(self.num_sanity_val_steps, val_batches) for val_batches in self.num_val_batches\n ]\n\n # run eval step\n with torch.no_grad():\n val_loop.run()\n\n self._call_callback_hooks(\"on_sanity_check_end\")\n\n # reset logger connector\n self._logger_connector.reset_results()\n self._logger_connector.reset_metrics()\n\n # reset the progress tracking state after sanity checking. we don't need to set the state before\n # because sanity check only runs when we are not restarting\n _reset_progress(val_loop)\n\n # restore the previous stage when the sanity check if finished\n self.state.stage = stage\n\n def __set_ckpt_path(self, ckpt_path: Optional[str], model_provided: bool, model_connected: bool) -> Optional[str]:\n # fault-tolerance takes precedence\n from pytorch_lightning.callbacks.fault_tolerance import _FaultToleranceCheckpoint\n\n ft_checkpoints = [cb for cb in self.callbacks if isinstance(cb, _FaultToleranceCheckpoint)]\n if ft_checkpoints:\n ft_ckpt_path = ft_checkpoints[0].ckpt_path\n fs = get_filesystem(ft_ckpt_path)\n if fs.exists(ft_ckpt_path):\n return ft_ckpt_path\n\n if model_provided and ckpt_path is None:\n # use passed model to function without loading weights\n return\n\n fn = self.state.fn.value\n\n if model_connected and ckpt_path is None:\n rank_zero_warn(\n f\"`.{fn}(ckpt_path=None)` was called without a model.\"\n \" The best model of the previous `fit` call will be used.\"\n f\" You can pass `{fn}(ckpt_path='best')` to use and best model\"\n \" checkpoint and avoid this warning or\"\n \" `ckpt_path=trainer.checkpoint_callback.last_model_path` to use the last model.\"\n )\n ckpt_path = \"best\"\n\n if ckpt_path == \"best\":\n if len(self.checkpoint_callbacks) > 1:\n rank_zero_warn(\n f'`.{fn}(ckpt_path=\"best\")` is called with Trainer configured with multiple `ModelCheckpoint`'\n \" callbacks. It will use the best checkpoint path from first checkpoint callback.\"\n )\n\n if not self.checkpoint_callback:\n raise MisconfigurationException(\n f'`.{fn}(ckpt_path=\"best\")` is set but `ModelCheckpoint` is not configured.'\n )\n\n if not self.checkpoint_callback.best_model_path:\n if self.fast_dev_run:\n raise MisconfigurationException(\n f'You cannot execute `.{fn}(ckpt_path=\"best\")` with `fast_dev_run=True`.'\n f\" Please pass an exact checkpoint path to `.{fn}(ckpt_path=...)`\"\n )\n raise MisconfigurationException(\n f'`.{fn}(ckpt_path=\"best\")` is set but `ModelCheckpoint` is not configured to save the best model.'\n )\n # load best weights\n ckpt_path = self.checkpoint_callback.best_model_path\n\n if not ckpt_path:\n raise MisconfigurationException(\n f\"`.{fn}()` found no path for the best weights: {ckpt_path!r}. Please\"\n f\" specify a path for a checkpoint `.{fn}(ckpt_path=PATH)`\"\n )\n return ckpt_path\n\n def _call_setup_hook(self) -> None:\n fn = self.state.fn._setup_fn\n\n self.strategy.barrier(\"pre_setup\")\n\n if self.datamodule is not None:\n self.datamodule.setup(stage=fn)\n self._call_callback_hooks(\"setup\", stage=fn)\n self._call_lightning_module_hook(\"setup\", stage=fn)\n\n self.strategy.barrier(\"post_setup\")\n\n def _call_configure_sharded_model(self) -> None:\n with self.strategy.model_sharded_context():\n self._handle_meta_model()\n self._call_lightning_module_hook(\"configure_sharded_model\")\n self._call_callback_hooks(\"on_configure_sharded_model\")\n\n def _handle_meta_model(self) -> None:\n if not is_on_meta_device(self.lightning_module):\n return\n\n if isinstance(self.strategy, DDPSpawnStrategy):\n raise MisconfigurationException(\"LightningModule on meta device isn't supported with spawn.\")\n\n materialize_module(self.lightning_module)\n # the trainer reference is lost during materialization\n self.lightning_module.trainer = proxy(self)\n\n def _call_teardown_hook(self) -> None:\n fn = self.state.fn._setup_fn\n\n if self.datamodule is not None:\n self.datamodule.teardown(stage=fn)\n\n self._call_callback_hooks(\"teardown\", stage=fn)\n self._call_lightning_module_hook(\"teardown\", stage=fn)\n\n self.lightning_module._current_fx_name = None\n # these could have become stale if metrics are defined in `setup`\n self.lightning_module._metric_attributes = None\n\n # todo: TPU 8 cores hangs in flush with TensorBoard. Might do for all loggers.\n # It might be related to xla tensors blocked when moving the cpu kill loggers.\n for logger in self.loggers:\n logger.finalize(\"success\")\n\n # summarize profile results\n self.profiler.describe()\n\n def call_hook(\n self, hook_name: str, *args: Any, pl_module: Optional[\"pl.LightningModule\"] = None, **kwargs: Any\n ) -> Any:\n r\"\"\"\n .. deprecated:: v1.6\n The Trainer's `call_hook` method was deprecated in v1.6 and will be removed in v1.8.\n \"\"\"\n rank_zero_deprecation(\"The Trainer's `call_hook` method was deprecated in v1.6 and will be removed in v1.8.\")\n pl_module = self.lightning_module or pl_module\n if pl_module:\n prev_fx_name = pl_module._current_fx_name\n pl_module._current_fx_name = hook_name\n\n # always profile hooks\n with self.profiler.profile(hook_name):\n\n # first call trainer hook\n callback_fx = getattr(self, hook_name, None)\n if callable(callback_fx):\n callback_fx(*args, **kwargs)\n\n # next call hook in lightningModule\n output = None\n model_fx = getattr(pl_module, hook_name, None)\n if callable(model_fx):\n output = model_fx(*args, **kwargs)\n\n # call the strategy hook\n if hook_name not in (\"setup\", \"teardown\", \"on_train_start\") and hasattr(self.strategy, hook_name):\n strategy_hook = getattr(self.strategy, hook_name)\n strategy_output = strategy_hook(*args, **kwargs)\n output = strategy_output if output is None else output\n\n if pl_module:\n # restore current_fx when nested context\n pl_module._current_fx_name = prev_fx_name\n\n return output\n\n def _call_lightning_module_hook(\n self,\n hook_name: str,\n *args: Any,\n pl_module: Optional[\"pl.LightningModule\"] = None,\n **kwargs: Any,\n ) -> Any:\n pl_module = pl_module or self.lightning_module\n\n if pl_module is None:\n raise TypeError(\"No Lightning Module is available to call hooks on\")\n\n fn = getattr(pl_module, hook_name)\n if not callable(fn):\n return\n\n prev_fx_name = pl_module._current_fx_name\n pl_module._current_fx_name = hook_name\n\n with self.profiler.profile(f\"[LightningModule]{pl_module.__class__.__name__}.{hook_name}\"):\n output = fn(*args, **kwargs)\n\n # restore current_fx when nested context\n pl_module._current_fx_name = prev_fx_name\n\n return output\n\n def _call_callback_hooks(\n self,\n hook_name: str,\n *args: Any,\n **kwargs: Any,\n ) -> None:\n log.detail(f\"{self.__class__.__name__}: calling callback hook: {hook_name}\")\n # TODO: remove if block in v1.8\n if hook_name in (\"on_init_start\", \"on_init_end\"):\n # these `Callback` hooks are the only ones that do not take a lightning module.\n # we also don't profile bc profiler hasn't been set yet\n for callback in self.callbacks:\n fn = getattr(callback, hook_name)\n if callable(fn):\n fn(self, *args, **kwargs)\n return\n\n pl_module = self.lightning_module\n if pl_module:\n prev_fx_name = pl_module._current_fx_name\n pl_module._current_fx_name = hook_name\n\n # TODO: remove if block in v1.7\n if hook_name == \"on_train_batch_start\":\n with self.profiler.profile(hook_name):\n self._on_train_batch_start(*args, **kwargs)\n elif hook_name == \"on_train_batch_end\":\n with self.profiler.profile(hook_name):\n self._on_train_batch_end(*args, **kwargs)\n else:\n for callback in self.callbacks:\n fn = getattr(callback, hook_name)\n if callable(fn):\n with self.profiler.profile(f\"[Callback]{callback.state_key}.{hook_name}\"):\n fn(self, self.lightning_module, *args, **kwargs)\n\n if pl_module:\n # restore current_fx when nested context\n pl_module._current_fx_name = prev_fx_name\n\n # TODO: Delete this in v1.7 (deprecations: #9816 and #11148)\n def _on_train_batch_start(self, batch, batch_idx, dataloader_idx=0):\n r\"\"\"Called when the training batch begins. This function is needed because of two different deprecations affecting\n the original function in TrainerCallbackHookMixin: #9816 and #11148.\n \"\"\"\n for callback in self.callbacks:\n if is_param_in_hook_signature(callback.on_train_batch_start, \"dataloader_idx\", explicit=True):\n callback.on_train_batch_start(self, self.lightning_module, batch, batch_idx, 0)\n else:\n callback.on_train_batch_start(self, self.lightning_module, batch, batch_idx)\n\n # TODO: Delete this in v1.7 (deprecations: #9816 and #11148)\n def _on_train_batch_end(self, outputs: STEP_OUTPUT, batch, batch_idx, dataloader_idx=0):\n r\"\"\"Called when the training batch ends. This function is needed because of two different deprecations affecting\n the original function in TrainerCallbackHookMixin: #9816 and #11148.\n \"\"\"\n for callback in self.callbacks:\n if is_param_in_hook_signature(callback.on_train_batch_end, \"dataloader_idx\", explicit=True):\n callback.on_train_batch_end(self, self.lightning_module, outputs, batch, batch_idx, 0)\n else:\n callback.on_train_batch_end(self, self.lightning_module, outputs, batch, batch_idx)\n\n def _call_callbacks_state_dict(self) -> Dict[str, dict]:\n \"\"\"Called when saving a model checkpoint, calls and returns every callback's `state_dict`, keyed by\n `Callback.state_key`.\"\"\"\n callback_state_dicts = {}\n for callback in self.callbacks:\n state_dict = callback.state_dict()\n if state_dict:\n callback_state_dicts[callback.state_key] = state_dict\n return callback_state_dicts\n\n def _call_callbacks_on_save_checkpoint(self, checkpoint: Dict[str, Any]) -> None:\n \"\"\"Called when saving a model checkpoint, calls every callback's `on_save_checkpoint` hook.\n\n Will be removed in v1.8: If state is returned, we insert the callback state into\n ``checkpoint[\"callbacks\"][Callback.state_key]``. It overrides ``state_dict`` if already present.\n \"\"\"\n for callback in self.callbacks:\n # TODO: Add profiling for on_save_checkpoint hook\n state = callback.on_save_checkpoint(self, self.lightning_module, checkpoint)\n if state:\n # TODO: Add deprecation warning if state is returned (see reference PR #11887)\n checkpoint[\"callbacks\"][callback.state_key] = state\n\n def _call_callbacks_on_load_checkpoint(self, checkpoint: Dict[str, Any]) -> None:\n \"\"\"Called when loading a model checkpoint.\n\n Calls every callback's `on_load_checkpoint` hook. We have a dedicated function for this rather than using\n `_call_callback_hooks` because we have special logic for getting callback_states.\n \"\"\"\n callback_states: Dict[Union[Type, str], Dict] = checkpoint.get(\"callbacks\")\n\n if callback_states is None:\n return\n\n is_legacy_ckpt = Version(checkpoint[\"pytorch-lightning_version\"]) < Version(\"1.5.0dev\")\n current_callbacks_keys = {cb._legacy_state_key if is_legacy_ckpt else cb.state_key for cb in self.callbacks}\n difference = callback_states.keys() - current_callbacks_keys\n if difference:\n rank_zero_warn(\n \"Be aware that when using `ckpt_path`,\"\n \" callbacks used to create the checkpoint need to be provided during `Trainer` instantiation.\"\n f\" Please add the following callbacks: {list(difference)}.\",\n )\n\n for callback in self.callbacks:\n state = callback_states.get(callback.state_key, callback_states.get(callback._legacy_state_key))\n if state:\n state = deepcopy(state)\n # TODO: Add profiling for on_load_checkpoint hook\n callback.on_load_checkpoint(self, self.lightning_module, state)\n\n def _call_callbacks_load_state_dict(self, checkpoint: Dict[str, Any]) -> None:\n \"\"\"Called when loading a model checkpoint, calls every callback's `load_state_dict`.\"\"\"\n callback_states: Dict[Union[Type, str], Dict] = checkpoint.get(\"callbacks\")\n\n if callback_states is None:\n return\n\n for callback in self.callbacks:\n state = callback_states.get(callback.state_key, callback_states.get(callback._legacy_state_key))\n if state:\n state = deepcopy(state)\n callback.load_state_dict(state)\n\n def _call_strategy_hook(\n self,\n hook_name: str,\n *args: Any,\n **kwargs: Any,\n ) -> Any:\n pl_module = self.lightning_module\n prev_fx_name = pl_module._current_fx_name\n pl_module._current_fx_name = hook_name\n\n fn = getattr(self.strategy, hook_name)\n if not callable(fn):\n return\n\n with self.profiler.profile(f\"[Strategy]{self.strategy.__class__.__name__}.{hook_name}\"):\n output = fn(*args, **kwargs)\n\n # restore current_fx when nested context\n pl_module._current_fx_name = prev_fx_name\n\n return output\n\n @staticmethod\n def _parse_devices(\n gpus: Optional[Union[List[int], str, int]],\n auto_select_gpus: bool,\n tpu_cores: Optional[Union[List[int], str, int]],\n ) -> Tuple[Optional[List[int]], Optional[Union[List[int], int]]]:\n return device_parser._parse_devices(gpus, auto_select_gpus, tpu_cores)\n\n @staticmethod\n def _log_api_event(event: str) -> None:\n torch._C._log_api_usage_once(\"lightning.trainer.\" + event)\n\n def __init_profiler(self, profiler: Optional[Union[BaseProfiler, str]]) -> None:\n if isinstance(profiler, str):\n PROFILERS = {\n \"simple\": SimpleProfiler,\n \"advanced\": AdvancedProfiler,\n \"pytorch\": PyTorchProfiler,\n \"xla\": XLAProfiler,\n }\n profiler = profiler.lower()\n if profiler not in PROFILERS:\n raise MisconfigurationException(\n \"When passing string value for the `profiler` parameter of `Trainer`,\"\n f\" it can only be one of {list(PROFILERS.keys())}\"\n )\n profiler_class = PROFILERS[profiler]\n profiler = profiler_class()\n self.profiler: BaseProfiler = profiler or PassThroughProfiler()\n\n def __setup_profiler(self) -> None:\n local_rank = self.local_rank if self.world_size > 1 else None\n self.profiler._lightning_module = proxy(self.lightning_module)\n self.profiler.setup(stage=self.state.fn._setup_fn, local_rank=local_rank, log_dir=self.log_dir)\n\n def _log_device_info(self) -> None:\n rank_zero_info(\n f\"GPU available: {torch.cuda.is_available()}, used: {isinstance(self.accelerator, GPUAccelerator)}\"\n )\n\n num_tpu_cores = (\n self.tpu_cores if self.tpu_cores is not None and isinstance(self.accelerator, TPUAccelerator) else 0\n )\n rank_zero_info(f\"TPU available: {_TPU_AVAILABLE}, using: {num_tpu_cores} TPU cores\")\n\n num_ipus = self.ipus if self.ipus is not None else 0\n rank_zero_info(f\"IPU available: {_IPU_AVAILABLE}, using: {num_ipus} IPUs\")\n\n if torch.cuda.is_available() and not isinstance(self.accelerator, GPUAccelerator):\n rank_zero_warn(\n \"GPU available but not used. Set `accelerator` and `devices` using\"\n f\" `Trainer(accelerator='gpu', devices={GPUAccelerator.auto_device_count()})`.\",\n category=PossibleUserWarning,\n )\n\n if _TPU_AVAILABLE and not isinstance(self.accelerator, TPUAccelerator):\n rank_zero_warn(\n \"TPU available but not used. Set `accelerator` and `devices` using\"\n f\" `Trainer(accelerator='tpu', devices={TPUAccelerator.auto_device_count()})`.\"\n )\n\n if _IPU_AVAILABLE and not isinstance(self.accelerator, IPUAccelerator):\n rank_zero_warn(\n \"IPU available but not used. Set `accelerator` and `devices` using\"\n f\" `Trainer(accelerator='ipu', devices={IPUAccelerator.auto_device_count()})`.\"\n )\n\n \"\"\"\n Data loading methods\n \"\"\"\n\n def reset_train_dataloader(self, model: Optional[\"pl.LightningModule\"] = None) -> None:\n \"\"\"Resets the train dataloader and initialises required variables (number of batches, when to validate,\n etc.).\n\n Args:\n model: The ``LightningModule`` if calling this outside of the trainer scope.\n \"\"\"\n source = self._data_connector._train_dataloader_source\n pl_module = self.lightning_module or model\n has_step = is_overridden(\"training_step\", pl_module)\n enable_training = self.limit_train_batches > 0\n if not (source.is_defined() and has_step and enable_training):\n return\n\n self.train_dataloader = self._data_connector._request_dataloader(RunningStage.TRAINING, model=model)\n\n if self.overfit_batches > 0:\n self.train_dataloader = self._data_connector._resolve_overfit_batches(self.train_dataloader)\n\n # automatically add samplers\n self.train_dataloader = apply_to_collection(\n self.train_dataloader,\n (DataLoader, CombinedLoader),\n self._data_connector._prepare_dataloader,\n mode=RunningStage.TRAINING,\n )\n loaders = (\n self.train_dataloader.loaders\n if isinstance(self.train_dataloader, CombinedLoader)\n else self.train_dataloader\n )\n\n # check the workers recursively\n apply_to_collection(loaders, DataLoader, self._data_connector._worker_check, \"train_dataloader\")\n\n # add worker_init_fn for correct seeding in worker processes\n apply_to_collection(loaders, DataLoader, _auto_add_worker_init_fn, rank=self.global_rank)\n\n # add collate_fn to collect metadata for fault tolerant training\n if _fault_tolerant_training():\n apply_to_collection(loaders, DataLoader, _add_capture_metadata_collate)\n\n # wrap the sequence of train loaders to a CombinedLoader object for computing the num_training_batches\n if not isinstance(self.train_dataloader, CombinedLoader):\n self.train_dataloader = CombinedLoader(loaders, self._data_connector.multiple_trainloader_mode)\n\n module = model or self.lightning_module or self.datamodule\n self.num_training_batches = (\n len(self.train_dataloader)\n if has_len_all_ranks(self.train_dataloader, self.strategy, module)\n else float(\"inf\")\n )\n\n if isinstance(self.limit_train_batches, int):\n self.num_training_batches = min(self.num_training_batches, int(self.limit_train_batches))\n elif self.num_training_batches != float(\"inf\"):\n self.num_training_batches = int(self.num_training_batches * self.limit_train_batches)\n elif self.limit_train_batches != 1.0:\n raise MisconfigurationException(\n \"When using an IterableDataset for `limit_train_batches`,\"\n \" `Trainer(limit_train_batches)` must be `1.0` or an int. An int k specifies\"\n \" `num_training_batches` to use.\"\n )\n\n if isinstance(self.val_check_interval, int):\n self.val_check_batch = self.val_check_interval\n if self.val_check_batch > self.num_training_batches:\n raise ValueError(\n f\"`val_check_interval` ({self.val_check_interval}) must be less than or equal \"\n f\"to the number of the training batches ({self.num_training_batches}). \"\n \"If you want to disable validation set `limit_val_batches` to 0.0 instead.\"\n )\n else:\n if not has_len_all_ranks(self.train_dataloader, self.strategy, module):\n if self.val_check_interval == 1.0:\n self.val_check_batch = float(\"inf\")\n else:\n raise MisconfigurationException(\n \"When using an IterableDataset for `train_dataloader`,\"\n \" `Trainer(val_check_interval)` must be `1.0` or an int. An int k specifies\"\n \" checking validation every k training batches.\"\n )\n else:\n self.val_check_batch = int(self.num_training_batches * self.val_check_interval)\n self.val_check_batch = max(1, self.val_check_batch)\n\n if self.loggers and self.num_training_batches < self.log_every_n_steps:\n rank_zero_warn(\n f\"The number of training samples ({self.num_training_batches}) is smaller than the logging interval\"\n f\" Trainer(log_every_n_steps={self.log_every_n_steps}). Set a lower value for log_every_n_steps if\"\n \" you want to see logs for the training epoch.\",\n category=PossibleUserWarning,\n )\n\n # store epoch of dataloader reset for reload_dataloaders_every_n_epochs\n self._last_train_dl_reload_epoch = self.current_epoch\n\n def reset_val_dataloader(self, model: Optional[\"pl.LightningModule\"] = None) -> None:\n \"\"\"Resets the validation dataloader and determines the number of batches.\n\n Args:\n model: The ``LightningModule`` if called outside of the trainer scope.\n \"\"\"\n source = self._data_connector._val_dataloader_source\n pl_module = self.lightning_module or model\n has_step = is_overridden(\"validation_step\", pl_module)\n enable_validation = self.limit_val_batches > 0\n if source.is_defined() and has_step and enable_validation:\n self.num_val_batches, self.val_dataloaders = self._data_connector._reset_eval_dataloader(\n RunningStage.VALIDATING, model=pl_module\n )\n\n # store epoch of dataloader reset for reload_dataloaders_every_n_epochs\n self._last_val_dl_reload_epoch = self.current_epoch\n\n def reset_test_dataloader(self, model: Optional[\"pl.LightningModule\"] = None) -> None:\n \"\"\"Resets the test dataloader and determines the number of batches.\n\n Args:\n model: The ``LightningModule`` if called outside of the trainer scope.\n \"\"\"\n source = self._data_connector._test_dataloader_source\n pl_module = self.lightning_module or model\n has_step = is_overridden(\"test_step\", pl_module)\n enable_testing = self.limit_test_batches > 0\n if source.is_defined() and has_step and enable_testing:\n self.num_test_batches, self.test_dataloaders = self._data_connector._reset_eval_dataloader(\n RunningStage.TESTING, model=pl_module\n )\n\n def reset_predict_dataloader(self, model: Optional[\"pl.LightningModule\"] = None) -> None:\n \"\"\"Resets the predict dataloader and determines the number of batches.\n\n Args:\n model: The ``LightningModule`` if called outside of the trainer scope.\n \"\"\"\n source = self._data_connector._predict_dataloader_source\n pl_module = self.lightning_module or model\n enable_prediction = self.limit_predict_batches > 0\n if source.is_defined() and enable_prediction:\n self.num_predict_batches, self.predict_dataloaders = self._data_connector._reset_eval_dataloader(\n RunningStage.PREDICTING, model=pl_module\n )\n\n def reset_train_val_dataloaders(self, model: Optional[\"pl.LightningModule\"] = None) -> None:\n \"\"\"Resets train and val dataloaders if none are attached to the trainer.\n\n The val dataloader must be initialized before training loop starts, as the training loop\n inspects the val dataloader to determine whether to run the evaluation loop.\n Args:\n model: The ``LightningModule`` if called outside of the trainer scope.\n \"\"\"\n if self.train_dataloader is None:\n self.reset_train_dataloader(model=model)\n if self.val_dataloaders is None:\n self.reset_val_dataloader(model=model)\n\n \"\"\"\n Accelerator properties\n \"\"\"\n\n @property\n def accelerator(self) -> Accelerator:\n return self.strategy.accelerator\n\n @property\n def strategy(self) -> Strategy:\n return self._accelerator_connector.strategy\n\n @property\n def training_type_plugin(self) -> Strategy:\n rank_zero_deprecation(\n \"`Trainer.training_type_plugin` is deprecated in v1.6 and will be removed in v1.8. Use\"\n \" `Trainer.strategy` instead.\"\n )\n return self.strategy\n\n @property\n def precision_plugin(self) -> PrecisionPlugin:\n return self.strategy.precision_plugin\n\n @property\n def global_rank(self) -> int:\n return self.strategy.global_rank\n\n @property\n def local_rank(self) -> int:\n # some training types define a local rank\n return getattr(self.strategy, \"local_rank\", 0)\n\n @property\n def node_rank(self) -> int:\n # some training types define a node rank\n return getattr(self.strategy, \"node_rank\", 0)\n\n @property\n def world_size(self) -> int:\n # some training types define a world size\n return getattr(self.strategy, \"world_size\", 1)\n\n @property\n def should_rank_save_checkpoint(self) -> bool:\n rank_zero_deprecation(\n \"`Trainer.should_rank_save_checkpoint` is deprecated in v1.6 and will be removed in v1.8.\", stacklevel=5\n )\n strategy = self.strategy\n return (\n isinstance(strategy, pl.strategies.TPUSpawnStrategy) and strategy.local_rank == 0 or strategy.is_global_zero\n )\n\n @property\n def num_nodes(self) -> int:\n return getattr(self.strategy, \"num_nodes\", 1)\n\n @property\n def device_ids(self) -> List[int]:\n \"\"\"List of device indexes per node.\"\"\"\n devices = getattr(self.strategy, \"parallel_devices\", [self.strategy.root_device])\n device_ids = []\n for idx, device in enumerate(devices):\n if isinstance(device, torch.device):\n device_ids.append(device.index or idx)\n elif isinstance(device, int):\n device_ids.append(device)\n return device_ids\n\n @property\n def num_devices(self) -> int:\n \"\"\"Number of devices the trainer uses per node.\"\"\"\n return len(self.device_ids)\n\n @property\n def num_processes(self) -> int:\n return self._accelerator_connector.num_processes\n\n @property\n def root_gpu(self) -> Optional[int]:\n rank_zero_deprecation(\n \"`Trainer.root_gpu` is deprecated in v1.6 and will be removed in v1.8. \"\n \"Please use `Trainer.strategy.root_device.index` instead.\"\n )\n return self.strategy.root_device.index if isinstance(self.accelerator, GPUAccelerator) else None\n\n @property\n def tpu_cores(self) -> int:\n return self._accelerator_connector.tpu_cores\n\n @property\n def ipus(self) -> int:\n return self._accelerator_connector.num_ipus\n\n @property\n def num_gpus(self) -> int:\n rank_zero_deprecation(\n \"`Trainer.num_gpus` was deprecated in v1.6 and will be removed in v1.8.\"\n \" Please use `Trainer.num_devices` instead.\"\n )\n return self.num_devices if isinstance(self.accelerator, GPUAccelerator) else 0\n\n @property\n def devices(self) -> int:\n rank_zero_deprecation(\n \"`Trainer.devices` was deprecated in v1.6 and will be removed in v1.8.\"\n \" Please use `Trainer.num_devices` or `Trainer.device_ids` to get device information instead.\"\n )\n return self.num_devices\n\n @property\n def data_parallel_device_ids(self) -> Optional[List[int]]:\n return (\n self._accelerator_connector.parallel_device_ids if self._accelerator_connector.parallel_device_ids else None\n )\n\n @property\n def lightning_module(self) -> \"pl.LightningModule\":\n # TODO: this is actually an optional return\n return self.strategy.lightning_module\n\n @property\n def optimizers(self) -> List[Optimizer]:\n return self.strategy.optimizers\n\n @optimizers.setter\n def optimizers(self, new_optims: Optional[List[Optimizer]]) -> None:\n self.strategy.optimizers = new_optims\n\n @property\n def lightning_optimizers(self) -> Dict[int, LightningOptimizer]:\n rank_zero_deprecation(\n \"`Trainer.lightning_optimizers` is deprecated in v1.6 and will be removed in v1.8\", stacklevel=5\n )\n return self.strategy._lightning_optimizers\n\n @property\n def lr_scheduler_configs(self) -> List[LRSchedulerConfig]:\n return self.strategy.lr_scheduler_configs\n\n @property\n def lr_schedulers(self) -> List[Dict[str, Any]]:\n rank_zero_deprecation(\n \"`Trainer.lr_schedulers` is deprecated in v1.6 and will be removed in v1.8.\"\n \" You can use `trainer.lr_scheduler_configs` instead which contains dataclasses instead of dictionaries.\",\n stacklevel=5,\n )\n from dataclasses import asdict\n\n return [asdict(config) for config in self.strategy.lr_scheduler_configs]\n\n @property\n def optimizer_frequencies(self) -> List[int]:\n return self.strategy.optimizer_frequencies\n\n @optimizer_frequencies.setter\n def optimizer_frequencies(self, new_freqs: List[int]) -> None:\n self.strategy.optimizer_frequencies = new_freqs\n\n @property\n def amp_backend(self) -> Optional[AMPType]:\n if isinstance(self.precision_plugin, ApexMixedPrecisionPlugin):\n return AMPType.APEX\n if isinstance(self.precision_plugin, NativeMixedPrecisionPlugin):\n return AMPType.NATIVE\n return None\n\n @property\n def precision(self) -> Union[str, int]:\n return self.strategy.precision_plugin.precision\n\n @property\n def scaler(self) -> Optional[Any]:\n return getattr(self.precision_plugin, \"scaler\", None)\n\n @property\n def gpus(self) -> Optional[Union[List[int], str, int]]:\n return self._accelerator_connector.gpus\n\n @property\n def model(self) -> torch.nn.Module:\n \"\"\"The LightningModule, but possibly wrapped into DataParallel or DistributedDataParallel.\n\n To access the pure LightningModule, use\n :meth:`~pytorch_lightning.trainer.trainer.Trainer.lightning_module` instead.\n \"\"\"\n return self.strategy.model\n\n @model.setter\n def model(self, model: torch.nn.Module) -> None:\n \"\"\"Setter for the model, pass-through to accelerator and plugin where the model reference is stored. Used\n by the Tuner to reset the state of Trainer and Accelerator.\n\n Args:\n model: The LightningModule, possibly wrapped into DataParallel or DistributedDataParallel, depending\n on the backend.\n \"\"\"\n self.strategy.model = model\n\n \"\"\"\n General properties\n \"\"\"\n\n @property\n def log_dir(self) -> Optional[str]:\n if len(self.loggers) == 1:\n if isinstance(self.logger, TensorBoardLogger):\n dirpath = self.logger.log_dir\n else:\n dirpath = self.logger.save_dir\n else:\n dirpath = self.default_root_dir\n\n dirpath = self.strategy.broadcast(dirpath)\n return dirpath\n\n @property\n def use_amp(self) -> bool:\n rank_zero_deprecation(\n \"`Trainer.use_amp` is deprecated in v1.6.0 and will be removed in v1.8.0.\"\n \" Please use `Trainer.amp_backend` instead.\"\n )\n return self.precision == 16\n\n @property\n def is_global_zero(self) -> bool:\n return self.strategy.is_global_zero\n\n @property\n def slurm_job_id(self) -> Optional[int]:\n rank_zero_deprecation(\"Method `slurm_job_id` is deprecated in v1.6.0 and will be removed in v1.7.0.\")\n return SLURMEnvironment.job_id()\n\n @property\n def distributed_sampler_kwargs(self) -> Optional[dict]:\n if isinstance(self.strategy, ParallelStrategy):\n return self.strategy.distributed_sampler_kwargs\n\n @property\n def data_parallel(self) -> bool:\n return isinstance(self.strategy, ParallelStrategy)\n\n @property\n def progress_bar_dict(self) -> dict:\n \"\"\"Read-only for progress bar metrics.\"\"\"\n rank_zero_deprecation(\n \"`trainer.progress_bar_dict` is deprecated in v1.5 and will be removed in v1.7.\"\n \" Use `ProgressBarBase.get_metrics` instead.\"\n )\n ref_model = self.lightning_module\n ref_model = cast(pl.LightningModule, ref_model)\n if self.progress_bar_callback:\n return self.progress_bar_callback.get_metrics(self, ref_model)\n return self.progress_bar_metrics\n\n @property\n def enable_validation(self) -> bool:\n \"\"\"Check if we should run validation during training.\"\"\"\n return (\n self._data_connector._val_dataloader_source.is_defined()\n and is_overridden(\"validation_step\", self.lightning_module)\n and self.limit_val_batches > 0\n )\n\n @property\n def default_root_dir(self) -> str:\n \"\"\"The default location to save artifacts of loggers, checkpoints etc.\n\n It is used as a fallback if logger or checkpoint callback do not define specific save paths.\n \"\"\"\n if get_filesystem(self._default_root_dir).protocol == \"file\":\n return os.path.normpath(self._default_root_dir)\n return self._default_root_dir\n\n @property\n def weights_save_path(self) -> str:\n \"\"\"\n The default root location to save weights (checkpoints), e.g., when the\n :class:`~pytorch_lightning.callbacks.model_checkpoint.ModelCheckpoint` does not define a file path.\n\n .. deprecated:: v1.6\n `Trainer.weights_save_path` has been deprecated in v1.6 and will be removed in v1.8.\n \"\"\"\n rank_zero_deprecation(\"`Trainer.weights_save_path` has been deprecated in v1.6 and will be removed in v1.8.\")\n return self._weights_save_path_internal\n\n # TODO: Remove _weights_save_path_internal in v1.8\n @property\n def _weights_save_path_internal(self) -> str:\n \"\"\"This is an internal implementation of weights_save_path which allows weights_save_path to be used\n internally by the framework without emitting a deprecation warning.\n\n To be removed in v1.8.\n \"\"\"\n if get_filesystem(self._weights_save_path).protocol == \"file\":\n return os.path.normpath(self._weights_save_path)\n return self._weights_save_path\n\n @property\n def early_stopping_callback(self) -> Optional[EarlyStopping]:\n \"\"\"The first :class:`~pytorch_lightning.callbacks.early_stopping.EarlyStopping` callback in the\n Trainer.callbacks list, or ``None`` if it doesn't exist.\"\"\"\n callbacks = self.early_stopping_callbacks\n return callbacks[0] if len(callbacks) > 0 else None\n\n @property\n def early_stopping_callbacks(self) -> List[EarlyStopping]:\n \"\"\"A list of all instances of :class:`~pytorch_lightning.callbacks.early_stopping.EarlyStopping` found in\n the Trainer.callbacks list.\"\"\"\n return [c for c in self.callbacks if isinstance(c, EarlyStopping)]\n\n @property\n def prediction_writer_callbacks(self) -> List[BasePredictionWriter]:\n \"\"\"A list of all instances of :class:`~pytorch_lightning.callbacks.prediction_writer.BasePredictionWriter`\n found in the Trainer.callbacks list.\"\"\"\n return [cb for cb in self.callbacks if isinstance(cb, BasePredictionWriter)]\n\n @property\n def checkpoint_callback(self) -> Optional[ModelCheckpoint]:\n \"\"\"The first :class:`~pytorch_lightning.callbacks.model_checkpoint.ModelCheckpoint` callback in the\n Trainer.callbacks list, or ``None`` if it doesn't exist.\"\"\"\n callbacks = self.checkpoint_callbacks\n return callbacks[0] if len(callbacks) > 0 else None\n\n @property\n def checkpoint_callbacks(self) -> List[ModelCheckpoint]:\n \"\"\"A list of all instances of :class:`~pytorch_lightning.callbacks.model_checkpoint.ModelCheckpoint` found\n in the Trainer.callbacks list.\"\"\"\n return [c for c in self.callbacks if isinstance(c, ModelCheckpoint)]\n\n @property\n def progress_bar_callback(self) -> Optional[ProgressBarBase]:\n \"\"\"An instance of :class:`~pytorch_lightning.callbacks.progress.base.ProgressBarBase` found in the\n Trainer.callbacks list, or ``None`` if one doesn't exist.\"\"\"\n for c in self.callbacks:\n if isinstance(c, ProgressBarBase):\n return c\n return None\n\n @property\n def resume_from_checkpoint(self) -> Optional[Union[str, Path]]:\n resume_from_checkpoint = self._checkpoint_connector.resume_from_checkpoint_fit_path\n if resume_from_checkpoint is not None:\n rank_zero_deprecation(\n \"`trainer.resume_from_checkpoint` is deprecated in v1.5 and will be removed in v2.0.\"\n \" Specify the fit checkpoint path with `trainer.fit(ckpt_path=)` instead.\",\n stacklevel=5,\n )\n\n return resume_from_checkpoint\n\n @property\n def ckpt_path(self) -> Optional[str]:\n \"\"\"Set to the path/URL of a checkpoint loaded via :meth:`~pytorch_lightning.trainer.trainer.Trainer.fit`,\n :meth:`~pytorch_lightning.trainer.trainer.Trainer.validate`,\n :meth:`~pytorch_lightning.trainer.trainer.Trainer.test`, or\n :meth:`~pytorch_lightning.trainer.trainer.Trainer.predict`. ``None`` otherwise.\"\"\"\n return self._ckpt_path\n\n @property\n def validated_ckpt_path(self) -> Optional[str]:\n rank_zero_deprecation(\n \"The `Trainer.validated_ckpt_path` attribute was deprecated in v1.6 and will be removed in v1.8. The\"\n \" path of a checkpoint loaded via `Trainer.{fit,validate,test,predict}` should be accessed via\"\n \" `Trainer.ckpt_path` instead.\",\n stacklevel=5,\n )\n return self._validated_ckpt_path\n\n @validated_ckpt_path.setter\n def validated_ckpt_path(self, ckpt_path: Optional[str]) -> None:\n rank_zero_deprecation(\n \"The `Trainer.validated_ckpt_path` attribute was deprecated in v1.6 and will be removed in v1.8. The\"\n \" path of a checkpoint loaded via `Trainer.{fit,validate,test,predict}` should be accessed via the\"\n \" read-only `Trainer.ckpt_path`.\",\n stacklevel=5,\n )\n self._validated_ckpt_path = ckpt_path\n\n @property\n def tested_ckpt_path(self) -> Optional[str]:\n rank_zero_deprecation(\n \"The `Trainer.tested_ckpt_path` attribute was deprecated in v1.6 and will be removed in v1.8. The\"\n \" path of a checkpoint loaded via `Trainer.{fit,validate,test,predict}` should be accessed via\"\n \" `Trainer.ckpt_path` instead.\",\n stacklevel=5,\n )\n return self._tested_ckpt_path\n\n @tested_ckpt_path.setter\n def tested_ckpt_path(self, ckpt_path: Optional[str]) -> None:\n rank_zero_deprecation(\n \"The `Trainer.tested_ckpt_path` attribute was deprecated in v1.6 and will be removed in v1.8. The\"\n \" path of a checkpoint loaded via `Trainer.{fit,validate,test,predict}` should be accessed via the\"\n \" read-only `Trainer.ckpt_path` instead.\",\n stacklevel=5,\n )\n self._tested_ckpt_path = ckpt_path\n\n @property\n def predicted_ckpt_path(self) -> Optional[str]:\n rank_zero_deprecation(\n \"The `Trainer.predicted_ckpt_path` attribute was deprecated in v1.6 and will be removed in v1.8. The\"\n \" path of a checkpoint loaded via `Trainer.{fit,validate,test,predict}` should be accessed via\"\n \" `Trainer.ckpt_path` instead.\",\n stacklevel=5,\n )\n return self._predicted_ckpt_path\n\n @predicted_ckpt_path.setter\n def predicted_ckpt_path(self, ckpt_path: Optional[str]) -> None:\n rank_zero_deprecation(\n \"The `Trainer.predicted_ckpt_path` attribute was deprecated in v1.6 and will be removed in v1.8. The\"\n \" path of a checkpoint loaded via `Trainer.{fit,validate,test,predict}` should be accessed via the\"\n \" read-only `Trainer.ckpt_path` instead.\",\n stacklevel=5,\n )\n self._predicted_ckpt_path = ckpt_path\n\n def save_checkpoint(\n self, filepath: _PATH, weights_only: bool = False, storage_options: Optional[Any] = None\n ) -> None:\n r\"\"\"\n Runs routine to create a checkpoint.\n\n Args:\n filepath: Path where checkpoint is saved.\n weights_only: If ``True``, will only save the model weights.\n storage_options: parameter for how to save to storage, passed to ``CheckpointIO`` plugin\n\n \"\"\"\n self._checkpoint_connector.save_checkpoint(filepath, weights_only=weights_only, storage_options=storage_options)\n\n \"\"\"\n Parsing properties\n \"\"\"\n\n @classmethod\n def default_attributes(cls) -> dict:\n init_signature = inspect.signature(cls)\n return {k: v.default for k, v in init_signature.parameters.items()}\n\n @classmethod\n def get_deprecated_arg_names(cls) -> List:\n \"\"\"Returns a list with deprecated Trainer arguments.\"\"\"\n depr_arg_names = []\n for name, val in cls.__dict__.items():\n if name.startswith(\"DEPRECATED\") and isinstance(val, (tuple, list)):\n depr_arg_names.extend(val)\n return depr_arg_names\n\n @classmethod\n def from_argparse_args(cls: Any, args: Union[Namespace, ArgumentParser], **kwargs) -> Any:\n return from_argparse_args(cls, args, **kwargs)\n\n @classmethod\n def parse_argparser(cls, arg_parser: Union[ArgumentParser, Namespace]) -> Namespace:\n return parse_argparser(cls, arg_parser)\n\n @classmethod\n def match_env_arguments(cls) -> Namespace:\n return parse_env_variables(cls)\n\n @classmethod\n def add_argparse_args(cls, parent_parser: ArgumentParser, **kwargs) -> ArgumentParser:\n return add_argparse_args(cls, parent_parser, **kwargs)\n\n \"\"\"\n State properties\n \"\"\"\n\n @property\n def interrupted(self) -> bool:\n return self.state.status == TrainerStatus.INTERRUPTED\n\n @property\n def training(self) -> bool:\n return self.state.stage == RunningStage.TRAINING\n\n @training.setter\n def training(self, val: bool) -> None:\n if val:\n self.state.stage = RunningStage.TRAINING\n elif self.training:\n self.state.stage = None\n\n @property\n def testing(self) -> bool:\n return self.state.stage == RunningStage.TESTING\n\n @testing.setter\n def testing(self, val: bool) -> None:\n if val:\n self.state.stage = RunningStage.TESTING\n elif self.testing:\n self.state.stage = None\n\n @property\n def predicting(self) -> bool:\n return self.state.stage == RunningStage.PREDICTING\n\n @predicting.setter\n def predicting(self, val: bool) -> None:\n if val:\n self.state.stage = RunningStage.PREDICTING\n elif self.predicting:\n self.state.stage = None\n\n @property\n def tuning(self) -> bool:\n return self.state.stage == RunningStage.TUNING\n\n @tuning.setter\n def tuning(self, val: bool) -> None:\n if val:\n self.state.stage = RunningStage.TUNING\n elif self.tuning:\n self.state.stage = None\n\n @property\n def validating(self) -> bool:\n return self.state.stage == RunningStage.VALIDATING\n\n @validating.setter\n def validating(self, val: bool) -> None:\n if val:\n self.state.stage = RunningStage.VALIDATING\n elif self.validating:\n self.state.stage = None\n\n @property\n def evaluating(self) -> bool:\n return self.state.stage and self.state.stage.evaluating\n\n @property\n def sanity_checking(self) -> bool:\n return self.state.stage == RunningStage.SANITY_CHECKING\n\n @sanity_checking.setter\n def sanity_checking(self, val: bool) -> None:\n if val:\n self.state.stage = RunningStage.SANITY_CHECKING\n elif self.sanity_checking:\n self.state.stage = None\n\n \"\"\"\n Loop properties\n \"\"\"\n\n @property\n def global_step(self) -> int:\n \"\"\"The number of optimizer steps taken (does not reset each epoch).\n\n This includes multiple optimizers and TBPTT steps (if enabled).\n \"\"\"\n return self.fit_loop.epoch_loop.global_step\n\n @property\n def current_epoch(self) -> int:\n \"\"\"The current epoch, updated after the epoch end hooks are run.\"\"\"\n return self.fit_loop.epoch_progress.current.completed\n\n @property\n def max_epochs(self) -> int:\n return self.fit_loop.max_epochs\n\n @property\n def min_epochs(self) -> int:\n return self.fit_loop.min_epochs\n\n @property\n def max_steps(self) -> int:\n return self.fit_loop.max_steps\n\n @property\n def min_steps(self) -> Optional[int]:\n return self.fit_loop.min_steps\n\n @property\n def is_last_batch(self) -> bool:\n return self.fit_loop.epoch_loop.batch_progress.is_last_batch\n\n @property\n def fit_loop(self) -> FitLoop:\n return self._fit_loop\n\n @fit_loop.setter\n def fit_loop(self, loop: FitLoop):\n \"\"\"Attach a custom fit loop to this Trainer.\n\n It will run with\n :meth:`~pytorch_lightning.trainer.trainer.Trainer.fit`.\n \"\"\"\n loop.trainer = self\n self._fit_loop = loop\n\n @property\n def validate_loop(self) -> EvaluationLoop:\n return self._validate_loop\n\n @validate_loop.setter\n def validate_loop(self, loop: EvaluationLoop):\n \"\"\"Attach a custom validation loop to this Trainer.\n\n It will run with\n :meth:`~pytorch_lightning.trainer.trainer.Trainer.validate`. Note that this loop is different from the one\n running during training inside the :meth:`pytorch_lightning.trainer.trainer.Trainer.fit` call.\n \"\"\"\n loop.trainer = self\n self._validate_loop = loop\n\n @property\n def test_loop(self) -> EvaluationLoop:\n return self._test_loop\n\n @test_loop.setter\n def test_loop(self, loop: EvaluationLoop):\n \"\"\"Attach a custom test loop to this Trainer.\n\n It will run with\n :meth:`~pytorch_lightning.trainer.trainer.Trainer.test`.\n \"\"\"\n loop.trainer = self\n self._test_loop = loop\n\n @property\n def predict_loop(self) -> PredictionLoop:\n return self._predict_loop\n\n @predict_loop.setter\n def predict_loop(self, loop: PredictionLoop):\n \"\"\"Attach a custom prediction loop to this Trainer.\n\n It will run with\n :meth:`~pytorch_lightning.trainer.trainer.Trainer.predict`.\n \"\"\"\n loop.trainer = self\n self._predict_loop = loop\n\n @property\n def verbose_evaluate(self) -> bool:\n rank_zero_deprecation(\n \"The `Trainer.verbose_evaluate` property has been deprecated and will be removed in v1.8. The current value\"\n \" returned is the union of the validate and test loop values. You can choose which one to access with\"\n \" `trainer.{validate,test}_loop.verbose`.\",\n stacklevel=5,\n )\n return self.validate_loop.verbose or self.test_loop.verbose\n\n @verbose_evaluate.setter\n def verbose_evaluate(self, verbose: bool) -> None:\n rank_zero_deprecation(\n \"The `Trainer.verbose_evaluate` property has been deprecated and will be removed in v1.8. This will set\"\n \" the value for both trainer.{validate,test}_loop.verbose`.\",\n stacklevel=5,\n )\n self.validate_loop.verbose = verbose\n self.test_loop.verbose = verbose\n\n @property\n def _evaluation_loop(self) -> EvaluationLoop:\n if self.state.fn in (TrainerFn.FITTING, TrainerFn.TUNING):\n return self.fit_loop.epoch_loop.val_loop\n if self.state.fn == TrainerFn.VALIDATING:\n return self.validate_loop\n if self.state.fn == TrainerFn.TESTING:\n return self.test_loop\n raise RuntimeError(\"The `Trainer._evaluation_loop` property isn't defined. Accessed outside of scope\")\n\n @property\n def _active_loop(self) -> Optional[Union[FitLoop, EvaluationLoop, PredictionLoop]]:\n if self.training:\n return self.fit_loop\n if self.sanity_checking or self.evaluating:\n return self._evaluation_loop\n if self.predicting:\n return self.predict_loop\n\n \"\"\"\n Logging properties\n \"\"\"\n\n @property\n def logger(self) -> Optional[LightningLoggerBase]:\n if len(self.loggers) == 0:\n return None\n if len(self.loggers) == 1:\n return self.loggers[0]\n else:\n rank_zero_warn(\n \"Using trainer.logger when Trainer is configured to use multiple loggers.\"\n \" This behavior will change in v1.8 when LoggerCollection is removed, and\"\n \" trainer.logger will return the first logger in trainer.loggers\"\n )\n with warnings.catch_warnings():\n warnings.simplefilter(\"ignore\")\n return LoggerCollection(self.loggers)\n\n @logger.setter\n def logger(self, logger: Optional[LightningLoggerBase]) -> None:\n if not logger:\n self.loggers = []\n elif isinstance(logger, LoggerCollection):\n self.loggers = list(logger)\n else:\n self.loggers = [logger]\n\n @property\n def loggers(self) -> List[LightningLoggerBase]:\n return self._loggers\n\n @loggers.setter\n def loggers(self, loggers: Optional[List[LightningLoggerBase]]) -> None:\n self._loggers = loggers if loggers else []\n\n @property\n def callback_metrics(self) -> dict:\n return self._logger_connector.callback_metrics\n\n @property\n def logged_metrics(self) -> dict:\n return self._logger_connector.logged_metrics\n\n @property\n def progress_bar_metrics(self) -> dict:\n return self._logger_connector.progress_bar_metrics\n\n @property\n def _results(self) -> Optional[_ResultCollection]:\n active_loop = self._active_loop\n if active_loop is not None:\n return active_loop._results\n\n def _exit_gracefully_on_signal(self) -> None:\n if not _fault_tolerant_training() or not self._should_terminate_gracefully():\n return\n raise ExitGracefullyException(0)\n\n def _should_terminate_gracefully(self) -> bool:\n value = torch.tensor(int(self._terminate_gracefully), device=self.strategy.root_device)\n return self.strategy.reduce(value, reduce_op=\"sum\") > 0\n\n @property\n def weights_summary(self) -> Optional[str]:\n rank_zero_deprecation(\"`Trainer.weights_summary` is deprecated in v1.5 and will be removed in v1.7.\")\n return self._weights_summary\n\n @weights_summary.setter\n def weights_summary(self, val: Optional[str]) -> None:\n rank_zero_deprecation(\"Setting `Trainer.weights_summary` is deprecated in v1.5 and will be removed in v1.7.\")\n self._weights_summary = val\n\n \"\"\"\n Other\n \"\"\"\n\n @property\n def estimated_stepping_batches(self) -> Union[int, float]:\n r\"\"\"\n Estimated stepping batches for the complete training inferred from DataLoaders, gradient\n accumulation factor and distributed setup.\n\n Examples::\n\n def configure_optimizers(self):\n optimizer = ...\n scheduler = torch.optim.lr_scheduler.OneCycleLR(\n optimizer, max_lr=1e-3, total_steps=self.trainer.estimated_stepping_batches\n )\n return [optimizer], [scheduler]\n\n \"\"\"\n accumulation_scheduler = self.accumulation_scheduler\n\n if accumulation_scheduler.epochs != [0]:\n raise MisconfigurationException(\n \"Estimated stepping batches cannot be computed with different\"\n \" `accumulate_grad_batches` at different epochs.\"\n )\n\n # infinite training\n if self.max_epochs == -1 and self.max_steps == -1:\n return float(\"inf\")\n\n if self.train_dataloader is None:\n rank_zero_info(\"Loading `train_dataloader` to estimate number of stepping batches.\")\n self.reset_train_dataloader()\n\n total_batches = self.num_training_batches\n\n # iterable dataset\n if total_batches == float(\"inf\"):\n return self.max_steps\n\n self.accumulate_grad_batches = accumulation_scheduler.get_accumulate_grad_batches(self.current_epoch)\n effective_batch_size = self.accumulate_grad_batches\n max_estimated_steps = math.ceil(total_batches / effective_batch_size) * max(self.max_epochs, 1)\n\n max_estimated_steps = min(max_estimated_steps, self.max_steps) if self.max_steps != -1 else max_estimated_steps\n return max_estimated_steps\n\n @property\n def terminate_on_nan(self) -> bool:\n rank_zero_deprecation(\"`Trainer.terminate_on_nan` is deprecated in v1.5 and will be removed in 1.7.\")\n return self._terminate_on_nan\n\n @terminate_on_nan.setter\n def terminate_on_nan(self, val: bool) -> None:\n rank_zero_deprecation(\n f\"Setting `Trainer.terminate_on_nan = {val}` is deprecated in v1.5 and will be removed in 1.7.\"\n f\" Please set `Trainer(detect_anomaly={val})` instead.\"\n )\n self._terminate_on_nan = val # : 212\n\n\ndef _determine_batch_limits(batches: Optional[Union[int, float]], name: str) -> Union[int, float]:\n if batches is None:\n # batches is optional to know if the user passed a value so that we can show the above info messages only to the\n # users that set a value explicitly\n return 1.0\n\n # differentiating based on the type can be error-prone for users. show a message describing the chosen behaviour\n if isinstance(batches, int) and batches == 1:\n if name == \"limit_train_batches\":\n message = \"1 batch per epoch will be used.\"\n elif name == \"val_check_interval\":\n message = \"validation will run after every batch.\"\n else:\n message = \"1 batch will be used.\"\n rank_zero_info(f\"`Trainer({name}=1)` was configured so {message}\")\n elif isinstance(batches, float) and batches == 1.0:\n if name == \"limit_train_batches\":\n message = \"100% of the batches per epoch will be used.\"\n elif name == \"val_check_interval\":\n message = \"validation will run at the end of the training epoch.\"\n else:\n message = \"100% of the batches will be used.\"\n rank_zero_info(f\"`Trainer({name}=1.0)` was configured so {message}.\")\n\n if 0 <= batches <= 1:\n return batches\n if batches > 1 and batches % 1.0 == 0:\n return int(batches)\n raise MisconfigurationException(\n f\"You have passed invalid value {batches} for {name}, it has to be in [0.0, 1.0] or an int.\"\n )\n",
"# Copyright The PyTorch Lightning team.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\"\"\"Test deprecated functionality which will be removed in v1.8.0.\"\"\"\nimport os\nimport time\nfrom unittest import mock\nfrom unittest.mock import Mock\n\nimport numpy as np\nimport pytest\nimport torch\nfrom torch import optim\n\nfrom pytorch_lightning import Callback, Trainer\nfrom pytorch_lightning.loggers import CSVLogger, LightningLoggerBase, LoggerCollection\nfrom pytorch_lightning.plugins.precision.precision_plugin import PrecisionPlugin\nfrom pytorch_lightning.plugins.training_type.ddp import DDPPlugin\nfrom pytorch_lightning.plugins.training_type.ddp2 import DDP2Plugin\nfrom pytorch_lightning.plugins.training_type.ddp_spawn import DDPSpawnPlugin\nfrom pytorch_lightning.plugins.training_type.deepspeed import DeepSpeedPlugin\nfrom pytorch_lightning.plugins.training_type.dp import DataParallelPlugin\nfrom pytorch_lightning.plugins.training_type.fully_sharded import DDPFullyShardedPlugin\nfrom pytorch_lightning.plugins.training_type.ipu import IPUPlugin\nfrom pytorch_lightning.plugins.training_type.sharded import DDPShardedPlugin\nfrom pytorch_lightning.plugins.training_type.sharded_spawn import DDPSpawnShardedPlugin\nfrom pytorch_lightning.plugins.training_type.single_device import SingleDevicePlugin\nfrom pytorch_lightning.plugins.training_type.single_tpu import SingleTPUPlugin\nfrom pytorch_lightning.plugins.training_type.tpu_spawn import TPUSpawnPlugin\nfrom pytorch_lightning.profiler import AbstractProfiler, AdvancedProfiler, SimpleProfiler\nfrom pytorch_lightning.strategies import ParallelStrategy\nfrom pytorch_lightning.trainer.configuration_validator import _check_datamodule_checkpoint_hooks\nfrom pytorch_lightning.trainer.states import RunningStage\nfrom pytorch_lightning.utilities.apply_func import move_data_to_device\nfrom pytorch_lightning.utilities.enums import DeviceType, DistributedType\nfrom pytorch_lightning.utilities.imports import _TORCHTEXT_LEGACY\nfrom pytorch_lightning.utilities.rank_zero import rank_zero_only, rank_zero_warn\nfrom tests.deprecated_api import no_deprecated_call\nfrom tests.helpers.boring_model import BoringDataModule, BoringModel\nfrom tests.helpers.runif import RunIf\nfrom tests.helpers.torchtext_utils import get_dummy_torchtext_data_iterator\n\n\ndef test_v1_8_0_deprecated_distributed_type_enum():\n\n with pytest.deprecated_call(match=\"has been deprecated in v1.6 and will be removed in v1.8.\"):\n _ = DistributedType.DDP\n\n\ndef test_v1_8_0_deprecated_device_type_enum():\n\n with pytest.deprecated_call(match=\"has been deprecated in v1.6 and will be removed in v1.8.\"):\n _ = DeviceType.CPU\n\n\[email protected](not _TORCHTEXT_LEGACY, reason=\"torchtext.legacy is deprecated.\")\ndef test_v1_8_0_deprecated_torchtext_batch():\n\n with pytest.deprecated_call(match=\"is deprecated and Lightning will remove support for it in v1.8\"):\n data_iterator, _ = get_dummy_torchtext_data_iterator(num_samples=3, batch_size=3)\n batch = next(iter(data_iterator))\n _ = move_data_to_device(batch=batch, device=torch.device(\"cpu\"))\n\n\ndef test_v1_8_0_on_init_start_end(tmpdir):\n class TestCallback(Callback):\n def on_init_start(self, trainer):\n print(\"Starting to init trainer!\")\n\n def on_init_end(self, trainer):\n print(\"Trainer is init now\")\n\n model = BoringModel()\n\n trainer = Trainer(\n callbacks=[TestCallback()],\n max_epochs=1,\n fast_dev_run=True,\n enable_progress_bar=False,\n logger=False,\n default_root_dir=tmpdir,\n )\n with pytest.deprecated_call(\n match=\"The `on_init_start` callback hook was deprecated in v1.6 and will be removed in v1.8\"\n ):\n trainer.fit(model)\n with pytest.deprecated_call(\n match=\"The `on_init_end` callback hook was deprecated in v1.6 and will be removed in v1.8\"\n ):\n trainer.validate(model)\n\n\ndef test_v1_8_0_deprecated_call_hook():\n trainer = Trainer(\n max_epochs=1,\n limit_val_batches=0.1,\n limit_train_batches=0.2,\n enable_progress_bar=False,\n logger=False,\n )\n with pytest.deprecated_call(match=\"was deprecated in v1.6 and will be removed in v1.8.\"):\n trainer.call_hook(\"test_hook\")\n\n\ndef test_v1_8_0_deprecated_warning_positional_category():\n with pytest.deprecated_call(match=r\"use `category=FutureWarning.\"):\n rank_zero_warn(\"foo\", FutureWarning)\n\n\ndef test_v1_8_0_deprecated_on_hpc_hooks(tmpdir):\n class TestModelSave(BoringModel):\n def on_hpc_save(self):\n print(\"on_hpc_save override\")\n\n class TestModelLoad(BoringModel):\n def on_hpc_load(self):\n print(\"on_hpc_load override\")\n\n save_model = TestModelSave()\n load_model = TestModelLoad()\n trainer = Trainer(default_root_dir=tmpdir, max_epochs=1, fast_dev_run=True)\n\n with pytest.deprecated_call(\n match=r\"Method `LightningModule.on_hpc_save` is deprecated in v1.6 and will be removed in v1.8.\"\n ):\n trainer.fit(save_model)\n with pytest.deprecated_call(\n match=r\"Method `LightningModule.on_hpc_load` is deprecated in v1.6 and will be removed in v1.8.\"\n ):\n trainer.fit(load_model)\n\n\ndef test_v1_8_0_deprecated_run_stage():\n trainer = Trainer()\n trainer._run_stage = Mock()\n with pytest.deprecated_call(match=\"`Trainer.run_stage` is deprecated in v1.6 and will be removed in v1.8.\"):\n trainer.run_stage()\n\n\ndef test_v1_8_0_trainer_verbose_evaluate():\n trainer = Trainer()\n with pytest.deprecated_call(match=\"verbose_evaluate` property has been deprecated and will be removed in v1.8\"):\n assert trainer.verbose_evaluate\n\n with pytest.deprecated_call(match=\"verbose_evaluate` property has been deprecated and will be removed in v1.8\"):\n trainer.verbose_evaluate = False\n\n\[email protected](\"fn_prefix\", [\"validated\", \"tested\", \"predicted\"])\ndef test_v1_8_0_trainer_ckpt_path_attributes(fn_prefix: str):\n test_attr = f\"{fn_prefix}_ckpt_path\"\n trainer = Trainer()\n with pytest.deprecated_call(match=f\"{test_attr}` attribute was deprecated in v1.6 and will be removed in v1.8\"):\n _ = getattr(trainer, test_attr)\n with pytest.deprecated_call(match=f\"{test_attr}` attribute was deprecated in v1.6 and will be removed in v1.8\"):\n setattr(trainer, test_attr, \"v\")\n\n\ndef test_v1_8_0_deprecated_trainer_should_rank_save_checkpoint(tmpdir):\n trainer = Trainer()\n with pytest.deprecated_call(\n match=r\"`Trainer.should_rank_save_checkpoint` is deprecated in v1.6 and will be removed in v1.8.\"\n ):\n _ = trainer.should_rank_save_checkpoint\n\n\ndef test_v1_8_0_deprecated_lr_scheduler():\n trainer = Trainer()\n with pytest.deprecated_call(match=r\"`Trainer.lr_schedulers` is deprecated in v1.6 and will be removed in v1.8.\"):\n assert trainer.lr_schedulers == []\n\n\ndef test_v1_8_0_trainer_optimizers_mixin():\n trainer = Trainer()\n model = BoringModel()\n trainer.strategy.connect(model)\n trainer.lightning_module.trainer = trainer\n\n with pytest.deprecated_call(\n match=r\"`TrainerOptimizersMixin.init_optimizers` was deprecated in v1.6 and will be removed in v1.8.\"\n ):\n trainer.init_optimizers(model)\n\n with pytest.deprecated_call(\n match=r\"`TrainerOptimizersMixin.convert_to_lightning_optimizers` was deprecated in v1.6 and will be removed in \"\n \"v1.8.\"\n ):\n trainer.convert_to_lightning_optimizers()\n\n\ndef test_v1_8_0_deprecate_trainer_callback_hook_mixin():\n methods_with_self = [\n \"on_before_accelerator_backend_setup\",\n \"on_configure_sharded_model\",\n \"on_init_start\",\n \"on_init_end\",\n \"on_fit_start\",\n \"on_fit_end\",\n \"on_sanity_check_start\",\n \"on_sanity_check_end\",\n \"on_train_epoch_start\",\n \"on_train_epoch_end\",\n \"on_validation_epoch_start\",\n \"on_validation_epoch_end\",\n \"on_test_epoch_start\",\n \"on_test_epoch_end\",\n \"on_predict_epoch_start\",\n \"on_epoch_start\",\n \"on_epoch_end\",\n \"on_train_start\",\n \"on_train_end\",\n \"on_pretrain_routine_start\",\n \"on_pretrain_routine_end\",\n \"on_batch_start\",\n \"on_batch_end\",\n \"on_validation_start\",\n \"on_validation_end\",\n \"on_test_start\",\n \"on_test_end\",\n \"on_predict_start\",\n \"on_predict_end\",\n \"on_after_backward\",\n ]\n methods_with_stage = [\n \"setup\",\n \"teardown\",\n ]\n methods_with_batch_batch_idx_dataloader_idx = [\n \"on_train_batch_start\",\n \"on_validation_batch_start\",\n \"on_test_batch_start\",\n \"on_predict_batch_start\",\n ]\n methods_with_outputs_batch_batch_idx_dataloader_idx = [\n \"on_train_batch_end\",\n \"on_validation_batch_end\",\n \"on_test_batch_end\",\n \"on_predict_batch_end\",\n ]\n methods_with_checkpoint = [\"on_save_checkpoint\", \"on_load_checkpoint\"]\n trainer = Trainer(\n max_epochs=1,\n limit_val_batches=0.1,\n limit_train_batches=0.2,\n enable_progress_bar=False,\n logger=False,\n )\n model = BoringModel()\n # need to attach model to trainer for testing of `on_pretrain_routine_start`\n trainer.strategy.connect(model)\n for method_name in methods_with_self:\n fn = getattr(trainer, method_name, None)\n with pytest.deprecated_call(match=\"was deprecated in v1.6 and will be removed in v1.8\"):\n fn()\n for method_name in methods_with_stage:\n fn = getattr(trainer, method_name)\n with pytest.deprecated_call(match=\"was deprecated in v1.6 and will be removed in v1.8\"):\n fn(stage=\"test\")\n for method_name in methods_with_batch_batch_idx_dataloader_idx:\n fn = getattr(trainer, method_name)\n with pytest.deprecated_call(match=\"was deprecated in v1.6 and will be removed in v1.8\"):\n fn(batch={}, batch_idx=0, dataloader_idx=0)\n for method_name in methods_with_outputs_batch_batch_idx_dataloader_idx:\n fn = getattr(trainer, method_name)\n with pytest.deprecated_call(match=\"was deprecated in v1.6 and will be removed in v1.8\"):\n fn(outputs=torch.tensor([[1.0, -1.0], [1.0, -1.0]]), batch={}, batch_idx=0, dataloader_idx=0)\n for method_name in methods_with_checkpoint:\n fn = getattr(trainer, method_name)\n with pytest.deprecated_call(match=\"was deprecated in v1.6 and will be removed in v1.8\"):\n fn(checkpoint={})\n with pytest.deprecated_call(match=\"was deprecated in v1.6 and will be removed in v1.8\"):\n trainer.on_predict_epoch_end(outputs=torch.tensor([[1.0, -1.0], [1.0, -1.0]]))\n with pytest.deprecated_call(match=\"was deprecated in v1.6 and will be removed in v1.8\"):\n trainer.on_exception(exception=Exception)\n with pytest.deprecated_call(match=\"was deprecated in v1.6 and will be removed in v1.8\"):\n trainer.on_before_backward(loss=torch.tensor([[1.0, -1.0], [1.0, -1.0]]))\n with pytest.deprecated_call(match=\"was deprecated in v1.6 and will be removed in v1.8\"):\n trainer.on_before_optimizer_step(\n optimizer=optim.SGD(model.parameters(), lr=0.01, momentum=0.9), optimizer_idx=0\n )\n with pytest.deprecated_call(match=\"was deprecated in v1.6 and will be removed in v1.8\"):\n trainer.on_before_zero_grad(optimizer=optim.SGD(model.parameters(), lr=0.01, momentum=0.9))\n\n\ndef test_v1_8_0_deprecated_training_type_plugin_property():\n trainer = Trainer()\n with pytest.deprecated_call(match=\"in v1.6 and will be removed in v1.8\"):\n trainer.training_type_plugin\n\n\ndef test_v1_8_0_deprecate_trainer_data_loading_mixin():\n trainer = Trainer(max_epochs=1)\n model = BoringModel()\n dm = BoringDataModule()\n trainer.fit(model, datamodule=dm)\n\n with pytest.deprecated_call(\n match=r\"`TrainerDataLoadingMixin.prepare_dataloader` was deprecated in v1.6 and will be removed in v1.8.\",\n ):\n trainer.prepare_dataloader(dataloader=model.train_dataloader, shuffle=False)\n with pytest.deprecated_call(\n match=r\"`TrainerDataLoadingMixin.request_dataloader` was deprecated in v1.6 and will be removed in v1.8.\",\n ):\n trainer.request_dataloader(stage=RunningStage.TRAINING)\n\n\ndef test_v_1_8_0_deprecated_device_stats_monitor_prefix_metric_keys():\n from pytorch_lightning.callbacks.device_stats_monitor import prefix_metric_keys\n\n with pytest.deprecated_call(match=\"in v1.6 and will be removed in v1.8\"):\n prefix_metric_keys({\"foo\": 1.0}, \"bar\")\n\n\[email protected](\n \"cls\",\n [\n DDPPlugin,\n DDP2Plugin,\n DDPSpawnPlugin,\n pytest.param(DeepSpeedPlugin, marks=RunIf(deepspeed=True)),\n DataParallelPlugin,\n DDPFullyShardedPlugin,\n pytest.param(IPUPlugin, marks=RunIf(ipu=True)),\n DDPShardedPlugin,\n DDPSpawnShardedPlugin,\n TPUSpawnPlugin,\n ],\n)\ndef test_v1_8_0_deprecated_training_type_plugin_classes(cls):\n old_name = cls.__name__\n new_name = old_name.replace(\"Plugin\", \"Strategy\")\n with pytest.deprecated_call(\n match=f\"{old_name}` is deprecated in v1.6 and will be removed in v1.8. Use .*{new_name}` instead.\"\n ):\n cls()\n\n\ndef test_v1_8_0_deprecated_single_device_plugin_class():\n with pytest.deprecated_call(\n match=(\n \"SingleDevicePlugin` is deprecated in v1.6 and will be removed in v1.8.\"\n \" Use `.*SingleDeviceStrategy` instead.\"\n )\n ):\n SingleDevicePlugin(\"cpu\")\n\n\n@RunIf(tpu=True)\ndef test_v1_8_0_deprecated_single_tpu_plugin_class():\n with pytest.deprecated_call(\n match=(\n \"SingleTPUPlugin` is deprecated in v1.6 and will be removed in v1.8.\" \" Use `.*SingleTPUStrategy` instead.\"\n )\n ):\n SingleTPUPlugin(0)\n\n\ndef test_v1_8_0_deprecated_lightning_optimizers():\n trainer = Trainer()\n with pytest.deprecated_call(\n match=\"Trainer.lightning_optimizers` is deprecated in v1.6 and will be removed in v1.8\"\n ):\n assert trainer.lightning_optimizers == {}\n\n\ndef test_v1_8_0_remove_on_batch_start_end(tmpdir):\n class TestCallback(Callback):\n def on_batch_start(self, *args, **kwargs):\n print(\"on_batch_start\")\n\n model = BoringModel()\n trainer = Trainer(\n callbacks=[TestCallback()],\n fast_dev_run=True,\n default_root_dir=tmpdir,\n )\n with pytest.deprecated_call(\n match=\"The `Callback.on_batch_start` hook was deprecated in v1.6 and will be removed in v1.8\"\n ):\n trainer.fit(model)\n\n class TestCallback(Callback):\n def on_batch_end(self, *args, **kwargs):\n print(\"on_batch_end\")\n\n trainer = Trainer(\n callbacks=[TestCallback()],\n fast_dev_run=True,\n default_root_dir=tmpdir,\n )\n with pytest.deprecated_call(\n match=\"The `Callback.on_batch_end` hook was deprecated in v1.6 and will be removed in v1.8\"\n ):\n trainer.fit(model)\n\n\ndef test_v1_8_0_on_configure_sharded_model(tmpdir):\n class TestCallback(Callback):\n def on_configure_sharded_model(self, trainer, model):\n print(\"Configuring sharded model\")\n\n model = BoringModel()\n\n trainer = Trainer(\n callbacks=[TestCallback()],\n max_epochs=1,\n fast_dev_run=True,\n enable_progress_bar=False,\n logger=False,\n default_root_dir=tmpdir,\n )\n with pytest.deprecated_call(\n match=\"The `on_configure_sharded_model` callback hook was deprecated in v1.6 and will be removed in v1.8.\"\n ):\n trainer.fit(model)\n\n\ndef test_v1_8_0_remove_on_epoch_start_end_lightning_module(tmpdir):\n class CustomModel(BoringModel):\n def on_epoch_start(self, *args, **kwargs):\n print(\"on_epoch_start\")\n\n model = CustomModel()\n trainer = Trainer(\n fast_dev_run=True,\n default_root_dir=tmpdir,\n )\n with pytest.deprecated_call(\n match=\"The `LightningModule.on_epoch_start` hook was deprecated in v1.6 and will be removed in v1.8\"\n ):\n trainer.fit(model)\n\n class CustomModel(BoringModel):\n def on_epoch_end(self, *args, **kwargs):\n print(\"on_epoch_end\")\n\n trainer = Trainer(\n fast_dev_run=True,\n default_root_dir=tmpdir,\n )\n\n model = CustomModel()\n with pytest.deprecated_call(\n match=\"The `LightningModule.on_epoch_end` hook was deprecated in v1.6 and will be removed in v1.8\"\n ):\n trainer.fit(model)\n\n\ndef test_v1_8_0_remove_on_pretrain_routine_start_end_lightning_module(tmpdir):\n class CustomModel(BoringModel):\n def on_pretrain_routine_start(self, *args, **kwargs):\n print(\"foo\")\n\n model = CustomModel()\n trainer = Trainer(\n fast_dev_run=True,\n default_root_dir=tmpdir,\n )\n with pytest.deprecated_call(\n match=\"The `LightningModule.on_pretrain_routine_start` hook was deprecated in v1.6 and will be removed in v1.8\"\n ):\n trainer.fit(model)\n\n class CustomModel(BoringModel):\n def on_pretrain_routine_end(self, *args, **kwargs):\n print(\"foo\")\n\n trainer = Trainer(\n fast_dev_run=True,\n default_root_dir=tmpdir,\n )\n\n model = CustomModel()\n with pytest.deprecated_call(\n match=\"The `LightningModule.on_pretrain_routine_end` hook was deprecated in v1.6 and will be removed in v1.8\"\n ):\n trainer.fit(model)\n\n\ndef test_v1_8_0_rank_zero_imports():\n\n import warnings\n\n from pytorch_lightning.utilities.distributed import rank_zero_debug, rank_zero_info\n from pytorch_lightning.utilities.warnings import LightningDeprecationWarning, rank_zero_deprecation, rank_zero_warn\n\n with pytest.deprecated_call(\n match=\"pytorch_lightning.utilities.distributed.rank_zero_debug has been deprecated in v1.6\"\n \" and will be removed in v1.8.\"\n ):\n rank_zero_debug(\"foo\")\n with pytest.deprecated_call(\n match=\"pytorch_lightning.utilities.distributed.rank_zero_info has been deprecated in v1.6\"\n \" and will be removed in v1.8.\"\n ):\n rank_zero_info(\"foo\")\n with pytest.deprecated_call(\n match=\"pytorch_lightning.utilities.warnings.rank_zero_warn has been deprecated in v1.6\"\n \" and will be removed in v1.8.\"\n ):\n rank_zero_warn(\"foo\")\n with pytest.deprecated_call(\n match=\"pytorch_lightning.utilities.warnings.rank_zero_deprecation has been deprecated in v1.6\"\n \" and will be removed in v1.8.\"\n ):\n rank_zero_deprecation(\"foo\")\n with pytest.deprecated_call(\n match=\"pytorch_lightning.utilities.warnings.LightningDeprecationWarning has been deprecated in v1.6\"\n \" and will be removed in v1.8.\"\n ):\n warnings.warn(\"foo\", LightningDeprecationWarning, stacklevel=5)\n\n\ndef test_v1_8_0_on_before_accelerator_backend_setup(tmpdir):\n class TestCallback(Callback):\n def on_before_accelerator_backend_setup(self, *args, **kwargs):\n print(\"on_before_accelerator_backend called.\")\n\n model = BoringModel()\n\n trainer = Trainer(\n callbacks=[TestCallback()],\n max_epochs=1,\n fast_dev_run=True,\n enable_progress_bar=False,\n logger=False,\n default_root_dir=tmpdir,\n )\n with pytest.deprecated_call(\n match=\"The `on_before_accelerator_backend_setup` callback hook was deprecated in v1.6\"\n \" and will be removed in v1.8\"\n ):\n trainer.fit(model)\n\n\ndef test_v1_8_0_logger_agg_parameters():\n class CustomLogger(LightningLoggerBase):\n @rank_zero_only\n def log_hyperparams(self, params):\n pass\n\n @rank_zero_only\n def log_metrics(self, metrics, step):\n pass\n\n @property\n def name(self):\n pass\n\n @property\n def version(self):\n pass\n\n with pytest.deprecated_call(\n match=\"The `agg_key_funcs` parameter for `LightningLoggerBase` was deprecated in v1.6\"\n \" and will be removed in v1.8.\"\n ):\n CustomLogger(agg_key_funcs={\"mean\", np.mean})\n\n with pytest.deprecated_call(\n match=\"The `agg_default_func` parameter for `LightningLoggerBase` was deprecated in v1.6\"\n \" and will be removed in v1.8.\"\n ):\n CustomLogger(agg_default_func=np.mean)\n\n # Should have no deprecation warning\n logger = CustomLogger()\n\n with pytest.deprecated_call(\n match=\"`LightningLoggerBase.update_agg_funcs` was deprecated in v1.6 and will be removed in v1.8.\"\n ):\n logger.update_agg_funcs()\n\n\ndef test_v1_8_0_deprecated_agg_and_log_metrics_override(tmpdir):\n class AggregationOverrideLogger(CSVLogger):\n @rank_zero_only\n def agg_and_log_metrics(self, metrics, step):\n self.log_metrics(metrics=metrics, step=step)\n\n logger = AggregationOverrideLogger(tmpdir)\n logger2 = CSVLogger(tmpdir)\n logger3 = CSVLogger(tmpdir)\n\n # Test single loggers\n with pytest.deprecated_call(\n match=\"`LightningLoggerBase.agg_and_log_metrics` is deprecated in v1.6 and will be removed\"\n \" in v1.8. `Trainer` will directly call `LightningLoggerBase.log_metrics` so custom\"\n \" loggers should not implement `LightningLoggerBase.agg_and_log_metrics`.\"\n ):\n Trainer(logger=logger)\n # Should have no deprecation warning\n Trainer(logger=logger2)\n\n # Test multiple loggers\n with pytest.deprecated_call(\n match=\"`LightningLoggerBase.agg_and_log_metrics` is deprecated in v1.6 and will be removed\"\n \" in v1.8. `Trainer` will directly call `LightningLoggerBase.log_metrics` so custom\"\n \" loggers should not implement `LightningLoggerBase.agg_and_log_metrics`.\"\n ):\n Trainer(logger=[logger, logger3])\n # Should have no deprecation warning\n Trainer(logger=[logger2, logger3])\n\n\ndef test_v1_8_0_callback_on_pretrain_routine_start_end(tmpdir):\n class TestCallback(Callback):\n def on_pretrain_routine_start(self, trainer, pl_module):\n print(\"on_pretrain_routine_start called.\")\n\n model = BoringModel()\n\n trainer = Trainer(\n callbacks=[TestCallback()],\n fast_dev_run=True,\n enable_progress_bar=False,\n default_root_dir=tmpdir,\n )\n with pytest.deprecated_call(\n match=\"The `Callback.on_pretrain_routine_start` hook has been deprecated in v1.6 and will be removed in v1.8\"\n ):\n trainer.fit(model)\n\n class TestCallback(Callback):\n def on_pretrain_routine_end(self, trainer, pl_module):\n print(\"on_pretrain_routine_end called.\")\n\n model = BoringModel()\n\n trainer = Trainer(\n callbacks=[TestCallback()],\n fast_dev_run=True,\n enable_progress_bar=False,\n default_root_dir=tmpdir,\n )\n with pytest.deprecated_call(\n match=\"The `Callback.on_pretrain_routine_end` hook has been deprecated in v1.6 and will be removed in v1.8\"\n ):\n trainer.fit(model)\n\n\ndef test_v1_8_0_weights_save_path(tmpdir):\n with pytest.deprecated_call(match=r\"Setting `Trainer\\(weights_save_path=\\)` has been deprecated in v1.6\"):\n trainer = Trainer(weights_save_path=tmpdir)\n with pytest.deprecated_call(match=r\"`Trainer.weights_save_path` has been deprecated in v1.6\"):\n _ = trainer.weights_save_path\n\n\ndef test_deprecated_epoch_outputs_format(tmpdir):\n class DeprecationModel(BoringModel):\n def __init__(self):\n super().__init__()\n self.truncated_bptt_steps = 1\n\n def training_step(self, batch, batch_idx, optimizer_idx, hiddens):\n output = super().training_step(batch, batch_idx)\n output[\"hiddens\"] = hiddens\n return output\n\n def tbptt_split_batch(self, batch, split_size):\n return [batch, batch]\n\n def training_epoch_end(self, outputs):\n ...\n\n def on_train_batch_end(self, outputs, batch, batch_idx) -> None:\n ...\n\n def configure_optimizers(self):\n return [torch.optim.Adam(self.parameters()), torch.optim.Adam(self.parameters())]\n\n trainer = Trainer(default_root_dir=tmpdir, fast_dev_run=True)\n model = DeprecationModel()\n batch_match = r\"on_train_batch_end.*will change in version v1.8 to \\(tbptt_steps, n_optimizers\\)\"\n with pytest.deprecated_call(match=batch_match):\n trainer.fit(model)\n\n class DeprecationModel2(DeprecationModel):\n def on_train_batch_end(self, *args, new_format=True):\n ...\n\n trainer = Trainer(default_root_dir=tmpdir, fast_dev_run=True)\n model = DeprecationModel()\n epoch_match = r\"training_epoch_end.*will change in version v1.8 to \\(n_batches, tbptt_steps, n_optimizers\\)\"\n with pytest.deprecated_call(match=epoch_match):\n trainer.fit(model)\n\n class NoDeprecationModel(DeprecationModel2):\n def training_epoch_end(self, outputs, new_format=True):\n ...\n\n trainer = Trainer(default_root_dir=tmpdir, fast_dev_run=True)\n model = NoDeprecationModel()\n with no_deprecated_call(match=\"will change in version v1.8.*new_format=True\"):\n trainer.fit(model)\n\n\[email protected](reruns=3)\[email protected]([\"action\", \"expected\"], [(\"a\", [3, 1]), (\"b\", [2]), (\"c\", [1])])\ndef test_simple_profiler_iterable_durations(tmpdir, action: str, expected: list):\n \"\"\"Ensure the reported durations are reasonably accurate.\"\"\"\n\n def _sleep_generator(durations):\n \"\"\"the profile_iterable method needs an iterable in which we can ensure that we're properly timing how long\n it takes to call __next__\"\"\"\n for duration in durations:\n time.sleep(duration)\n yield duration\n\n def _get_python_cprofile_total_duration(profile):\n return sum(x.inlinetime for x in profile.getstats())\n\n simple_profiler = SimpleProfiler()\n iterable = _sleep_generator(expected)\n\n with pytest.deprecated_call(\n match=\"`BaseProfiler.profile_iterable` is deprecated in v1.6 and will be removed in v1.8.\"\n ):\n for _ in simple_profiler.profile_iterable(iterable, action):\n pass\n\n # we exclude the last item in the recorded durations since that's when StopIteration is raised\n np.testing.assert_allclose(simple_profiler.recorded_durations[action][:-1], expected, rtol=0.2)\n\n advanced_profiler = AdvancedProfiler(dirpath=tmpdir, filename=\"profiler\")\n\n iterable = _sleep_generator(expected)\n\n with pytest.deprecated_call(\n match=\"`BaseProfiler.profile_iterable` is deprecated in v1.6 and will be removed in v1.8.\"\n ):\n for _ in advanced_profiler.profile_iterable(iterable, action):\n pass\n\n recorded_total_duration = _get_python_cprofile_total_duration(advanced_profiler.profiled_actions[action])\n expected_total_duration = np.sum(expected)\n np.testing.assert_allclose(recorded_total_duration, expected_total_duration, rtol=0.2)\n\n\ndef test_v1_8_0_logger_collection(tmpdir):\n logger1 = CSVLogger(tmpdir)\n logger2 = CSVLogger(tmpdir)\n\n trainer1 = Trainer(logger=logger1)\n trainer2 = Trainer(logger=[logger1, logger2])\n\n # Should have no deprecation warning\n trainer1.logger\n trainer1.loggers\n trainer2.loggers\n trainer2.logger\n\n with pytest.deprecated_call(match=\"`LoggerCollection` is deprecated in v1.6\"):\n LoggerCollection([logger1, logger2])\n\n\ndef test_v1_8_0_precision_plugin_checkpoint_hooks(tmpdir):\n class PrecisionPluginSaveHook(PrecisionPlugin):\n def on_save_checkpoint(self, checkpoint):\n print(\"override on_save_checkpoint\")\n\n class PrecisionPluginLoadHook(PrecisionPlugin):\n def on_load_checkpoint(self, checkpoint):\n print(\"override on_load_checkpoint\")\n\n model = BoringModel()\n\n precplugin_save = PrecisionPluginSaveHook()\n trainer = Trainer(default_root_dir=tmpdir, max_epochs=1, plugins=[precplugin_save])\n with pytest.deprecated_call(\n match=\"`PrecisionPlugin.on_save_checkpoint` was deprecated in\"\n \" v1.6 and will be removed in v1.8. Use `state_dict` instead.\"\n ):\n trainer.fit(model)\n\n precplugin_load = PrecisionPluginLoadHook()\n trainer = Trainer(default_root_dir=tmpdir, max_epochs=1, plugins=[precplugin_load])\n with pytest.deprecated_call(\n match=\"`PrecisionPlugin.on_load_checkpoint` was deprecated in\"\n \" v1.6 and will be removed in v1.8. Use `load_state_dict` instead.\"\n ):\n trainer.fit(model)\n\n\ndef test_v1_8_0_abstract_profiler():\n assert \"`AbstractProfiler` was deprecated in v1.6\" in AbstractProfiler.__doc__\n\n\ndef test_v1_8_0_datamodule_checkpointhooks():\n class CustomBoringDataModuleSave(BoringDataModule):\n def on_save_checkpoint(self, checkpoint):\n print(\"override on_save_checkpoint\")\n\n class CustomBoringDataModuleLoad(BoringDataModule):\n def on_load_checkpoint(self, checkpoint):\n print(\"override on_load_checkpoint\")\n\n trainer = Mock()\n\n trainer.datamodule = CustomBoringDataModuleSave()\n with pytest.deprecated_call(\n match=\"`LightningDataModule.on_save_checkpoint` was deprecated in\"\n \" v1.6 and will be removed in v1.8. Use `state_dict` instead.\"\n ):\n _check_datamodule_checkpoint_hooks(trainer)\n\n trainer.datamodule = CustomBoringDataModuleLoad()\n with pytest.deprecated_call(\n match=\"`LightningDataModule.on_load_checkpoint` was deprecated in\"\n \" v1.6 and will be removed in v1.8. Use `load_state_dict` instead.\"\n ):\n _check_datamodule_checkpoint_hooks(trainer)\n\n\ndef test_v1_8_0_trainer_use_amp(tmpdir):\n trainer = Trainer()\n\n with pytest.deprecated_call(match=\"`Trainer.use_amp` is deprecated in v1.6.0\"):\n _ = trainer.use_amp\n\n\ndef test_v1_8_0_lightning_module_use_amp():\n model = BoringModel()\n with pytest.deprecated_call(match=\"`LightningModule.use_amp` was deprecated in v1.6\"):\n _ = model.use_amp\n with pytest.deprecated_call(match=\"`LightningModule.use_amp` was deprecated in v1.6\"):\n model.use_amp = False\n\n\[email protected](os.environ, {\"PL_TORCH_DISTRIBUTED_BACKEND\": \"foo\"})\ndef test_v1_8_0_torch_distributed_backend_env():\n from pytorch_lightning.utilities.distributed import _get_process_group_backend_from_env\n\n with pytest.deprecated_call(\n match=\"Environment variable `PL_TORCH_DISTRIBUTED_BACKEND`\"\n \" was deprecated in v1.6 and will be removed in v1.8.\"\n ):\n _get_process_group_backend_from_env()\n\n\ndef test_parallel_strategy_torch_distributed_backend():\n class CustomParallel(ParallelStrategy):\n @property\n def root_device(self) -> torch.device:\n return torch.device(\"cpu\")\n\n def model_to_device(self):\n pass\n\n @property\n def is_global_zero(self):\n return True\n\n def broadcast(self, obj):\n return obj\n\n def reduce(self, tensor):\n return tensor\n\n def barrier(self):\n return\n\n def all_gather(self, tensor):\n return tensor\n\n strategy = CustomParallel()\n with pytest.deprecated_call(\n match=\"ParallelStrategy.torch_distributed_backend was deprecated\" \" in v1.6 and will be removed in v1.8.\"\n ):\n strategy.torch_distributed_backend\n\n\ndef test_trainer_config_device_ids():\n trainer = Trainer(devices=2)\n with pytest.deprecated_call(\n match=\"`Trainer.devices` was deprecated in v1.6 and will be removed in v1.8.\"\n \" Please use `Trainer.num_devices` or `Trainer.device_ids` to get device information instead.\"\n ):\n trainer.devices == 2\n\n\[email protected](\n [\"gpus\", \"expected_root_gpu\", \"strategy\"],\n [\n pytest.param(None, None, \"ddp\", id=\"None is None\"),\n pytest.param(0, None, \"ddp\", id=\"O gpus, expect gpu root device to be None.\"),\n pytest.param(1, 0, \"ddp\", id=\"1 gpu, expect gpu root device to be 0.\"),\n pytest.param(-1, 0, \"ddp\", id=\"-1 - use all gpus, expect gpu root device to be 0.\"),\n pytest.param(\"-1\", 0, \"ddp\", id=\"'-1' - use all gpus, expect gpu root device to be 0.\"),\n pytest.param(3, 0, \"ddp\", id=\"3 gpus, expect gpu root device to be 0.(backend:ddp)\"),\n ],\n)\ndef test_root_gpu_property(monkeypatch, gpus, expected_root_gpu, strategy):\n monkeypatch.setattr(torch.cuda, \"is_available\", lambda: True)\n monkeypatch.setattr(torch.cuda, \"device_count\", lambda: 16)\n with pytest.deprecated_call(\n match=\"`Trainer.root_gpu` is deprecated in v1.6 and will be removed in v1.8. \"\n \"Please use `Trainer.strategy.root_device.index` instead.\"\n ):\n assert Trainer(gpus=gpus, strategy=strategy).root_gpu == expected_root_gpu\n\n\[email protected](\n [\"gpus\", \"expected_root_gpu\", \"strategy\"],\n [\n pytest.param(None, None, None, id=\"None is None\"),\n pytest.param(None, None, \"ddp\", id=\"None is None\"),\n pytest.param(0, None, \"ddp\", id=\"None is None\"),\n ],\n)\ndef test_root_gpu_property_0_passing(monkeypatch, gpus, expected_root_gpu, strategy):\n monkeypatch.setattr(torch.cuda, \"device_count\", lambda: 0)\n with pytest.deprecated_call(\n match=\"`Trainer.root_gpu` is deprecated in v1.6 and will be removed in v1.8. \"\n \"Please use `Trainer.strategy.root_device.index` instead.\"\n ):\n assert Trainer(gpus=gpus, strategy=strategy).root_gpu == expected_root_gpu\n\n\[email protected](\n [\"gpus\", \"expected_num_gpus\", \"strategy\"],\n [\n pytest.param(None, 0, None, id=\"None - expect 0 gpu to use.\"),\n pytest.param(0, 0, None, id=\"Oth gpu, expect 1 gpu to use.\"),\n pytest.param(1, 1, None, id=\"1st gpu, expect 1 gpu to use.\"),\n pytest.param(-1, 16, \"ddp\", id=\"-1 - use all gpus\"),\n pytest.param(\"-1\", 16, \"ddp\", id=\"'-1' - use all gpus\"),\n pytest.param(3, 3, \"ddp\", id=\"3rd gpu - 1 gpu to use (backend:ddp)\"),\n ],\n)\ndef test_trainer_gpu_parse(monkeypatch, gpus, expected_num_gpus, strategy):\n monkeypatch.setattr(torch.cuda, \"is_available\", lambda: True)\n monkeypatch.setattr(torch.cuda, \"device_count\", lambda: 16)\n with pytest.deprecated_call(\n match=\"`Trainer.num_gpus` was deprecated in v1.6 and will be removed in v1.8.\"\n \" Please use `Trainer.num_devices` instead.\"\n ):\n assert Trainer(gpus=gpus, strategy=strategy).num_gpus == expected_num_gpus\n\n\[email protected](\n [\"gpus\", \"expected_num_gpus\", \"strategy\"],\n [\n pytest.param(None, 0, None, id=\"None - expect 0 gpu to use.\"),\n pytest.param(None, 0, \"ddp\", id=\"None - expect 0 gpu to use.\"),\n ],\n)\ndef test_trainer_num_gpu_0(monkeypatch, gpus, expected_num_gpus, strategy):\n monkeypatch.setattr(torch.cuda, \"device_count\", lambda: 0)\n with pytest.deprecated_call(\n match=\"`Trainer.num_gpus` was deprecated in v1.6 and will be removed in v1.8.\"\n \" Please use `Trainer.num_devices` instead.\"\n ):\n assert Trainer(gpus=gpus, strategy=strategy).num_gpus == expected_num_gpus\n"
] | [
[
"torch._C._log_api_usage_once",
"torch.no_grad",
"torch.autograd.set_detect_anomaly",
"torch.cuda.is_available",
"torch.set_grad_enabled"
],
[
"numpy.testing.assert_allclose",
"torch.device",
"numpy.sum",
"torch.tensor"
]
] |
saranyakrish14/glow | [
"3562fba6a77d2bb4aacf98a5bff5a737a93f6adc",
"3562fba6a77d2bb4aacf98a5bff5a737a93f6adc"
] | [
"torch_glow/tests/nodes/add_test.py",
"torch_glow/tests/nodes/sigmoid_test.py"
] | [
"from __future__ import absolute_import, division, print_function, unicode_literals\n\nimport torch\nfrom tests import utils\n\n\nclass SimpleAddModule(torch.nn.Module):\n def __init__(self, inplace=False):\n super(SimpleAddModule, self).__init__()\n self.inplace = inplace\n\n def forward(self, a, b):\n if b.size() == torch.Size([]):\n return (a * a).add(b.item())\n if self.inplace:\n c = a.add_(b)\n return c.add_(c)\n else:\n c = a.add(b)\n return c.add(c)\n\n\nclass TestAdd(utils.TorchGlowTestCase):\n @utils.deterministic_expand(\n [\n lambda: (\"basic\", SimpleAddModule(), torch.randn(4), torch.randn(4)),\n lambda: (\"inplace\", SimpleAddModule(True), torch.randn(4), torch.randn(4)),\n lambda: (\n \"broadcast\",\n SimpleAddModule(),\n torch.randn(8, 3, 4, 2),\n torch.randn(4, 2),\n ),\n lambda: (\n \"broadcast\",\n SimpleAddModule(),\n torch.randn(8, 3, 4, 2),\n torch.randn(1, 2),\n ),\n lambda: (\n \"broadcast\",\n SimpleAddModule(),\n torch.randn(4, 2),\n torch.randn(8, 3, 4, 2),\n ),\n lambda: (\"float\", SimpleAddModule(), torch.randn(4), torch.tensor(1.2345)),\n lambda: (\n \"float_and_int\",\n SimpleAddModule(),\n torch.randn(4),\n torch.tensor(42),\n True,\n ),\n lambda: (\n \"int32\",\n SimpleAddModule(),\n torch.torch.randint(-10, 10, (2, 4), dtype=torch.int32),\n torch.torch.randint(-10, 10, (2, 4), dtype=torch.int32),\n ),\n lambda: (\n \"int64\",\n SimpleAddModule(),\n torch.torch.randint(-10, 10, (2, 4), dtype=torch.int64),\n torch.torch.randint(-10, 10, (2, 4), dtype=torch.int64),\n ),\n ]\n )\n def test_add(self, _, module, a, b, skip_to_glow=False):\n utils.run_comparison_tests(\n module,\n (a, b),\n fusible_ops={\"aten::add_\"} if module.inplace else {\"aten::add\"},\n )\n",
"# isort:skip_file\nfrom __future__ import absolute_import, division, print_function, unicode_literals\n\nimport torch\nfrom tests import utils\n\n\nclass SimpleSigmoidModel(torch.nn.Module):\n def __init__(self, inplace=False):\n super(SimpleSigmoidModel, self).__init__()\n self.inplace = inplace\n\n def forward(self, tensor):\n if self.inplace:\n other = tensor + tensor\n return other.sigmoid_()\n else:\n other = tensor + tensor\n return other.sigmoid()\n\n\nclass TestSigmoid(utils.TorchGlowTestCase):\n @utils.deterministic_expand(\n [\n lambda: (\"basic\", SimpleSigmoidModel(), torch.randn(6)),\n lambda: (\"inplace\", SimpleSigmoidModel(inplace=True), torch.randn(6)),\n ]\n )\n def test_sigmoid(self, _, module, tensor):\n utils.compare_tracing_methods(module, tensor, fusible_ops={\"aten::sigmoid\"})\n"
] | [
[
"torch.Size",
"torch.torch.randint",
"torch.tensor",
"torch.randn"
],
[
"torch.randn"
]
] |
kuangliu/pytorch-ssd | [
"02ed1cbe6962e791895ab1c455dc5ddfb87291b9"
] | [
"encoder.py"
] | [
"'''Encode target locations and labels.'''\nimport torch\n\nimport math\nimport itertools\n\nclass DataEncoder:\n def __init__(self):\n '''Compute default box sizes with scale and aspect transform.'''\n scale = 300.\n steps = [s / scale for s in (8, 16, 32, 64, 100, 300)]\n sizes = [s / scale for s in (30, 60, 111, 162, 213, 264, 315)]\n aspect_ratios = ((2,), (2,3), (2,3), (2,3), (2,), (2,))\n feature_map_sizes = (38, 19, 10, 5, 3, 1)\n\n num_layers = len(feature_map_sizes)\n\n boxes = []\n for i in range(num_layers):\n fmsize = feature_map_sizes[i]\n for h,w in itertools.product(range(fmsize), repeat=2):\n cx = (w + 0.5)*steps[i]\n cy = (h + 0.5)*steps[i]\n\n s = sizes[i]\n boxes.append((cx, cy, s, s))\n\n s = math.sqrt(sizes[i] * sizes[i+1])\n boxes.append((cx, cy, s, s))\n\n s = sizes[i]\n for ar in aspect_ratios[i]:\n boxes.append((cx, cy, s * math.sqrt(ar), s / math.sqrt(ar)))\n boxes.append((cx, cy, s / math.sqrt(ar), s * math.sqrt(ar)))\n\n self.default_boxes = torch.Tensor(boxes)\n\n def iou(self, box1, box2):\n '''Compute the intersection over union of two set of boxes, each box is [x1,y1,x2,y2].\n\n Args:\n box1: (tensor) bounding boxes, sized [N,4].\n box2: (tensor) bounding boxes, sized [M,4].\n\n Return:\n (tensor) iou, sized [N,M].\n '''\n N = box1.size(0)\n M = box2.size(0)\n\n lt = torch.max(\n box1[:,:2].unsqueeze(1).expand(N,M,2), # [N,2] -> [N,1,2] -> [N,M,2]\n box2[:,:2].unsqueeze(0).expand(N,M,2), # [M,2] -> [1,M,2] -> [N,M,2]\n )\n\n rb = torch.min(\n box1[:,2:].unsqueeze(1).expand(N,M,2), # [N,2] -> [N,1,2] -> [N,M,2]\n box2[:,2:].unsqueeze(0).expand(N,M,2), # [M,2] -> [1,M,2] -> [N,M,2]\n )\n\n wh = rb - lt # [N,M,2]\n wh[wh<0] = 0 # clip at 0\n inter = wh[:,:,0] * wh[:,:,1] # [N,M]\n\n area1 = (box1[:,2]-box1[:,0]) * (box1[:,3]-box1[:,1]) # [N,]\n area2 = (box2[:,2]-box2[:,0]) * (box2[:,3]-box2[:,1]) # [M,]\n area1 = area1.unsqueeze(1).expand_as(inter) # [N,] -> [N,1] -> [N,M]\n area2 = area2.unsqueeze(0).expand_as(inter) # [M,] -> [1,M] -> [N,M]\n\n iou = inter / (area1 + area2 - inter)\n return iou\n\n def encode(self, boxes, classes, threshold=0.5):\n '''Transform target bounding boxes and class labels to SSD boxes and classes.\n\n Match each object box to all the default boxes, pick the ones with the\n Jaccard-Index > 0.5:\n Jaccard(A,B) = AB / (A+B-AB)\n\n Args:\n boxes: (tensor) object bounding boxes (xmin,ymin,xmax,ymax) of a image, sized [#obj, 4].\n classes: (tensor) object class labels of a image, sized [#obj,].\n threshold: (float) Jaccard index threshold\n\n Returns:\n boxes: (tensor) bounding boxes, sized [#obj, 8732, 4].\n classes: (tensor) class labels, sized [8732,]\n '''\n default_boxes = self.default_boxes\n num_default_boxes = default_boxes.size(0)\n num_objs = boxes.size(0)\n\n iou = self.iou( # [#obj,8732]\n boxes,\n torch.cat([default_boxes[:,:2] - default_boxes[:,2:]/2,\n default_boxes[:,:2] + default_boxes[:,2:]/2], 1)\n )\n\n iou, max_idx = iou.max(0) # [1,8732]\n max_idx.squeeze_(0) # [8732,]\n iou.squeeze_(0) # [8732,]\n\n boxes = boxes[max_idx] # [8732,4]\n variances = [0.1, 0.2]\n cxcy = (boxes[:,:2] + boxes[:,2:])/2 - default_boxes[:,:2] # [8732,2]\n cxcy /= variances[0] * default_boxes[:,2:]\n wh = (boxes[:,2:] - boxes[:,:2]) / default_boxes[:,2:] # [8732,2]\n wh = torch.log(wh) / variances[1]\n loc = torch.cat([cxcy, wh], 1) # [8732,4]\n\n conf = 1 + classes[max_idx] # [8732,], background class = 0\n conf[iou<threshold] = 0 # background\n return loc, conf\n\n def nms(self, bboxes, scores, threshold=0.5, mode='union'):\n '''Non maximum suppression.\n\n Args:\n bboxes: (tensor) bounding boxes, sized [N,4].\n scores: (tensor) bbox scores, sized [N,].\n threshold: (float) overlap threshold.\n mode: (str) 'union' or 'min'.\n\n Returns:\n keep: (tensor) selected indices.\n\n Ref:\n https://github.com/rbgirshick/py-faster-rcnn/blob/master/lib/nms/py_cpu_nms.py\n '''\n x1 = bboxes[:,0]\n y1 = bboxes[:,1]\n x2 = bboxes[:,2]\n y2 = bboxes[:,3]\n\n areas = (x2-x1) * (y2-y1)\n _, order = scores.sort(0, descending=True)\n\n keep = []\n while order.numel() > 0:\n i = order[0]\n keep.append(i)\n\n if order.numel() == 1:\n break\n\n xx1 = x1[order[1:]].clamp(min=x1[i])\n yy1 = y1[order[1:]].clamp(min=y1[i])\n xx2 = x2[order[1:]].clamp(max=x2[i])\n yy2 = y2[order[1:]].clamp(max=y2[i])\n\n w = (xx2-xx1).clamp(min=0)\n h = (yy2-yy1).clamp(min=0)\n inter = w*h\n\n if mode == 'union':\n ovr = inter / (areas[i] + areas[order[1:]] - inter)\n elif mode == 'min':\n ovr = inter / areas[order[1:]].clamp(max=areas[i])\n else:\n raise TypeError('Unknown nms mode: %s.' % mode)\n\n ids = (ovr<=threshold).nonzero().squeeze()\n if ids.numel() == 0:\n break\n order = order[ids+1]\n return torch.LongTensor(keep)\n\n def decode(self, loc, conf):\n '''Transform predicted loc/conf back to real bbox locations and class labels.\n\n Args:\n loc: (tensor) predicted loc, sized [8732,4].\n conf: (tensor) predicted conf, sized [8732,21].\n\n Returns:\n boxes: (tensor) bbox locations, sized [#obj, 4].\n labels: (tensor) class labels, sized [#obj,1].\n '''\n variances = [0.1, 0.2]\n wh = torch.exp(loc[:,2:]*variances[1]) * self.default_boxes[:,2:]\n cxcy = loc[:,:2] * variances[0] * self.default_boxes[:,2:] + self.default_boxes[:,:2]\n boxes = torch.cat([cxcy-wh/2, cxcy+wh/2], 1) # [8732,4]\n\n max_conf, labels = conf.max(1) # [8732,1]\n ids = labels.squeeze(1).nonzero().squeeze(1) # [#boxes,]\n\n keep = self.nms(boxes[ids], max_conf[ids].squeeze(1))\n return boxes[ids][keep], labels[ids][keep], max_conf[ids][keep]\n"
] | [
[
"torch.cat",
"torch.LongTensor",
"torch.log",
"torch.Tensor",
"torch.exp"
]
] |
johnmgregoire/JCAPGeneratePrintCode | [
"afc1dbe6125d0024a46889011ab653ed24016fe4"
] | [
"platemapgenerator_calccompsforsingleplate.py"
] | [
"import time, copy, pickle\nimport os, os.path\nimport sys\nimport numpy, pylab\n\nsys.path.append('C:/Users/Gregoire/Documents/PythonCode/JCAP')\nfrom readplatemap import *\n\nmodelpath='C:/Users/Gregoire/Documents/CaltechWork/platemaps/Quaternarysingleplate/plate333_1map_full.txt'\nnewpath='C:/Users/Gregoire/Documents/CaltechWork/platemaps/Quaternarysingleplate/plate20intervwbin.txt'\n\nwritelines=[]\nf=open(modelpath, mode='r')\nls=f.readlines()[:2]\nwritelines+=[l.strip() for l in ls]\nf.close()\n\ndlist=readsingleplatemaptxt(modelpath, returnfiducials=False)\ndlistsrc=readplatemaptxt(codes=[0, 1, 2, 3])\n\nsmpsrc=numpy.array([d['Sample'] for d in dlistsrc])\ncodesrc=numpy.array([d['code'] for d in dlistsrc])\n\nintervs=20\ncomps=[[1.0*b/intervs, 1.0*c/intervs, 1.0*(intervs-a-b-c)/intervs, 1.0*a/intervs] for a in numpy.arange(0,intervs+1)[::-1] for b in numpy.arange(0,intervs+1-a) for c in numpy.arange(0, intervs+1-a-b)][::-1]\n\ndef genbinarycomps(intervs, elind1, elind2, ndim=4):\n aa=numpy.linspace(0.,1.,intervs+1)\n c=numpy.zeros((len(aa), ndim), dtype='float64')\n c[:, elind1]=aa\n c[:, elind2]=1.-aa\n return c\n\ncomps2=comps\ncodes=[0]*len(comps)\nbinintervs=5\nfor i, j in [(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]:\n comps2+=list(genbinarycomps(binintervs, i, j))+[numpy.zeros(4, dtype='float64')] #add 6 compositions in binary line and then zeros\n codes+=[4]*6+[1]\ncomps2+=[numpy.zeros(4, dtype='float64')]*6 #6 more zeros to round out the 1819 code0 samples in a standard platemap\ncodes+=[1]*6\ncomps2=[numpy.array(c) for c in comps2]\n\ncomps2pop=copy.copy(comps2)\ncodespop=copy.copy(codes)\n\nfor d in dlist:\n if d['code']==0:\n c=comps2pop.pop(0)\n cd=codespop.pop(0)\n for k, v in zip(['A', 'B', 'C', 'D'], c):\n d[k]=v\n d['code']=cd\n\nk_f=[\\\n('Sample','%04d'),\\\n('x','%.2f'),\\\n('y','%.2f'),\\\n('dx','%.2f'),\\\n('dx','%.2f'),\\\n('A','%.3f'),\\\n('B','%.3f'),\\\n('C','%.3f'),\\\n('D','%.3f'),\\\n('E','%.3f'),\\\n('F','%.3f'),\\\n('G','%.3f'),\\\n('H','%.3f'),\\\n('code','%d'),\\\n]\n\nwritelines+=[', '.join([f %d[k] for k, f in k_f]) for d in dlist]\n\nf=open(newpath, mode='w')\nf.write('\\n'.join(writelines))\nf.close()\n\nsys.path.append('C:/Users/Gregoire/Documents/PythonCode/ternaryplot')\nfrom myquaternaryutility import QuaternaryPlot\n\nfor d in dlist:\n c=numpy.array([d[el] for el in ['A', 'B', 'C', 'D']])\n if c.sum()>0:\n c/=c.sum()\n d['compositions']=c\n\ncarr=numpy.array([d['compositions'] for d in dlist])\nstpq=QuaternaryPlot(111)\nstpq.scatter(carr)\npylab.show()\n"
] | [
[
"numpy.array",
"numpy.arange",
"numpy.zeros",
"numpy.linspace"
]
] |
hfurkanbozkurt/syne-tune | [
"05ee2668f0155b40c3ee3b61e4b3d58f3f9f3c4f",
"05ee2668f0155b40c3ee3b61e4b3d58f3f9f3c4f"
] | [
"syne_tune/optimizer/schedulers/searchers/bayesopt/utils/test_objects.py",
"syne_tune/optimizer/schedulers/searchers/bayesopt/models/meanstd_acqfunc_impl.py"
] | [
"# Copyright 2021 Amazon.com, Inc. or its affiliates. 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# A copy of the License is located at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# or in the \"license\" file accompanying this file. This file is distributed\n# on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either\n# express or implied. See the License for the specific language governing\n# permissions and limitations under the License.\n# Could eventually remove this code: Is this needed in unit tests?\n\n\"\"\"\nObject definitions that are used for testing.\n\"\"\"\n\nfrom typing import Iterator, Tuple, Dict, List, Optional, Union\nimport numpy as np\n\nfrom syne_tune.optimizer.schedulers.searchers.bayesopt.datatypes.common \\\n import Hyperparameter, Configuration, dictionarize_objective\nfrom syne_tune.config_space import Categorical, loguniform, randint, \\\n choice, uniform\nfrom syne_tune.optimizer.schedulers.searchers.bayesopt.datatypes.hp_ranges \\\n import HyperparameterRanges\nfrom syne_tune.optimizer.schedulers.searchers.bayesopt.datatypes.hp_ranges_factory \\\n import make_hyperparameter_ranges\nfrom syne_tune.optimizer.schedulers.searchers.bayesopt.datatypes.tuning_job_state \\\n import TuningJobState\nfrom syne_tune.optimizer.schedulers.searchers.bayesopt.datatypes.common import \\\n TrialEvaluations, PendingEvaluation\nfrom syne_tune.optimizer.schedulers.searchers.bayesopt.gpautograd.constants \\\n import MCMCConfig, OptimizationConfig\nfrom syne_tune.optimizer.schedulers.searchers.bayesopt.gpautograd.gp_regression \\\n import GaussianProcessRegression\nfrom syne_tune.optimizer.schedulers.searchers.bayesopt.gpautograd.gpr_mcmc \\\n import GPRegressionMCMC\nfrom syne_tune.optimizer.schedulers.searchers.bayesopt.gpautograd.kernel \\\n import Matern52, KernelFunction\nfrom syne_tune.optimizer.schedulers.searchers.bayesopt.gpautograd.warping \\\n import WarpedKernel, Warping\nfrom syne_tune.optimizer.schedulers.searchers.bayesopt.tuning_algorithms.base_classes \\\n import CandidateGenerator\nfrom syne_tune.optimizer.schedulers.searchers.bayesopt.tuning_algorithms.common \\\n import ExclusionList\n\n\ndef build_kernel(state: TuningJobState,\n do_warping: bool = False) -> KernelFunction:\n dims, warping_ranges = dimensionality_and_warping_ranges(state.hp_ranges)\n kernel = Matern52(dims, ARD=True)\n if do_warping:\n return WarpedKernel(\n kernel=kernel, warping=Warping(dims, warping_ranges))\n else:\n return kernel\n\n\ndef default_gpmodel(\n state: TuningJobState, random_seed: int,\n optimization_config: OptimizationConfig) -> GaussianProcessRegression:\n return GaussianProcessRegression(\n kernel=build_kernel(state),\n optimization_config=optimization_config,\n random_seed=random_seed\n )\n\n\ndef default_gpmodel_mcmc(\n state: TuningJobState, random_seed: int,\n mcmc_config: MCMCConfig) -> GPRegressionMCMC:\n return GPRegressionMCMC(\n build_kernel=lambda: build_kernel(state),\n mcmc_config=mcmc_config,\n random_seed=random_seed\n )\n\n\ndef dimensionality_and_warping_ranges(hp_ranges: HyperparameterRanges) -> \\\n Tuple[int, Dict[int, Tuple[float, float]]]:\n lower_config = dict()\n upper_config = dict()\n for name, hp_range in hp_ranges.config_space.items():\n if not isinstance(hp_range, Categorical):\n lower_config[name] = hp_range.lower\n upper_config[name] = hp_range.upper\n else:\n lower_config[name] = hp_range.categories[0]\n upper_config[name] = hp_range.categories[0]\n lower_internal = hp_ranges.to_ndarray(lower_config)\n upper_internal = hp_ranges.to_ndarray(upper_config)\n dims = 0\n warping_ranges = dict()\n for name in hp_ranges.internal_keys:\n hp_range = hp_ranges.config_space[name]\n if not isinstance(hp_range, Categorical):\n _lower = lower_internal[dims]\n _upper = upper_internal[dims]\n if _upper > _lower: # exclude cases where max equal to min\n warping_ranges[dims] = (_lower, _upper)\n else:\n assert _lower == _upper\n dims += 1\n else:\n # For binary, we use a single dimension, not 2\n sz = len(hp_range.categories)\n if sz == 2:\n sz = 1\n dims += sz\n return dims, warping_ranges\n\n\nclass RepeatedCandidateGenerator(CandidateGenerator):\n \"\"\"Generates candidates from a fixed set. Used to test the deduplication logic.\"\"\"\n def __init__(self, n_unique_candidates: int):\n self.config_space = {\n 'a': uniform(0, n_unique_candidates),\n 'b': randint(0, n_unique_candidates),\n 'c': choice([f\"value_{i}\" for i in range(n_unique_candidates)])}\n self.hp_ranges = make_hyperparameter_ranges(self.config_space)\n self.all_unique_candidates = [\n {'a': 1.0*j, 'b': j, 'c': f\"value_{j}\"}\n for j in range(n_unique_candidates)]\n\n def generate_candidates(self) -> Iterator[Configuration]:\n i = 0\n while True:\n i += 1\n yield self.all_unique_candidates[i % len(self.all_unique_candidates)]\n\n\n# Example black box function, with adjustable location of global minimum.\n# Potentially could catch issues with optimizer, e.g. if the optimizer\n# ignoring somehow candidates on the edge of search space.\n# A simple quadratic function is used.\nclass Quadratic3d:\n def __init__(self, local_minima, active_metric, metric_names):\n # local_minima: point where local_minima is located\n self.local_minima = np.array(local_minima).astype('float')\n self.local_minima[0] = np.log10(self.local_minima[0])\n self.active_metric = active_metric\n self.metric_names = metric_names\n\n @property\n def search_space(self):\n config_space = {\n 'x': loguniform(1.0, 100.0),\n 'y': randint(0, 2),\n 'z': choice(['0.0', '1.0', '2.0'])}\n return make_hyperparameter_ranges(config_space)\n\n @property\n def f_min(self):\n return 0.0\n\n def __call__(self, candidate):\n p = np.array([float(hp) for hp in candidate])\n p[0] = np.log10(p[0])\n return dictionarize_objective(np.sum((self.local_minima - p) ** 2))\n\n\ndef tuples_to_configs(config_tpls: List[Tuple[Hyperparameter, ...]],\n hp_ranges: HyperparameterRanges) -> List[Configuration]:\n \"\"\"\n Many unit tests write configs as tuples.\n\n \"\"\"\n return [hp_ranges.tuple_to_config(x) for x in config_tpls]\n\n\ndef create_exclusion_set(\n candidates_tpl, hp_ranges: HyperparameterRanges,\n is_dict: bool = False) -> ExclusionList:\n \"\"\"\n Creates exclusion list from set of tuples.\n\n \"\"\"\n if not is_dict:\n candidates_tpl = tuples_to_configs(candidates_tpl, hp_ranges)\n config_for_trial = {\n str(trial_id): config for trial_id, config in enumerate(candidates_tpl)}\n state = TuningJobState(\n hp_ranges=hp_ranges,\n config_for_trial=config_for_trial,\n trials_evaluations=[],\n failed_trials=[str(x) for x in range(len(candidates_tpl))])\n return ExclusionList(state)\n\n\nTupleOrDict = Union[tuple, dict]\n\n\ndef create_tuning_job_state(\n hp_ranges: HyperparameterRanges, cand_tuples: List[TupleOrDict],\n metrics: List[Dict],\n pending_tuples: Optional[List[TupleOrDict]] = None,\n failed_tuples: Optional[List[TupleOrDict]] = None) -> TuningJobState:\n \"\"\"\n Builds `TuningJobState` from basics, where configs are given as tuples or\n as dicts.\n\n NOTE: We assume that all configs in the different lists are different!\n\n \"\"\"\n if cand_tuples and isinstance(cand_tuples[0], tuple):\n configs = tuples_to_configs(cand_tuples, hp_ranges)\n else:\n configs = cand_tuples\n trials_evaluations = [TrialEvaluations(trial_id=str(trial_id), metrics=y)\n for trial_id, y in enumerate(metrics)]\n pending_evaluations = None\n if pending_tuples is not None:\n sz = len(configs)\n extra = len(pending_tuples)\n if pending_tuples and isinstance(pending_tuples[0], tuple):\n extra_configs = tuples_to_configs(pending_tuples, hp_ranges)\n else:\n extra_configs = pending_tuples\n configs.extend(extra_configs)\n pending_evaluations = [PendingEvaluation(trial_id=str(trial_id))\n for trial_id in range(sz, sz + extra)]\n failed_trials = None\n if failed_tuples is not None:\n sz = len(configs)\n extra = len(failed_tuples)\n if failed_tuples and isinstance(failed_tuples[0], tuple):\n extra_configs = tuples_to_configs(failed_tuples, hp_ranges)\n else:\n extra_configs = failed_tuples\n configs.extend(extra_configs)\n failed_trials = [str(x) for x in range(sz, sz + extra)]\n\n config_for_trial = {\n str(trial_id): config for trial_id, config in enumerate(configs)}\n return TuningJobState(\n hp_ranges=hp_ranges,\n config_for_trial=config_for_trial,\n trials_evaluations=trials_evaluations,\n failed_trials=failed_trials,\n pending_evaluations=pending_evaluations)\n",
"# Copyright 2021 Amazon.com, Inc. or its affiliates. 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# A copy of the License is located at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# or in the \"license\" file accompanying this file. This file is distributed\n# on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either\n# express or implied. See the License for the specific language governing\n# permissions and limitations under the License.\nimport numpy as np\nfrom typing import Dict, Optional, Set, List, Tuple\nimport logging\nfrom scipy.stats import norm\nimport itertools\n\nfrom syne_tune.optimizer.schedulers.searchers.bayesopt.models.meanstd_acqfunc \\\n import MeanStdAcquisitionFunction, HeadWithGradient, \\\n SamplePredictionsPerOutput, CurrentBestProvider\nfrom syne_tune.optimizer.schedulers.searchers.bayesopt.models.model_base \\\n import BaseSurrogateModel\nfrom syne_tune.optimizer.schedulers.searchers.bayesopt.tuning_algorithms.base_classes \\\n import SurrogateOutputModel, SurrogateModel\nfrom syne_tune.optimizer.schedulers.searchers.bayesopt.utils.density \\\n import get_quantiles\n\nlogger = logging.getLogger(__name__)\n\n\nMIN_COST = 1e-12 # For numerical stability when dividing EI / cost\nMIN_STD_CONSTRAINT = 1e-12 # For numerical stability when computing the constraint probability in CEI\n\n\ndef _extract_active_and_secondary_metric(model_output_names, active_metric):\n \"\"\"\n Returns the active metric and the secondary metric (such as the cost or constraint metric) from model_output_names.\n \"\"\"\n\n assert len(model_output_names) == 2, f\"The model should consist of exactly 2 outputs, \" \\\n f\"while the current outputs are {model_output_names}\"\n assert active_metric in model_output_names, f\"{active_metric} is not a valid metric. \" \\\n f\"The metric name must match one of the following metrics \" \\\n f\"in the model output: {model_output_names}\"\n if model_output_names[0] == active_metric:\n secondary_metric = model_output_names[1]\n else:\n secondary_metric = model_output_names[0]\n logger.debug(\n f\"There are two metrics in the output: {model_output_names}. \"\n f\"The metric to optimize was set to '{active_metric}'. \"\n f\"The secondary metric is assumed to be '{secondary_metric}'\")\n return active_metric, secondary_metric\n\n\ndef _postprocess_gradient(grad: np.ndarray, nf: int) -> np.ndarray:\n if nf > 1:\n assert grad.size == nf # Sanity check\n return grad / nf\n else:\n return np.mean(grad, keepdims=True)\n\n\nclass EIAcquisitionFunction(MeanStdAcquisitionFunction):\n \"\"\"\n Minus expected improvement acquisition function\n (minus because the convention is to always minimize acquisition functions)\n\n \"\"\"\n def __init__(\n self, model: SurrogateOutputModel, active_metric: str = None,\n jitter: float = 0.01):\n assert isinstance(model, SurrogateModel)\n super().__init__(model, active_metric)\n self.jitter = jitter\n\n def _head_needs_current_best(self) -> bool:\n return True\n\n def _compute_head(\n self, output_to_predictions: SamplePredictionsPerOutput,\n current_best: Optional[np.ndarray]) -> np.ndarray:\n assert current_best is not None\n means, stds = self._extract_mean_and_std(output_to_predictions)\n\n # phi, Phi is PDF and CDF of Gaussian\n phi, Phi, u = get_quantiles(self.jitter, current_best, means, stds)\n return np.mean((-stds) * (u * Phi + phi), axis=1)\n\n def _compute_head_and_gradient(\n self, output_to_predictions: SamplePredictionsPerOutput,\n current_best: Optional[np.ndarray]) -> HeadWithGradient:\n assert current_best is not None\n mean, std = self._extract_mean_and_std(output_to_predictions)\n nf_mean = mean.size\n assert current_best.size == nf_mean\n\n # phi, Phi is PDF and CDF of Gaussian\n phi, Phi, u = get_quantiles(self.jitter, current_best, mean, std)\n f_acqu = std * (u * Phi + phi)\n dh_dmean = _postprocess_gradient(Phi, nf=nf_mean)\n dh_dstd = _postprocess_gradient(-phi, nf=1)\n return HeadWithGradient(\n hval=-np.mean(f_acqu),\n gradient={self.active_metric: dict(mean=dh_dmean, std=dh_dstd)})\n\n\nclass LCBAcquisitionFunction(MeanStdAcquisitionFunction):\n \"\"\"\n Lower confidence bound (LCB) acquisition function:\n\n h(mean, std) = mean - kappa * std\n\n \"\"\"\n def __init__(\n self, model: SurrogateOutputModel, kappa: float,\n active_metric: str = None):\n super().__init__(model, active_metric)\n assert isinstance(model, SurrogateModel)\n assert kappa > 0, 'kappa must be positive'\n self.kappa = kappa\n\n def _head_needs_current_best(self) -> bool:\n return False\n\n def _compute_head(self, output_to_predictions: SamplePredictionsPerOutput,\n current_best: Optional[np.ndarray]) -> np.ndarray:\n means, stds = self._extract_mean_and_std(output_to_predictions)\n return np.mean(means - stds * self.kappa, axis=1)\n\n def _compute_head_and_gradient(\n self, output_to_predictions: SamplePredictionsPerOutput,\n current_best: Optional[np.ndarray]) -> HeadWithGradient:\n mean, std = self._extract_mean_and_std(output_to_predictions)\n nf_mean = mean.size\n\n dh_dmean = np.ones_like(mean) / nf_mean\n dh_dstd = (-self.kappa) * np.ones_like(std)\n return HeadWithGradient(\n hval=np.mean(mean - std * self.kappa),\n gradient={self.active_metric: dict(mean=dh_dmean, std=dh_dstd)})\n\n\nclass EIpuAcquisitionFunction(MeanStdAcquisitionFunction):\n \"\"\"\n Minus cost-aware expected improvement acquisition function.\n\n This is defined as\n\n EIpu(x) = EI(x) / power(cost(x), exponent_cost),\n\n where EI(x) is expected improvement, cost(x) is the predictive mean of\n a cost model, and `exponent_cost` is an exponent in (0, 1].\n\n `exponent_cost` scales the influence of the cost term on the acquisition\n function. See also:\n\n Lee etal.\n Cost-aware Bayesian Optimization\n https://arxiv.org/abs/2003.10870\n\n Note: two metrics are expected in the model output: the main objective and the cost.\n The main objective needs to be indicated as active_metric when initializing EIpuAcquisitionFunction.\n The cost is automatically assumed to be the other metric.\n\n \"\"\"\n def __init__(\n self, model: SurrogateOutputModel, active_metric: str = None,\n exponent_cost: float = 1.0, jitter: float = 0.01):\n super().__init__(model, active_metric)\n assert 0 < exponent_cost <= 1, \\\n f\"exponent_cost = {exponent_cost} must lie in (0, 1]\"\n self.jitter = jitter\n self.exponent_cost = exponent_cost\n self.active_metric, self.cost_metric = _extract_active_and_secondary_metric(\n self.model_output_names, active_metric)\n\n def _head_needs_current_best(self) -> bool:\n return True\n\n def _output_to_keys_predict(self) -> Dict[str, Set[str]]:\n \"\"\"\n The cost model may be deterministic, as the acquisition function\n only needs the mean.\n \"\"\"\n return {\n self.model_output_names[0]: {'mean', 'std'},\n self.model_output_names[1]: {'mean'}}\n\n def _compute_head(\n self, output_to_predictions: SamplePredictionsPerOutput,\n current_best: Optional[np.ndarray]) -> np.ndarray:\n \"\"\"\n Returns minus the cost-aware expected improvement.\n \"\"\"\n assert current_best is not None\n means, stds = self._extract_mean_and_std(output_to_predictions)\n pred_costs = self._extract_positive_cost(output_to_predictions)\n\n # phi, Phi is PDF and CDF of Gaussian\n phi, Phi, u = get_quantiles(self.jitter, current_best, means, stds)\n f_acqu = stds * (u * Phi + phi) * np.power(pred_costs,\n -self.exponent_cost)\n return -np.mean(f_acqu, axis=1)\n\n def _compute_head_and_gradient(\n self, output_to_predictions: SamplePredictionsPerOutput,\n current_best: Optional[np.ndarray]) -> HeadWithGradient:\n \"\"\"\n Returns minus cost-aware expected improvement and, for each output model, the gradients\n with respect to the mean and standard deviation of that model.\n \"\"\"\n assert current_best is not None\n mean, std = self._extract_mean_and_std(output_to_predictions)\n pred_cost = self._extract_positive_cost(output_to_predictions)\n nf_active = mean.size\n nf_cost = pred_cost.size\n\n # phi, Phi is PDF and CDF of Gaussian\n phi, Phi, u = get_quantiles(self.jitter, current_best, mean, std)\n inv_cost_power = np.power(pred_cost, -self.exponent_cost)\n f_acqu = std * (u * Phi + phi) * inv_cost_power\n\n dh_dmean_active = _postprocess_gradient(\n Phi * inv_cost_power, nf=nf_active)\n dh_dstd_active = _postprocess_gradient(-phi * inv_cost_power, nf=1)\n # Flip the sign twice: once because of the derivative of 1 / x, and\n # once because the head is actually - f_ei\n dh_dmean_cost = _postprocess_gradient(\n self.exponent_cost * f_acqu / pred_cost, nf=nf_cost)\n\n gradient = {\n self.active_metric: dict(mean=dh_dmean_active, std=dh_dstd_active),\n self.cost_metric: dict(mean=dh_dmean_cost)}\n return HeadWithGradient(hval=-np.mean(f_acqu), gradient=gradient)\n\n def _extract_positive_cost(self, output_to_predictions):\n pred_cost = output_to_predictions[self.cost_metric]['mean']\n if np.any(pred_cost) < 0.0:\n logger.warning(f'The model for {self.cost_metric} predicted some negative cost. '\n f'Capping the minimum cost at {MIN_COST}.')\n pred_cost = np.maximum(pred_cost, MIN_COST) # ensure that the predicted cost/run-time is positive\n return pred_cost\n\n\nclass ConstraintCurrentBestProvider(CurrentBestProvider):\n \"\"\"\n Here, `current_best` depends on two models, for active and\n constraint metric.\n\n \"\"\"\n def __init__(self, current_best_list: List[np.ndarray],\n num_samples_active: int):\n list_size = len(current_best_list)\n assert list_size > 0 and list_size % num_samples_active == 0\n self._active_and_constraint_current_best = [\n v.reshape((1, -1)) for v in current_best_list]\n self._num_samples_active = num_samples_active\n\n def __call__(self, positions: Tuple[int, ...]) -> Optional[np.ndarray]:\n flat_pos = positions[1] * self._num_samples_active + positions[0]\n return self._active_and_constraint_current_best[flat_pos]\n\n\nclass CEIAcquisitionFunction(MeanStdAcquisitionFunction):\n \"\"\"\n Minus constrained expected improvement acquisition function.\n (minus because the convention is to always minimize the acquisition function)\n\n This is defined as CEI(x) = EI(x) * P(c(x) <= 0), where EI is the standard expected improvement with respect\n to the current *feasible best*, and P(c(x) <= 0) is the probability that the hyperparameter\n configuration x satisfies the constraint modeled by c(x).\n\n If there are no feasible hyperparameters yet, the current feasible best is undefined. Thus, CEI is\n reduced to the P(c(x) <= 0) term until a feasible configuration is found.\n\n Two metrics are expected in the model output: the main objective and the constraint metric.\n The main objective needs to be indicated as active_metric when initializing CEIAcquisitionFunction.\n The constraint is automatically assumed to be the other metric.\n\n References on CEI:\n Gardner et al., Bayesian Optimization with Inequality Constraints. In ICML, 2014.\n Gelbart et al., Bayesian Optimization with Unknown Constraints. In UAI, 2014.\n\n \"\"\"\n def __init__(\n self, model: SurrogateOutputModel, active_metric: str = None,\n jitter: float = 0.01):\n super().__init__(model, active_metric)\n self.jitter = jitter\n self._feasible_best_list = None\n self.active_metric, self.constraint_metric = _extract_active_and_secondary_metric(\n self.model_output_names, active_metric)\n\n def _head_needs_current_best(self) -> bool:\n return True\n\n def _compute_head(self, output_to_predictions: SamplePredictionsPerOutput,\n current_best: Optional[np.ndarray]) -> np.ndarray:\n \"\"\"\n Returns minus the constrained expected improvement (- CEI).\n \"\"\"\n assert current_best is not None\n means, stds = self._extract_mean_and_std(output_to_predictions)\n means_constr, stds_constr = self._extract_mean_and_std(\n output_to_predictions, metric=self.constraint_metric)\n\n # Compute the probability of satisfying the constraint P(c(x) <= 0)\n constr_probs = norm.cdf(- means_constr / (stds_constr + MIN_STD_CONSTRAINT))\n # If for some fantasies there are not feasible candidates, there is also no current_best (i.e., a nan).\n # The acquisition function is replaced by only the P(c(x) <= 0) term when no feasible best exist.\n feas_idx = ~np.isnan(current_best).reshape((1, -1))\n\n # phi, Phi is PDF and CDF of Gaussian\n phi, Phi, u = get_quantiles(self.jitter, current_best, means, stds)\n f_ei = stds * (u * Phi + phi)\n # CEI(x) = EI(x) * P(c(x) <= 0) if feasible best exists, CEI(x) = P(c(x) <= 0) otherwise\n f_acqu = np.where(feas_idx, f_ei * constr_probs, constr_probs)\n return -np.mean(f_acqu, axis=1)\n\n def _compute_head_and_gradient(\n self, output_to_predictions: SamplePredictionsPerOutput,\n current_best: Optional[np.ndarray]) -> HeadWithGradient:\n \"\"\"\n Returns minus cost-aware expected improvement (- CEI) and, for each output model, the gradients\n with respect to the mean and standard deviation of that model.\n \"\"\"\n assert current_best is not None\n mean, std = self._extract_mean_and_std(output_to_predictions)\n mean_constr, std_constr = self._extract_mean_and_std(\n output_to_predictions, metric=self.constraint_metric)\n nf_mean = mean.size\n nf_constr = mean_constr.size\n\n # Compute the probability of satisfying the constraint P(c(x) <= 0)\n std_constr = std_constr + MIN_STD_CONSTRAINT\n z = - mean_constr / std_constr\n constr_prob = norm.cdf(z)\n # Useful variables for computing the head gradients\n mean_over_squared_std_constr = mean_constr / std_constr ** 2\n inverse_std_constr = 1. / std_constr\n phi_constr = norm.pdf(z)\n\n # If for some fantasies there are not feasible candidates, there is also no current_best (i.e., a nan).\n # The acquisition function is replaced by only the P(c(x) <= 0) term when no feasible best exist.\n feas_idx = ~np.isnan(current_best)\n phi, Phi, u = get_quantiles(self.jitter, current_best, mean, std) # phi, Phi is PDF and CDF of Gaussian\n f_ei = std * (u * Phi + phi)\n f_acqu = np.where(feas_idx, f_ei * constr_prob, constr_prob) # CEI(x) = EI(x) * P(c(x) <= 0) if feasible best\n # exists, CEI(x) = P(c(x) <= 0) otherwise\n dh_dmean_constraint_feas = f_ei * inverse_std_constr * phi_constr\n dh_dstd_constraint_feas = - f_ei * mean_over_squared_std_constr * phi_constr\n dh_dmean_active_feas = Phi * constr_prob\n dh_dstd_active_feas = - phi * constr_prob\n dh_dmean_constraint_infeas = inverse_std_constr * phi_constr\n dh_dstd_constraint_infeas = - mean_over_squared_std_constr * phi_constr\n dh_dmean_active_infeas = np.zeros_like(phi_constr)\n dh_dstd_active_infeas = np.zeros_like(phi_constr)\n dh_dmean_active = _postprocess_gradient(\n np.where(feas_idx, dh_dmean_active_feas, dh_dmean_active_infeas),\n nf=nf_mean)\n dh_dstd_active = _postprocess_gradient(\n np.where(feas_idx, dh_dstd_active_feas, dh_dstd_active_infeas),\n nf=1)\n dh_dmean_constraint = _postprocess_gradient(\n np.where(feas_idx, dh_dmean_constraint_feas,\n dh_dmean_constraint_infeas), nf=nf_constr)\n dh_dstd_constraint = _postprocess_gradient(\n np.where(feas_idx, dh_dstd_constraint_feas,\n dh_dstd_constraint_infeas), nf=1)\n gradient = {\n self.active_metric: dict(mean=dh_dmean_active,\n std=dh_dstd_active),\n self.constraint_metric: dict(mean=dh_dmean_constraint,\n std=dh_dstd_constraint)}\n return HeadWithGradient(hval=-np.mean(f_acqu), gradient=gradient)\n\n def _get_current_bests_internal(\n self, model: SurrogateOutputModel) -> CurrentBestProvider:\n active_model = model[self.active_metric]\n assert isinstance(active_model, BaseSurrogateModel)\n all_means_active = active_model.predict_mean_current_candidates()\n num_samples_active = len(all_means_active)\n constraint_model = model[self.constraint_metric]\n assert isinstance(constraint_model, BaseSurrogateModel)\n all_means_constraint = constraint_model.predict_mean_current_candidates()\n common_shape = all_means_active[0].shape\n assert all(x.shape == common_shape for x in all_means_constraint), \\\n \"Shape mismatch between models for predict_mean_current_candidates\"\n current_best_list = []\n for means_constraint, means_active in itertools.product(\n all_means_constraint, all_means_active):\n # Remove all infeasible candidates (i.e., where means_constraint\n # is >= 0)\n means_active[means_constraint >= 0] = np.nan\n # Compute the current *feasible* best (separately for every fantasy)\n min_across_observations = np.nanmin(means_active, axis=0)\n current_best_list.append(min_across_observations)\n return ConstraintCurrentBestProvider(\n current_best_list, num_samples_active)\n"
] | [
[
"numpy.sum",
"numpy.log10",
"numpy.array"
],
[
"scipy.stats.norm.pdf",
"numpy.zeros_like",
"numpy.ones_like",
"numpy.isnan",
"numpy.mean",
"numpy.nanmin",
"numpy.where",
"numpy.any",
"numpy.power",
"scipy.stats.norm.cdf",
"numpy.maximum"
]
] |
uhrwecker/GRDonuts | [
"3087aeb5c169251bdb711b425dcc3040ff962da7"
] | [
"util/utility.py"
] | [
"import numpy as np\n\nclass UtilInverse():\n def __init__(self, verbose=True):\n self.verbose = verbose\n\n def find_nearest_ind(self, array, value):\n index = []\n for ind in range(len(array)-1):\n if array[ind] < value and array[ind+1] > value:\n index.append(ind)\n if array[ind] > value and array[ind+1] < value:\n index.append(ind)\n return index\n\n def sort_array_by_column(self, array, order=['f0']):\n bits = 'i8'+',i8'*(len(array[0])-1)\n array.view(bits).sort(order=order, axis=0)\n return array\n\n \n\nclass UtilStability():\n def __init__(self, verbose=True):\n self.verbose = verbose\n\n def retrieve_extrema(self, w, r):\n self.check_for_stable_point(w, self.verbose)\n \n min_mask = np.r_[True, w[1:] < w[:-1]] & np.r_[w[:-1] < w[1:], True]\n max_mask = np.r_[True, w[1:] > w[:-1]] & np.r_[w[:-1] > w[1:], True]\n\n w_min = w[min_mask]\n r_min = r[min_mask]\n w_max = w[max_mask]\n r_max = r[max_mask]\n\n try:\n\n if w_min[0] == w[0]:\n w_min = np.delete(w_min, 0)\n r_min = np.delete(r_min, 0)\n\n if w_max[-1] == w[-1]:\n w_max = np.delete(w_max, -1)\n r_max = np.delete(r_max, -1)\n\n if self.verbose:\n print('Simple extremum analysis: ')\n print('- W has maximum/a at w='+str(w_max.tolist()))\n print('- W has minimum/a at w='+str(w_min.tolist()))\n\n return w_min.tolist(), w_max.tolist(), r_min.tolist(), r_max.tolist()\n except:\n return [0], [0], [0], [0]\n\n def check_for_stable_point(self, w, exit_if_not_stable=False):\n '''\n Checks if array has at least one minimum and\n its maximum is only local\n '''\n min_mask = np.r_[True, w[1:] < w[:-1]] & np.r_[w[:-1] < w[1:], True]\n max_mask = np.r_[True, w[1:] > w[:-1]] & np.r_[w[:-1] > w[1:], True]\n\n\n w_min = w[min_mask]\n w_max = w[max_mask]\n\n## if w_max[0] == w[0] or w_max[0] == w[1]:\n## '''\n## The potentianl comes from +inf, so its not a stable point.\n## '''\n## raise ValueError()\n\n if len(w_min) < 2 and len(w_max) < 2:\n '''\n The function is monotonically. There is no stable point.\n '''\n self._error_monotonically(exit_if_not_stable)\n\n elif len(w_min) < 1 or len(w_max) < 1:\n '''\n The function has either a local maximum OR local minimum, but not\n both, thus is not stable\n '''\n self._error_only_one_extremum(exit_if_not_stable)\n\n elif w_max[0] > w_max[1]:\n '''\n The potential is not closed, there is no Roche limit.\n Matter will extend into infitiy.\n '''\n self._error_no_roche_limit(exit_if_not_stable)\n\n elif self.verbose and len(w_min) > 1 and len(w_max) > 1:\n print('Potential is possibly stable')\n\n return 0\n\n def closure_rating_function(self, w, r):\n wmin, wmax, rmin, rmax = self.retrieve_extrema(w, r)\n\n int_l = np.where(r == rmax[0])[0][0]\n int_r = np.where(w > wmax[0])[0][0]\n\n area_func = abs(w[int_l:int_r] - wmax[-1])\n\n area = np.trapz(area_func)\n\n return area\n \n\n def _error_monotonically(self, flag):\n if flag:\n raise ValueError('Potential not closed, potential is monotonically.')\n else:\n if self.verbose:\n print('WARNING: Potential not closed, potential is monotonically.')\n \n def _error_only_one_extremum(self, flag):\n if flag:\n raise ValueError('Potential not closed, only has one extremum.')\n else:\n if self.verbose:\n print('WARNING: Potential not closed, only has one extremum.')\n\n\n def _error_no_roche_limit(self, flag):\n if flag:\n raise ValueError('Potential is not closed, matter extends into infinity.')\n else:\n if self.verbose:\n print('WARNING: Potential not close, no Roche limit.')\n"
] | [
[
"numpy.where",
"numpy.delete",
"numpy.trapz"
]
] |
blokhinnv/dgl | [
"bcf92f6c21afd4ad48a86d2ee543386099190791"
] | [
"python/dgl/distributed/dist_graph.py"
] | [
"\"\"\"Define distributed graph.\"\"\"\n\nfrom collections.abc import MutableMapping\nfrom collections import namedtuple\n\nimport os\nimport numpy as np\n\nfrom ..heterograph import DGLHeteroGraph\nfrom ..convert import heterograph as dgl_heterograph\nfrom ..convert import graph as dgl_graph\nfrom ..transform import compact_graphs\nfrom .. import heterograph_index\nfrom .. import backend as F\nfrom ..base import NID, EID, NTYPE, ETYPE, ALL, is_all\nfrom .kvstore import KVServer, get_kvstore\nfrom .._ffi.ndarray import empty_shared_mem\nfrom ..frame import infer_scheme\nfrom .partition import load_partition, load_partition_book\nfrom .graph_partition_book import PartitionPolicy, get_shared_mem_partition_book\nfrom .graph_partition_book import HeteroDataName, parse_hetero_data_name\nfrom .graph_partition_book import NodePartitionPolicy, EdgePartitionPolicy\nfrom .shared_mem_utils import _to_shared_mem, _get_ndata_path, _get_edata_path, DTYPE_DICT\nfrom . import rpc\nfrom . import role\nfrom .server_state import ServerState\nfrom .rpc_server import start_server\nfrom .graph_services import find_edges as dist_find_edges\nfrom .graph_services import out_degrees as dist_out_degrees\nfrom .graph_services import in_degrees as dist_in_degrees\nfrom .dist_tensor import DistTensor\n\nINIT_GRAPH = 800001\n\nclass InitGraphRequest(rpc.Request):\n \"\"\" Init graph on the backup servers.\n\n When the backup server starts, they don't load the graph structure.\n This request tells the backup servers that they can map to the graph structure\n with shared memory.\n \"\"\"\n def __init__(self, graph_name):\n self._graph_name = graph_name\n\n def __getstate__(self):\n return self._graph_name\n\n def __setstate__(self, state):\n self._graph_name = state\n\n def process_request(self, server_state):\n if server_state.graph is None:\n server_state.graph = _get_graph_from_shared_mem(self._graph_name)\n return InitGraphResponse(self._graph_name)\n\nclass InitGraphResponse(rpc.Response):\n \"\"\" Ack the init graph request\n \"\"\"\n def __init__(self, graph_name):\n self._graph_name = graph_name\n\n def __getstate__(self):\n return self._graph_name\n\n def __setstate__(self, state):\n self._graph_name = state\n\ndef _copy_graph_to_shared_mem(g, graph_name, graph_format):\n new_g = g.shared_memory(graph_name, formats=graph_format)\n # We should share the node/edge data to the client explicitly instead of putting them\n # in the KVStore because some of the node/edge data may be duplicated.\n new_g.ndata['inner_node'] = _to_shared_mem(g.ndata['inner_node'],\n _get_ndata_path(graph_name, 'inner_node'))\n new_g.ndata[NID] = _to_shared_mem(g.ndata[NID], _get_ndata_path(graph_name, NID))\n\n new_g.edata['inner_edge'] = _to_shared_mem(g.edata['inner_edge'],\n _get_edata_path(graph_name, 'inner_edge'))\n new_g.edata[EID] = _to_shared_mem(g.edata[EID], _get_edata_path(graph_name, EID))\n new_g.edata[ETYPE] = _to_shared_mem(g.edata[ETYPE], _get_edata_path(graph_name, ETYPE))\n return new_g\n\nFIELD_DICT = {'inner_node': F.int32, # A flag indicates whether the node is inside a partition.\n 'inner_edge': F.int32, # A flag indicates whether the edge is inside a partition.\n NID: F.int64,\n EID: F.int64,\n NTYPE: F.int32,\n ETYPE: F.int32}\n\ndef _get_shared_mem_ndata(g, graph_name, name):\n ''' Get shared-memory node data from DistGraph server.\n\n This is called by the DistGraph client to access the node data in the DistGraph server\n with shared memory.\n '''\n shape = (g.number_of_nodes(),)\n dtype = FIELD_DICT[name]\n dtype = DTYPE_DICT[dtype]\n data = empty_shared_mem(_get_ndata_path(graph_name, name), False, shape, dtype)\n dlpack = data.to_dlpack()\n return F.zerocopy_from_dlpack(dlpack)\n\ndef _get_shared_mem_edata(g, graph_name, name):\n ''' Get shared-memory edge data from DistGraph server.\n\n This is called by the DistGraph client to access the edge data in the DistGraph server\n with shared memory.\n '''\n shape = (g.number_of_edges(),)\n dtype = FIELD_DICT[name]\n dtype = DTYPE_DICT[dtype]\n data = empty_shared_mem(_get_edata_path(graph_name, name), False, shape, dtype)\n dlpack = data.to_dlpack()\n return F.zerocopy_from_dlpack(dlpack)\n\ndef _get_graph_from_shared_mem(graph_name):\n ''' Get the graph from the DistGraph server.\n\n The DistGraph server puts the graph structure of the local partition in the shared memory.\n The client can access the graph structure and some metadata on nodes and edges directly\n through shared memory to reduce the overhead of data access.\n '''\n g, ntypes, etypes = heterograph_index.create_heterograph_from_shared_memory(graph_name)\n if g is None:\n return None\n g = DGLHeteroGraph(g, ntypes, etypes)\n\n g.ndata['inner_node'] = _get_shared_mem_ndata(g, graph_name, 'inner_node')\n g.ndata[NID] = _get_shared_mem_ndata(g, graph_name, NID)\n\n g.edata['inner_edge'] = _get_shared_mem_edata(g, graph_name, 'inner_edge')\n g.edata[EID] = _get_shared_mem_edata(g, graph_name, EID)\n g.edata[ETYPE] = _get_shared_mem_edata(g, graph_name, ETYPE)\n return g\n\nNodeSpace = namedtuple('NodeSpace', ['data'])\nEdgeSpace = namedtuple('EdgeSpace', ['data'])\n\nclass HeteroNodeView(object):\n \"\"\"A NodeView class to act as G.nodes for a DistGraph.\"\"\"\n __slots__ = ['_graph']\n\n def __init__(self, graph):\n self._graph = graph\n\n def __getitem__(self, key):\n assert isinstance(key, str)\n return NodeSpace(data=NodeDataView(self._graph, key))\n\nclass HeteroEdgeView(object):\n \"\"\"A NodeView class to act as G.nodes for a DistGraph.\"\"\"\n __slots__ = ['_graph']\n\n def __init__(self, graph):\n self._graph = graph\n\n def __getitem__(self, key):\n assert isinstance(key, str)\n return EdgeSpace(data=EdgeDataView(self._graph, key))\n\nclass NodeDataView(MutableMapping):\n \"\"\"The data view class when dist_graph.ndata[...].data is called.\n \"\"\"\n __slots__ = ['_graph', '_data']\n\n def __init__(self, g, ntype=None):\n self._graph = g\n # When this is created, the server may already load node data. We need to\n # initialize the node data in advance.\n names = g._get_ndata_names(ntype)\n if ntype is None:\n self._data = g._ndata_store\n else:\n if ntype in g._ndata_store:\n self._data = g._ndata_store[ntype]\n else:\n self._data = {}\n g._ndata_store[ntype] = self._data\n for name in names:\n assert name.is_node()\n policy = PartitionPolicy(name.policy_str, g.get_partition_book())\n dtype, shape, _ = g._client.get_data_meta(str(name))\n # We create a wrapper on the existing tensor in the kvstore.\n self._data[name.get_name()] = DistTensor(shape, dtype, name.get_name(),\n part_policy=policy)\n\n def _get_names(self):\n return list(self._data.keys())\n\n def __getitem__(self, key):\n return self._data[key]\n\n def __setitem__(self, key, val):\n self._data[key] = val\n\n def __delitem__(self, key):\n del self._data[key]\n\n def __len__(self):\n # The number of node data may change. Let's count it every time we need them.\n # It's not called frequently. It should be fine.\n return len(self._data)\n\n def __iter__(self):\n return iter(self._data)\n\n def __repr__(self):\n reprs = {}\n for name in self._data:\n dtype = F.dtype(self._data[name])\n shape = F.shape(self._data[name])\n reprs[name] = 'DistTensor(shape={}, dtype={})'.format(str(shape), str(dtype))\n return repr(reprs)\n\nclass EdgeDataView(MutableMapping):\n \"\"\"The data view class when G.edges[...].data is called.\n \"\"\"\n __slots__ = ['_graph', '_data']\n\n def __init__(self, g, etype=None):\n self._graph = g\n # When this is created, the server may already load edge data. We need to\n # initialize the edge data in advance.\n names = g._get_edata_names(etype)\n if etype is None:\n self._data = g._edata_store\n else:\n if etype in g._edata_store:\n self._data = g._edata_store[etype]\n else:\n self._data = {}\n g._edata_store[etype] = self._data\n for name in names:\n assert name.is_edge()\n policy = PartitionPolicy(name.policy_str, g.get_partition_book())\n dtype, shape, _ = g._client.get_data_meta(str(name))\n # We create a wrapper on the existing tensor in the kvstore.\n self._data[name.get_name()] = DistTensor(shape, dtype, name.get_name(),\n part_policy=policy)\n\n def _get_names(self):\n return list(self._data.keys())\n\n def __getitem__(self, key):\n return self._data[key]\n\n def __setitem__(self, key, val):\n self._data[key] = val\n\n def __delitem__(self, key):\n del self._data[key]\n\n def __len__(self):\n # The number of edge data may change. Let's count it every time we need them.\n # It's not called frequently. It should be fine.\n return len(self._data)\n\n def __iter__(self):\n return iter(self._data)\n\n def __repr__(self):\n reprs = {}\n for name in self._data:\n dtype = F.dtype(self._data[name])\n shape = F.shape(self._data[name])\n reprs[name] = 'DistTensor(shape={}, dtype={})'.format(str(shape), str(dtype))\n return repr(reprs)\n\n\nclass DistGraphServer(KVServer):\n ''' The DistGraph server.\n\n This DistGraph server loads the graph data and sets up a service so that trainers and\n samplers can read data of a graph partition (graph structure, node data and edge data)\n from remote machines. A server is responsible for one graph partition.\n\n Currently, each machine runs only one main server with a set of backup servers to handle\n clients' requests. The main server and the backup servers all handle the requests for the same\n graph partition. They all share the partition data (graph structure and node/edge data) with\n shared memory.\n\n By default, the partition data is shared with the DistGraph clients that run on\n the same machine. However, a user can disable shared memory option. This is useful for the case\n that a user wants to run the server and the client on different machines.\n\n Parameters\n ----------\n server_id : int\n The server ID (start from 0).\n ip_config : str\n Path of IP configuration file.\n num_servers : int\n Server count on each machine.\n num_clients : int\n Total number of client nodes.\n part_config : string\n The path of the config file generated by the partition tool.\n disable_shared_mem : bool\n Disable shared memory.\n graph_format : str or list of str\n The graph formats.\n '''\n def __init__(self, server_id, ip_config, num_servers,\n num_clients, part_config, disable_shared_mem=False,\n graph_format=('csc', 'coo')):\n super(DistGraphServer, self).__init__(server_id=server_id,\n ip_config=ip_config,\n num_servers=num_servers,\n num_clients=num_clients)\n self.ip_config = ip_config\n self.num_servers = num_servers\n # Load graph partition data.\n if self.is_backup_server():\n # The backup server doesn't load the graph partition. It'll initialized afterwards.\n self.gpb, graph_name, ntypes, etypes = load_partition_book(part_config, self.part_id)\n self.client_g = None\n else:\n self.client_g, node_feats, edge_feats, self.gpb, graph_name, \\\n ntypes, etypes = load_partition(part_config, self.part_id)\n print('load ' + graph_name)\n # Create the graph formats specified the users.\n self.client_g = self.client_g.formats(graph_format)\n self.client_g.create_formats_()\n if not disable_shared_mem:\n self.client_g = _copy_graph_to_shared_mem(self.client_g, graph_name, graph_format)\n\n if not disable_shared_mem:\n self.gpb.shared_memory(graph_name)\n assert self.gpb.partid == self.part_id\n for ntype in ntypes:\n node_name = HeteroDataName(True, ntype, None)\n self.add_part_policy(PartitionPolicy(node_name.policy_str, self.gpb))\n for etype in etypes:\n edge_name = HeteroDataName(False, etype, None)\n self.add_part_policy(PartitionPolicy(edge_name.policy_str, self.gpb))\n\n if not self.is_backup_server():\n for name in node_feats:\n # The feature name has the following format: node_type + \"/\" + feature_name to avoid\n # feature name collision for different node types.\n ntype, feat_name = name.split('/')\n data_name = HeteroDataName(True, ntype, feat_name)\n self.init_data(name=str(data_name), policy_str=data_name.policy_str,\n data_tensor=node_feats[name])\n for name in edge_feats:\n # The feature name has the following format: edge_type + \"/\" + feature_name to avoid\n # feature name collision for different edge types.\n etype, feat_name = name.split('/')\n data_name = HeteroDataName(False, etype, feat_name)\n self.init_data(name=str(data_name), policy_str=data_name.policy_str,\n data_tensor=edge_feats[name])\n\n def start(self):\n \"\"\" Start graph store server.\n \"\"\"\n # start server\n server_state = ServerState(kv_store=self, local_g=self.client_g, partition_book=self.gpb)\n print('start graph service on server {} for part {}'.format(self.server_id, self.part_id))\n start_server(server_id=self.server_id,\n ip_config=self.ip_config,\n num_servers=self.num_servers,\n num_clients=self.num_clients, server_state=server_state)\n\nclass DistGraph:\n '''The class for accessing a distributed graph.\n\n This class provides a subset of DGLGraph APIs for accessing partitioned graph data in\n distributed GNN training and inference. Thus, its main use case is to work with\n distributed sampling APIs to generate mini-batches and perform forward and\n backward computation on the mini-batches.\n\n The class can run in two modes: the standalone mode and the distributed mode.\n\n * When a user runs the training script normally, ``DistGraph`` will be in the standalone mode.\n In this mode, the input data must be constructed by\n :py:meth:`~dgl.distributed.partition.partition_graph` with only one partition. This mode is\n used for testing and debugging purpose. In this mode, users have to provide ``part_config``\n so that ``DistGraph`` can load the input graph.\n * When a user runs the training script with the distributed launch script, ``DistGraph`` will\n be set into the distributed mode. This is used for actual distributed training. All data of\n partitions are loaded by the ``DistGraph`` servers, which are created by DGL's launch script.\n ``DistGraph`` connects with the servers to access the partitioned graph data.\n\n Currently, the ``DistGraph`` servers and clients run on the same set of machines\n in the distributed mode. ``DistGraph`` uses shared-memory to access the partition data\n in the local machine. This gives the best performance for distributed training\n\n Users may want to run ``DistGraph`` servers and clients on separate sets of machines.\n In this case, a user may want to disable shared memory by passing\n ``disable_shared_mem=False`` when creating ``DistGraphServer``. When shared memory is disabled,\n a user has to pass a partition book.\n\n Parameters\n ----------\n graph_name : str\n The name of the graph. This name has to be the same as the one used for\n partitioning a graph in :py:meth:`dgl.distributed.partition.partition_graph`.\n gpb : GraphPartitionBook, optional\n The partition book object. Normally, users do not need to provide the partition book.\n This argument is necessary only when users want to run server process and trainer\n processes on different machines.\n part_config : str, optional\n The path of partition configuration file generated by\n :py:meth:`dgl.distributed.partition.partition_graph`. It's used in the standalone mode.\n\n Examples\n --------\n The example shows the creation of ``DistGraph`` in the standalone mode.\n\n >>> dgl.distributed.partition_graph(g, 'graph_name', 1, num_hops=1, part_method='metis',\n ... out_path='output/', reshuffle=True)\n >>> g = dgl.distributed.DistGraph('graph_name', part_config='output/graph_name.json')\n\n The example shows the creation of ``DistGraph`` in the distributed mode.\n\n >>> g = dgl.distributed.DistGraph('graph-name')\n\n The code below shows the mini-batch training using ``DistGraph``.\n\n >>> def sample(seeds):\n ... seeds = th.LongTensor(np.asarray(seeds))\n ... frontier = dgl.distributed.sample_neighbors(g, seeds, 10)\n ... return dgl.to_block(frontier, seeds)\n >>> dataloader = dgl.distributed.DistDataLoader(dataset=nodes, batch_size=1000,\n ... collate_fn=sample, shuffle=True)\n >>> for block in dataloader:\n ... feat = g.ndata['features'][block.srcdata[dgl.NID]]\n ... labels = g.ndata['labels'][block.dstdata[dgl.NID]]\n ... pred = model(block, feat)\n\n Note\n ----\n DGL's distributed training by default runs server processes and trainer processes on the same\n set of machines. If users need to run them on different sets of machines, it requires\n manually setting up servers and trainers. The setup is not fully tested yet.\n '''\n def __init__(self, graph_name, gpb=None, part_config=None):\n self.graph_name = graph_name\n self._gpb_input = gpb\n if os.environ.get('DGL_DIST_MODE', 'standalone') == 'standalone':\n assert part_config is not None, \\\n 'When running in the standalone model, the partition config file is required'\n self._client = get_kvstore()\n assert self._client is not None, \\\n 'Distributed module is not initialized. Please call dgl.distributed.initialize.'\n # Load graph partition data.\n g, node_feats, edge_feats, self._gpb, _, _, _ = load_partition(part_config, 0)\n assert self._gpb.num_partitions() == 1, \\\n 'The standalone mode can only work with the graph data with one partition'\n if self._gpb is None:\n self._gpb = gpb\n self._g = g\n for name in node_feats:\n # The feature name has the following format: node_type + \"/\" + feature_name.\n ntype, feat_name = name.split('/')\n self._client.add_data(str(HeteroDataName(True, ntype, feat_name)),\n node_feats[name],\n NodePartitionPolicy(self._gpb, ntype=ntype))\n for name in edge_feats:\n # The feature name has the following format: edge_type + \"/\" + feature_name.\n etype, feat_name = name.split('/')\n self._client.add_data(str(HeteroDataName(False, etype, feat_name)),\n edge_feats[name],\n EdgePartitionPolicy(self._gpb, etype=etype))\n self._client.map_shared_data(self._gpb)\n rpc.set_num_client(1)\n else:\n self._init()\n # Tell the backup servers to load the graph structure from shared memory.\n for server_id in range(self._client.num_servers):\n rpc.send_request(server_id, InitGraphRequest(graph_name))\n for server_id in range(self._client.num_servers):\n rpc.recv_response()\n self._client.barrier()\n\n self._ndata_store = {}\n self._edata_store = {}\n self._ndata = NodeDataView(self)\n self._edata = EdgeDataView(self)\n\n self._num_nodes = 0\n self._num_edges = 0\n for part_md in self._gpb.metadata():\n self._num_nodes += int(part_md['num_nodes'])\n self._num_edges += int(part_md['num_edges'])\n\n # When we store node/edge types in a list, they are stored in the order of type IDs.\n self._ntype_map = {ntype:i for i, ntype in enumerate(self.ntypes)}\n self._etype_map = {etype:i for i, etype in enumerate(self.etypes)}\n\n # Get canonical edge types.\n # TODO(zhengda) this requires the server to store the graph with coo format.\n eid = []\n for etype in self.etypes:\n type_eid = F.zeros((1,), F.int64, F.cpu())\n eid.append(self._gpb.map_to_homo_eid(type_eid, etype))\n eid = F.cat(eid, 0)\n src, dst = dist_find_edges(self, eid)\n src_tids, _ = self._gpb.map_to_per_ntype(src)\n dst_tids, _ = self._gpb.map_to_per_ntype(dst)\n self._canonical_etypes = []\n etype_ids = F.arange(0, len(self.etypes))\n for src_tid, etype_id, dst_tid in zip(src_tids, etype_ids, dst_tids):\n src_tid = F.as_scalar(src_tid)\n etype_id = F.as_scalar(etype_id)\n dst_tid = F.as_scalar(dst_tid)\n self._canonical_etypes.append((self.ntypes[src_tid], self.etypes[etype_id],\n self.ntypes[dst_tid]))\n self._etype2canonical = {}\n for src_type, etype, dst_type in self._canonical_etypes:\n if etype in self._etype2canonical:\n self._etype2canonical[etype] = ()\n else:\n self._etype2canonical[etype] = (src_type, etype, dst_type)\n\n def _init(self):\n self._client = get_kvstore()\n assert self._client is not None, \\\n 'Distributed module is not initialized. Please call dgl.distributed.initialize.'\n self._g = _get_graph_from_shared_mem(self.graph_name)\n self._gpb = get_shared_mem_partition_book(self.graph_name, self._g)\n if self._gpb is None:\n self._gpb = self._gpb_input\n self._client.map_shared_data(self._gpb)\n\n def __getstate__(self):\n return self.graph_name, self._gpb, self._canonical_etypes\n\n def __setstate__(self, state):\n self.graph_name, self._gpb_input, self._canonical_etypes = state\n self._init()\n\n self._etype2canonical = {}\n for src_type, etype, dst_type in self._canonical_etypes:\n if etype in self._etype2canonical:\n self._etype2canonical[etype] = ()\n else:\n self._etype2canonical[etype] = (src_type, etype, dst_type)\n self._ndata_store = {}\n self._edata_store = {}\n self._ndata = NodeDataView(self)\n self._edata = EdgeDataView(self)\n self._num_nodes = 0\n self._num_edges = 0\n for part_md in self._gpb.metadata():\n self._num_nodes += int(part_md['num_nodes'])\n self._num_edges += int(part_md['num_edges'])\n\n @property\n def local_partition(self):\n ''' Return the local partition on the client\n\n DistGraph provides a global view of the distributed graph. Internally,\n it may contains a partition of the graph if it is co-located with\n the server. When servers and clients run on separate sets of machines,\n this returns None.\n\n Returns\n -------\n DGLGraph\n The local partition\n '''\n return self._g\n\n @property\n def nodes(self):\n '''Return a node view\n '''\n return HeteroNodeView(self)\n\n @property\n def edges(self):\n '''Return an edge view\n '''\n return HeteroEdgeView(self)\n\n @property\n def ndata(self):\n \"\"\"Return the data view of all the nodes.\n\n Returns\n -------\n NodeDataView\n The data view in the distributed graph storage.\n \"\"\"\n assert len(self.ntypes) == 1, \"ndata only works for a graph with one node type.\"\n return self._ndata\n\n @property\n def edata(self):\n \"\"\"Return the data view of all the edges.\n\n Returns\n -------\n EdgeDataView\n The data view in the distributed graph storage.\n \"\"\"\n assert len(self.etypes) == 1, \"edata only works for a graph with one edge type.\"\n return self._edata\n\n @property\n def idtype(self):\n \"\"\"The dtype of graph index\n\n Returns\n -------\n backend dtype object\n th.int32/th.int64 or tf.int32/tf.int64 etc.\n\n See Also\n --------\n long\n int\n \"\"\"\n # TODO(da?): describe when self._g is None and idtype shouldn't be called.\n return F.int64\n\n @property\n def device(self):\n \"\"\"Get the device context of this graph.\n\n Examples\n --------\n The following example uses PyTorch backend.\n\n >>> g = dgl.bipartite(([0, 1, 1, 2], [0, 0, 2, 1]), 'user', 'plays', 'game')\n >>> print(g.device)\n device(type='cpu')\n >>> g = g.to('cuda:0')\n >>> print(g.device)\n device(type='cuda', index=0)\n\n Returns\n -------\n Device context object\n \"\"\"\n # TODO(da?): describe when self._g is None and device shouldn't be called.\n return F.cpu()\n\n @property\n def ntypes(self):\n \"\"\"Return the list of node types of this graph.\n\n Returns\n -------\n list of str\n\n Examples\n --------\n\n >>> g = DistGraph(\"test\")\n >>> g.ntypes\n ['_U']\n \"\"\"\n return self._gpb.ntypes\n\n @property\n def etypes(self):\n \"\"\"Return the list of edge types of this graph.\n\n Returns\n -------\n list of str\n\n Examples\n --------\n\n >>> g = DistGraph(\"test\")\n >>> g.etypes\n ['_E']\n \"\"\"\n # Currently, we only support a graph with one edge type.\n return self._gpb.etypes\n\n @property\n def canonical_etypes(self):\n \"\"\"Return all the canonical edge types in the graph.\n\n A canonical edge type is a string triplet ``(str, str, str)``\n for source node type, edge type and destination node type.\n\n Returns\n -------\n list[(str, str, str)]\n All the canonical edge type triplets in a list.\n\n Notes\n -----\n DGL internally assigns an integer ID for each edge type. The returned\n edge type names are sorted according to their IDs.\n\n See Also\n --------\n etypes\n\n Examples\n --------\n The following example uses PyTorch backend.\n\n >>> import dgl\n >>> import torch\n\n >>> g = DistGraph(\"test\")\n >>> g.canonical_etypes\n [('user', 'follows', 'user'),\n ('user', 'follows', 'game'),\n ('user', 'plays', 'game')]\n \"\"\"\n return self._canonical_etypes\n\n def to_canonical_etype(self, etype):\n \"\"\"Convert an edge type to the corresponding canonical edge type in the graph.\n\n A canonical edge type is a string triplet ``(str, str, str)``\n for source node type, edge type and destination node type.\n\n The function expects the given edge type name can uniquely identify a canonical edge\n type. DGL will raise error if this is not the case.\n\n Parameters\n ----------\n etype : str or (str, str, str)\n If :attr:`etype` is an edge type (str), it returns the corresponding canonical edge\n type in the graph. If :attr:`etype` is already a canonical edge type,\n it directly returns the input unchanged.\n\n Returns\n -------\n (str, str, str)\n The canonical edge type corresponding to the edge type.\n\n Examples\n --------\n The following example uses PyTorch backend.\n\n >>> import dgl\n >>> import torch\n\n >>> g = DistGraph(\"test\")\n >>> g.canonical_etypes\n [('user', 'follows', 'user'),\n ('user', 'follows', 'game'),\n ('user', 'plays', 'game')]\n\n >>> g.to_canonical_etype('plays')\n ('user', 'plays', 'game')\n >>> g.to_canonical_etype(('user', 'plays', 'game'))\n ('user', 'plays', 'game')\n\n See Also\n --------\n canonical_etypes\n \"\"\"\n if etype is None:\n if len(self.etypes) != 1:\n raise DGLError('Edge type name must be specified if there are more than one '\n 'edge types.')\n etype = self.etypes[0]\n if isinstance(etype, tuple):\n return etype\n else:\n ret = self._etype2canonical.get(etype, None)\n if ret is None:\n raise DGLError('Edge type \"{}\" does not exist.'.format(etype))\n if len(ret) != 3:\n raise DGLError('Edge type \"{}\" is ambiguous. Please use canonical edge type '\n 'in the form of (srctype, etype, dsttype)'.format(etype))\n return ret\n\n def get_ntype_id(self, ntype):\n \"\"\"Return the ID of the given node type.\n\n ntype can also be None. If so, there should be only one node type in the\n graph.\n\n Parameters\n ----------\n ntype : str\n Node type\n\n Returns\n -------\n int\n \"\"\"\n if ntype is None:\n if len(self._ntype_map) != 1:\n raise DGLError('Node type name must be specified if there are more than one '\n 'node types.')\n return 0\n return self._ntype_map[ntype]\n\n def get_etype_id(self, etype):\n \"\"\"Return the id of the given edge type.\n\n etype can also be None. If so, there should be only one edge type in the\n graph.\n\n Parameters\n ----------\n etype : str or tuple of str\n Edge type\n\n Returns\n -------\n int\n \"\"\"\n if etype is None:\n if len(self._etype_map) != 1:\n raise DGLError('Edge type name must be specified if there are more than one '\n 'edge types.')\n return 0\n return self._etype_map[etype]\n\n def number_of_nodes(self, ntype=None):\n \"\"\"Alias of :func:`num_nodes`\"\"\"\n return self.num_nodes(ntype)\n\n def number_of_edges(self, etype=None):\n \"\"\"Alias of :func:`num_edges`\"\"\"\n return self.num_edges(etype)\n\n def num_nodes(self, ntype=None):\n \"\"\"Return the total number of nodes in the distributed graph.\n\n Parameters\n ----------\n ntype : str, optional\n The node type name. If given, it returns the number of nodes of the\n type. If not given (default), it returns the total number of nodes of all types.\n\n Returns\n -------\n int\n The number of nodes\n\n Examples\n --------\n >>> g = dgl.distributed.DistGraph('ogb-product')\n >>> print(g.num_nodes())\n 2449029\n \"\"\"\n if ntype is None:\n if len(self.ntypes) == 1:\n return self._gpb._num_nodes(self.ntypes[0])\n else:\n return sum([self._gpb._num_nodes(ntype) for ntype in self.ntypes])\n return self._gpb._num_nodes(ntype)\n\n def num_edges(self, etype=None):\n \"\"\"Return the total number of edges in the distributed graph.\n\n Parameters\n ----------\n etype : str or (str, str, str), optional\n The type name of the edges. The allowed type name formats are:\n\n * ``(str, str, str)`` for source node type, edge type and destination node type.\n * or one ``str`` edge type name if the name can uniquely identify a\n triplet format in the graph.\n\n If not provided, return the total number of edges regardless of the types\n in the graph.\n\n Returns\n -------\n int\n The number of edges\n\n Examples\n --------\n >>> g = dgl.distributed.DistGraph('ogb-product')\n >>> print(g.num_edges())\n 123718280\n \"\"\"\n if etype is None:\n if len(self.etypes) == 1:\n return self._gpb._num_edges(self.etypes[0])\n else:\n return sum([self._gpb._num_edges(etype) for etype in self.etypes])\n return self._gpb._num_edges(etype)\n\n def out_degrees(self, u=ALL):\n \"\"\"Return the out-degree(s) of the given nodes.\n\n It computes the out-degree(s).\n It does not support heterogeneous graphs yet.\n\n Parameters\n ----------\n u : node IDs\n The node IDs. The allowed formats are:\n\n * ``int``: A single node.\n * Int Tensor: Each element is a node ID. The tensor must have the same device type\n and ID data type as the graph's.\n * iterable[int]: Each element is a node ID.\n\n If not given, return the in-degrees of all the nodes.\n\n Returns\n -------\n int or Tensor\n The out-degree(s) of the node(s) in a Tensor. The i-th element is the out-degree\n of the i-th input node. If :attr:`v` is an ``int``, return an ``int`` too.\n\n Examples\n --------\n The following example uses PyTorch backend.\n\n >>> import dgl\n >>> import torch\n\n Query for all nodes.\n\n >>> g.out_degrees()\n tensor([2, 2, 0, 0])\n\n Query for nodes 1 and 2.\n\n >>> g.out_degrees(torch.tensor([1, 2]))\n tensor([2, 0])\n\n See Also\n --------\n in_degrees\n \"\"\"\n if is_all(u):\n u = F.arange(0, self.number_of_nodes())\n return dist_out_degrees(self, u)\n\n def in_degrees(self, v=ALL):\n \"\"\"Return the in-degree(s) of the given nodes.\n\n It computes the in-degree(s).\n It does not support heterogeneous graphs yet.\n\n Parameters\n ----------\n v : node IDs\n The node IDs. The allowed formats are:\n\n * ``int``: A single node.\n * Int Tensor: Each element is a node ID. The tensor must have the same device type\n and ID data type as the graph's.\n * iterable[int]: Each element is a node ID.\n\n If not given, return the in-degrees of all the nodes.\n\n Returns\n -------\n int or Tensor\n The in-degree(s) of the node(s) in a Tensor. The i-th element is the in-degree\n of the i-th input node. If :attr:`v` is an ``int``, return an ``int`` too.\n\n Examples\n --------\n The following example uses PyTorch backend.\n\n >>> import dgl\n >>> import torch\n\n Query for all nodes.\n\n >>> g.in_degrees()\n tensor([0, 2, 1, 1])\n\n Query for nodes 1 and 2.\n\n >>> g.in_degrees(torch.tensor([1, 2]))\n tensor([2, 1])\n\n See Also\n --------\n out_degrees\n \"\"\"\n if is_all(v):\n v = F.arange(0, self.number_of_nodes())\n return dist_in_degrees(self, v)\n\n def node_attr_schemes(self):\n \"\"\"Return the node feature schemes.\n\n Each feature scheme is a named tuple that stores the shape and data type\n of the node feature.\n\n Returns\n -------\n dict of str to schemes\n The schemes of node feature columns.\n\n Examples\n --------\n The following uses PyTorch backend.\n\n >>> g.node_attr_schemes()\n {'h': Scheme(shape=(4,), dtype=torch.float32)}\n\n See Also\n --------\n edge_attr_schemes\n \"\"\"\n schemes = {}\n for key in self.ndata:\n schemes[key] = infer_scheme(self.ndata[key])\n return schemes\n\n def edge_attr_schemes(self):\n \"\"\"Return the edge feature schemes.\n\n Each feature scheme is a named tuple that stores the shape and data type\n of the edge feature.\n\n Returns\n -------\n dict of str to schemes\n The schemes of edge feature columns.\n\n Examples\n --------\n The following uses PyTorch backend.\n\n >>> g.edge_attr_schemes()\n {'h': Scheme(shape=(4,), dtype=torch.float32)}\n\n See Also\n --------\n node_attr_schemes\n \"\"\"\n schemes = {}\n for key in self.edata:\n schemes[key] = infer_scheme(self.edata[key])\n return schemes\n\n def rank(self):\n ''' The rank of the current DistGraph.\n\n This returns a unique number to identify the DistGraph object among all of\n the client processes.\n\n Returns\n -------\n int\n The rank of the current DistGraph.\n '''\n return role.get_global_rank()\n\n def find_edges(self, edges, etype=None):\n \"\"\" Given an edge ID array, return the source\n and destination node ID array ``s`` and ``d``. ``s[i]`` and ``d[i]``\n are source and destination node ID for edge ``eid[i]``.\n\n Parameters\n ----------\n edges : Int Tensor\n Each element is an ID. The tensor must have the same device type\n and ID data type as the graph's.\n\n etype : str or (str, str, str), optional\n The type names of the edges. The allowed type name formats are:\n\n * ``(str, str, str)`` for source node type, edge type and destination node type.\n * or one ``str`` edge type name if the name can uniquely identify a\n triplet format in the graph.\n\n Can be omitted if the graph has only one type of edges.\n\n Returns\n -------\n tensor\n The source node ID array.\n tensor\n The destination node ID array.\n \"\"\"\n if etype is None:\n assert len(self.etypes) == 1, 'find_edges requires etype for heterogeneous graphs.'\n\n gpb = self.get_partition_book()\n if len(gpb.etypes) > 1:\n # if etype is a canonical edge type (str, str, str), extract the edge type\n if len(etype) == 3:\n etype = etype[1]\n edges = gpb.map_to_homo_eid(edges, etype)\n src, dst = dist_find_edges(self, edges)\n if len(gpb.ntypes) > 1:\n _, src = gpb.map_to_per_ntype(src)\n _, dst = gpb.map_to_per_ntype(dst)\n return src, dst\n\n def edge_subgraph(self, edges, relabel_nodes=True, store_ids=True):\n \"\"\"Return a subgraph induced on the given edges.\n\n An edge-induced subgraph is equivalent to creating a new graph using the given\n edges. In addition to extracting the subgraph, DGL also copies the features\n of the extracted nodes and edges to the resulting graph. The copy is *lazy*\n and incurs data movement only when needed.\n\n If the graph is heterogeneous, DGL extracts a subgraph per relation and composes\n them as the resulting graph. Thus, the resulting graph has the same set of relations\n as the input one.\n\n Parameters\n ----------\n edges : Int Tensor or dict[(str, str, str), Int Tensor]\n The edges to form the subgraph. Each element is an edge ID. The tensor must have\n the same device type and ID data type as the graph's.\n\n If the graph is homogeneous, one can directly pass an Int Tensor.\n Otherwise, the argument must be a dictionary with keys being edge types\n and values being the edge IDs in the above formats.\n relabel_nodes : bool, optional\n If True, it will remove the isolated nodes and relabel the incident nodes in the\n extracted subgraph.\n store_ids : bool, optional\n If True, it will store the raw IDs of the extracted edges in the ``edata`` of the\n resulting graph under name ``dgl.EID``; if ``relabel_nodes`` is ``True``, it will\n also store the raw IDs of the incident nodes in the ``ndata`` of the resulting\n graph under name ``dgl.NID``.\n\n Returns\n -------\n G : DGLGraph\n The subgraph.\n \"\"\"\n if isinstance(edges, dict):\n # TODO(zhengda) we need to directly generate subgraph of all relations with\n # one invocation.\n if isinstance(edges, tuple):\n subg = {etype: self.find_edges(edges[etype], etype[1]) for etype in edges}\n else:\n subg = {}\n for etype in edges:\n assert len(self._etype2canonical[etype]) == 3, \\\n 'the etype in input edges is ambiguous'\n subg[self._etype2canonical[etype]] = self.find_edges(edges[etype], etype)\n num_nodes = {ntype: self.number_of_nodes(ntype) for ntype in self.ntypes}\n subg = dgl_heterograph(subg, num_nodes_dict=num_nodes)\n for etype in edges:\n subg.edges[etype].data[EID] = edges[etype]\n else:\n assert len(self.etypes) == 1\n subg = self.find_edges(edges)\n subg = dgl_graph(subg, num_nodes=self.number_of_nodes())\n subg.edata[EID] = edges\n\n if relabel_nodes:\n subg = compact_graphs(subg)\n assert store_ids, 'edge_subgraph always stores original node/edge IDs.'\n return subg\n\n def get_partition_book(self):\n \"\"\"Get the partition information.\n\n Returns\n -------\n GraphPartitionBook\n Object that stores all graph partition information.\n \"\"\"\n return self._gpb\n\n def get_node_partition_policy(self, ntype):\n \"\"\"Get the partition policy for a node type.\n\n When creating a new distributed tensor, we need to provide a partition policy\n that indicates how to distribute data of the distributed tensor in a cluster\n of machines. When we load a distributed graph in the cluster, we have pre-defined\n partition policies for each node type and each edge type. By providing\n the node type, we can reference to the pre-defined partition policy for the node type.\n\n Parameters\n ----------\n ntype : str\n The node type\n\n Returns\n -------\n PartitionPolicy\n The partition policy for the node type.\n \"\"\"\n return NodePartitionPolicy(self.get_partition_book(), ntype)\n\n def get_edge_partition_policy(self, etype):\n \"\"\"Get the partition policy for an edge type.\n\n When creating a new distributed tensor, we need to provide a partition policy\n that indicates how to distribute data of the distributed tensor in a cluster\n of machines. When we load a distributed graph in the cluster, we have pre-defined\n partition policies for each node type and each edge type. By providing\n the edge type, we can reference to the pre-defined partition policy for the edge type.\n\n Parameters\n ----------\n etype : str\n The edge type\n\n Returns\n -------\n PartitionPolicy\n The partition policy for the edge type.\n \"\"\"\n return EdgePartitionPolicy(self.get_partition_book(), etype)\n\n def barrier(self):\n '''Barrier for all client nodes.\n\n This API blocks the current process untill all the clients invoke this API.\n Please use this API with caution.\n '''\n self._client.barrier()\n\n def _get_ndata_names(self, ntype=None):\n ''' Get the names of all node data.\n '''\n names = self._client.gdata_name_list()\n ndata_names = []\n for name in names:\n name = parse_hetero_data_name(name)\n right_type = (name.get_type() == ntype) if ntype is not None else True\n if name.is_node() and right_type:\n ndata_names.append(name)\n return ndata_names\n\n def _get_edata_names(self, etype=None):\n ''' Get the names of all edge data.\n '''\n names = self._client.gdata_name_list()\n edata_names = []\n for name in names:\n name = parse_hetero_data_name(name)\n right_type = (name.get_type() == etype) if etype is not None else True\n if name.is_edge() and right_type:\n edata_names.append(name)\n return edata_names\n\ndef _get_overlap(mask_arr, ids):\n \"\"\" Select the IDs given a boolean mask array.\n\n The boolean mask array indicates all of the IDs to be selected. We want to\n find the overlap between the IDs selected by the boolean mask array and\n the ID array.\n\n Parameters\n ----------\n mask_arr : 1D tensor\n A boolean mask array.\n ids : 1D tensor\n A vector with IDs.\n\n Returns\n -------\n 1D tensor\n The selected IDs.\n \"\"\"\n if isinstance(mask_arr, DistTensor):\n masks = mask_arr[ids]\n return F.boolean_mask(ids, masks)\n else:\n masks = F.gather_row(F.tensor(mask_arr), ids)\n return F.boolean_mask(ids, masks)\n\ndef _split_local(partition_book, rank, elements, local_eles):\n ''' Split the input element list with respect to data locality.\n '''\n num_clients = role.get_num_trainers()\n num_client_per_part = num_clients // partition_book.num_partitions()\n if rank is None:\n rank = role.get_trainer_rank()\n assert rank < num_clients, \\\n 'The input rank ({}) is incorrect. #Trainers: {}'.format(rank, num_clients)\n # all ranks of the clients in the same machine are in a contiguous range.\n client_id_in_part = rank % num_client_per_part\n local_eles = _get_overlap(elements, local_eles)\n\n # get a subset for the local client.\n size = len(local_eles) // num_client_per_part\n # if this isn't the last client in the partition.\n if client_id_in_part + 1 < num_client_per_part:\n return local_eles[(size * client_id_in_part):(size * (client_id_in_part + 1))]\n else:\n return local_eles[(size * client_id_in_part):]\n\ndef _even_offset(n, k):\n ''' Split an array of length n into k segments and the difference of thier length is\n at most 1. Return the offset of each segment.\n '''\n eles_per_part = n // k\n offset = np.array([0] + [eles_per_part] * k, dtype=int)\n offset[1 : n - eles_per_part * k + 1] += 1\n return np.cumsum(offset)\n\ndef _split_even_to_part(partition_book, elements):\n ''' Split the input element list evenly.\n '''\n # here we divide the element list as evenly as possible. If we use range partitioning,\n # the split results also respect the data locality. Range partitioning is the default\n # strategy.\n # TODO(zhengda) we need another way to divide the list for other partitioning strategy.\n if isinstance(elements, DistTensor):\n nonzero_count = elements.count_nonzero()\n else:\n elements = F.tensor(elements)\n nonzero_count = F.count_nonzero(elements)\n # compute the offset of each split and ensure that the difference of each partition size\n # is 1.\n offsets = _even_offset(nonzero_count, partition_book.num_partitions())\n assert offsets[-1] == nonzero_count\n\n # Get the elements that belong to the partition.\n partid = partition_book.partid\n left, right = offsets[partid], offsets[partid + 1]\n\n x = y = 0\n num_elements = len(elements)\n block_size = num_elements // partition_book.num_partitions()\n part_eles = None\n # compute the nonzero tensor of each partition instead of whole tensor to save memory\n for idx in range(0, num_elements, block_size):\n nonzero_block = F.nonzero_1d(elements[idx:min(idx+block_size, num_elements)])\n x = y\n y += len(nonzero_block)\n if y > left and x < right:\n start = max(x, left) - x\n end = min(y, right) - x\n tmp = nonzero_block[start:end] + idx\n if part_eles is None:\n part_eles = tmp\n else:\n part_eles = F.cat((part_eles, tmp), 0)\n elif x >= right:\n break\n\n return part_eles\n\ndef _split_random_within_part(partition_book, rank, part_eles):\n # If there are more than one client in a partition, we need to randomly select a subset of\n # elements in the partition for a client. We have to make sure that the set of elements\n # for different clients are disjoint.\n\n num_clients = role.get_num_trainers()\n num_client_per_part = num_clients // partition_book.num_partitions()\n if num_client_per_part == 1:\n return part_eles\n if rank is None:\n rank = role.get_trainer_rank()\n assert rank < num_clients, \\\n 'The input rank ({}) is incorrect. #Trainers: {}'.format(rank, num_clients)\n client_id_in_part = rank % num_client_per_part\n offset = _even_offset(len(part_eles), num_client_per_part)\n\n # We set the random seed for each partition, so that each process (client) in a partition\n # permute the elements in a partition in the same way, so each process gets a disjoint subset\n # of elements.\n np.random.seed(partition_book.partid)\n rand_idx = np.random.permutation(len(part_eles))\n rand_idx = rand_idx[offset[client_id_in_part] : offset[client_id_in_part + 1]]\n idx, _ = F.sort_1d(F.tensor(rand_idx))\n return F.gather_row(part_eles, idx)\n\ndef _split_by_trainer_id(partition_book, part_eles, trainer_id,\n num_client_per_part, client_id_in_part):\n # TODO(zhengda): MXNet cannot deal with empty tensors, which makes the implementation\n # much more difficult. Let's just use numpy for the computation for now. We just\n # perform operations on vectors. It shouldn't be too difficult.\n trainer_id = F.asnumpy(trainer_id)\n part_eles = F.asnumpy(part_eles)\n part_id = trainer_id // num_client_per_part\n trainer_id = trainer_id % num_client_per_part\n local_eles = part_eles[np.nonzero(part_id[part_eles] == partition_book.partid)[0]]\n # these are the Ids of the local elements in the partition. The Ids are global Ids.\n remote_eles = part_eles[np.nonzero(part_id[part_eles] != partition_book.partid)[0]]\n # these are the Ids of the remote nodes in the partition. The Ids are global Ids.\n local_eles_idx = np.concatenate(\n [np.nonzero(trainer_id[local_eles] == i)[0] for i in range(num_client_per_part)],\n # trainer_id[local_eles] is the trainer ids of local nodes in the partition and we\n # pick out the indices where the node belongs to each trainer i respectively, and\n # concatenate them.\n axis=0\n )\n # `local_eles_idx` is used to sort `local_eles` according to `trainer_id`. It is a\n # permutation of 0...(len(local_eles)-1)\n local_eles = local_eles[local_eles_idx]\n\n # evenly split local nodes to trainers\n local_offsets = _even_offset(len(local_eles), num_client_per_part)\n # evenly split remote nodes to trainers\n remote_offsets = _even_offset(len(remote_eles), num_client_per_part)\n\n client_local_eles = local_eles[\n local_offsets[client_id_in_part]:local_offsets[client_id_in_part + 1]]\n client_remote_eles = remote_eles[\n remote_offsets[client_id_in_part]:remote_offsets[client_id_in_part + 1]]\n client_eles = np.concatenate([client_local_eles, client_remote_eles], axis=0)\n return F.tensor(client_eles)\n\ndef node_split(nodes, partition_book=None, ntype='_N', rank=None, force_even=True,\n node_trainer_ids=None):\n ''' Split nodes and return a subset for the local rank.\n\n This function splits the input nodes based on the partition book and\n returns a subset of nodes for the local rank. This method is used for\n dividing workloads for distributed training.\n\n The input nodes are stored as a vector of masks. The length of the vector is\n the same as the number of nodes in a graph; 1 indicates that the vertex in\n the corresponding location exists.\n\n There are two strategies to split the nodes. By default, it splits the nodes\n in a way to maximize data locality. That is, all nodes that belong to a process\n are returned. If ``force_even`` is set to true, the nodes are split evenly so\n that each process gets almost the same number of nodes.\n\n When ``force_even`` is True, the data locality is still preserved if a graph is partitioned\n with Metis and the node/edge IDs are shuffled.\n In this case, majority of the nodes returned for a process are the ones that\n belong to the process. If node/edge IDs are not shuffled, data locality is not guaranteed.\n\n Parameters\n ----------\n nodes : 1D tensor or DistTensor\n A boolean mask vector that indicates input nodes.\n partition_book : GraphPartitionBook, optional\n The graph partition book\n ntype : str, optional\n The node type of the input nodes.\n rank : int, optional\n The rank of a process. If not given, the rank of the current process is used.\n force_even : bool, optional\n Force the nodes are split evenly.\n node_trainer_ids : 1D tensor or DistTensor, optional\n If not None, split the nodes to the trainers on the same machine according to\n trainer IDs assigned to each node. Otherwise, split randomly.\n\n Returns\n -------\n 1D-tensor\n The vector of node IDs that belong to the rank.\n '''\n if not isinstance(nodes, DistTensor):\n assert partition_book is not None, 'Regular tensor requires a partition book.'\n elif partition_book is None:\n partition_book = nodes.part_policy.partition_book\n\n assert len(nodes) == partition_book._num_nodes(ntype), \\\n 'The length of boolean mask vector should be the number of nodes in the graph.'\n if rank is None:\n rank = role.get_trainer_rank()\n if force_even:\n num_clients = role.get_num_trainers()\n num_client_per_part = num_clients // partition_book.num_partitions()\n assert num_clients % partition_book.num_partitions() == 0, \\\n 'The total number of clients should be multiple of the number of partitions.'\n part_nid = _split_even_to_part(partition_book, nodes)\n if num_client_per_part == 1:\n return part_nid\n elif node_trainer_ids is None:\n return _split_random_within_part(partition_book, rank, part_nid)\n else:\n trainer_id = node_trainer_ids[0:len(node_trainer_ids)]\n max_trainer_id = F.as_scalar(F.reduce_max(trainer_id)) + 1\n\n if max_trainer_id > num_clients:\n # We hope the partition scheme with trainer_id could be used when the number of\n # trainers is less than the `num_trainers_per_machine` previously assigned during\n # partitioning.\n assert max_trainer_id % num_clients == 0\n trainer_id //= (max_trainer_id // num_clients)\n\n client_id_in_part = rank % num_client_per_part\n return _split_by_trainer_id(partition_book, part_nid, trainer_id,\n num_client_per_part, client_id_in_part)\n else:\n # Get all nodes that belong to the rank.\n local_nids = partition_book.partid2nids(partition_book.partid)\n return _split_local(partition_book, rank, nodes, local_nids)\n\ndef edge_split(edges, partition_book=None, etype='_E', rank=None, force_even=True,\n edge_trainer_ids=None):\n ''' Split edges and return a subset for the local rank.\n\n This function splits the input edges based on the partition book and\n returns a subset of edges for the local rank. This method is used for\n dividing workloads for distributed training.\n\n The input edges can be stored as a vector of masks. The length of the vector is\n the same as the number of edges in a graph; 1 indicates that the edge in\n the corresponding location exists.\n\n There are two strategies to split the edges. By default, it splits the edges\n in a way to maximize data locality. That is, all edges that belong to a process\n are returned. If ``force_even`` is set to true, the edges are split evenly so\n that each process gets almost the same number of edges.\n\n When ``force_even`` is True, the data locality is still preserved if a graph is partitioned\n with Metis and the node/edge IDs are shuffled.\n In this case, majority of the nodes returned for a process are the ones that\n belong to the process. If node/edge IDs are not shuffled, data locality is not guaranteed.\n\n Parameters\n ----------\n edges : 1D tensor or DistTensor\n A boolean mask vector that indicates input edges.\n partition_book : GraphPartitionBook, optional\n The graph partition book\n etype : str, optional\n The edge type of the input edges.\n rank : int, optional\n The rank of a process. If not given, the rank of the current process is used.\n force_even : bool, optional\n Force the edges are split evenly.\n edge_trainer_ids : 1D tensor or DistTensor, optional\n If not None, split the edges to the trainers on the same machine according to\n trainer IDs assigned to each edge. Otherwise, split randomly.\n\n Returns\n -------\n 1D-tensor\n The vector of edge IDs that belong to the rank.\n '''\n if not isinstance(edges, DistTensor):\n assert partition_book is not None, 'Regular tensor requires a partition book.'\n elif partition_book is None:\n partition_book = edges.part_policy.partition_book\n assert len(edges) == partition_book._num_edges(etype), \\\n 'The length of boolean mask vector should be the number of edges in the graph.'\n if rank is None:\n rank = role.get_trainer_rank()\n if force_even:\n num_clients = role.get_num_trainers()\n num_client_per_part = num_clients // partition_book.num_partitions()\n assert num_clients % partition_book.num_partitions() == 0, \\\n 'The total number of clients should be multiple of the number of partitions.'\n part_eid = _split_even_to_part(partition_book, edges)\n if num_client_per_part == 1:\n return part_eid\n elif edge_trainer_ids is None:\n return _split_random_within_part(partition_book, rank, part_eid)\n else:\n trainer_id = edge_trainer_ids[0:len(edge_trainer_ids)]\n max_trainer_id = F.as_scalar(F.reduce_max(trainer_id)) + 1\n\n if max_trainer_id > num_clients:\n # We hope the partition scheme with trainer_id could be used when the number of\n # trainers is less than the `num_trainers_per_machine` previously assigned during\n # partitioning.\n assert max_trainer_id % num_clients == 0\n trainer_id //= (max_trainer_id // num_clients)\n\n client_id_in_part = rank % num_client_per_part\n return _split_by_trainer_id(partition_book, part_eid, trainer_id,\n num_client_per_part, client_id_in_part)\n else:\n # Get all edges that belong to the rank.\n local_eids = partition_book.partid2eids(partition_book.partid)\n return _split_local(partition_book, rank, edges, local_eids)\n\nrpc.register_service(INIT_GRAPH, InitGraphRequest, InitGraphResponse)\n"
] | [
[
"numpy.concatenate",
"numpy.array",
"numpy.random.seed",
"numpy.nonzero",
"numpy.cumsum"
]
] |
minrk/discretisedfield | [
"251584f8d976a7fafdff5402d16327489407c4dd"
] | [
"discretisedfield/field.py"
] | [
"import pyvtk\nimport struct\nimport matplotlib\nimport numpy as np\nimport mpl_toolkits.axes_grid1\nimport discretisedfield as df\nimport ubermagutil.typesystem as ts\nimport discretisedfield.util as dfu\nimport matplotlib.pyplot as plt\n\n\[email protected](mesh=ts.Typed(expected_type=df.Mesh),\n dim=ts.Scalar(expected_type=int, unsigned=True, const=True),\n name=ts.Name(const=True))\nclass Field:\n \"\"\"Finite difference field.\n\n This class defines a finite difference field and enables certain\n operations for its analysis and visualisation. The field is\n defined on a finite difference mesh (`discretisedfield.Mesh`).\n\n Parameters\n ----------\n mesh : discretisedfield.Mesh\n Finite difference rectangular mesh.\n dim : int, optional\n Dimension of the field value. For instance, if `dim=3` the\n field is a three-dimensional vector field and for `dim=1`\n the field is a scalar field. Defaults to `dim=3`.\n value : array_like, callable, optional\n Please refer to the `value` property:\n :py:func:`~discretisedfield.Field.value`. Defaults to 0,\n meaning that if the value is not provided in the\n initialisation process, \"zero-field\" will be defined.\n norm : numbers.Real, callable, optional\n Please refer to the `norm` property:\n :py:func:`~discretisedfield.Field.norm`. Defaults to `None`\n (`norm=None` defines no norm).\n name : str, optional\n Field name (defaults to `'field'`). The field name must be a\n valid Python variable name string. More specifically, it must\n not contain spaces, or start with underscore or numeric\n character.\n\n Examples\n --------\n 1. Creating a uniform three-dimensional vector field on a\n nano-sized thin film.\n\n >>> import discretisedfield as df\n ...\n >>> p1 = (-50e-9, -25e-9, 0)\n >>> p2 = (50e-9, 25e-9, 5e-9)\n >>> cell = (1e-9, 1e-9, 0.1e-9)\n >>> mesh = df.Mesh(p1=p1, p2=p2, cell=cell)\n ...\n >>> dim = 3\n >>> value = (0, 0, 1)\n >>> field = df.Field(mesh=mesh, dim=dim, value=value)\n >>> field\n Field(mesh=...)\n\n 2. Creating a scalar field.\n\n >>> import discretisedfield as df\n ...\n >>> p1 = (-10, -10, -10)\n >>> p2 = (10, 10, 10)\n >>> n = (1, 1, 1)\n >>> mesh = df.Mesh(p1=p1, p2=p2, n=n)\n >>> dim = 1\n >>> value = 3.14\n >>> field = df.Field(mesh=mesh, dim=dim, value=value)\n >>> field\n Field(mesh=...)\n\n .. seealso:: :py:func:`~discretisedfield.Mesh`\n\n \"\"\"\n def __init__(self, mesh, dim=3, value=0, norm=None, name='field'):\n self.mesh = mesh\n self.dim = dim\n self.value = value\n self.norm = norm\n self.name = name\n\n @property\n def value(self):\n \"\"\"Field value representation.\n\n This propertry returns a representation of the field value if\n it exists. Otherwise, the `numpy.ndarray` containing all\n values from the field is returned.\n\n Parameters\n ----------\n value : 0, array_like, callable\n For scalar fields (`dim=1`) `numbers.Real` values are\n allowed. In the case of vector fields, \"array_like\" (list,\n tuple, numpy.ndarray) value with length equal to `dim`\n should be used. Finally, the value can also be a callable\n (e.g. Python function or another field), which for every\n coordinate in the mesh returns a valid value. If\n `value=0`, all values in the field will be set to zero\n independent of the field dimension.\n\n Returns\n -------\n array_like, callable, numbers.Real\n The value used (representation) for setting the field is\n returned. However, if the actual value of the field does\n not correspond to the initially used value anymore, a\n `numpy.ndarray` is returned containing all field values.\n\n Raises\n ------\n ValueError\n If unsupported type is passed\n\n Examples\n --------\n 1. Different ways of setting and getting the field value.\n\n >>> import discretisedfield as df\n ...\n >>> p1 = (0, 0, 0)\n >>> p2 = (2, 2, 1)\n >>> cell = (1, 1, 1)\n >>> mesh = df.Mesh(p1=p1, p2=p2, cell=cell)\n >>> value = (0, 0, 1)\n >>> # if value is not specified, zero-field is defined\n >>> field = df.Field(mesh=mesh, dim=3)\n >>> field.value\n 0\n >>> field.value = (0, 0, 1)\n >>> field.value\n (0, 0, 1)\n >>> # Setting the field value using a Python function (callable).\n >>> def value_function(pos):\n ... x, y, z = pos\n ... if x <= 1:\n ... return (0, 0, 1)\n ... else:\n ... return (0, 0, -1)\n >>> field.value = value_function\n >>> field.value\n <function value_function at ...>\n >>> # We now change the value of a single cell so that the\n >>> # representation used for initialising field is not valid\n >>> # anymore.\n >>> field.array[0, 0, 0, :] = (0, 0, 0)\n >>> field.value\n array(...)\n\n .. seealso:: :py:func:`~discretisedfield.Field.array`\n\n \"\"\"\n value_array = dfu.as_array(self.mesh, self.dim, self._value)\n if np.array_equal(self.array, value_array):\n return self._value\n else:\n return self.array\n\n @value.setter\n def value(self, val):\n self._value = val\n self.array = dfu.as_array(self.mesh, self.dim, val)\n\n @property\n def array(self):\n \"\"\"Numpy array of a field value.\n\n `array` has shape of `(self.mesh.n[0], self.mesh.n[1],\n self.mesh.n[2], dim)`.\n\n Parameters\n ----------\n array : numpy.ndarray\n Numpy array with dimensions `(self.mesh.n[0],\n self.mesh.n[1], self.mesh.n[2], dim)`\n\n Returns\n -------\n numpy.ndarray\n Field values array.\n\n Raises\n ------\n ValueError\n If setting the array with wrong type, shape, or value.\n\n Examples\n --------\n 1. Accessing and setting the field array.\n\n >>> import discretisedfield as df\n >>> import numpy as np\n ...\n >>> p1 = (0, 0, 0)\n >>> p2 = (1, 1, 1)\n >>> cell = (0.5, 1, 1)\n >>> mesh = df.Mesh(p1=p1, p2=p2, cell=cell)\n >>> value = (0, 0, 1)\n >>> field = df.Field(mesh=mesh, dim=3, value=value)\n >>> field.array\n array(...)\n >>> field.array.shape\n (2, 1, 1, 3)\n >>> field.array = np.ones(field.array.shape)\n >>> field.array\n array(...)\n\n .. seealso:: :py:func:`~discretisedfield.Field.value`\n\n \"\"\"\n return self._array\n\n @array.setter\n def array(self, val):\n if isinstance(val, np.ndarray) and \\\n val.shape == self.mesh.n + (self.dim,):\n self._array = val\n else:\n msg = (f'Unsupported type(val)={type(val)} '\n 'or invalid value dimensions.')\n raise ValueError(msg)\n\n @property\n def norm(self):\n \"\"\"Norm of a field.\n\n This property computes the norm of the field and returns it as\n a `discretisedfield.Field` object with `dim=1`. Norm of a\n scalar field cannot be set and `ValueError` is raised.\n\n Parameters\n ----------\n numbers.Real, numpy.ndarray\n Norm value\n\n Returns\n -------\n discretisedfield.Field\n Scalar field with norm values.\n\n Raises\n ------\n ValueError\n If setting the norm with wrong type, shape, or value. In\n addition, if the field is scalar (dim=1) or it contains\n zero vector values.\n\n Examples\n --------\n 1. Manipulating the field norm\n\n >>> import discretisedfield as df\n ...\n >>> p1 = (0, 0, 0)\n >>> p2 = (1, 1, 1)\n >>> cell = (1, 1, 1)\n >>> mesh = df.Mesh(p1=p1, p2=p2, cell=cell)\n >>> field = df.Field(mesh=mesh, dim=3, value=(0, 0, 1))\n >>> field.norm\n Field(...)\n >>> field.norm = 2\n >>> field.norm\n Field(...)\n >>> field.value = (1, 0, 0)\n >>> field.norm.array\n array([[[[1.]]]])\n\n \"\"\"\n current_norm = np.linalg.norm(self.array, axis=-1)[..., None]\n return Field(self.mesh, dim=1, value=current_norm, name='norm')\n\n @norm.setter\n def norm(self, val):\n if val is not None:\n if self.dim == 1:\n msg = f'Cannot set norm for field with dim={self.dim}.'\n raise ValueError(msg)\n\n if not np.all(self.norm.array):\n msg = 'Cannot normalise field with zero values.'\n raise ValueError(msg)\n\n self.array /= self.norm.array # normalise to 1\n self.array *= dfu.as_array(self.mesh, dim=1, val=val)\n\n @property\n def average(self):\n \"\"\"Field average.\n\n It computes the average of the field over the entire volume of\n the mesh.\n\n Returns\n -------\n tuple\n Field average tuple whose length equals to the field's\n dimension.\n\n Examples\n --------\n 1. Computing the vector field average.\n\n >>> import discretisedfield as df\n ...\n >>> p1 = (0, 0, 0)\n >>> p2 = (5, 5, 5)\n >>> cell = (1, 1, 1)\n >>> mesh = df.Mesh(p1=p1, p2=p2, cell=cell)\n >>> field1 = df.Field(mesh=mesh, dim=3, value=(0, 0, 1))\n >>> field1.average\n (0.0, 0.0, 1.0)\n >>> field2 = df.Field(mesh=mesh, dim=1, value=55)\n >>> field2.average\n (55.0,)\n\n \"\"\"\n return tuple(self.array.mean(axis=(0, 1, 2)))\n\n def __repr__(self):\n \"\"\"Field representation string.\n\n This method returns the string that can ideally be copied in\n another Python script so that exactly the same field object\n could be defined. However, this is usually not the case due to\n complex values used.\n\n Returns\n -------\n str\n Field representation string.\n\n Example\n -------\n 1. Getting field representation string.\n\n >>> import discretisedfield as df\n ...\n >>> p1 = (0, 0, 0)\n >>> p2 = (2, 2, 1)\n >>> cell = (1, 1, 1)\n >>> mesh = df.Mesh(p1=p1, p2=p2, cell=cell)\n >>> field = df.Field(mesh, dim=1, value=1)\n >>> repr(field)\n \"Field(mesh=...)\"\n\n \"\"\"\n return (f'Field(mesh={repr(self.mesh)}, '\n f'dim={self.dim}, name=\\'{self.name}\\')')\n\n def __call__(self, point):\n \"\"\"Sample the field at `point`.\n\n It returns the value of the discreatisation cell `point`\n belongs to. It always returns a tuple, whose length is the\n same as the dimension of the field.\n\n Parameters\n ----------\n point : (3,) array_like\n The mesh point coordinate :math:`(p_{x}, p_{y}, p_{z})`.\n\n Returns\n -------\n tuple\n A tuple, whose length is the same as the dimension of the\n field.\n\n Example\n -------\n 1. Sampling the field value\n\n >>> import discretisedfield as df\n ...\n >>> p1 = (0, 0, 0)\n >>> p2 = (20, 20, 20)\n >>> n = (20, 20, 20)\n >>> mesh = df.Mesh(p1=p1, p2=p2, n=n)\n >>> field = df.Field(mesh, dim=3, value=(1, 3, 4))\n >>> point = (10, 2, 3)\n >>> field(point)\n (1.0, 3.0, 4.0)\n\n \"\"\"\n value = self.array[self.mesh.point2index(point)]\n if self.dim > 1:\n value = tuple(value)\n return value\n\n def __getattr__(self, name):\n \"\"\"Extracting the component of the vector field.\n\n If `'x'`, `'y'`, or `'z'` is accessed, a new scalar field of\n that component will be returned. This method is effective for\n vector fields with dimension 2 or 3.\n\n Returns\n -------\n discretisedfield.Field\n Scalar field with vector field component values.\n\n Examples\n --------\n 1. Accessing the vector field components.\n\n >>> import discretisedfield as df\n ...\n >>> p1 = (0, 0, 0)\n >>> p2 = (2, 2, 2)\n >>> cell = (1, 1, 1)\n >>> mesh = df.Mesh(p1=p1, p2=p2, cell=cell)\n >>> field = df.Field(mesh=mesh, dim=3, value=(0, 0, 1))\n >>> field.x\n Field(...)\n >>> field.y\n Field(...)\n >>> field.z\n Field(...)\n >>> field.z.dim\n 1\n\n \"\"\"\n if name in list(dfu.axesdict.keys())[:self.dim] and 1 < self.dim <= 3:\n # Components x, y, and z make sense only for vector fields\n # with typical dimensions 2 and 3.\n component_array = self.array[..., dfu.axesdict[name]][..., None]\n fieldname = f'{self.name}-{name}'.format(self.name, name)\n return Field(mesh=self.mesh, dim=1,\n value=component_array, name=fieldname)\n else:\n msg = f'{type(self).__name__} object has no attribute {name}.'\n raise AttributeError(msg.format(type(self).__name__, name))\n\n def __dir__(self):\n \"\"\"Extension of the tab-completion list.\n\n Adds `'x'`, `'y'`, and `'z'`, depending on the dimension of\n the field, to the tab-completion list. This is effective in\n IPython or Jupyter notebook environment.\n\n \"\"\"\n if 1 < self.dim <= 3:\n extension = list(dfu.axesdict.keys())[:self.dim]\n else:\n extension = []\n return list(self.__dict__.keys()) + extension\n\n def __iter__(self):\n \"\"\"Generator yielding coordinates and values of all field cells.\n\n The discretisation cell coordinate corresponds to the cell\n centre point.\n\n Yields\n ------\n tuple (2,)\n The first value is the mesh cell coordinates (`px`, `py`,\n `pz`), whereas the second one is the field value.\n\n Examples\n --------\n 1. Iterating through the field coordinates and values\n\n >>> import discretisedfield as df\n ...\n >>> p1 = (0, 0, 0)\n >>> p2 = (2, 2, 1)\n >>> cell = (1, 1, 1)\n >>> mesh = df.Mesh(p1=p1, p2=p2, cell=cell)\n >>> field = df.Field(mesh, dim=3, value=(0, 0, 1))\n >>> for coord, value in field:\n ... print (coord, value)\n (0.5, 0.5, 0.5) (0.0, 0.0, 1.0)\n (1.5, 0.5, 0.5) (0.0, 0.0, 1.0)\n (0.5, 1.5, 0.5) (0.0, 0.0, 1.0)\n (1.5, 1.5, 0.5) (0.0, 0.0, 1.0)\n\n .. seealso:: :py:func:`~discretisedfield.Mesh.indices`\n\n \"\"\"\n for point in self.mesh.coordinates:\n yield point, self.__call__(point)\n\n def line(self, p1, p2, n=100):\n \"\"\"Sampling the field along the line.\n\n Given two points :math:`p_{1}` and :math:`p_{2}`, :math:`n`\n position coordinates are generated and the corresponding field\n values.\n\n .. math::\n\n \\\\mathbf{r}_{i} = i\\\\frac{\\\\mathbf{p}_{2} -\n \\\\mathbf{p}_{1}}{n-1}\n\n Parameters\n ----------\n p1, p2 : (3,) array_like\n Two points between which the line is generated.\n n : int\n Number of points on the line.\n\n Yields\n ------\n tuple\n The first element is the coordinate of the point on the\n line, whereas the second one is the value of the field.\n\n Raises\n ------\n ValueError\n If `p1` or `p2` is outside the mesh domain.\n\n Examples\n --------\n 1. Sampling the field along the line.\n\n >>> import discretisedfield as df\n ...\n >>> p1 = (0, 0, 0)\n >>> p2 = (2, 2, 2)\n >>> cell = (1, 1, 1)\n >>> mesh = df.Mesh(p1=p1, p2=p2, cell=cell)\n >>> field = df.Field(mesh, dim=2, value=(0, 3))\n >>> for coord, value in field.line(p1=(0, 0, 0), p2=(2, 0, 0), n=3):\n ... print(coord, value)\n (0.0, 0.0, 0.0) (0.0, 3.0)\n (1.0, 0.0, 0.0) (0.0, 3.0)\n (2.0, 0.0, 0.0) (0.0, 3.0)\n\n \"\"\"\n for point in self.mesh.line(p1=p1, p2=p2, n=n):\n yield point, self.__call__(point)\n\n def plane(self, *args, n=None, **kwargs):\n \"\"\"Slices the field with a plane.\n\n If one of the axes (`'x'`, `'y'`, or `'z'`) is passed as a\n string, a plane perpendicular to that axis is generated which\n intersects the field at its centre. Alternatively, if a keyword\n argument is passed (e.g. `x=1`), a plane perpendicular to the\n x-axis and intersecting it at x=1 is generated. The number of\n points in two dimensions on the plane can be defined using `n`\n (e.g. `n=(10, 15)`). Using the generated plane, a new\n \"two-dimensional\" field is created and returned.\n\n Parameters\n ----------\n n : tuple of length 2\n The number of points on the plane in two dimensions\n\n Returns\n ------\n discretisedfield.Field\n A field obtained as an intersection of mesh and the plane.\n\n Example\n -------\n 1. Intersecting the field with a plane.\n\n >>> import discretisedfield as df\n ...\n >>> p1 = (0, 0, 0)\n >>> p2 = (2, 2, 2)\n >>> cell = (1, 1, 1)\n >>> mesh = df.Mesh(p1=p1, p2=p2, cell=cell)\n >>> field = df.Field(mesh, dim=3)\n >>> field.plane(y=1)\n Field(mesh=...)\n\n \"\"\"\n plane_mesh = self.mesh.plane(*args, n=n, **kwargs)\n return self.__class__(plane_mesh, dim=self.dim, value=self)\n\n def write(self, filename, representation='txt', extend_scalar=False):\n \"\"\"Write the field in .ovf, .omf, .ohf, or vtk format.\n\n If the extension of the `filename` is `.vtk`, a VTK file is\n written\n (:py:func:`~discretisedfield.Field._writevtk`). Otherwise, for\n `.ovf`, `.omf`, or `.ohf` extensions, an OOMMF file is written\n (:py:func:`~discretisedfield.Field._writeovf`). The\n representation (`bin4`, 'bin8', or 'txt') is passed using\n `representation` argument.\n\n Parameters\n ----------\n filename : str\n Name of the file written. It depends on its extension the\n format it is going to be written as.\n representation : str\n In the case of OOMMF files (`.ovf`, `.omf`, or `.ohf`),\n representation can be specified (`bin4`, `bin8`, or\n `txt`). Defaults to 'txt'.\n extend_scalar : bool\n If True, a scalar field will be saved as a vector\n field. More precisely, if the value at a cell is 3, that\n cell will be saved as (3, 0, 0). This is valid only for\n the OVF file formats.\n\n Example\n -------\n 1. Write an .omf file and delete it from the disk\n\n >>> import os\n >>> import discretisedfield as df\n ...\n >>> p1 = (0, 0, -5)\n >>> p2 = (5, 15, 15)\n >>> n = (5, 15, 20)\n >>> mesh = df.Mesh(p1=p1, p2=p2, n=n)\n >>> field = df.Field(mesh, value=(5, 6, 7))\n >>> filename = 'mytestfile.omf'\n >>> field.write(filename) # write the file\n >>> os.remove(filename) # delete the file\n\n .. seealso:: :py:func:`~discretisedfield.Field.fromfile`\n\n \"\"\"\n if any([filename.endswith(ext) for ext in ['.omf', '.ovf', '.ohf']]):\n self._writeovf(filename, representation=representation,\n extend_scalar=extend_scalar)\n elif filename.endswith('.vtk'):\n self._writevtk(filename)\n else:\n msg = ('Allowed extensions for writing the field are '\n '.omf, .ovf, .ohf, and .vtk.')\n raise ValueError(msg)\n\n def _writeovf(self, filename, representation='txt', extend_scalar=False):\n \"\"\"Write the field in .ovf, .omf, or .ohf format.\n\n The extension of the `filename` should be `.ovf`, `.omf`, or\n `.ohf`. The representation (`bin4`, 'bin8', or 'txt') is\n passed using `representation` argument.\n\n Parameters\n ----------\n filename : str\n Name of the file written.\n representation : str\n Representation of the file (`bin4`, `bin8`, or\n `txt`). Defaults to 'txt'.\n extend_scalar : bool\n If True, a scalar field will be saved as a vector\n field. More precisely, if the value at a cell is 3, that\n cell will be saved as (3, 0, 0).\n\n Example\n -------\n 1. Write an .omf file and delete it from the disk\n\n >>> import os\n >>> import discretisedfield as df\n ...\n >>> p1 = (0, 0, -5)\n >>> p2 = (5, 15, 15)\n >>> n = (5, 15, 20)\n >>> mesh = df.Mesh(p1=p1, p2=p2, n=n)\n >>> field = df.Field(mesh, value=(5, 6, 7))\n >>> filename = 'mytestfile.omf'\n >>> field._writeovf(filename) # write the file\n >>> os.remove(filename) # delete the file\n\n \"\"\"\n if extend_scalar and self.dim == 1:\n write_dim = 3\n else:\n write_dim = self.dim\n header = ['OOMMF OVF 2.0',\n '',\n 'Segment count: 1',\n '',\n 'Begin: Segment',\n 'Begin: Header',\n '',\n 'Title: Field generated omf file',\n 'Desc: File generated by Field class',\n 'meshunit: m',\n 'meshtype: rectangular',\n f'xbase: {self.mesh.pmin[0] + self.mesh.cell[0]/2}',\n f'ybase: {self.mesh.pmin[1] + self.mesh.cell[1]/2}',\n f'zbase: {self.mesh.pmin[2] + self.mesh.cell[2]/2}',\n f'xnodes: {self.mesh.n[0]}',\n f'ynodes: {self.mesh.n[1]}',\n f'znodes: {self.mesh.n[2]}',\n f'xstepsize: {self.mesh.cell[0]}',\n f'ystepsize: {self.mesh.cell[1]}',\n f'zstepsize: {self.mesh.cell[2]}',\n f'xmin: {self.mesh.pmin[0]}',\n f'ymin: {self.mesh.pmin[1]}',\n f'zmin: {self.mesh.pmin[2]}',\n f'xmax: {self.mesh.pmax[0]}',\n f'ymax: {self.mesh.pmax[1]}',\n f'zmax: {self.mesh.pmax[2]}',\n f'valuedim: {write_dim}',\n f'valuelabels: {self.name}_x {self.name}_y {self.name}_z',\n 'valueunits: A/m A/m A/m',\n '',\n 'End: Header',\n '']\n\n if representation == 'bin4':\n header.append('Begin: Data Binary 4')\n footer = ['End: Data Binary 4',\n 'End: Segment']\n elif representation == 'bin8':\n header.append('Begin: Data Binary 8')\n footer = ['End: Data Binary 8',\n 'End: Segment']\n elif representation == 'txt':\n header.append('Begin: Data Text')\n footer = ['End: Data Text',\n 'End: Segment']\n\n # Write header lines to the ovf file.\n f = open(filename, 'w')\n f.write(''.join(map(lambda line: f'# {line}\\n', header)))\n f.close()\n\n binary_reps = {'bin4': (1234567.0, 'f'),\n 'bin8': (123456789012345.0, 'd')}\n\n if representation in binary_reps:\n # Reopen the file with binary write, appending to the end\n # of the file.\n f = open(filename, 'ab')\n\n # Add the 8 bit binary check value that OOMMF uses.\n packarray = [binary_reps[representation][0]]\n\n # Write data to the ovf file.\n for i in self.mesh.indices:\n for vi in self.array[i]:\n packarray.append(vi)\n\n v_bin = struct.pack(binary_reps[representation][1]*len(packarray),\n *packarray)\n f.write(v_bin)\n f.close()\n\n else:\n # Reopen the file for txt representation, appending to the\n # file.\n f = open(filename, 'a')\n for i in self.mesh.indices:\n if self.dim == 3:\n v = [vi for vi in self.array[i]]\n elif self.dim == 1:\n if extend_scalar:\n v = [self.array[i][0], 0.0, 0.0]\n else:\n v = [self.array[i][0]]\n else:\n msg = (f'Cannot write dim={self.dim} field.')\n raise TypeError(msg)\n for vi in v:\n f.write(' ' + str(vi))\n f.write('\\n')\n f.close()\n\n # Write footer lines to OOMMF file.\n f = open(filename, 'a')\n f.write(''.join(map(lambda line: f'# {line}\\n', footer)))\n f.close()\n\n def _writevtk(self, filename):\n \"\"\"Write the field in the VTK format.\n\n The extension of the `filename` should be `.vtk`.\n\n Parameters\n ----------\n filename : str\n Name of the file written.\n\n Example\n -------\n 1. Write a .vtk file and delete it from the disk\n\n >>> import os\n >>> import discretisedfield as df\n ...\n >>> p1 = (0, 0, -5)\n >>> p2 = (5, 15, 15)\n >>> n = (5, 15, 20)\n >>> mesh = df.Mesh(p1=p1, p2=p2, n=n)\n >>> field = df.Field(mesh, value=(5, 6, 7))\n >>> filename = 'mytestfile.vtk'\n >>> field._writevtk(filename) # write the file\n >>> os.remove(filename) # delete the file\n\n \"\"\"\n grid = [pmini + np.linspace(0, li, ni+1) for pmini, li, ni in\n zip(self.mesh.pmin, self.mesh.l, self.mesh.n)]\n\n structure = pyvtk.RectilinearGrid(*grid)\n vtkdata = pyvtk.VtkData(structure)\n\n vectors = [self.__call__(coord) for coord in self.mesh.coordinates]\n vtkdata.cell_data.append(pyvtk.Vectors(vectors, self.name))\n for i, component in enumerate(dfu.axesdict.keys()):\n name = f'{self.name}_{component}'\n vtkdata.cell_data.append(pyvtk.Scalars(list(zip(*vectors))[i],\n name))\n\n vtkdata.tofile(filename)\n\n @classmethod\n def fromfile(cls, filename, norm=None, name='field'):\n \"\"\"Read the field from .ovf, .omf, or .ohf file.\n\n The extension of the `filename` should be `.ovf`, `.omf`, or\n `.ohf`. If the field should be normalised, `norm` argument can\n be passed. The `name` of the field defaults to `'field'`. This\n is a `classmethod` and should be called as\n `discretisedfield.Field.fromfile('myfile.omf')`.\n\n Parameters\n ----------\n filename : str\n Name of the file to be read.\n norm : numbers.Real, numpy.ndarray, callable\n For details, refer to :py:func:`~discretisedfield.Field.value`.\n name : str\n Name of the field read.\n\n Returns\n -------\n discretisedfield.Field\n\n Example\n -------\n 1. Read a field from the .ovf file\n\n >>> import os\n >>> import discretisedfield as df\n ...\n >>> ovffile = os.path.join(os.path.dirname(__file__),\n ... 'tests', 'test_sample',\n ... 'mumax-output-linux.ovf')\n >>> field = df.Field.fromfile(ovffile)\n >>> field\n Field(mesh=...)\n\n .. seealso:: :py:func:`~discretisedfield.Field.write`\n\n \"\"\"\n mdatalist = ['xmin', 'ymin', 'zmin', 'xmax', 'ymax', 'zmax',\n 'xstepsize', 'ystepsize', 'zstepsize', 'valuedim']\n mdatadict = dict()\n\n try:\n with open(filename, 'r', encoding='utf-8') as ovffile:\n f = ovffile.read()\n lines = f.split('\\n')\n\n mdatalines = filter(lambda s: s.startswith('#'), lines)\n datalines = np.loadtxt(filter(lambda s: not s.startswith('#'),\n lines))\n\n for line in mdatalines:\n for mdatum in mdatalist:\n if mdatum in line:\n mdatadict[mdatum] = float(line.split()[-1])\n break\n\n except UnicodeDecodeError:\n with open(filename, 'rb') as ovffile:\n f = ovffile.read()\n lines = f.split(b'\\n')\n\n mdatalines = filter(lambda s: s.startswith(bytes('#', 'utf-8')),\n lines)\n\n for line in mdatalines:\n for mdatum in mdatalist:\n if bytes(mdatum, 'utf-8') in line:\n mdatadict[mdatum] = float(line.split()[-1])\n break\n\n header = b'# Begin: Data Binary '\n data_start = f.find(header)\n header = f[data_start:data_start + len(header) + 1]\n\n data_start += len(b'# Begin: Data Binary 8')\n data_end = f.find(b'# End: Data Binary ')\n\n # ordered by length\n newlines = [b'\\n\\r', b'\\r\\n', b'\\n']\n for nl in newlines:\n if f.startswith(nl, data_start):\n data_start += len(nl)\n break\n\n if b'4' in header:\n formatstr = '@f'\n checkvalue = 1234567.0\n elif b'8' in header:\n formatstr = '@d'\n checkvalue = 123456789012345.0\n\n listdata = list(struct.iter_unpack(formatstr,\n f[data_start:data_end]))\n datalines = np.array(listdata)\n\n if datalines[0] != checkvalue:\n # These two lines cannot be accessed via\n # tests. Therefore, they are excluded from coverage.\n msg = 'Binary Data cannot be read.' # pragma: no cover\n raise AssertionError(msg) # pragma: no cover\n\n datalines = datalines[1:] # check value removal\n\n p1 = (mdatadict[key] for key in ['xmin', 'ymin', 'zmin'])\n p2 = (mdatadict[key] for key in ['xmax', 'ymax', 'zmax'])\n cell = (mdatadict[key] for key in ['xstepsize', 'ystepsize',\n 'zstepsize'])\n dim = int(mdatadict['valuedim'])\n\n mesh = df.Mesh(p1=p1, p2=p2, cell=cell)\n\n field = df.Field(mesh, dim=dim, name=name)\n\n r_tuple = tuple(reversed(field.mesh.n)) + (int(mdatadict['valuedim']),)\n t_tuple = tuple(reversed(range(3))) + (3,)\n field.array = datalines.reshape(r_tuple).transpose(t_tuple)\n field.norm = norm # Normalise if norm is passed\n\n return field\n\n def mpl(self, figsize=None):\n \"\"\"Plots a field plane using matplotlib.\n\n Before the field can be plotted, it must be sliced with a\n plane (e.g. `field.plane(`z`)`). Otherwise, ValueError is\n raised. For vector fields, this method plots both `quiver`\n (vector) and `imshow` (scalar) plots. The `imshow` plot\n represents the value of the out-of-plane vector component and\n the `quiver` plot is not coloured. On the other hand, only\n `imshow` is plotted for scalar fields. Where the norm of the\n field is zero, no vectors are shown and those `imshow` pixels\n are not coloured. In order to use this function inside Jupyter\n notebook `%matplotlib inline` must be activated after\n `discretisedfield` is imported.\n\n Parameters\n ----------\n figsize : tuple, optional\n Length-2 tuple passed to the `matplotlib.figure` function.\n\n Raises\n ------\n ValueError\n If the field has not been sliced with a plane.\n\n Example\n -------\n >>> import discretisedfield as df\n ...\n >>> p1 = (0, 0, 0)\n >>> p2 = (100, 100, 100)\n >>> n = (10, 10, 10)\n >>> mesh = df.Mesh(p1=p1, p2=p2, n=n)\n >>> field = df.Field(mesh, dim=3, value=(1, 2, 0))\n >>> field.plane(z=50, n=(5, 5)).mpl()\n\n .. seealso:: :py:func:`~discretisedfield.Field.k3d_vectors`\n\n \"\"\"\n if not hasattr(self.mesh, 'info'):\n msg = ('Only sliced field can be plotted using mpl. '\n 'For instance, field.plane(\\'x\\').mpl().')\n raise ValueError(msg)\n\n fig = plt.figure(figsize=figsize)\n ax = fig.add_subplot(111)\n\n planeaxis = dfu.raxesdict[self.mesh.info['planeaxis']]\n\n if self.dim > 1:\n # Vector field has both quiver and imshow plots.\n self.quiver(ax=ax, headwidth=5)\n scfield = getattr(self, planeaxis)\n coloredplot = scfield.imshow(ax=ax, norm_field=self.norm)\n else:\n # Scalar field has only imshow.\n scfield = self\n coloredplot = scfield.imshow(ax=ax, norm_field=None)\n\n # Add colorbar to imshow plot.\n cbar = self.colorbar(ax, coloredplot)\n\n # Add labels.\n ax.set_xlabel(dfu.raxesdict[self.mesh.info['axis1']])\n ax.set_ylabel(dfu.raxesdict[self.mesh.info['axis2']])\n if self.dim > 1:\n cbar.ax.set_ylabel(planeaxis + ' component')\n\n def imshow(self, ax, norm_field=None, **kwargs):\n \"\"\"Plots a scalar field plane using `matplotlib.pyplot.imshow`.\n\n Before the field can be plotted, it must be sliced with a\n plane (e.g. `field.plane(`y`)`) and field must be of dimension\n 1 (scalar field). Otherwise, ValueError is raised. `imshow`\n adds the plot to `matplotlib.axes.Axes` passed via `ax`\n argument. If the scalar field plotted is extracted from a\n vector field, which has coordinates where the norm of the\n field is zero, the norm of that vector field can be passed\n using `norm_field` argument, so that pixels at those\n coordinates are not coloured. All other parameters accepted by\n `matplotlib.pyplot.imshow` can be passed. In order to use this\n function inside Jupyter notebook `%matplotlib inline` must be\n activated after `discretisedfield` is imported.\n\n Parameters\n ----------\n ax : matplotlib.axes.Axes\n Axes object to which the scalar plot will be added.\n norm_field : discretisedfield.Field, optional\n A (scalar) norm field used for determining whether certain\n pixels should be coloured.\n\n Returns\n -------\n matplotlib.image.AxesImage object\n\n Raises\n ------\n ValueError\n If the field has not been sliced with a plane or its\n dimension is not 1.\n\n Example\n -------\n >>> import discretisedfield as df\n ...\n >>> p1 = (0, 0, 0)\n >>> p2 = (100, 100, 100)\n >>> n = (10, 10, 10)\n >>> mesh = df.Mesh(p1=p1, p2=p2, n=n)\n >>> field = df.Field(mesh, dim=1, value=2)\n >>> fig = plt.figure()\n >>> ax = fig.add_subplot(111)\n >>> field.plane('y').imshow(ax=ax)\n <matplotlib.image.AxesImage object at ...>\n\n .. seealso:: :py:func:`~discretisedfield.Field.quiver`\n\n \"\"\"\n if not hasattr(self.mesh, 'info'):\n msg = ('Only sliced field can be plotted using imshow. '\n 'For instance, field.plane(\\'x\\').imshow(ax=ax).')\n raise ValueError(msg)\n if self.dim > 1:\n msg = ('Only scalar (dim=1) fields can be plotted. Consider '\n 'plotting one component, e.g. field.x.imshow(ax=ax) '\n 'or norm field.norm.imshow(ax=ax).')\n raise ValueError(msg)\n\n points, values = list(zip(*list(self)))\n\n # If norm_field is passed, set values where norm=0 to np.nan,\n # so that they are not plotted.\n if norm_field is not None:\n values = list(values) # make values mutable\n for i, point in enumerate(points):\n if norm_field(point) == 0:\n values[i] = np.nan\n\n # \"Unpack\" values inside arrays.\n values = [v[0] if not np.isnan(v) else v for v in values]\n else:\n # \"Unpack\" values inside arrays.\n values = list(zip(*values))\n\n points = list(zip(*points))\n\n extent = [self.mesh.pmin[self.mesh.info['axis1']],\n self.mesh.pmax[self.mesh.info['axis1']],\n self.mesh.pmin[self.mesh.info['axis2']],\n self.mesh.pmax[self.mesh.info['axis2']]]\n n = (self.mesh.n[self.mesh.info['axis2']],\n self.mesh.n[self.mesh.info['axis1']])\n\n imax = ax.imshow(np.array(values).reshape(n), origin='lower',\n extent=extent, **kwargs)\n\n return imax\n\n def quiver(self, ax=None, color_field=None, **kwargs):\n \"\"\"Plots a vector field plane using `matplotlib.pyplot.quiver`.\n\n Before the field can be plotted, it must be sliced with a\n plane (e.g. `field.plane(`y`)`) and field must be of dimension\n 3 (vector field). Otherwise, ValueError is raised. `quiver`\n adds the plot to `matplotlib.axes.Axes` passed via `ax`\n argument. If there are coordinates where the norm of the field\n is zero, vectors are not plotted at those coordinates. By\n default, plot is not coloured, but by passing a\n `discretisedfield.Field` object of dimension 1 as\n `color_field`, quiver plot will be coloured based on the\n values from the field. All other parameters accepted by\n `matplotlib.pyplot.quiver` can be passed. In order to use this\n function inside Jupyter notebook `%matplotlib inline` must be\n activated after `discretisedfield` is imported.\n\n Parameters\n ----------\n ax : matplotlib.axes.Axes\n Axes object to which the quiver plot will be added.\n color_field : discretisedfield.Field, optional\n A (scalar) field used for determining the colour of the\n quiver plot.\n\n Returns\n -------\n matplotlib.quiver.Quiver object\n\n Raises\n ------\n ValueError\n If the field has not been sliced with a plane or its\n dimension is not 3.\n\n Example\n -------\n >>> import discretisedfield as df\n ...\n >>> p1 = (0, 0, 0)\n >>> p2 = (100, 100, 100)\n >>> n = (10, 10, 10)\n >>> mesh = df.Mesh(p1=p1, p2=p2, n=n)\n >>> field = df.Field(mesh, dim=3, value=(1, 2, 0))\n >>> fig = plt.figure()\n >>> ax = fig.add_subplot(111)\n >>> field.plane(z=50).quiver(ax=ax, color_field=field.z)\n <matplotlib.quiver.Quiver object at ...>\n\n .. seealso:: :py:func:`~discretisedfield.Field.imshow`\n\n \"\"\"\n if not hasattr(self.mesh, 'info'):\n msg = ('Only sliced field can be plotted using quiver. '\n 'For instance, field.plane(\\'x\\').quiver(ax=ax).')\n raise ValueError(msg)\n if self.dim != 3:\n msg = 'Only three-dimensional (dim=3) fields can be plotted.'\n raise ValueError(msg)\n\n points, values = list(zip(*list(self)))\n\n # Remove values where norm is 0\n points, values = list(points), list(values) # make them mutable\n points = [p for p, v in zip(points, values)\n if not np.equal(v, 0).all()]\n values = [v for v in values if not np.equal(v, 0).all()]\n if color_field is not None:\n colors = [color_field(p) for p in points]\n colors = list(zip(*colors))\n\n # \"Unpack\" values inside arrays.\n points, values = list(zip(*points)), list(zip(*values))\n\n # Are there any vectors pointing out-of-plane? If yes, set the scale.\n if not any(values[self.mesh.info['axis1']] +\n values[self.mesh.info['axis2']]):\n kwargs['scale'] = 1\n\n kwargs['pivot'] = 'mid' # arrow at the centre of the cell\n\n if color_field is None:\n # quiver plot is not coloured.\n qvax = ax.quiver(points[self.mesh.info['axis1']],\n points[self.mesh.info['axis2']],\n values[self.mesh.info['axis1']],\n values[self.mesh.info['axis2']],\n **kwargs)\n\n else:\n # quiver plot is coloured.\n qvax = ax.quiver(points[self.mesh.info['axis1']],\n points[self.mesh.info['axis2']],\n values[self.mesh.info['axis1']],\n values[self.mesh.info['axis2']],\n colors,\n **kwargs)\n\n return qvax\n\n def colorbar(self, ax, coloredplot, cax=None, **kwargs):\n \"\"\"Adds a colorbar to the axes using `matplotlib.pyplot.colorbar`.\n\n Axes to which the colorbar should be added is passed via `ax`\n argument. If the colorbar axes are made before the method is\n called, they should be passed as `cax`. The plot to which the\n colorbar should correspond to is passed via `coloredplot`. All\n other parameters accepted by `matplotlib.pyplot.colorbar` can\n be passed. In order to use this function inside Jupyter\n notebook `%matplotlib inline` must be activated after\n `discretisedfield` is imported.\n\n Parameters\n ----------\n ax : matplotlib.axes.Axes\n Axes object to which the colorbar will be added.\n coloredplot : matplotlib.quiver.Quiver, matplotlib.image.AxesImage\n A plot to which the colorbar should correspond\n cax : matplotlib.axes.Axes, optional\n Colorbar axes.\n\n Returns\n -------\n matplotlib.colorbar.Colorbar\n\n Example\n -------\n >>> import discretisedfield as df\n ...\n >>> p1 = (0, 0, 0)\n >>> p2 = (100, 100, 100)\n >>> n = (10, 10, 10)\n >>> mesh = df.Mesh(p1=p1, p2=p2, n=n)\n >>> field = df.Field(mesh, dim=3, value=(1, 2, 0))\n >>> fig = plt.figure()\n >>> ax = fig.add_subplot(111)\n >>> coloredplot = field.plane(z=50).quiver(ax=ax, color_field=field.z)\n >>> field.colorbar(ax=ax, coloredplot=coloredplot)\n <matplotlib.colorbar.Colorbar object at ...>\n\n \"\"\"\n if cax is None:\n divider = mpl_toolkits.axes_grid1.make_axes_locatable(ax)\n cax = divider.append_axes('right', size='5%', pad=0.1)\n\n cbar = plt.colorbar(coloredplot, cax=cax, **kwargs)\n\n return cbar\n\n def k3d_nonzero(self, color=dfu.colormap[0], plot=None, **kwargs):\n \"\"\"Plots the voxels where the value of a scalar field is nonzero.\n\n All mesh cells where the value of the field is not zero will\n be marked using the same color. Only scalar fields can be\n plotted. Otherwise, ValueError is raised. Different colour of\n voxels can be passed in the RGB format using `color`\n parameter. This function is often used to look at the defined\n sample in the finite difference mesh, by inspecting its norm\n (`field.norm.k3d_nonzero`). If `plot` is passed as a\n `k3d.plot.Plot`, plot is added to it. Otherwise, a new k3d\n plot is created. All arguments allowed in `k3d.voxels()` can\n be passed. This function is to be called in Jupyter notebook.\n\n Parameters\n ----------\n color : int/hex, optional\n Voxel color in hexadecimal format.\n plot : k3d.plot.Plot, optional\n If this argument is passed, plot is added to\n it. Otherwise, a new k3d plot is created.\n\n Example\n -------\n >>> import discretisedfield as df\n ...\n >>> p1 = (-50, -50, -50)\n >>> p2 = (50, 50, 50)\n >>> n = (10, 10, 10)\n >>> mesh = df.Mesh(p1=p1, p2=p2, n=n)\n >>> field = df.Field(mesh, dim=3, value=(1, 2, 0))\n >>> def normfun(pos):\n ... x, y, z = pos\n ... if x**2 + y**2 < 30**2:\n ... return 1\n ... else:\n ... return 0\n >>> field.norm = normfun\n >>> field.norm.k3d_nonzero()\n Plot(...)\n\n .. seealso:: :py:func:`~discretisedfield.Field.k3d_voxels`\n \"\"\"\n if self.dim > 1:\n msg = ('Only scalar (dim=1) fields can be plotted. Consider '\n 'plotting one component, e.g. field.x.k3d_nonzero() '\n 'or norm field.norm.k3d_nonzero().')\n raise ValueError(msg)\n plot_array = np.copy(self.array) # make a deep copy\n plot_array = np.squeeze(plot_array) # remove an empty dimension\n plot_array = np.swapaxes(plot_array, 0, 2) # k3d: arrays are (z, y, x)\n plot_array[plot_array != 0] = 1 # all cells have the same colour\n\n # In the case of nano-sized samples, fix the order of\n # magnitude of the plot extent to avoid freezing the k3d plot.\n if np.any(np.divide(self.mesh.cell, 1e-9) < 1e3):\n pmin = np.divide(self.mesh.pmin, 1e-9)\n pmax = np.divide(self.mesh.pmax, 1e-9)\n else:\n pmin = self.mesh.pmin\n pmax = self.mesh.pmax\n\n dfu.voxels(plot_array, pmin, pmax, colormap=color,\n plot=plot, **kwargs)\n\n def k3d_voxels(self, norm_field=None, plot=None, **kwargs):\n \"\"\"Plots the scalar field as a coloured `k3d.voxels()` plot.\n\n At all mesh cells, a voxel will be plotted anc coloured\n according to its value. If the scalar field plotted is\n extracted from a vector field, which has coordinates where the\n norm of the field is zero, the norm of that vector field can\n be passed using `norm_field` argument, so that voxels at those\n coordinates are not showed. Only scalar fields can be\n plotted. Otherwise, ValueError is raised. If `plot` is passed\n as a `k3d.plot.Plot`, plot is added to it. Otherwise, a new\n k3d plot is created. All arguments allowed in `k3d.voxels()`\n can be passed. This function is to be called in Jupyter\n notebook.\n\n Parameters\n ----------\n norm_field : discretisedfield.Field, optional\n A (scalar) norm field used for determining whether certain\n voxels should be plotted.\n plot : k3d.plot.Plot, optional\n If this argument is passed, plot is added to\n it. Otherwise, a new k3d plot is created.\n\n Example\n -------\n >>> import discretisedfield as df\n ...\n >>> p1 = (-50, -50, -50)\n >>> p2 = (50, 50, 50)\n >>> n = (10, 10, 10)\n >>> mesh = df.Mesh(p1=p1, p2=p2, n=n)\n >>> field = df.Field(mesh, dim=3, value=(1, 2, 0))\n >>> def normfun(pos):\n ... x, y, z = pos\n ... if x**2 + y**2 < 30**2:\n ... return 1\n ... else:\n ... return 0\n >>> field.norm = normfun\n >>> field.x.k3d_voxels(norm_field=field.norm)\n Plot(...)\n\n .. seealso:: :py:func:`~discretisedfield.Field.k3d_vectors`\n\n \"\"\"\n if self.dim > 1:\n msg = ('Only scalar (dim=1) fields can be plotted. Consider '\n 'plotting one component, e.g. field.x.k3d_nonzero() '\n 'or norm field.norm.k3d_nonzero().')\n raise ValueError(msg)\n\n plot_array = np.copy(self.array) # make a deep copy\n plot_array = plot_array[..., 0] # remove an empty dimension\n\n plot_array -= plot_array.min()\n # In the case of uniform fields, division by zero can be\n # encountered.\n if plot_array.max() != 0:\n plot_array /= plot_array.max()\n plot_array *= 254\n plot_array += 1\n plot_array = plot_array.round()\n plot_array = plot_array.astype(int)\n\n if norm_field is not None:\n for index in self.mesh.indices:\n if norm_field(self.mesh.index2point(index)) == 0:\n plot_array[index] = 0\n\n plot_array = np.swapaxes(plot_array, 0, 2) # k3d: arrays are (z, y, x)\n\n cmap = matplotlib.cm.get_cmap('viridis', 256)\n colormap = [dfu.num2hexcolor(i, cmap) for i in range(cmap.N)]\n\n # In the case of nano-sized samples, fix the order of\n # magnitude of the plot extent to avoid freezing the k3d plot.\n if np.any(np.divide(self.mesh.cell, 1e-9) < 1e3):\n pmin = np.divide(self.mesh.pmin, 1e-9)\n pmax = np.divide(self.mesh.pmax, 1e-9)\n else:\n pmin = self.mesh.pmin\n pmax = self.mesh.pmax\n\n dfu.voxels(plot_array, pmin, pmax, colormap=colormap,\n plot=plot, **kwargs)\n\n def k3d_vectors(self, color_field=None, points=True, plot=None, **kwargs):\n \"\"\"Plots the vector field as a `k3d.vectors()` plot.\n\n At all mesh cells, a vector will be plotted if its norm is not\n zero. Vectors can be coloured according to the values of the\n scalar field passed as `color_field`. Only vector fields can\n be plotted. Otherwise, ValueError is raised. Points at the\n discretisation cell centres can be added by setting\n `points=True`. If `plot` is passed as a `k3d.plot.Plot`, plot\n is added to it. Otherwise, a new k3d plot is created. All\n arguments allowed in `k3d.vectors()` can be passed. This\n function is to be called in Jupyter notebook.\n\n Parameters\n ----------\n color_field : discretisedfield.Field, optional\n A (scalar) field used for determining the colours of\n vectors.\n points : bool, optional\n If `True`, points will be added to the discretisation cell\n centres.\n plot : k3d.plot.Plot, optional\n If this argument is passed, plot is added to\n it. Otherwise, a new k3d plot is created.\n\n Example\n -------\n 1. Plotting an entire vector field.\n\n >>> import discretisedfield as df\n ...\n >>> p1 = (-50, -50, -50)\n >>> p2 = (50, 50, 50)\n >>> n = (10, 10, 10)\n >>> mesh = df.Mesh(p1=p1, p2=p2, n=n)\n >>> field = df.Field(mesh, dim=3, value=(1, 2, 0))\n >>> field.k3d_vectors(color_field=field.x)\n Plot(...)\n\n 2. Plotting the slice of a vector field.\n\n >>> import discretisedfield as df\n ...\n >>> p1 = (-50, -50, -50)\n >>> p2 = (50, 50, 50)\n >>> n = (10, 10, 10)\n >>> mesh = df.Mesh(p1=p1, p2=p2, n=n)\n >>> field = df.Field(mesh, dim=3, value=(1, 2, 0))\n >>> field.plane('x').k3d_vectors(color_field=field.x)\n Plot(...)\n\n .. seealso:: :py:func:`~discretisedfield.Field.k3d_voxels`\n\n \"\"\"\n if self.dim != 3:\n msg = 'Only three-dimensional (dim=3) fields can be plotted.'\n raise ValueError(msg)\n\n coordinates, vectors, color_values = [], [], []\n norm = self.norm # assigned to be computed only once\n for coord, value in self:\n if norm(coord) > 0:\n coordinates.append(coord)\n vectors.append(value)\n if color_field is not None:\n color_values.append(color_field(coord)[0])\n\n coordinates, vectors = np.array(coordinates), np.array(vectors)\n\n # In the case of nano-sized samples, fix the order of\n # magnitude of the coordinates to avoid freezing the k3d plot.\n if np.any(np.divide(self.mesh.cell, 1e-9) < 1e3):\n coordinates /= 1e-9\n cell = np.divide(self.mesh.cell, 1e-9)\n else:\n cell = self.mesh.cell\n\n # Scale the vectors to correspond to the size of cells.\n vectors /= vectors.max()\n vectors *= 0.8*np.array(cell)\n\n # Middle of the arrow is at the cell centre.\n coordinates -= 0.5 * vectors\n\n if color_field is not None:\n color_values = np.array(color_values)\n color_values -= color_values.min()\n # In the case of uniform fields, division by zero can be\n # encountered.\n if color_values.max() != 0:\n color_values /= color_values.max()\n color_values *= 256\n color_values = color_values.round()\n color_values = color_values.astype(int)\n\n cmap = matplotlib.cm.get_cmap('viridis', 256)\n colors = []\n for c in color_values:\n color = dfu.num2hexcolor(c, cmap)\n colors.append((color, color))\n else:\n colors = []\n\n plot = dfu.vectors(coordinates, vectors, colors=colors,\n plot=plot, **kwargs)\n\n if points:\n dfu.points(coordinates + 0.5 * vectors, plot=plot)\n"
] | [
[
"numpy.divide",
"numpy.equal",
"matplotlib.pyplot.colorbar",
"numpy.linalg.norm",
"numpy.array_equal",
"numpy.array",
"matplotlib.cm.get_cmap",
"numpy.isnan",
"numpy.copy",
"matplotlib.pyplot.figure",
"numpy.swapaxes",
"numpy.all",
"numpy.linspace",
"numpy.squeeze"
]
] |
Fei-Wang/dl-pytorch | [
"a7672603e2de7824d0ff7e97b69dedad3fd9d476"
] | [
"test/test_models/test_palm.py"
] | [
"import torch\n\nfrom luffy.models.palm import *\n\n\ndef test_palm_tony():\n model = PaLMTony(num_tokens=20000)\n\n tokens = torch.randint(0, 20000, (1, 2048))\n feat = model(tokens)\n assert feat.shape == (1, 2048, 20000)\n"
] | [
[
"torch.randint"
]
] |
bestetc/batchflow | [
"d2a843640383fbe860654236881483f755227e06",
"d2a843640383fbe860654236881483f755227e06",
"d2a843640383fbe860654236881483f755227e06",
"d2a843640383fbe860654236881483f755227e06"
] | [
"batchflow/models/tf/nn/train.py",
"batchflow/models/metrics/loss.py",
"batchflow/batch_image.py",
"batchflow/models/tf/utils.py"
] | [
"\"\"\" Helpers for training \"\"\"\nfrom math import pi\n\nimport tensorflow as tf\n\ndef piecewise_constant(global_step, *args, **kwargs):\n \"\"\" Constant learning rate decay (uses global_step param instead of x) \"\"\"\n return tf.train.piecewise_constant(global_step, *args, **kwargs)\n\ndef cyclic_learning_rate(learning_rate, global_step, max_lr, step_size=10,\n mode='tri', name='CyclicLearningRate'):\n \"\"\" This function varies the learning rate between the\n minimum (learning_rate) and the maximum (max_lr).\n It returns the decayed learning rate.\n\n Parameters\n ----------\n learning_rate : float or tf.Tensor\n The minimum learning rate boundary.\n global_step : int or tf.Tensor\n Global_step refers to the number of batches seen by the model.\n It is use for the cyclic computation. Must not be negative.\n max_lr : float or tf.Tensor\n The maximum learning rate boundary.\n step_size : int or tf.Tensor\n The number of iterations in half a cycle (the default is 10).\n mode : {'tri', 'sin', 'saw'}\n Set the learning rate change function.\n name : str\n Name of the operation (the default is 'CyclicLearningRate').\n\n Returns\n -------\n tf.Tensor\n\n Notes\n -----\n More detailed information about `mode`:\n\n If 'tri':\n Default, linearly increasing then linearly decreasing the\n learning rate at each cycle. Learning rate starting\n from (max_lr-learning_rate)/2 then decreasing to `learning_rate`.\n See `Leslie N. Smith, Cyclical Learning Rates for Training Neural Networks\n <https://arxiv.org/abs/1506.01186>`_ for more information.\n\n It is computed as::\n\n decayed_learning_rate = abs(mod((global_step + step_size / 4) / step_size, 1) - 0.5) *\n 2 * (max_lr - learning_rate) +\n learning_rate\n\n\n If 'sin':\n Learning rate changes as a sine wave, starting\n from (max_lr-learning_rate)/2 then decreasing to `learning_rate`.\n\n It is computed as::\n\n decayed_learning_rate = (learning_rate - max_lr) / 2 *\n sin(pi * global_step / step_size) +\n (max_lr + learning_rate) / 2\n\n\n If 'saw':\n Learning rate linearly increasing from `learning_rate` to `max_lr`\n and then sharply drops to `learning_rate` at each cycle.\n Learning rate starting from `learning_rate` then increasing.\n\n It is computed as::\n\n decayed_learning_rate = (max_lr - learning_rate) *\n (floor(global_step / step_size) - global_step / step_size) +\n learning_rate\n \"\"\"\n with tf.name_scope(name):\n learning_rate = tf.cast(learning_rate, dtype=tf.float32)\n global_step = tf.cast(global_step, dtype=tf.float32)\n step_size = tf.cast(step_size, dtype=tf.float32)\n max_lr = tf.cast(max_lr, dtype=tf.float32)\n\n if mode == 'tri':\n periodic_comp = tf.mod((global_step + step_size / 4) / step_size, 1)\n first_factor = tf.abs(periodic_comp - 0.5)\n second_factor = 2 * (max_lr - learning_rate)\n second_comp = learning_rate\n elif mode == 'sin':\n first_factor = (learning_rate - max_lr) / 2.\n second_factor = tf.sin((pi * global_step) / step_size)\n second_comp = (learning_rate + max_lr) / 2.\n elif mode == 'saw':\n first_factor = max_lr - learning_rate\n second_factor = tf.mod(global_step / step_size, 1)\n second_comp = learning_rate\n return first_factor * second_factor + second_comp\n",
"\"\"\" Loss as a Metrics to be used in research pipelines added with `run=True` \"\"\"\n\nimport numpy as np\n\nfrom .base import Metrics\n\n\nclass Loss(Metrics):\n \"\"\"\n This is a helper class to aggregate losses from pipelines\n that are used in Research objects with `run=True`,\n like test pipelines\n\n Parameters\n ----------\n loss : float\n loss value obtained from model\n \"\"\"\n\n def __init__(self, loss, batch_len):\n super().__init__()\n\n self.losses = [loss]\n self.batch_lengths = [batch_len]\n\n def agg_loss(args):\n losses, blens = args\n return np.sum(np.asarray(losses) * np.asarray(blens)) / np.sum(blens)\n\n self._agg_fn_dict.update(mean=agg_loss)\n\n def batchwise_loss(args):\n losses, _ = args\n return losses\n\n self._agg_fn_dict.update(batchwise=batchwise_loss)\n\n def append(self, metrics):\n \"\"\" Extend with data from another metrics. \"\"\"\n self.losses.extend(metrics.losses)\n self.batch_lengths.extend(metrics.batch_lengths)\n\n def loss(self):\n return self.losses, self.batch_lengths\n",
"\"\"\" Contains Batch classes for images \"\"\"\nimport os\nimport warnings\nfrom numbers import Number\n\nimport numpy as np\nimport PIL\nimport PIL.ImageOps\nimport PIL.ImageChops\nimport PIL.ImageFilter\nimport PIL.ImageEnhance\n\nfrom .batch import Batch\nfrom .decorators import action, apply_parallel, inbatch_parallel\nfrom .dsindex import FilesIndex\n\n\nclass BaseImagesBatch(Batch):\n \"\"\" Batch class for 2D images.\n\n Note, that if any class method is wrapped with `@apply_parallel` decorator\n than for inner calls (i.e. from other class methods) should be used version\n of desired method with underscores. (For example, if there is a decorated\n `method` than you need to call `_method_` from inside of `other_method`).\n Same is applicable for all child classes of :class:`batch.Batch`.\n \"\"\"\n components = \"images\", \"labels\", \"masks\"\n # Class-specific defaults for :meth:`.Batch.apply_parallel`\n apply_defaults = dict(target='for',\n post='_assemble',\n src='images',\n dst='images',\n )\n\n def _make_path(self, ix, src=None):\n \"\"\" Compose path.\n\n Parameters\n ----------\n ix : str\n element's index (filename)\n src : str\n Path to folder with images. Used if `self.index` is not `FilesIndex`.\n\n Returns\n -------\n path : str\n Full path to an element.\n \"\"\"\n\n if isinstance(src, FilesIndex):\n path = src.get_fullpath(ix)\n elif isinstance(self.index, FilesIndex):\n path = self.index.get_fullpath(ix)\n else:\n path = os.path.join(src, str(ix))\n return path\n\n def _load_image(self, ix, src=None, fmt=None, dst=\"images\"):\n \"\"\" Loads image.\n\n .. note:: Please note that ``dst`` must be ``str`` only, sequence is not allowed here.\n\n Parameters\n ----------\n src : str, dataset.FilesIndex, None\n path to the folder with an image. If src is None then it is determined from the index.\n dst : str\n Component to write images to.\n fmt : str\n Format of the an image\n\n Raises\n ------\n NotImplementedError\n If this method is not defined in a child class\n \"\"\"\n _ = self, ix, src, dst, fmt\n raise NotImplementedError(\"Must be implemented in a child class\")\n\n @action\n def load(self, *args, src=None, fmt=None, dst=None, **kwargs):\n \"\"\" Load data.\n\n .. note:: if `fmt='images'` than ``components`` must be a single component (str).\n .. note:: All parameters must be named only.\n\n Parameters\n ----------\n src : str, None\n Path to the folder with data. If src is None then path is determined from the index.\n fmt : {'image', 'blosc', 'csv', 'hdf5', 'feather'}\n Format of the file to download.\n dst : str, sequence\n components to download.\n \"\"\"\n if fmt == 'image':\n return self._load_image(src, fmt=fmt, dst=dst)\n return super().load(src=src, fmt=fmt, dst=dst, *args, **kwargs)\n\n\n def _dump_image(self, ix, src='images', dst=None, fmt=None):\n \"\"\" Saves image to dst.\n\n .. note:: Please note that ``src`` must be ``str`` only, sequence is not allowed here.\n\n Parameters\n ----------\n src : str\n Component to get images from.\n dst : str\n Folder where to dump. If dst is None then it is determined from index.\n\n Raises\n ------\n NotImplementedError\n If this method is not defined in a child class\n \"\"\"\n _ = self, ix, src, dst, fmt\n raise NotImplementedError(\"Must be implemented in a child class\")\n\n @action\n def dump(self, *args, dst=None, fmt=None, components=\"images\", **kwargs):\n \"\"\" Dump data.\n\n .. note:: If `fmt='images'` than ``dst`` must be a single component (str).\n\n .. note:: All parameters must be named only.\n\n Parameters\n ----------\n dst : str, None\n Path to the folder where to dump. If dst is None then path is determined from the index.\n fmt : {'image', 'blosc', 'csv', 'hdf5', 'feather'}\n Format of the file to save.\n components : str, sequence\n Components to save.\n ext: str\n Format to save images to.\n\n Returns\n -------\n self\n \"\"\"\n if fmt == 'image':\n return self._dump_image(components, dst, fmt=kwargs.pop('ext'))\n return super().dump(dst=dst, fmt=fmt, components=components, *args, **kwargs)\n\n\nclass ImagesBatch(BaseImagesBatch):\n \"\"\" Batch class for 2D images.\n\n Images are stored as numpy arrays of PIL.Image.\n\n PIL.Image has the following system of coordinates::\n\n X\n 0 -------------- >\n |\n |\n | images's pixels\n |\n |\n Y v\n\n Pixel's position is defined as (x, y)\n\n Note, that if any class method is wrapped with `@apply_parallel` decorator\n than for inner calls (i.e. from other class methods) should be used version\n of desired method with underscores. (For example, if there is a decorated\n `method` than you need to call `_method_` from inside of `other_method`).\n Same is applicable for all child classes of :class:`batch.Batch`.\n \"\"\"\n\n @classmethod\n def _get_image_shape(cls, image):\n if isinstance(image, PIL.Image.Image):\n return image.size\n return image.shape[:2]\n\n @property\n def image_shape(self):\n \"\"\": tuple - shape of the image\"\"\"\n _, shapes_count = np.unique([image.size for image in self.images], return_counts=True, axis=0)\n if len(shapes_count) == 1:\n if isinstance(self.images[0], PIL.Image.Image):\n return (*self.images[0].size, len(self.images[0].getbands()))\n return self.images[0].shape\n raise RuntimeError('Images have different shapes')\n\n @inbatch_parallel(init='indices', post='_assemble')\n def _load_image(self, ix, src=None, fmt=None, dst=\"images\"):\n \"\"\" Loads image\n\n .. note:: Please note that ``dst`` must be ``str`` only, sequence is not allowed here.\n\n Parameters\n ----------\n src : str, dataset.FilesIndex, None\n Path to the folder with an image. If src is None then it is determined from the index.\n dst : str\n Component to write images to.\n fmt : str\n Format of an image.\n \"\"\"\n return PIL.Image.open(self._make_path(ix, src))\n\n @inbatch_parallel(init='indices')\n def _dump_image(self, ix, src='images', dst=None, fmt=None):\n \"\"\" Saves image to dst.\n\n .. note:: Please note that ``src`` must be ``str`` only, sequence is not allowed here.\n\n Parameters\n ----------\n src : str\n Component to get images from.\n dst : str\n Folder where to dump.\n fmt : str\n Format of saved image.\n \"\"\"\n if dst is None:\n raise RuntimeError('You must specify `dst`')\n image = self.get(ix, src)\n ix = str(ix) + '.' + fmt if fmt is not None else str(ix)\n image.save(os.path.join(dst, ix))\n\n def _assemble_component(self, result, *args, component='images', **kwargs):\n \"\"\" Assemble one component after parallel execution.\n\n Parameters\n ----------\n result : sequence, array_like\n Results after inbatch_parallel.\n component : str\n component to assemble\n \"\"\"\n _ = args, kwargs\n if isinstance(result[0], PIL.Image.Image):\n setattr(self, component, np.asarray(result, dtype=object))\n else:\n try:\n setattr(self, component, np.stack(result))\n except ValueError:\n array_result = np.empty(len(result), dtype=object)\n array_result[:] = result\n setattr(self, component, array_result)\n\n @apply_parallel\n def to_pil(self, image, mode=None):\n \"\"\"converts images in Batch to PIL format\n\n Parameters\n ----------\n src : str\n Component to get images from. Default is 'images'.\n dst : str\n Component to write images to. Default is 'images'.\n \"\"\"\n if isinstance(image, PIL.Image.Image):\n return image\n\n if mode is None:\n if len(image.shape) == 2:\n mode = 'L'\n elif len(image.shape) == 3:\n if image.shape[-1] == 3:\n mode = 'RGB'\n elif image.shape[-1] == 1:\n mode = 'L'\n image = image[:, :, 0]\n elif image.shape[-1] == 2:\n mode = 'LA'\n elif image.shape[-1] == 4:\n mode = 'RGBA'\n else:\n raise ValueError('Unknown image type as image has', image.shape[-1], 'channels')\n elif mode == 'L' and len(image.shape) == 3:\n image = image[..., 0]\n return PIL.Image.fromarray(image, mode)\n\n def _calc_origin(self, image_shape, origin, background_shape):\n \"\"\" Calculate coordinate of the input image with respect to the background.\n\n Parameters\n ----------\n image_shape : sequence\n shape of the input image.\n origin : array_like, sequence, {'center', 'top_left', 'top_right', 'bottom_left', 'bottom_right', 'random'}\n Position of the input image with respect to the background. Can be one of:\n - 'center' - place the center of the input image on the center of the background and crop\n the input image accordingly.\n - 'top_left' - place the upper-left corner of the input image on the upper-left of the background\n and crop the input image accordingly.\n - 'top_right' - crop an image such that upper-right corners of\n an image and the cropping box coincide\n - 'bottom_left' - crop an image such that lower-left corners of\n an image and the cropping box coincide\n - 'bottom_right' - crop an image such that lower-right corners of\n an image and the cropping box coincide\n - 'random' - place the upper-left corner of the input image on the randomly sampled position\n in the background. Position is sampled uniformly such that there is no need for cropping.\n - other - sequence of ints or sequence of floats in [0, 1) interval;\n place the upper-left corner of the input image on the given position in the background.\n If `origin` is a sequence of floats in [0, 1), it defines a relative position of\n the origin in a valid region of image.\n\n background_shape : sequence\n shape of the background image.\n\n Returns\n -------\n sequence : calculated origin in the form (column, row)\n \"\"\"\n if isinstance(origin, str):\n if origin == 'top_left':\n origin = 0, 0\n elif origin == 'top_right':\n origin = (background_shape[0]-image_shape[0]+1, 0)\n elif origin == 'bottom_left':\n origin = (0, background_shape[1]-image_shape[1]+1)\n elif origin == 'bottom_right':\n origin = (background_shape[0]-image_shape[0]+1,\n background_shape[1]-image_shape[1]+1)\n elif origin == 'center':\n origin = np.maximum(0, np.asarray(background_shape) - image_shape) // 2\n elif origin == 'random':\n origin = (np.random.randint(background_shape[0]-image_shape[0]+1),\n np.random.randint(background_shape[1]-image_shape[1]+1))\n else:\n raise ValueError(\"If string, origin should be one of ['center', 'top_left', 'top_right', \"\n \"'bottom_left', 'bottom_right', 'random']. Got '{}'.\".format(origin))\n elif all(0 <= elem < 1 for elem in origin):\n region = ((background_shape[0]-image_shape[0]+1),\n (background_shape[1]-image_shape[1]+1))\n origin = np.asarray(origin) * region\n elif not all(isinstance(elem, int) for elem in origin):\n raise ValueError('If not a string, origin should be either a sequence of ints or sequence of '\n 'floats in [0, 1) interval. Got {}'.format(origin))\n\n return np.asarray(origin, dtype=np.int)\n\n @apply_parallel\n def scale(self, image, factor, preserve_shape=False, origin='center', resample=0):\n \"\"\" Scale the content of each image in the batch.\n\n Resulting shape is obtained as original_shape * factor.\n\n Parameters\n -----------\n factor : float, sequence\n resulting shape is obtained as original_shape * factor\n\n - float - scale all axes with the given factor\n - sequence (factor_1, factort_2, ...) - scale each axis with the given factor separately\n\n preserve_shape : bool\n whether to preserve the shape of the image after scaling\n\n origin : array-like, {'center', 'top_left', 'top_right', 'bottom_left', 'bottom_right', 'random'}\n Relevant only if `preserve_shape` is True.\n If `scale` < 1, defines position of the scaled image with respect to the original one's shape.\n If `scale` > 1, defines position of cropping box.\n\n Can be one of:\n\n - 'center' - place the center of the input image on the center of the background and crop\n the input image accordingly.\n - 'top_left' - place the upper-left corner of the input image on the upper-left of the background\n and crop the input image accordingly.\n - 'top_right' - crop an image such that upper-right corners of\n an image and the cropping box coincide\n - 'bottom_left' - crop an image such that lower-left corners of\n an image and the cropping box coincide\n - 'bottom_right' - crop an image such that lower-right corners of\n an image and the cropping box coincide\n - 'random' - place the upper-left corner of the input image on the randomly sampled position\n in the background. Position is sampled uniformly such that there is no need for cropping.\n - array_like - sequence of ints or sequence of floats in [0, 1) interval;\n place the upper-left corner of the input image on the given position in the background.\n If `origin` is a sequence of floats in [0, 1), it defines a relative position\n of the origin in a valid region of image.\n\n resample: int\n Parameter passed to PIL.Image.resize. Interpolation order\n src : str\n Component to get images from. Default is 'images'.\n dst : str\n Component to write images to. Default is 'images'.\n p : float\n Probability of applying the transform. Default is 1.\n\n Notes\n -----\n Using 'random' option for origin with `src` as list with multiple elements will not result in same crop for each\n element, as origin will be sampled independently for each `src` element.\n To randomly sample same origin for a number of components, use `R` named expression for `origin` argument.\n\n Returns\n -------\n self\n \"\"\"\n original_shape = self._get_image_shape(image)\n rescaled_shape = list(np.int32(np.ceil(np.asarray(original_shape)*factor)))\n rescaled_image = image.resize(rescaled_shape, resample=resample)\n if preserve_shape:\n rescaled_image = self._preserve_shape(original_shape, rescaled_image, origin)\n return rescaled_image\n\n @apply_parallel\n def crop(self, image, origin, shape, crop_boundaries=False):\n \"\"\" Crop an image.\n\n Extract image data from the window of the size given by `shape` and placed at `origin`.\n\n Parameters\n ----------\n origin : sequence, str\n Location of the cropping box. See :meth:`.ImagesBatch._calc_origin` for details.\n shape : sequence\n crop size in the form of (rows, columns)\n crop_boundaries : bool\n If `True` then crop is got only from image's area. Shape of the crop might diverge with the passed one\n src : str\n Component to get images from. Default is 'images'.\n dst : str\n Component to write images to. Default is 'images'.\n p : float\n Probability of applying the transform. Default is 1.\n\n Notes\n -----\n Using 'random' origin with `src` as list with multiple elements will not result in same crop for each\n element, as origin will be sampled independently for each `src` element.\n To randomly sample same origin for a number of components, use `R` named expression for `origin` argument.\n \"\"\"\n origin = self._calc_origin(shape, origin, image.size)\n right_bottom = origin + shape\n\n if crop_boundaries:\n out_of_boundaries = origin < 0\n origin[out_of_boundaries] = 0\n\n image_shape = np.asarray(image.size)\n out_of_boundaries = right_bottom > image_shape\n right_bottom[out_of_boundaries] = image_shape[out_of_boundaries]\n\n return image.crop((*origin, *right_bottom))\n\n @apply_parallel\n def put_on_background(self, image, background, origin, mask=None):\n \"\"\" Put an image on a background at given origin\n\n Parameters\n ----------\n background : PIL.Image, np.ndarray of np.uint8\n Blank background to put image on.\n origin : sequence, str\n Location of the cropping box. See :meth:`.ImagesBatch._calc_origin` for details.\n mask : None, PIL.Image, np.ndarray of np.uint8\n mask passed to PIL.Image.paste\n\n Notes\n -----\n Using 'random' origin with `src` as list with multiple elements will not result in same crop for each\n element, as origin will be sampled independently for each `src` element.\n To randomly sample same origin for a number of components, use `R` named expression for `origin` argument.\n \"\"\"\n if not isinstance(background, PIL.Image.Image):\n background = PIL.Image.fromarray(background)\n else:\n background = background.copy()\n\n if not isinstance(mask, PIL.Image.Image):\n mask = PIL.Image.fromarray(mask) if mask is not None else None\n\n origin = list(self._calc_origin(self._get_image_shape(image), origin,\n self._get_image_shape(background)))\n\n background.paste(image, origin, mask)\n\n return background\n\n def _preserve_shape(self, original_shape, transformed_image, origin='center'):\n \"\"\" Change the transformed image's shape by cropping and adding empty pixels to fit the shape of original image.\n\n Parameters\n ----------\n original_shape : sequence\n transformed_image : np.ndarray\n input_origin : array-like, {'center', 'top_left', 'random'}\n Position of the scaled image with respect to the original one's shape.\n - 'center' - place the center of the input image on the center of the background and crop\n the input image accordingly.\n - 'top_left' - place the upper-left corner of the input image on the upper-left of the background\n and crop the input image accordingly.\n - 'top_right' - crop an image such that upper-right corners of\n an image and the cropping box coincide\n - 'bottom_left' - crop an image such that lower-left corners of\n an image and the cropping box coincide\n - 'bottom_right' - crop an image such that lower-right corners of\n an image and the cropping box coincide\n - 'random' - place the upper-left corner of the input image on the randomly sampled position\n in the background. Position is sampled uniformly such that there is no need for cropping.\n - array_like - sequence of ints or sequence of floats in [0, 1) interval;\n place the upper-left corner of the input image on the given position in the background.\n If `origin` is a sequence of floats in [0, 1), it defines a relative position\n of the origin in a valid region of image.\n crop_origin: array-like, {'center', 'top_left', 'random'}\n Position of crop from transformed image.\n Has same values as `input_origin`.\n\n Returns\n -------\n np.ndarray : image after described actions\n \"\"\"\n transformed_shape = self._get_image_shape(transformed_image)\n if np.any(np.array(transformed_shape) < np.array(original_shape)):\n n_channels = len(transformed_image.getbands())\n if n_channels == 1:\n background = np.zeros(original_shape, dtype=np.uint8)\n else:\n background = np.zeros((*original_shape, n_channels), dtype=np.uint8)\n return self._put_on_background_(transformed_image, background, origin)\n return self._crop_(transformed_image, origin, original_shape, True)\n\n @apply_parallel\n def filter(self, image, mode, *args, **kwargs):\n \"\"\" Filters an image. Calls ``image.filter(getattr(PIL.ImageFilter, mode)(*args, **kwargs))``.\n\n For more details see `ImageFilter <http://pillow.readthedocs.io/en/stable/reference/ImageFilter.html>_`.\n\n Parameters\n ----------\n mode : str\n Name of the filter.\n src : str\n Component to get images from. Default is 'images'.\n dst : str\n Component to write images to. Default is 'images'.\n p : float\n Probability of applying the transform. Default is 1.\n \"\"\"\n return image.filter(getattr(PIL.ImageFilter, mode)(*args, **kwargs))\n\n @apply_parallel\n def transform(self, image, *args, **kwargs):\n \"\"\" Calls ``image.transform(*args, **kwargs)``.\n\n For more information see\n `<http://pillow.readthedocs.io/en/stable/reference/Image.html#PIL.Image.Image.transform>_`.\n\n Parameters\n ----------\n src : str\n Component to get images from. Default is 'images'.\n dst : str\n Component to write images to. Default is 'images'.\n p : float\n Probability of applying the transform. Default is 1.\n \"\"\"\n size = kwargs.pop('size', self._get_image_shape(image))\n return image.transform(*args, size=size, **kwargs)\n\n @apply_parallel\n def resize(self, image, size, *args, **kwargs):\n \"\"\" Calls ``image.resize(*args, **kwargs)``.\n\n For more details see `<https://pillow.readthedocs.io/en/stable/reference/Image.html#PIL.Image.Image.resize>_`.\n\n Parameters\n ----------\n size : tuple\n the resulting size of the image. If one of the components of tuple is None,\n corresponding dimension will be proportionally resized.\n src : str\n Component to get images from. Default is 'images'.\n dst : str\n Component to write images to. Default is 'images'.\n p : float\n Probability of applying the transform. Default is 1.\n \"\"\"\n if size[0] is None and size[1] is None:\n raise ValueError('At least one component of the parameter \"size\" must be a number.')\n if size[0] is None:\n new_size = (int(image.size[0] * size[1] / image.size[1]), size[1])\n elif size[1] is None:\n new_size = (size[0], int(image.size[1] * size[0] / image.size[0]))\n else:\n new_size = size\n\n return image.resize(new_size, *args, **kwargs)\n\n @apply_parallel\n def shift(self, image, offset, mode='const'):\n \"\"\" Shifts an image.\n\n Parameters\n ----------\n offset : (Number, Number)\n mode : {'const', 'wrap'}\n How to fill borders\n src : str\n Component to get images from. Default is 'images'.\n dst : str\n Component to write images to. Default is 'images'.\n p : float\n Probability of applying the transform. Default is 1.\n \"\"\"\n if mode == 'const':\n image = image.transform(size=image.size,\n method=PIL.Image.AFFINE,\n data=(1, 0, -offset[0], 0, 1, -offset[1]))\n elif mode == 'wrap':\n image = PIL.ImageChops.offset(image, *offset)\n else:\n raise ValueError(\"mode must be one of ['const', 'wrap']\")\n return image\n\n @apply_parallel\n def pad(self, image, *args, **kwargs):\n \"\"\" Calls ``PIL.ImageOps.expand``.\n\n For more details see `<http://pillow.readthedocs.io/en/stable/reference/ImageOps.html#PIL.ImageOps.expand>`_.\n\n Parameters\n ----------\n offset : sequence\n Size of the borders in pixels. The order is (left, top, right, bottom).\n mode : {'const', 'wrap'}\n Filling mode\n src : str\n Component to get images from. Default is 'images'.\n dst : str\n Component to write images to. Default is 'images'.\n p : float\n Probability of applying the transform. Default is 1.\n \"\"\"\n return PIL.ImageOps.expand(image, *args, **kwargs)\n\n @apply_parallel\n def rotate(self, image, *args, **kwargs):\n \"\"\" Rotates an image.\n\n kwargs are passed to PIL.Image.rotate\n\n Parameters\n ----------\n angle: Number\n In degrees counter clockwise.\n resample: int\n Interpolation order\n expand: bool\n Whether to expand the output to hold the whole image. Default is False.\n center: (Number, Number)\n Center of rotation. Default is the center of the image.\n src : str\n Component to get images from. Default is 'images'.\n dst : str\n Component to write images to. Default is 'images'.\n p : float\n Probability of applying the transform. Default is 1.\n \"\"\"\n return image.rotate(*args, **kwargs)\n\n @apply_parallel\n def flip(self, image, mode='lr'):\n \"\"\" Flips image.\n\n Parameters\n ----------\n mode : {'lr', 'ud'}\n\n - 'lr' - apply the left/right flip\n - 'ud' - apply the upside/down flip\n src : str\n Component to get images from. Default is 'images'.\n dst : str\n Component to write images to. Default is 'images'.\n p : float\n Probability of applying the transform. Default is 1.\n \"\"\"\n if mode == 'lr':\n return PIL.ImageOps.mirror(image)\n return PIL.ImageOps.flip(image)\n\n @apply_parallel\n def invert(self, image, channels='all'):\n \"\"\" Invert givn channels.\n\n Parameters\n ----------\n channels : int, sequence\n Indices of the channels to invert.\n src : str\n Component to get images from. Default is 'images'.\n dst : str\n Component to write images to. Default is 'images'.\n p : float\n Probability of applying the transform. Default is 1.\n \"\"\"\n if channels == 'all':\n image = PIL.ImageChops.invert(image)\n else:\n bands = list(image.split())\n channels = (channels,) if isinstance(channels, Number) else channels\n for channel in channels:\n bands[channel] = PIL.ImageChops.invert(bands[channel])\n image = PIL.Image.merge('RGB', bands)\n return image\n\n @apply_parallel\n def salt(self, image, p_noise=.015, color=255, size=(1, 1)):\n \"\"\" Set random pixel on image to givan value.\n\n Every pixel will be set to ``color`` value with probability ``p_noise``.\n\n Parameters\n ----------\n p_noise : float\n Probability of salting a pixel.\n color : float, int, sequence, callable\n Color's value.\n\n - int, float, sequence -- value of color\n - callable -- color is sampled for every chosen pixel (rules are the same as for int, float and sequence)\n size : int, sequence of int, callable\n Size of salt\n\n - int -- square salt with side ``size``\n - sequence -- recangular salt in the form (row, columns)\n - callable -- size is sampled for every chosen pixel (rules are the same as for int and sequence)\n src : str\n Component to get images from. Default is 'images'.\n dst : str\n Component to write images to. Default is 'images'.\n p : float\n Probability of applying the transform. Default is 1.\n \"\"\"\n mask_size = np.asarray(self._get_image_shape(image))\n mask_salt = np.random.binomial(1, p_noise, size=mask_size).astype(bool)\n image = np.array(image)\n if isinstance(size, (tuple, int)) and size in [1, (1, 1)] and not callable(color):\n image[mask_salt] = color\n else:\n size_lambda = size if callable(size) else lambda: size\n color_lambda = color if callable(color) else lambda: color\n mask_salt = np.where(mask_salt)\n for i in range(len(mask_salt[0])):\n current_size = size_lambda()\n current_size = (current_size, current_size) if isinstance(current_size, Number) else current_size\n left_top = np.asarray((mask_salt[0][i], mask_salt[1][i]))\n right_bottom = np.minimum(left_top + current_size, self._get_image_shape(image))\n image[left_top[0]:right_bottom[0], left_top[1]:right_bottom[1]] = color_lambda()\n\n return PIL.Image.fromarray(image)\n\n @apply_parallel\n def clip(self, image, low=0, high=255):\n \"\"\" Truncate image's pixels.\n\n Parameters\n ----------\n low : int, float, sequence\n Actual pixel's value is equal max(value, low). If sequence is given, then its length must coincide\n with the number of channels in an image and each channel is thresholded separately\n high : int, float, sequence\n Actual pixel's value is equal min(value, high). If sequence is given, then its length must coincide\n with the number of channels in an image and each channel is thresholded separately\n src : str\n Component to get images from. Default is 'images'.\n dst : str\n Component to write images to. Default is 'images'.\n p : float\n Probability of applying the transform. Default is 1.\n \"\"\"\n if isinstance(low, Number):\n low = tuple([low]*3)\n if isinstance(high, Number):\n high = tuple([high]*3)\n\n high = PIL.Image.new('RGB', image.size, high)\n low = PIL.Image.new('RGB', image.size, low)\n return PIL.ImageChops.lighter(PIL.ImageChops.darker(image, high), low)\n\n @apply_parallel\n def enhance(self, image, layout='hcbs', factor=(1, 1, 1, 1)):\n \"\"\" Apply enhancements from PIL.ImageEnhance to the image.\n\n Parameters\n ----------\n layout : str\n defines layout of operations, default is `hcbs`:\n h - color\n c - contrast\n b - brightness\n s - sharpness\n\n factor : float or tuple of float\n factor of enhancement for each operation listed in `layout`.\n \"\"\"\n enhancements = {\n 'h': 'Color',\n 'c': 'Contrast',\n 'b': 'Brightness',\n 's': 'Sharpness'\n }\n\n if isinstance(factor, float):\n factor = (factor,) * len(layout)\n if len(layout) != len(factor):\n raise ValueError(\"'layout' and 'factor' should be of same length!\")\n\n for alias, multiplier in zip(layout, factor):\n enhancement = enhancements.get(alias)\n if enhancement is None:\n raise ValueError('Unknown enhancement alias: ', alias)\n image = getattr(PIL.ImageEnhance, enhancement)(image).enhance(multiplier)\n\n return image\n\n @apply_parallel\n def multiply(self, image, multiplier=1., clip=False, preserve_type=False):\n \"\"\" Multiply each pixel by the given multiplier.\n\n Parameters\n ----------\n multiplier : float, sequence\n clip : bool\n whether to force image's pixels to be in [0, 255] or [0, 1.]\n preserve_type : bool\n Whether to preserve ``dtype`` of transformed images.\n If ``False`` is given then the resulting type will be ``np.float``.\n src : str\n Component to get images from. Default is 'images'.\n dst : str\n Component to write images to. Default is 'images'.\n p : float\n Probability of applying the transform. Default is 1.\n \"\"\"\n multiplier = np.float32(multiplier)\n if isinstance(image, PIL.Image.Image):\n if preserve_type is False:\n warnings.warn(\"Note that some info might be lost during `multiply` transformation since PIL.image \"\n \"stores data as `np.uint8`. To suppress this warning, use `preserve_type=True` or \"\n \"consider using `to_array` action before multiplication.\")\n return PIL.Image.fromarray(np.clip(multiplier*np.asarray(image), 0, 255).astype(np.uint8))\n dtype = image.dtype if preserve_type else np.float\n if clip:\n image = np.clip(multiplier*image, 0, 255 if dtype == np.uint8 else 1.)\n else:\n image = multiplier * image\n return image.astype(dtype)\n\n @apply_parallel\n def add(self, image, term=1., clip=False, preserve_type=False):\n \"\"\" Add term to each pixel.\n\n Parameters\n ----------\n term : float, sequence\n clip : bool\n whether to force image's pixels to be in [0, 255] or [0, 1.]\n preserve_type : bool\n Whether to preserve ``dtype`` of transformed images.\n If ``False`` is given then the resulting type will be ``np.float``.\n src : str\n Component to get images from. Default is 'images'.\n dst : str\n Component to write images to. Default is 'images'.\n p : float\n Probability of applying the transform. Default is 1.\n \"\"\"\n term = np.float32(term)\n if isinstance(image, PIL.Image.Image):\n return PIL.Image.fromarray(np.clip(term+np.asarray(image), 0, 255).astype(np.uint8))\n dtype = image.dtype if preserve_type else np.float\n if clip:\n image = np.clip(term+image, 0, 255 if dtype == np.uint8 else 1.)\n else:\n image = term + image\n return image.astype(dtype)\n\n @apply_parallel\n def pil_convert(self, image, mode=\"L\"):\n \"\"\" Convert image. Actually calls ``image.convert(mode)``.\n\n Parameters\n ----------\n mode : str\n Pass 'L' to convert to grayscale\n src : str\n Component to get images from. Default is 'images'.\n dst : str\n Component to write images to. Default is 'images'.\n p : float\n Probability of applying the transform. Default is 1.\n \"\"\"\n return image.convert(mode)\n\n @apply_parallel\n def posterize(self, image, bits=4):\n \"\"\" Posterizes image.\n\n More concretely, it quantizes pixels' values so that they have``2^bits`` colors\n\n Parameters\n ----------\n bits : int\n Number of bits used to store a color's component.\n src : str\n Component to get images from. Default is 'images'.\n dst : str\n Component to write images to. Default is 'images'.\n p : float\n Probability of applying the transform. Default is 1.\n \"\"\"\n return PIL.ImageOps.posterize(image, bits)\n\n @apply_parallel\n def cutout(self, image, origin, shape, color):\n \"\"\" Fills given areas with color\n\n .. note:: It is assumed that ``origins``, ``shapes`` and ``colors`` have the same length.\n\n Parameters\n ----------\n origin : sequence, str\n Location of the cropping box. See :meth:`.ImagesBatch._calc_origin` for details.\n shape : sequence, int\n Shape of a filled box. Can be one of:\n - sequence - crop size in the form of (rows, columns)\n - int - shape has squared form\n\n color : sequence, number\n Color of a filled box. Can be one of:\n\n - sequence - (r,g,b) form\n - number - grayscale\n src : str\n Component to get images from. Default is 'images'.\n dst : str\n Component to write images to. Default is 'images'.\n p : float\n Probability of applying the transform. Default is 1.\n\n Notes\n -----\n Using 'random' origin with `src` as list with multiple elements will not result in same crop for each\n element, as origin will be sampled independently for each `src` element.\n To randomly sample same origin for a number of components, use `R` named expression for `origin` argument.\n \"\"\"\n image = image.copy()\n shape = (shape, shape) if isinstance(shape, Number) else shape\n origin = self._calc_origin(shape, origin, self._get_image_shape(image))\n color = (color, color, color) if isinstance(color, Number) else color\n image.paste(PIL.Image.new('RGB', tuple(shape), tuple(color)), tuple(origin))\n return image\n\n def _assemble_patches(self, patches, *args, dst, **kwargs):\n \"\"\" Assembles patches after parallel execution.\n\n Parameters\n ----------\n patches : sequence\n Patches to gather. pathces.shape must be like (batch.size, patches_i, patch_height, patch_width, n_channels)\n dst : str\n Component to put patches in.\n \"\"\"\n _ = args, kwargs\n new_items = np.concatenate(patches)\n setattr(self, dst, new_items)\n\n @action\n @inbatch_parallel(init='indices', post='_assemble_patches')\n def split_to_patches(self, ix, patch_shape, stride=1, drop_last=False, src='images', dst=None):\n \"\"\" Splits image to patches.\n\n Small images with the same shape (``patch_shape``) are cropped from the original one with stride ``stride``.\n\n Parameters\n ----------\n patch_shape : int, sequence\n Patch's shape in the from (rows, columns). If int is given then patches have square shape.\n stride : int, square\n Step of the moving window from which patches are cropped. If int is given then the window has square shape.\n drop_last : bool\n Whether to drop patches whose window covers area out of the image.\n If False is passed then these patches are cropped from the edge of an image. See more in tutorials.\n src : str\n Component to get images from. Default is 'images'.\n dst : str\n Component to write images to. Default is 'images'.\n p : float\n Probability of applying the transform. Default is 1.\n \"\"\"\n _ = dst\n image = self.get(ix, src)\n image_shape = self._get_image_shape(image)\n image = np.array(image)\n stride = (stride, stride) if isinstance(stride, Number) else stride\n patch_shape = (patch_shape, patch_shape) if isinstance(patch_shape, Number) else patch_shape\n patches = []\n\n def _iterate_columns(row_from, row_to):\n column = 0\n while column < image_shape[1]-patch_shape[1]+1:\n patches.append(PIL.Image.fromarray(image[row_from:row_to, column:column+patch_shape[1]]))\n column += stride[1]\n if not drop_last and column + patch_shape[1] != image_shape[1]:\n patches.append(PIL.Image.fromarray(image[row_from:row_to,\n image_shape[1]-patch_shape[1]:image_shape[1]]))\n\n row = 0\n while row < image_shape[0]-patch_shape[0]+1:\n _iterate_columns(row, row+patch_shape[0])\n row += stride[0]\n if not drop_last and row + patch_shape[0] != image_shape[0]:\n _iterate_columns(image_shape[0]-patch_shape[0], image_shape[0])\n\n return np.array(patches, dtype=object)\n\n @apply_parallel\n def additive_noise(self, image, noise, clip=False, preserve_type=False):\n \"\"\" Add additive noise to an image.\n\n Parameters\n ----------\n noise : callable\n Distribution. Must have ``size`` parameter.\n clip : bool\n whether to force image's pixels to be in [0, 255] or [0, 1.]\n preserve_type : bool\n Whether to preserve ``dtype`` of transformed images.\n If ``False`` is given then the resulting type will be ``np.float``.\n src : str\n Component to get images from. Default is 'images'.\n dst : str\n Component to write images to. Default is 'images'.\n p : float\n Probability of applying the transform. Default is 1.\n \"\"\"\n noise = noise(size=(*image.size, len(image.getbands())) if isinstance(image, PIL.Image.Image) else image.shape)\n return self._add_(image, noise, clip, preserve_type)\n\n @apply_parallel\n def multiplicative_noise(self, image, noise, clip=False, preserve_type=False):\n \"\"\" Add multiplicative noise to an image.\n\n Parameters\n ----------\n noise : callable\n Distribution. Must have ``size`` parameter.\n clip : bool\n whether to force image's pixels to be in [0, 255] or [0, 1.]\n preserve_type : bool\n Whether to preserve ``dtype`` of transformed images.\n If ``False`` is given then the resulting type will be ``np.float``.\n src : str\n Component to get images from. Default is 'images'.\n dst : str\n Component to write images to. Default is 'images'.\n p : float\n Probability of applying the transform. Default is 1.\n \"\"\"\n noise = noise(size=(*image.size, len(image.getbands())) if isinstance(image, PIL.Image.Image) else image.shape)\n return self._multiply_(image, noise, clip, preserve_type)\n\n @apply_parallel\n def elastic_transform(self, image, alpha, sigma, **kwargs):\n \"\"\" Deformation of images as described by Simard, Steinkraus and Platt, `Best Practices for Convolutional\n Neural Networks applied to Visual Document Analysis <http://cognitivemedium.com/assets/rmnist/Simard.pdf>_`.\n\n Code slightly differs from `<https://gist.github.com/chsasank/4d8f68caf01f041a6453e67fb30f8f5a>`_.\n\n Parameters\n ----------\n alpha : number\n maximum of vectors' norms.\n sigma : number\n Smooth factor.\n src : str\n Component to get images from. Default is 'images'.\n dst : str\n Component to write images to. Default is 'images'.\n p : float\n Probability of applying the transform. Default is 1.\n \"\"\"\n image = np.array(image)\n # full shape is needed\n shape = image.shape\n if len(shape) == 2:\n image = image[..., None]\n shape = image.shape\n\n kwargs.setdefault('mode', 'constant')\n kwargs.setdefault('cval', 0)\n\n column_shift = self._sp_gaussian_filter_(np.random.uniform(-1, 1, size=shape), sigma, **kwargs) * alpha\n row_shift = self._sp_gaussian_filter_(np.random.uniform(-1, 1, size=shape), sigma, **kwargs) * alpha\n\n row, column, channel = np.meshgrid(range(shape[0]), range(shape[1]), range(shape[2]))\n\n indices = (column + column_shift, row + row_shift, channel)\n\n distored_image = self._sp_map_coordinates_(image, indices, order=1, mode='reflect')\n\n if shape[-1] == 1:\n return PIL.Image.fromarray(np.uint8(distored_image.reshape(image.shape))[..., 0])\n return PIL.Image.fromarray(np.uint8(distored_image.reshape(image.shape)))\n",
"\"\"\" Utility functions. \"\"\"\nimport tensorflow as tf\n\n\n\ndef get_shape(tensor, dynamic=False):\n \"\"\" Return shape of the input tensor without batch size.\n\n Parameters\n ----------\n tensor : tf.Tensor\n\n dynamic : bool\n If True, returns tensor which represents shape. If False, returns list of ints and/or Nones.\n\n Returns\n -------\n shape : tf.Tensor or list\n \"\"\"\n if dynamic:\n shape = tf.shape(tensor)\n else:\n shape = tensor.get_shape().as_list()\n return shape[1:]\n\ndef get_num_dims(tensor):\n \"\"\" Return a number of semantic dimensions (i.e. excluding batch and channels axis)\"\"\"\n shape = get_shape(tensor)\n dim = len(shape)\n return max(1, dim - 2)\n\n\ndef get_channels_axis(data_format='channels_last'):\n \"\"\" Return the integer channels axis based on string data format. \"\"\"\n return 1 if data_format == \"channels_first\" or data_format.startswith(\"NC\") else -1\n\ndef get_num_channels(tensor, data_format='channels_last'):\n \"\"\" Return number of channels in the input tensor.\n\n Parameters\n ----------\n tensor : tf.Tensor\n\n Returns\n -------\n shape : tuple of ints\n \"\"\"\n shape = tensor.get_shape().as_list()\n axis = get_channels_axis(data_format)\n return shape[axis]\n\n\ndef get_batch_size(tensor, dynamic=False):\n \"\"\" Return batch size (the length of the first dimension) of the input tensor.\n\n Parameters\n ----------\n tensor : tf.Tensor\n\n Returns\n -------\n batch size : int or None\n \"\"\"\n if dynamic:\n return tf.shape(tensor)[0]\n return tensor.get_shape().as_list()[0]\n\n\ndef get_spatial_dim(tensor):\n \"\"\" Return spatial dim of the input tensor (without channels and batch dimension).\n\n Parameters\n ----------\n tensor : tf.Tensor\n\n Returns\n -------\n dim : int\n \"\"\"\n return len(tensor.get_shape().as_list()) - 2\n\ndef get_spatial_shape(tensor, data_format='channels_last', dynamic=False):\n \"\"\" Return the tensor spatial shape (without batch and channels dimensions).\n\n Parameters\n ----------\n tensor : tf.Tensor\n\n dynamic : bool\n If True, returns tensor which represents shape. If False, returns list of ints and/or Nones.\n\n Returns\n -------\n shape : tf.Tensor or list\n \"\"\"\n if dynamic:\n shape = tf.shape(tensor)\n else:\n shape = tensor.get_shape().as_list()\n axis = slice(1, -1) if data_format == \"channels_last\" else slice(2, None)\n return shape[axis]\n"
] | [
[
"tensorflow.abs",
"tensorflow.mod",
"tensorflow.name_scope",
"tensorflow.sin",
"tensorflow.train.piecewise_constant",
"tensorflow.cast"
],
[
"numpy.sum",
"numpy.asarray"
],
[
"numpy.concatenate",
"numpy.array",
"numpy.random.binomial",
"numpy.asarray",
"numpy.zeros",
"numpy.where",
"numpy.float32",
"numpy.random.uniform",
"numpy.stack",
"numpy.random.randint",
"numpy.clip",
"numpy.unique"
],
[
"tensorflow.shape"
]
] |
sayanmondal2098/pandas | [
"a1fee9199eba7ebf423880243936b9f1501d3d3a",
"a1fee9199eba7ebf423880243936b9f1501d3d3a"
] | [
"pandas/tests/io/parser/test_parse_dates.py",
"pandas/tests/io/test_pytables.py"
] | [
"# -*- coding: utf-8 -*-\n\n\"\"\"\nTests date parsing functionality for all of the\nparsers defined in parsers.py\n\"\"\"\n\nfrom datetime import date, datetime\nfrom io import StringIO\n\nimport numpy as np\nimport pytest\nimport pytz\n\nfrom pandas._libs.tslib import Timestamp\nfrom pandas._libs.tslibs import parsing\nfrom pandas.compat import lrange, parse_date\nfrom pandas.compat.numpy import np_array_datetime64_compat\n\nimport pandas as pd\nfrom pandas import DataFrame, DatetimeIndex, Index, MultiIndex\nfrom pandas.core.indexes.datetimes import date_range\nimport pandas.util.testing as tm\n\nimport pandas.io.date_converters as conv\nimport pandas.io.parsers as parsers\n\n\ndef test_separator_date_conflict(all_parsers):\n # Regression test for gh-4678\n #\n # Make sure thousands separator and\n # date parsing do not conflict.\n parser = all_parsers\n data = \"06-02-2013;13:00;1-000.215\"\n expected = DataFrame([[datetime(2013, 6, 2, 13, 0, 0), 1000.215]],\n columns=[\"Date\", 2])\n\n df = parser.read_csv(StringIO(data), sep=\";\", thousands=\"-\",\n parse_dates={\"Date\": [0, 1]}, header=None)\n tm.assert_frame_equal(df, expected)\n\n\[email protected](\"keep_date_col\", [True, False])\ndef test_multiple_date_col_custom(all_parsers, keep_date_col):\n data = \"\"\"\\\nKORD,19990127, 19:00:00, 18:56:00, 0.8100, 2.8100, 7.2000, 0.0000, 280.0000\nKORD,19990127, 20:00:00, 19:56:00, 0.0100, 2.2100, 7.2000, 0.0000, 260.0000\nKORD,19990127, 21:00:00, 20:56:00, -0.5900, 2.2100, 5.7000, 0.0000, 280.0000\nKORD,19990127, 21:00:00, 21:18:00, -0.9900, 2.0100, 3.6000, 0.0000, 270.0000\nKORD,19990127, 22:00:00, 21:56:00, -0.5900, 1.7100, 5.1000, 0.0000, 290.0000\nKORD,19990127, 23:00:00, 22:56:00, -0.5900, 1.7100, 4.6000, 0.0000, 280.0000\n\"\"\"\n parser = all_parsers\n\n def date_parser(*date_cols):\n \"\"\"\n Test date parser.\n\n Parameters\n ----------\n date_cols : args\n The list of data columns to parse.\n\n Returns\n -------\n parsed : Series\n \"\"\"\n return parsing.try_parse_dates(parsers._concat_date_cols(date_cols))\n\n result = parser.read_csv(StringIO(data), header=None,\n date_parser=date_parser, prefix=\"X\",\n parse_dates={\"actual\": [1, 2],\n \"nominal\": [1, 3]},\n keep_date_col=keep_date_col)\n expected = DataFrame([\n [datetime(1999, 1, 27, 19, 0), datetime(1999, 1, 27, 18, 56),\n \"KORD\", \"19990127\", \" 19:00:00\", \" 18:56:00\",\n 0.81, 2.81, 7.2, 0.0, 280.0],\n [datetime(1999, 1, 27, 20, 0), datetime(1999, 1, 27, 19, 56),\n \"KORD\", \"19990127\", \" 20:00:00\", \" 19:56:00\",\n 0.01, 2.21, 7.2, 0.0, 260.0],\n [datetime(1999, 1, 27, 21, 0), datetime(1999, 1, 27, 20, 56),\n \"KORD\", \"19990127\", \" 21:00:00\", \" 20:56:00\",\n -0.59, 2.21, 5.7, 0.0, 280.0],\n [datetime(1999, 1, 27, 21, 0), datetime(1999, 1, 27, 21, 18),\n \"KORD\", \"19990127\", \" 21:00:00\", \" 21:18:00\",\n -0.99, 2.01, 3.6, 0.0, 270.0],\n [datetime(1999, 1, 27, 22, 0), datetime(1999, 1, 27, 21, 56),\n \"KORD\", \"19990127\", \" 22:00:00\", \" 21:56:00\",\n -0.59, 1.71, 5.1, 0.0, 290.0],\n [datetime(1999, 1, 27, 23, 0), datetime(1999, 1, 27, 22, 56),\n \"KORD\", \"19990127\", \" 23:00:00\", \" 22:56:00\",\n -0.59, 1.71, 4.6, 0.0, 280.0],\n ], columns=[\"actual\", \"nominal\", \"X0\", \"X1\", \"X2\",\n \"X3\", \"X4\", \"X5\", \"X6\", \"X7\", \"X8\"])\n\n if not keep_date_col:\n expected = expected.drop([\"X1\", \"X2\", \"X3\"], axis=1)\n elif parser.engine == \"python\":\n expected[\"X1\"] = expected[\"X1\"].astype(np.int64)\n\n # Python can sometimes be flaky about how\n # the aggregated columns are entered, so\n # this standardizes the order.\n result = result[expected.columns]\n tm.assert_frame_equal(result, expected)\n\n\[email protected](\"keep_date_col\", [True, False])\ndef test_multiple_date_col(all_parsers, keep_date_col):\n data = \"\"\"\\\nKORD,19990127, 19:00:00, 18:56:00, 0.8100, 2.8100, 7.2000, 0.0000, 280.0000\nKORD,19990127, 20:00:00, 19:56:00, 0.0100, 2.2100, 7.2000, 0.0000, 260.0000\nKORD,19990127, 21:00:00, 20:56:00, -0.5900, 2.2100, 5.7000, 0.0000, 280.0000\nKORD,19990127, 21:00:00, 21:18:00, -0.9900, 2.0100, 3.6000, 0.0000, 270.0000\nKORD,19990127, 22:00:00, 21:56:00, -0.5900, 1.7100, 5.1000, 0.0000, 290.0000\nKORD,19990127, 23:00:00, 22:56:00, -0.5900, 1.7100, 4.6000, 0.0000, 280.0000\n\"\"\"\n parser = all_parsers\n result = parser.read_csv(StringIO(data), header=None,\n prefix=\"X\", parse_dates=[[1, 2], [1, 3]],\n keep_date_col=keep_date_col)\n expected = DataFrame([\n [datetime(1999, 1, 27, 19, 0), datetime(1999, 1, 27, 18, 56),\n \"KORD\", \"19990127\", \" 19:00:00\", \" 18:56:00\",\n 0.81, 2.81, 7.2, 0.0, 280.0],\n [datetime(1999, 1, 27, 20, 0), datetime(1999, 1, 27, 19, 56),\n \"KORD\", \"19990127\", \" 20:00:00\", \" 19:56:00\",\n 0.01, 2.21, 7.2, 0.0, 260.0],\n [datetime(1999, 1, 27, 21, 0), datetime(1999, 1, 27, 20, 56),\n \"KORD\", \"19990127\", \" 21:00:00\", \" 20:56:00\",\n -0.59, 2.21, 5.7, 0.0, 280.0],\n [datetime(1999, 1, 27, 21, 0), datetime(1999, 1, 27, 21, 18),\n \"KORD\", \"19990127\", \" 21:00:00\", \" 21:18:00\",\n -0.99, 2.01, 3.6, 0.0, 270.0],\n [datetime(1999, 1, 27, 22, 0), datetime(1999, 1, 27, 21, 56),\n \"KORD\", \"19990127\", \" 22:00:00\", \" 21:56:00\",\n -0.59, 1.71, 5.1, 0.0, 290.0],\n [datetime(1999, 1, 27, 23, 0), datetime(1999, 1, 27, 22, 56),\n \"KORD\", \"19990127\", \" 23:00:00\", \" 22:56:00\",\n -0.59, 1.71, 4.6, 0.0, 280.0],\n ], columns=[\"X1_X2\", \"X1_X3\", \"X0\", \"X1\", \"X2\",\n \"X3\", \"X4\", \"X5\", \"X6\", \"X7\", \"X8\"])\n\n if not keep_date_col:\n expected = expected.drop([\"X1\", \"X2\", \"X3\"], axis=1)\n elif parser.engine == \"python\":\n expected[\"X1\"] = expected[\"X1\"].astype(np.int64)\n\n tm.assert_frame_equal(result, expected)\n\n\ndef test_date_col_as_index_col(all_parsers):\n data = \"\"\"\\\nKORD,19990127 19:00:00, 18:56:00, 0.8100, 2.8100, 7.2000, 0.0000, 280.0000\nKORD,19990127 20:00:00, 19:56:00, 0.0100, 2.2100, 7.2000, 0.0000, 260.0000\nKORD,19990127 21:00:00, 20:56:00, -0.5900, 2.2100, 5.7000, 0.0000, 280.0000\nKORD,19990127 21:00:00, 21:18:00, -0.9900, 2.0100, 3.6000, 0.0000, 270.0000\nKORD,19990127 22:00:00, 21:56:00, -0.5900, 1.7100, 5.1000, 0.0000, 290.0000\n\"\"\"\n parser = all_parsers\n result = parser.read_csv(StringIO(data), header=None, prefix=\"X\",\n parse_dates=[1], index_col=1)\n\n index = Index([datetime(1999, 1, 27, 19, 0), datetime(1999, 1, 27, 20, 0),\n datetime(1999, 1, 27, 21, 0), datetime(1999, 1, 27, 21, 0),\n datetime(1999, 1, 27, 22, 0)], name=\"X1\")\n expected = DataFrame([\n [\"KORD\", \" 18:56:00\", 0.81, 2.81, 7.2, 0.0, 280.0],\n [\"KORD\", \" 19:56:00\", 0.01, 2.21, 7.2, 0.0, 260.0],\n [\"KORD\", \" 20:56:00\", -0.59, 2.21, 5.7, 0.0, 280.0],\n [\"KORD\", \" 21:18:00\", -0.99, 2.01, 3.6, 0.0, 270.0],\n [\"KORD\", \" 21:56:00\", -0.59, 1.71, 5.1, 0.0, 290.0],\n ], columns=[\"X0\", \"X2\", \"X3\", \"X4\", \"X5\", \"X6\", \"X7\"], index=index)\n tm.assert_frame_equal(result, expected)\n\n\ndef test_multiple_date_cols_int_cast(all_parsers):\n data = (\"KORD,19990127, 19:00:00, 18:56:00, 0.8100\\n\"\n \"KORD,19990127, 20:00:00, 19:56:00, 0.0100\\n\"\n \"KORD,19990127, 21:00:00, 20:56:00, -0.5900\\n\"\n \"KORD,19990127, 21:00:00, 21:18:00, -0.9900\\n\"\n \"KORD,19990127, 22:00:00, 21:56:00, -0.5900\\n\"\n \"KORD,19990127, 23:00:00, 22:56:00, -0.5900\")\n parse_dates = {\"actual\": [1, 2], \"nominal\": [1, 3]}\n parser = all_parsers\n\n result = parser.read_csv(StringIO(data), header=None,\n date_parser=conv.parse_date_time,\n parse_dates=parse_dates, prefix=\"X\")\n expected = DataFrame([\n [datetime(1999, 1, 27, 19, 0), datetime(1999, 1, 27, 18, 56),\n \"KORD\", 0.81],\n [datetime(1999, 1, 27, 20, 0), datetime(1999, 1, 27, 19, 56),\n \"KORD\", 0.01],\n [datetime(1999, 1, 27, 21, 0), datetime(1999, 1, 27, 20, 56),\n \"KORD\", -0.59],\n [datetime(1999, 1, 27, 21, 0), datetime(1999, 1, 27, 21, 18),\n \"KORD\", -0.99],\n [datetime(1999, 1, 27, 22, 0), datetime(1999, 1, 27, 21, 56),\n \"KORD\", -0.59],\n [datetime(1999, 1, 27, 23, 0), datetime(1999, 1, 27, 22, 56),\n \"KORD\", -0.59],\n ], columns=[\"actual\", \"nominal\", \"X0\", \"X4\"])\n\n # Python can sometimes be flaky about how\n # the aggregated columns are entered, so\n # this standardizes the order.\n result = result[expected.columns]\n tm.assert_frame_equal(result, expected)\n\n\ndef test_multiple_date_col_timestamp_parse(all_parsers):\n parser = all_parsers\n data = \"\"\"05/31/2012,15:30:00.029,1306.25,1,E,0,,1306.25\n05/31/2012,15:30:00.029,1306.25,8,E,0,,1306.25\"\"\"\n\n result = parser.read_csv(StringIO(data), parse_dates=[[0, 1]],\n header=None, date_parser=Timestamp)\n expected = DataFrame([\n [Timestamp(\"05/31/2012, 15:30:00.029\"),\n 1306.25, 1, \"E\", 0, np.nan, 1306.25],\n [Timestamp(\"05/31/2012, 15:30:00.029\"),\n 1306.25, 8, \"E\", 0, np.nan, 1306.25]\n ], columns=[\"0_1\", 2, 3, 4, 5, 6, 7])\n tm.assert_frame_equal(result, expected)\n\n\ndef test_multiple_date_cols_with_header(all_parsers):\n parser = all_parsers\n data = \"\"\"\\\nID,date,NominalTime,ActualTime,TDew,TAir,Windspeed,Precip,WindDir\nKORD,19990127, 19:00:00, 18:56:00, 0.8100, 2.8100, 7.2000, 0.0000, 280.0000\nKORD,19990127, 20:00:00, 19:56:00, 0.0100, 2.2100, 7.2000, 0.0000, 260.0000\nKORD,19990127, 21:00:00, 20:56:00, -0.5900, 2.2100, 5.7000, 0.0000, 280.0000\nKORD,19990127, 21:00:00, 21:18:00, -0.9900, 2.0100, 3.6000, 0.0000, 270.0000\nKORD,19990127, 22:00:00, 21:56:00, -0.5900, 1.7100, 5.1000, 0.0000, 290.0000\nKORD,19990127, 23:00:00, 22:56:00, -0.5900, 1.7100, 4.6000, 0.0000, 280.0000\"\"\"\n\n result = parser.read_csv(StringIO(data), parse_dates={\"nominal\": [1, 2]})\n expected = DataFrame([\n [datetime(1999, 1, 27, 19, 0), \"KORD\", \" 18:56:00\",\n 0.81, 2.81, 7.2, 0.0, 280.0],\n [datetime(1999, 1, 27, 20, 0), \"KORD\", \" 19:56:00\",\n 0.01, 2.21, 7.2, 0.0, 260.0],\n [datetime(1999, 1, 27, 21, 0), \"KORD\", \" 20:56:00\",\n -0.59, 2.21, 5.7, 0.0, 280.0],\n [datetime(1999, 1, 27, 21, 0), \"KORD\", \" 21:18:00\",\n -0.99, 2.01, 3.6, 0.0, 270.0],\n [datetime(1999, 1, 27, 22, 0), \"KORD\", \" 21:56:00\",\n -0.59, 1.71, 5.1, 0.0, 290.0],\n [datetime(1999, 1, 27, 23, 0), \"KORD\", \" 22:56:00\",\n -0.59, 1.71, 4.6, 0.0, 280.0],\n ], columns=[\"nominal\", \"ID\", \"ActualTime\", \"TDew\",\n \"TAir\", \"Windspeed\", \"Precip\", \"WindDir\"])\n tm.assert_frame_equal(result, expected)\n\n\[email protected](\"data,parse_dates,msg\", [\n (\"\"\"\\\ndate_NominalTime,date,NominalTime\nKORD1,19990127, 19:00:00\nKORD2,19990127, 20:00:00\"\"\", [[1, 2]], (\"New date column already \"\n \"in dict date_NominalTime\")),\n (\"\"\"\\\nID,date,nominalTime\nKORD,19990127, 19:00:00\nKORD,19990127, 20:00:00\"\"\", dict(ID=[1, 2]), \"Date column ID already in dict\")\n])\ndef test_multiple_date_col_name_collision(all_parsers, data, parse_dates, msg):\n parser = all_parsers\n\n with pytest.raises(ValueError, match=msg):\n parser.read_csv(StringIO(data), parse_dates=parse_dates)\n\n\ndef test_date_parser_int_bug(all_parsers):\n # see gh-3071\n parser = all_parsers\n data = (\"posix_timestamp,elapsed,sys,user,queries,query_time,rows,\"\n \"accountid,userid,contactid,level,silo,method\\n\"\n \"1343103150,0.062353,0,4,6,0.01690,3,\"\n \"12345,1,-1,3,invoice_InvoiceResource,search\\n\")\n\n result = parser.read_csv(\n StringIO(data), index_col=0, parse_dates=[0],\n date_parser=lambda x: datetime.utcfromtimestamp(int(x)))\n expected = DataFrame([[0.062353, 0, 4, 6, 0.01690, 3, 12345, 1, -1,\n 3, \"invoice_InvoiceResource\", \"search\"]],\n columns=[\"elapsed\", \"sys\", \"user\", \"queries\",\n \"query_time\", \"rows\", \"accountid\",\n \"userid\", \"contactid\", \"level\",\n \"silo\", \"method\"],\n index=Index([Timestamp(\"2012-07-24 04:12:30\")],\n name=\"posix_timestamp\"))\n tm.assert_frame_equal(result, expected)\n\n\ndef test_nat_parse(all_parsers):\n # see gh-3062\n parser = all_parsers\n df = DataFrame(dict({\"A\": np.asarray(lrange(10), dtype=\"float64\"),\n \"B\": pd.Timestamp(\"20010101\")}))\n df.iloc[3:6, :] = np.nan\n\n with tm.ensure_clean(\"__nat_parse_.csv\") as path:\n df.to_csv(path)\n\n result = parser.read_csv(path, index_col=0, parse_dates=[\"B\"])\n tm.assert_frame_equal(result, df)\n\n\ndef test_csv_custom_parser(all_parsers):\n data = \"\"\"A,B,C\n20090101,a,1,2\n20090102,b,3,4\n20090103,c,4,5\n\"\"\"\n parser = all_parsers\n result = parser.read_csv(\n StringIO(data),\n date_parser=lambda x: datetime.strptime(x, \"%Y%m%d\"))\n expected = parser.read_csv(StringIO(data), parse_dates=True)\n tm.assert_frame_equal(result, expected)\n\n\ndef test_parse_dates_implicit_first_col(all_parsers):\n data = \"\"\"A,B,C\n20090101,a,1,2\n20090102,b,3,4\n20090103,c,4,5\n\"\"\"\n parser = all_parsers\n result = parser.read_csv(StringIO(data), parse_dates=True)\n\n expected = parser.read_csv(StringIO(data), index_col=0,\n parse_dates=True)\n tm.assert_frame_equal(result, expected)\n\n\ndef test_parse_dates_string(all_parsers):\n data = \"\"\"date,A,B,C\n20090101,a,1,2\n20090102,b,3,4\n20090103,c,4,5\n\"\"\"\n parser = all_parsers\n result = parser.read_csv(StringIO(data), index_col=\"date\",\n parse_dates=[\"date\"])\n index = date_range(\"1/1/2009\", periods=3)\n index.name = \"date\"\n\n expected = DataFrame({\"A\": [\"a\", \"b\", \"c\"], \"B\": [1, 3, 4],\n \"C\": [2, 4, 5]}, index=index)\n tm.assert_frame_equal(result, expected)\n\n\n# Bug in https://github.com/dateutil/dateutil/issues/217\n# has been addressed, but we just don't pass in the `yearfirst`\[email protected](reason=\"yearfirst is not surfaced in read_*\")\[email protected](\"parse_dates\", [\n [[\"date\", \"time\"]],\n [[0, 1]]\n])\ndef test_yy_format_with_year_first(all_parsers, parse_dates):\n data = \"\"\"date,time,B,C\n090131,0010,1,2\n090228,1020,3,4\n090331,0830,5,6\n\"\"\"\n parser = all_parsers\n result = parser.read_csv(StringIO(data), index_col=0,\n parse_dates=parse_dates)\n index = DatetimeIndex([datetime(2009, 1, 31, 0, 10, 0),\n datetime(2009, 2, 28, 10, 20, 0),\n datetime(2009, 3, 31, 8, 30, 0)],\n dtype=object, name=\"date_time\")\n expected = DataFrame({\"B\": [1, 3, 5], \"C\": [2, 4, 6]}, index=index)\n tm.assert_frame_equal(result, expected)\n\n\[email protected](\"parse_dates\", [[0, 2], [\"a\", \"c\"]])\ndef test_parse_dates_column_list(all_parsers, parse_dates):\n data = \"a,b,c\\n01/01/2010,1,15/02/2010\"\n parser = all_parsers\n\n expected = DataFrame({\"a\": [datetime(2010, 1, 1)], \"b\": [1],\n \"c\": [datetime(2010, 2, 15)]})\n expected = expected.set_index([\"a\", \"b\"])\n\n result = parser.read_csv(StringIO(data), index_col=[0, 1],\n parse_dates=parse_dates, dayfirst=True)\n tm.assert_frame_equal(result, expected)\n\n\[email protected](\"index_col\", [[0, 1], [1, 0]])\ndef test_multi_index_parse_dates(all_parsers, index_col):\n data = \"\"\"index1,index2,A,B,C\n20090101,one,a,1,2\n20090101,two,b,3,4\n20090101,three,c,4,5\n20090102,one,a,1,2\n20090102,two,b,3,4\n20090102,three,c,4,5\n20090103,one,a,1,2\n20090103,two,b,3,4\n20090103,three,c,4,5\n\"\"\"\n parser = all_parsers\n index = MultiIndex.from_product([\n (datetime(2009, 1, 1), datetime(2009, 1, 2),\n datetime(2009, 1, 3)), (\"one\", \"two\", \"three\")],\n names=[\"index1\", \"index2\"])\n\n # Out of order.\n if index_col == [1, 0]:\n index = index.swaplevel(0, 1)\n\n expected = DataFrame([[\"a\", 1, 2], [\"b\", 3, 4], [\"c\", 4, 5],\n [\"a\", 1, 2], [\"b\", 3, 4], [\"c\", 4, 5],\n [\"a\", 1, 2], [\"b\", 3, 4], [\"c\", 4, 5]],\n columns=[\"A\", \"B\", \"C\"], index=index)\n result = parser.read_csv(StringIO(data), index_col=index_col,\n parse_dates=True)\n tm.assert_frame_equal(result, expected)\n\n\[email protected](\"kwargs\", [\n dict(dayfirst=True), dict(day_first=True)\n])\ndef test_parse_dates_custom_euro_format(all_parsers, kwargs):\n parser = all_parsers\n data = \"\"\"foo,bar,baz\n31/01/2010,1,2\n01/02/2010,1,NA\n02/02/2010,1,2\n\"\"\"\n if \"dayfirst\" in kwargs:\n df = parser.read_csv(StringIO(data), names=[\"time\", \"Q\", \"NTU\"],\n date_parser=lambda d: parse_date(d, **kwargs),\n header=0, index_col=0, parse_dates=True,\n na_values=[\"NA\"])\n exp_index = Index([datetime(2010, 1, 31), datetime(2010, 2, 1),\n datetime(2010, 2, 2)], name=\"time\")\n expected = DataFrame({\"Q\": [1, 1, 1], \"NTU\": [2, np.nan, 2]},\n index=exp_index, columns=[\"Q\", \"NTU\"])\n tm.assert_frame_equal(df, expected)\n else:\n msg = \"got an unexpected keyword argument 'day_first'\"\n with pytest.raises(TypeError, match=msg):\n parser.read_csv(StringIO(data), names=[\"time\", \"Q\", \"NTU\"],\n date_parser=lambda d: parse_date(d, **kwargs),\n skiprows=[0], index_col=0, parse_dates=True,\n na_values=[\"NA\"])\n\n\ndef test_parse_tz_aware(all_parsers):\n # See gh-1693\n parser = all_parsers\n data = \"Date,x\\n2012-06-13T01:39:00Z,0.5\"\n\n result = parser.read_csv(StringIO(data), index_col=0,\n parse_dates=True)\n expected = DataFrame({\"x\": [0.5]}, index=Index([Timestamp(\n \"2012-06-13 01:39:00+00:00\")], name=\"Date\"))\n tm.assert_frame_equal(result, expected)\n assert result.index.tz is pytz.utc\n\n\[email protected](\"parse_dates,index_col\", [\n ({\"nominal\": [1, 2]}, \"nominal\"),\n ({\"nominal\": [1, 2]}, 0),\n ([[1, 2]], 0),\n])\ndef test_multiple_date_cols_index(all_parsers, parse_dates, index_col):\n parser = all_parsers\n data = \"\"\"\nID,date,NominalTime,ActualTime,TDew,TAir,Windspeed,Precip,WindDir\nKORD1,19990127, 19:00:00, 18:56:00, 0.8100, 2.8100, 7.2000, 0.0000, 280.0000\nKORD2,19990127, 20:00:00, 19:56:00, 0.0100, 2.2100, 7.2000, 0.0000, 260.0000\nKORD3,19990127, 21:00:00, 20:56:00, -0.5900, 2.2100, 5.7000, 0.0000, 280.0000\nKORD4,19990127, 21:00:00, 21:18:00, -0.9900, 2.0100, 3.6000, 0.0000, 270.0000\nKORD5,19990127, 22:00:00, 21:56:00, -0.5900, 1.7100, 5.1000, 0.0000, 290.0000\nKORD6,19990127, 23:00:00, 22:56:00, -0.5900, 1.7100, 4.6000, 0.0000, 280.0000\n\"\"\"\n expected = DataFrame([\n [datetime(1999, 1, 27, 19, 0), \"KORD1\", \" 18:56:00\",\n 0.81, 2.81, 7.2, 0.0, 280.0],\n [datetime(1999, 1, 27, 20, 0), \"KORD2\", \" 19:56:00\",\n 0.01, 2.21, 7.2, 0.0, 260.0],\n [datetime(1999, 1, 27, 21, 0), \"KORD3\", \" 20:56:00\",\n -0.59, 2.21, 5.7, 0.0, 280.0],\n [datetime(1999, 1, 27, 21, 0), \"KORD4\", \" 21:18:00\",\n -0.99, 2.01, 3.6, 0.0, 270.0],\n [datetime(1999, 1, 27, 22, 0), \"KORD5\", \" 21:56:00\",\n -0.59, 1.71, 5.1, 0.0, 290.0],\n [datetime(1999, 1, 27, 23, 0), \"KORD6\", \" 22:56:00\",\n -0.59, 1.71, 4.6, 0.0, 280.0],\n ], columns=[\"nominal\", \"ID\", \"ActualTime\", \"TDew\",\n \"TAir\", \"Windspeed\", \"Precip\", \"WindDir\"])\n expected = expected.set_index(\"nominal\")\n\n if not isinstance(parse_dates, dict):\n expected.index.name = \"date_NominalTime\"\n\n result = parser.read_csv(StringIO(data), parse_dates=parse_dates,\n index_col=index_col)\n tm.assert_frame_equal(result, expected)\n\n\ndef test_multiple_date_cols_chunked(all_parsers):\n parser = all_parsers\n data = \"\"\"\\\nID,date,nominalTime,actualTime,A,B,C,D,E\nKORD,19990127, 19:00:00, 18:56:00, 0.8100, 2.8100, 7.2000, 0.0000, 280.0000\nKORD,19990127, 20:00:00, 19:56:00, 0.0100, 2.2100, 7.2000, 0.0000, 260.0000\nKORD,19990127, 21:00:00, 20:56:00, -0.5900, 2.2100, 5.7000, 0.0000, 280.0000\nKORD,19990127, 21:00:00, 21:18:00, -0.9900, 2.0100, 3.6000, 0.0000, 270.0000\nKORD,19990127, 22:00:00, 21:56:00, -0.5900, 1.7100, 5.1000, 0.0000, 290.0000\nKORD,19990127, 23:00:00, 22:56:00, -0.5900, 1.7100, 4.6000, 0.0000, 280.0000\n\"\"\"\n\n expected = DataFrame([\n [datetime(1999, 1, 27, 19, 0), \"KORD\", \" 18:56:00\",\n 0.81, 2.81, 7.2, 0.0, 280.0],\n [datetime(1999, 1, 27, 20, 0), \"KORD\", \" 19:56:00\",\n 0.01, 2.21, 7.2, 0.0, 260.0],\n [datetime(1999, 1, 27, 21, 0), \"KORD\", \" 20:56:00\",\n -0.59, 2.21, 5.7, 0.0, 280.0],\n [datetime(1999, 1, 27, 21, 0), \"KORD\", \" 21:18:00\",\n -0.99, 2.01, 3.6, 0.0, 270.0],\n [datetime(1999, 1, 27, 22, 0), \"KORD\", \" 21:56:00\",\n -0.59, 1.71, 5.1, 0.0, 290.0],\n [datetime(1999, 1, 27, 23, 0), \"KORD\", \" 22:56:00\",\n -0.59, 1.71, 4.6, 0.0, 280.0],\n ], columns=[\"nominal\", \"ID\", \"actualTime\", \"A\", \"B\", \"C\", \"D\", \"E\"])\n expected = expected.set_index(\"nominal\")\n\n reader = parser.read_csv(StringIO(data), parse_dates={\"nominal\": [1, 2]},\n index_col=\"nominal\", chunksize=2)\n chunks = list(reader)\n\n tm.assert_frame_equal(chunks[0], expected[:2])\n tm.assert_frame_equal(chunks[1], expected[2:4])\n tm.assert_frame_equal(chunks[2], expected[4:])\n\n\ndef test_multiple_date_col_named_index_compat(all_parsers):\n parser = all_parsers\n data = \"\"\"\\\nID,date,nominalTime,actualTime,A,B,C,D,E\nKORD,19990127, 19:00:00, 18:56:00, 0.8100, 2.8100, 7.2000, 0.0000, 280.0000\nKORD,19990127, 20:00:00, 19:56:00, 0.0100, 2.2100, 7.2000, 0.0000, 260.0000\nKORD,19990127, 21:00:00, 20:56:00, -0.5900, 2.2100, 5.7000, 0.0000, 280.0000\nKORD,19990127, 21:00:00, 21:18:00, -0.9900, 2.0100, 3.6000, 0.0000, 270.0000\nKORD,19990127, 22:00:00, 21:56:00, -0.5900, 1.7100, 5.1000, 0.0000, 290.0000\nKORD,19990127, 23:00:00, 22:56:00, -0.5900, 1.7100, 4.6000, 0.0000, 280.0000\n\"\"\"\n\n with_indices = parser.read_csv(StringIO(data),\n parse_dates={\"nominal\": [1, 2]},\n index_col=\"nominal\")\n with_names = parser.read_csv(StringIO(data), index_col=\"nominal\",\n parse_dates={\"nominal\": [\n \"date\", \"nominalTime\"]})\n tm.assert_frame_equal(with_indices, with_names)\n\n\ndef test_multiple_date_col_multiple_index_compat(all_parsers):\n parser = all_parsers\n data = \"\"\"\\\nID,date,nominalTime,actualTime,A,B,C,D,E\nKORD,19990127, 19:00:00, 18:56:00, 0.8100, 2.8100, 7.2000, 0.0000, 280.0000\nKORD,19990127, 20:00:00, 19:56:00, 0.0100, 2.2100, 7.2000, 0.0000, 260.0000\nKORD,19990127, 21:00:00, 20:56:00, -0.5900, 2.2100, 5.7000, 0.0000, 280.0000\nKORD,19990127, 21:00:00, 21:18:00, -0.9900, 2.0100, 3.6000, 0.0000, 270.0000\nKORD,19990127, 22:00:00, 21:56:00, -0.5900, 1.7100, 5.1000, 0.0000, 290.0000\nKORD,19990127, 23:00:00, 22:56:00, -0.5900, 1.7100, 4.6000, 0.0000, 280.0000\n\"\"\"\n result = parser.read_csv(StringIO(data), index_col=[\"nominal\", \"ID\"],\n parse_dates={\"nominal\": [1, 2]})\n expected = parser.read_csv(StringIO(data),\n parse_dates={\"nominal\": [1, 2]})\n\n expected = expected.set_index([\"nominal\", \"ID\"])\n tm.assert_frame_equal(result, expected)\n\n\[email protected](\"kwargs\", [dict(), dict(index_col=\"C\")])\ndef test_read_with_parse_dates_scalar_non_bool(all_parsers, kwargs):\n # see gh-5636\n parser = all_parsers\n msg = (\"Only booleans, lists, and dictionaries \"\n \"are accepted for the 'parse_dates' parameter\")\n data = \"\"\"A,B,C\n 1,2,2003-11-1\"\"\"\n\n with pytest.raises(TypeError, match=msg):\n parser.read_csv(StringIO(data), parse_dates=\"C\", **kwargs)\n\n\[email protected](\"parse_dates\", [\n (1,), np.array([4, 5]), {1, 3, 3}\n])\ndef test_read_with_parse_dates_invalid_type(all_parsers, parse_dates):\n parser = all_parsers\n msg = (\"Only booleans, lists, and dictionaries \"\n \"are accepted for the 'parse_dates' parameter\")\n data = \"\"\"A,B,C\n 1,2,2003-11-1\"\"\"\n\n with pytest.raises(TypeError, match=msg):\n parser.read_csv(StringIO(data), parse_dates=(1,))\n\n\ndef test_parse_dates_empty_string(all_parsers):\n # see gh-2263\n parser = all_parsers\n data = \"Date,test\\n2012-01-01,1\\n,2\"\n result = parser.read_csv(StringIO(data), parse_dates=[\"Date\"],\n na_filter=False)\n\n expected = DataFrame([[datetime(2012, 1, 1), 1], [pd.NaT, 2]],\n columns=[\"Date\", \"test\"])\n tm.assert_frame_equal(result, expected)\n\n\[email protected](\"data,kwargs,expected\", [\n (\"a\\n04.15.2016\", dict(parse_dates=[\"a\"]),\n DataFrame([datetime(2016, 4, 15)], columns=[\"a\"])),\n (\"a\\n04.15.2016\", dict(parse_dates=True, index_col=0),\n DataFrame(index=DatetimeIndex([\"2016-04-15\"], name=\"a\"))),\n (\"a,b\\n04.15.2016,09.16.2013\", dict(parse_dates=[\"a\", \"b\"]),\n DataFrame([[datetime(2016, 4, 15), datetime(2013, 9, 16)]],\n columns=[\"a\", \"b\"])),\n (\"a,b\\n04.15.2016,09.16.2013\", dict(parse_dates=True, index_col=[0, 1]),\n DataFrame(index=MultiIndex.from_tuples(\n [(datetime(2016, 4, 15), datetime(2013, 9, 16))], names=[\"a\", \"b\"]))),\n])\ndef test_parse_dates_no_convert_thousands(all_parsers, data, kwargs, expected):\n # see gh-14066\n parser = all_parsers\n\n result = parser.read_csv(StringIO(data), thousands=\".\", **kwargs)\n tm.assert_frame_equal(result, expected)\n\n\ndef test_parse_date_time_multi_level_column_name(all_parsers):\n data = \"\"\"\\\nD,T,A,B\ndate, time,a,b\n2001-01-05, 09:00:00, 0.0, 10.\n2001-01-06, 00:00:00, 1.0, 11.\n\"\"\"\n parser = all_parsers\n result = parser.read_csv(StringIO(data), header=[0, 1],\n parse_dates={\"date_time\": [0, 1]},\n date_parser=conv.parse_date_time)\n\n expected_data = [[datetime(2001, 1, 5, 9, 0, 0), 0., 10.],\n [datetime(2001, 1, 6, 0, 0, 0), 1., 11.]]\n expected = DataFrame(expected_data,\n columns=[\"date_time\", (\"A\", \"a\"), (\"B\", \"b\")])\n tm.assert_frame_equal(result, expected)\n\n\[email protected](\"data,kwargs,expected\", [\n (\"\"\"\\\ndate,time,a,b\n2001-01-05, 10:00:00, 0.0, 10.\n2001-01-05, 00:00:00, 1., 11.\n\"\"\", dict(header=0, parse_dates={\"date_time\": [0, 1]}),\n DataFrame([[datetime(2001, 1, 5, 10, 0, 0), 0.0, 10],\n [datetime(2001, 1, 5, 0, 0, 0), 1.0, 11.0]],\n columns=[\"date_time\", \"a\", \"b\"])),\n ((\"KORD,19990127, 19:00:00, 18:56:00, 0.8100\\n\"\n \"KORD,19990127, 20:00:00, 19:56:00, 0.0100\\n\"\n \"KORD,19990127, 21:00:00, 20:56:00, -0.5900\\n\"\n \"KORD,19990127, 21:00:00, 21:18:00, -0.9900\\n\"\n \"KORD,19990127, 22:00:00, 21:56:00, -0.5900\\n\"\n \"KORD,19990127, 23:00:00, 22:56:00, -0.5900\"),\n dict(header=None, parse_dates={\"actual\": [1, 2], \"nominal\": [1, 3]}),\n DataFrame([\n [datetime(1999, 1, 27, 19, 0), datetime(1999, 1, 27, 18, 56),\n \"KORD\", 0.81],\n [datetime(1999, 1, 27, 20, 0), datetime(1999, 1, 27, 19, 56),\n \"KORD\", 0.01],\n [datetime(1999, 1, 27, 21, 0), datetime(1999, 1, 27, 20, 56),\n \"KORD\", -0.59],\n [datetime(1999, 1, 27, 21, 0), datetime(1999, 1, 27, 21, 18),\n \"KORD\", -0.99],\n [datetime(1999, 1, 27, 22, 0), datetime(1999, 1, 27, 21, 56),\n \"KORD\", -0.59],\n [datetime(1999, 1, 27, 23, 0), datetime(1999, 1, 27, 22, 56),\n \"KORD\", -0.59]], columns=[\"actual\", \"nominal\", 0, 4])),\n])\ndef test_parse_date_time(all_parsers, data, kwargs, expected):\n parser = all_parsers\n result = parser.read_csv(StringIO(data), date_parser=conv.parse_date_time,\n **kwargs)\n\n # Python can sometimes be flaky about how\n # the aggregated columns are entered, so\n # this standardizes the order.\n result = result[expected.columns]\n tm.assert_frame_equal(result, expected)\n\n\ndef test_parse_date_fields(all_parsers):\n parser = all_parsers\n data = (\"year,month,day,a\\n2001,01,10,10.\\n\"\n \"2001,02,1,11.\")\n result = parser.read_csv(StringIO(data), header=0,\n parse_dates={\"ymd\": [0, 1, 2]},\n date_parser=conv.parse_date_fields)\n\n expected = DataFrame([[datetime(2001, 1, 10), 10.],\n [datetime(2001, 2, 1), 11.]], columns=[\"ymd\", \"a\"])\n tm.assert_frame_equal(result, expected)\n\n\ndef test_parse_date_all_fields(all_parsers):\n parser = all_parsers\n data = \"\"\"\\\nyear,month,day,hour,minute,second,a,b\n2001,01,05,10,00,0,0.0,10.\n2001,01,5,10,0,00,1.,11.\n\"\"\"\n result = parser.read_csv(StringIO(data), header=0,\n date_parser=conv.parse_all_fields,\n parse_dates={\"ymdHMS\": [0, 1, 2, 3, 4, 5]})\n expected = DataFrame([[datetime(2001, 1, 5, 10, 0, 0), 0.0, 10.0],\n [datetime(2001, 1, 5, 10, 0, 0), 1.0, 11.0]],\n columns=[\"ymdHMS\", \"a\", \"b\"])\n tm.assert_frame_equal(result, expected)\n\n\ndef test_datetime_fractional_seconds(all_parsers):\n parser = all_parsers\n data = \"\"\"\\\nyear,month,day,hour,minute,second,a,b\n2001,01,05,10,00,0.123456,0.0,10.\n2001,01,5,10,0,0.500000,1.,11.\n\"\"\"\n result = parser.read_csv(StringIO(data), header=0,\n date_parser=conv.parse_all_fields,\n parse_dates={\"ymdHMS\": [0, 1, 2, 3, 4, 5]})\n expected = DataFrame([[datetime(2001, 1, 5, 10, 0, 0,\n microsecond=123456), 0.0, 10.0],\n [datetime(2001, 1, 5, 10, 0, 0,\n microsecond=500000), 1.0, 11.0]],\n columns=[\"ymdHMS\", \"a\", \"b\"])\n tm.assert_frame_equal(result, expected)\n\n\ndef test_generic(all_parsers):\n parser = all_parsers\n data = \"year,month,day,a\\n2001,01,10,10.\\n2001,02,1,11.\"\n\n result = parser.read_csv(StringIO(data), header=0,\n parse_dates={\"ym\": [0, 1]},\n date_parser=lambda y, m: date(year=int(y),\n month=int(m),\n day=1))\n expected = DataFrame([[date(2001, 1, 1), 10, 10.],\n [date(2001, 2, 1), 1, 11.]],\n columns=[\"ym\", \"day\", \"a\"])\n tm.assert_frame_equal(result, expected)\n\n\ndef test_date_parser_resolution_if_not_ns(all_parsers):\n # see gh-10245\n parser = all_parsers\n data = \"\"\"\\\ndate,time,prn,rxstatus\n2013-11-03,19:00:00,126,00E80000\n2013-11-03,19:00:00,23,00E80000\n2013-11-03,19:00:00,13,00E80000\n\"\"\"\n\n def date_parser(dt, time):\n return np_array_datetime64_compat(dt + \"T\" + time + \"Z\",\n dtype=\"datetime64[s]\")\n\n result = parser.read_csv(StringIO(data), date_parser=date_parser,\n parse_dates={\"datetime\": [\"date\", \"time\"]},\n index_col=[\"datetime\", \"prn\"])\n\n datetimes = np_array_datetime64_compat([\"2013-11-03T19:00:00Z\"] * 3,\n dtype=\"datetime64[s]\")\n expected = DataFrame(data={\"rxstatus\": [\"00E80000\"] * 3},\n index=MultiIndex.from_tuples(\n [(datetimes[0], 126), (datetimes[1], 23),\n (datetimes[2], 13)], names=[\"datetime\", \"prn\"]))\n tm.assert_frame_equal(result, expected)\n\n\ndef test_parse_date_column_with_empty_string(all_parsers):\n # see gh-6428\n parser = all_parsers\n data = \"case,opdate\\n7,10/18/2006\\n7,10/18/2008\\n621, \"\n result = parser.read_csv(StringIO(data), parse_dates=[\"opdate\"])\n\n expected_data = [[7, \"10/18/2006\"],\n [7, \"10/18/2008\"],\n [621, \" \"]]\n expected = DataFrame(expected_data, columns=[\"case\", \"opdate\"])\n tm.assert_frame_equal(result, expected)\n\n\[email protected](\"data,expected\", [\n (\"a\\n135217135789158401\\n1352171357E+5\",\n DataFrame({\"a\": [135217135789158401,\n 135217135700000]}, dtype=\"float64\")),\n (\"a\\n99999999999\\n123456789012345\\n1234E+0\",\n DataFrame({\"a\": [99999999999,\n 123456789012345,\n 1234]}, dtype=\"float64\"))\n])\[email protected](\"parse_dates\", [True, False])\ndef test_parse_date_float(all_parsers, data, expected, parse_dates):\n # see gh-2697\n #\n # Date parsing should fail, so we leave the data untouched\n # (i.e. float precision should remain unchanged).\n parser = all_parsers\n\n result = parser.read_csv(StringIO(data), parse_dates=parse_dates)\n tm.assert_frame_equal(result, expected)\n\n\ndef test_parse_timezone(all_parsers):\n # see gh-22256\n parser = all_parsers\n data = \"\"\"dt,val\n 2018-01-04 09:01:00+09:00,23350\n 2018-01-04 09:02:00+09:00,23400\n 2018-01-04 09:03:00+09:00,23400\n 2018-01-04 09:04:00+09:00,23400\n 2018-01-04 09:05:00+09:00,23400\"\"\"\n result = parser.read_csv(StringIO(data), parse_dates=[\"dt\"])\n\n dti = pd.date_range(start=\"2018-01-04 09:01:00\",\n end=\"2018-01-04 09:05:00\", freq=\"1min\",\n tz=pytz.FixedOffset(540))\n expected_data = {\"dt\": dti, \"val\": [23350, 23400, 23400, 23400, 23400]}\n\n expected = DataFrame(expected_data)\n tm.assert_frame_equal(result, expected)\n",
"from contextlib import contextmanager\nimport datetime\nfrom datetime import timedelta\nfrom distutils.version import LooseVersion\nfrom io import BytesIO\nimport os\nimport tempfile\nfrom warnings import catch_warnings, simplefilter\n\nimport numpy as np\nimport pytest\n\nfrom pandas.compat import (\n PY35, PY36, is_platform_little_endian, is_platform_windows, lrange)\nimport pandas.util._test_decorators as td\n\nfrom pandas.core.dtypes.common import is_categorical_dtype\n\nimport pandas as pd\nfrom pandas import (\n Categorical, DataFrame, DatetimeIndex, Index, Int64Index, MultiIndex,\n RangeIndex, Series, Timestamp, bdate_range, concat, date_range, isna,\n timedelta_range)\nimport pandas.util.testing as tm\nfrom pandas.util.testing import (\n assert_frame_equal, assert_series_equal, set_timezone)\n\nfrom pandas.io import pytables as pytables # noqa:E402\nfrom pandas.io.formats.printing import pprint_thing\nfrom pandas.io.pytables import (\n ClosedFileError, HDFStore, PossibleDataLossError, Term, read_hdf)\nfrom pandas.io.pytables import TableIterator # noqa:E402\n\ntables = pytest.importorskip('tables')\n\n\n# TODO:\n# remove when gh-24839 is fixed; this affects numpy 1.16\n# and pytables 3.4.4\nxfail_non_writeable = pytest.mark.xfail(\n LooseVersion(np.__version__) >= LooseVersion('1.16') and\n LooseVersion(tables.__version__) < LooseVersion('3.5.1'),\n reason=('gh-25511, gh-24839. pytables needs a '\n 'release beyong 3.4.4 to support numpy 1.16x'))\n\n\n_default_compressor = ('blosc' if LooseVersion(tables.__version__) >=\n LooseVersion('2.2') else 'zlib')\n\n\nignore_natural_naming_warning = pytest.mark.filterwarnings(\n \"ignore:object name:tables.exceptions.NaturalNameWarning\"\n)\n\n# contextmanager to ensure the file cleanup\n\n\ndef safe_remove(path):\n if path is not None:\n try:\n os.remove(path)\n except OSError:\n pass\n\n\ndef safe_close(store):\n try:\n if store is not None:\n store.close()\n except IOError:\n pass\n\n\ndef create_tempfile(path):\n \"\"\" create an unopened named temporary file \"\"\"\n return os.path.join(tempfile.gettempdir(), path)\n\n\n@contextmanager\ndef ensure_clean_store(path, mode='a', complevel=None, complib=None,\n fletcher32=False):\n\n try:\n\n # put in the temporary path if we don't have one already\n if not len(os.path.dirname(path)):\n path = create_tempfile(path)\n\n store = HDFStore(path, mode=mode, complevel=complevel,\n complib=complib, fletcher32=False)\n yield store\n finally:\n safe_close(store)\n if mode == 'w' or mode == 'a':\n safe_remove(path)\n\n\n@contextmanager\ndef ensure_clean_path(path):\n \"\"\"\n return essentially a named temporary file that is not opened\n and deleted on existing; if path is a list, then create and\n return list of filenames\n \"\"\"\n try:\n if isinstance(path, list):\n filenames = [create_tempfile(p) for p in path]\n yield filenames\n else:\n filenames = [create_tempfile(path)]\n yield filenames[0]\n finally:\n for f in filenames:\n safe_remove(f)\n\n\n# set these parameters so we don't have file sharing\ntables.parameters.MAX_NUMEXPR_THREADS = 1\ntables.parameters.MAX_BLOSC_THREADS = 1\ntables.parameters.MAX_THREADS = 1\n\n\ndef _maybe_remove(store, key):\n \"\"\"For tests using tables, try removing the table to be sure there is\n no content from previous tests using the same table name.\"\"\"\n try:\n store.remove(key)\n except (ValueError, KeyError):\n pass\n\n\nclass Base(object):\n\n @classmethod\n def setup_class(cls):\n\n # Pytables 3.0.0 deprecates lots of things\n tm.reset_testing_mode()\n\n @classmethod\n def teardown_class(cls):\n\n # Pytables 3.0.0 deprecates lots of things\n tm.set_testing_mode()\n\n def setup_method(self, method):\n self.path = 'tmp.__%s__.h5' % tm.rands(10)\n\n def teardown_method(self, method):\n pass\n\n\[email protected]\nclass TestHDFStore(Base):\n\n def test_format_kwarg_in_constructor(self):\n # GH 13291\n with ensure_clean_path(self.path) as path:\n with pytest.raises(ValueError):\n HDFStore(path, format=\"table\")\n\n def test_context(self):\n path = create_tempfile(self.path)\n try:\n with HDFStore(path) as tbl:\n raise ValueError('blah')\n except ValueError:\n pass\n finally:\n safe_remove(path)\n\n try:\n with HDFStore(path) as tbl:\n tbl['a'] = tm.makeDataFrame()\n\n with HDFStore(path) as tbl:\n assert len(tbl) == 1\n assert type(tbl['a']) == DataFrame\n finally:\n safe_remove(path)\n\n def test_conv_read_write(self):\n path = create_tempfile(self.path)\n try:\n def roundtrip(key, obj, **kwargs):\n obj.to_hdf(path, key, **kwargs)\n return read_hdf(path, key)\n\n o = tm.makeTimeSeries()\n assert_series_equal(o, roundtrip('series', o))\n\n o = tm.makeStringSeries()\n assert_series_equal(o, roundtrip('string_series', o))\n\n o = tm.makeDataFrame()\n assert_frame_equal(o, roundtrip('frame', o))\n\n # table\n df = DataFrame(dict(A=lrange(5), B=lrange(5)))\n df.to_hdf(path, 'table', append=True)\n result = read_hdf(path, 'table', where=['index>2'])\n assert_frame_equal(df[df.index > 2], result)\n\n finally:\n safe_remove(path)\n\n def test_long_strings(self):\n\n # GH6166\n df = DataFrame({'a': tm.rands_array(100, size=10)},\n index=tm.rands_array(100, size=10))\n\n with ensure_clean_store(self.path) as store:\n store.append('df', df, data_columns=['a'])\n\n result = store.select('df')\n assert_frame_equal(df, result)\n\n def test_api(self):\n\n # GH4584\n # API issue when to_hdf doesn't acdept append AND format args\n with ensure_clean_path(self.path) as path:\n\n df = tm.makeDataFrame()\n df.iloc[:10].to_hdf(path, 'df', append=True, format='table')\n df.iloc[10:].to_hdf(path, 'df', append=True, format='table')\n assert_frame_equal(read_hdf(path, 'df'), df)\n\n # append to False\n df.iloc[:10].to_hdf(path, 'df', append=False, format='table')\n df.iloc[10:].to_hdf(path, 'df', append=True, format='table')\n assert_frame_equal(read_hdf(path, 'df'), df)\n\n with ensure_clean_path(self.path) as path:\n\n df = tm.makeDataFrame()\n df.iloc[:10].to_hdf(path, 'df', append=True)\n df.iloc[10:].to_hdf(path, 'df', append=True, format='table')\n assert_frame_equal(read_hdf(path, 'df'), df)\n\n # append to False\n df.iloc[:10].to_hdf(path, 'df', append=False, format='table')\n df.iloc[10:].to_hdf(path, 'df', append=True)\n assert_frame_equal(read_hdf(path, 'df'), df)\n\n with ensure_clean_path(self.path) as path:\n\n df = tm.makeDataFrame()\n df.to_hdf(path, 'df', append=False, format='fixed')\n assert_frame_equal(read_hdf(path, 'df'), df)\n\n df.to_hdf(path, 'df', append=False, format='f')\n assert_frame_equal(read_hdf(path, 'df'), df)\n\n df.to_hdf(path, 'df', append=False)\n assert_frame_equal(read_hdf(path, 'df'), df)\n\n df.to_hdf(path, 'df')\n assert_frame_equal(read_hdf(path, 'df'), df)\n\n with ensure_clean_store(self.path) as store:\n\n path = store._path\n df = tm.makeDataFrame()\n\n _maybe_remove(store, 'df')\n store.append('df', df.iloc[:10], append=True, format='table')\n store.append('df', df.iloc[10:], append=True, format='table')\n assert_frame_equal(store.select('df'), df)\n\n # append to False\n _maybe_remove(store, 'df')\n store.append('df', df.iloc[:10], append=False, format='table')\n store.append('df', df.iloc[10:], append=True, format='table')\n assert_frame_equal(store.select('df'), df)\n\n # formats\n _maybe_remove(store, 'df')\n store.append('df', df.iloc[:10], append=False, format='table')\n store.append('df', df.iloc[10:], append=True, format='table')\n assert_frame_equal(store.select('df'), df)\n\n _maybe_remove(store, 'df')\n store.append('df', df.iloc[:10], append=False, format='table')\n store.append('df', df.iloc[10:], append=True, format=None)\n assert_frame_equal(store.select('df'), df)\n\n with ensure_clean_path(self.path) as path:\n # Invalid.\n df = tm.makeDataFrame()\n\n with pytest.raises(ValueError):\n df.to_hdf(path, \"df\", append=True, format=\"f\")\n\n with pytest.raises(ValueError):\n df.to_hdf(path, \"df\", append=True, format=\"fixed\")\n\n with pytest.raises(TypeError):\n df.to_hdf(path, \"df\", append=True, format=\"foo\")\n\n with pytest.raises(TypeError):\n df.to_hdf(path, \"df\", append=False, format=\"bar\")\n\n # File path doesn't exist\n path = \"\"\n with pytest.raises(FileNotFoundError):\n read_hdf(path, \"df\")\n\n def test_api_default_format(self):\n\n # default_format option\n with ensure_clean_store(self.path) as store:\n df = tm.makeDataFrame()\n\n pd.set_option('io.hdf.default_format', 'fixed')\n _maybe_remove(store, 'df')\n store.put('df', df)\n assert not store.get_storer('df').is_table\n with pytest.raises(ValueError):\n store.append(\"df2\", df)\n\n pd.set_option('io.hdf.default_format', 'table')\n _maybe_remove(store, 'df')\n store.put('df', df)\n assert store.get_storer('df').is_table\n _maybe_remove(store, 'df2')\n store.append('df2', df)\n assert store.get_storer('df').is_table\n\n pd.set_option('io.hdf.default_format', None)\n\n with ensure_clean_path(self.path) as path:\n\n df = tm.makeDataFrame()\n\n pd.set_option('io.hdf.default_format', 'fixed')\n df.to_hdf(path, 'df')\n with HDFStore(path) as store:\n assert not store.get_storer('df').is_table\n with pytest.raises(ValueError):\n df.to_hdf(path, \"df2\", append=True)\n\n pd.set_option('io.hdf.default_format', 'table')\n df.to_hdf(path, 'df3')\n with HDFStore(path) as store:\n assert store.get_storer('df3').is_table\n df.to_hdf(path, 'df4', append=True)\n with HDFStore(path) as store:\n assert store.get_storer('df4').is_table\n\n pd.set_option('io.hdf.default_format', None)\n\n def test_keys(self):\n\n with ensure_clean_store(self.path) as store:\n store['a'] = tm.makeTimeSeries()\n store['b'] = tm.makeStringSeries()\n store['c'] = tm.makeDataFrame()\n\n assert len(store) == 3\n expected = {'/a', '/b', '/c'}\n assert set(store.keys()) == expected\n assert set(store) == expected\n\n def test_keys_ignore_hdf_softlink(self):\n\n # GH 20523\n # Puts a softlink into HDF file and rereads\n\n with ensure_clean_store(self.path) as store:\n\n df = DataFrame(dict(A=lrange(5), B=lrange(5)))\n store.put(\"df\", df)\n\n assert store.keys() == [\"/df\"]\n\n store._handle.create_soft_link(store._handle.root, \"symlink\", \"df\")\n\n # Should ignore the softlink\n assert store.keys() == [\"/df\"]\n\n def test_iter_empty(self):\n\n with ensure_clean_store(self.path) as store:\n # GH 12221\n assert list(store) == []\n\n def test_repr(self):\n\n with ensure_clean_store(self.path) as store:\n repr(store)\n store.info()\n store['a'] = tm.makeTimeSeries()\n store['b'] = tm.makeStringSeries()\n store['c'] = tm.makeDataFrame()\n\n df = tm.makeDataFrame()\n df['obj1'] = 'foo'\n df['obj2'] = 'bar'\n df['bool1'] = df['A'] > 0\n df['bool2'] = df['B'] > 0\n df['bool3'] = True\n df['int1'] = 1\n df['int2'] = 2\n df['timestamp1'] = Timestamp('20010102')\n df['timestamp2'] = Timestamp('20010103')\n df['datetime1'] = datetime.datetime(2001, 1, 2, 0, 0)\n df['datetime2'] = datetime.datetime(2001, 1, 3, 0, 0)\n df.loc[3:6, ['obj1']] = np.nan\n df = df._consolidate()._convert(datetime=True)\n\n with catch_warnings(record=True):\n simplefilter(\"ignore\", pd.errors.PerformanceWarning)\n store['df'] = df\n\n # make a random group in hdf space\n store._handle.create_group(store._handle.root, 'bah')\n\n assert store.filename in repr(store)\n assert store.filename in str(store)\n store.info()\n\n # storers\n with ensure_clean_store(self.path) as store:\n\n df = tm.makeDataFrame()\n store.append('df', df)\n\n s = store.get_storer('df')\n repr(s)\n str(s)\n\n @ignore_natural_naming_warning\n def test_contains(self):\n\n with ensure_clean_store(self.path) as store:\n store['a'] = tm.makeTimeSeries()\n store['b'] = tm.makeDataFrame()\n store['foo/bar'] = tm.makeDataFrame()\n assert 'a' in store\n assert 'b' in store\n assert 'c' not in store\n assert 'foo/bar' in store\n assert '/foo/bar' in store\n assert '/foo/b' not in store\n assert 'bar' not in store\n\n # gh-2694: tables.NaturalNameWarning\n with catch_warnings(record=True):\n store['node())'] = tm.makeDataFrame()\n assert 'node())' in store\n\n def test_versioning(self):\n\n with ensure_clean_store(self.path) as store:\n store['a'] = tm.makeTimeSeries()\n store['b'] = tm.makeDataFrame()\n df = tm.makeTimeDataFrame()\n _maybe_remove(store, 'df1')\n store.append('df1', df[:10])\n store.append('df1', df[10:])\n assert store.root.a._v_attrs.pandas_version == '0.15.2'\n assert store.root.b._v_attrs.pandas_version == '0.15.2'\n assert store.root.df1._v_attrs.pandas_version == '0.15.2'\n\n # write a file and wipe its versioning\n _maybe_remove(store, 'df2')\n store.append('df2', df)\n\n # this is an error because its table_type is appendable, but no\n # version info\n store.get_node('df2')._v_attrs.pandas_version = None\n with pytest.raises(Exception):\n store.select(\"df2\")\n\n def test_mode(self):\n\n df = tm.makeTimeDataFrame()\n\n def check(mode):\n\n with ensure_clean_path(self.path) as path:\n\n # constructor\n if mode in ['r', 'r+']:\n with pytest.raises(IOError):\n HDFStore(path, mode=mode)\n\n else:\n store = HDFStore(path, mode=mode)\n assert store._handle.mode == mode\n store.close()\n\n with ensure_clean_path(self.path) as path:\n\n # context\n if mode in ['r', 'r+']:\n with pytest.raises(IOError):\n with HDFStore(path, mode=mode) as store: # noqa\n pass\n else:\n with HDFStore(path, mode=mode) as store:\n assert store._handle.mode == mode\n\n with ensure_clean_path(self.path) as path:\n\n # conv write\n if mode in ['r', 'r+']:\n with pytest.raises(IOError):\n df.to_hdf(path, \"df\", mode=mode)\n df.to_hdf(path, 'df', mode='w')\n else:\n df.to_hdf(path, 'df', mode=mode)\n\n # conv read\n if mode in ['w']:\n with pytest.raises(ValueError):\n read_hdf(path, \"df\", mode=mode)\n else:\n result = read_hdf(path, 'df', mode=mode)\n assert_frame_equal(result, df)\n\n def check_default_mode():\n\n # read_hdf uses default mode\n with ensure_clean_path(self.path) as path:\n df.to_hdf(path, 'df', mode='w')\n result = read_hdf(path, 'df')\n assert_frame_equal(result, df)\n\n check('r')\n check('r+')\n check('a')\n check('w')\n check_default_mode()\n\n def test_reopen_handle(self):\n\n with ensure_clean_path(self.path) as path:\n\n store = HDFStore(path, mode='a')\n store['a'] = tm.makeTimeSeries()\n\n # invalid mode change\n with pytest.raises(PossibleDataLossError):\n store.open(\"w\")\n\n store.close()\n assert not store.is_open\n\n # truncation ok here\n store.open('w')\n assert store.is_open\n assert len(store) == 0\n store.close()\n assert not store.is_open\n\n store = HDFStore(path, mode='a')\n store['a'] = tm.makeTimeSeries()\n\n # reopen as read\n store.open('r')\n assert store.is_open\n assert len(store) == 1\n assert store._mode == 'r'\n store.close()\n assert not store.is_open\n\n # reopen as append\n store.open('a')\n assert store.is_open\n assert len(store) == 1\n assert store._mode == 'a'\n store.close()\n assert not store.is_open\n\n # reopen as append (again)\n store.open('a')\n assert store.is_open\n assert len(store) == 1\n assert store._mode == 'a'\n store.close()\n assert not store.is_open\n\n def test_open_args(self):\n\n with ensure_clean_path(self.path) as path:\n\n df = tm.makeDataFrame()\n\n # create an in memory store\n store = HDFStore(path, mode='a', driver='H5FD_CORE',\n driver_core_backing_store=0)\n store['df'] = df\n store.append('df2', df)\n\n tm.assert_frame_equal(store['df'], df)\n tm.assert_frame_equal(store['df2'], df)\n\n store.close()\n\n # the file should not have actually been written\n assert not os.path.exists(path)\n\n def test_flush(self):\n\n with ensure_clean_store(self.path) as store:\n store['a'] = tm.makeTimeSeries()\n store.flush()\n store.flush(fsync=True)\n\n def test_get(self):\n\n with ensure_clean_store(self.path) as store:\n store['a'] = tm.makeTimeSeries()\n left = store.get('a')\n right = store['a']\n tm.assert_series_equal(left, right)\n\n left = store.get('/a')\n right = store['/a']\n tm.assert_series_equal(left, right)\n\n with pytest.raises(KeyError):\n store.get(\"b\")\n\n @pytest.mark.parametrize('where, expected', [\n ('/', {\n '': ({'first_group', 'second_group'}, set()),\n '/first_group': (set(), {'df1', 'df2'}),\n '/second_group': ({'third_group'}, {'df3', 's1'}),\n '/second_group/third_group': (set(), {'df4'}),\n }),\n ('/second_group', {\n '/second_group': ({'third_group'}, {'df3', 's1'}),\n '/second_group/third_group': (set(), {'df4'}),\n })\n ])\n def test_walk(self, where, expected):\n # GH10143\n objs = {\n 'df1': pd.DataFrame([1, 2, 3]),\n 'df2': pd.DataFrame([4, 5, 6]),\n 'df3': pd.DataFrame([6, 7, 8]),\n 'df4': pd.DataFrame([9, 10, 11]),\n 's1': pd.Series([10, 9, 8]),\n # Next 3 items aren't pandas objects and should be ignored\n 'a1': np.array([[1, 2, 3], [4, 5, 6]]),\n 'tb1': np.array([(1, 2, 3), (4, 5, 6)], dtype='i,i,i'),\n 'tb2': np.array([(7, 8, 9), (10, 11, 12)], dtype='i,i,i')\n }\n\n with ensure_clean_store('walk_groups.hdf', mode='w') as store:\n store.put('/first_group/df1', objs['df1'])\n store.put('/first_group/df2', objs['df2'])\n store.put('/second_group/df3', objs['df3'])\n store.put('/second_group/s1', objs['s1'])\n store.put('/second_group/third_group/df4', objs['df4'])\n # Create non-pandas objects\n store._handle.create_array('/first_group', 'a1', objs['a1'])\n store._handle.create_table('/first_group', 'tb1', obj=objs['tb1'])\n store._handle.create_table('/second_group', 'tb2', obj=objs['tb2'])\n\n assert len(list(store.walk(where=where))) == len(expected)\n for path, groups, leaves in store.walk(where=where):\n assert path in expected\n expected_groups, expected_frames = expected[path]\n assert expected_groups == set(groups)\n assert expected_frames == set(leaves)\n for leaf in leaves:\n frame_path = '/'.join([path, leaf])\n obj = store.get(frame_path)\n if 'df' in leaf:\n tm.assert_frame_equal(obj, objs[leaf])\n else:\n tm.assert_series_equal(obj, objs[leaf])\n\n def test_getattr(self):\n\n with ensure_clean_store(self.path) as store:\n\n s = tm.makeTimeSeries()\n store['a'] = s\n\n # test attribute access\n result = store.a\n tm.assert_series_equal(result, s)\n result = getattr(store, 'a')\n tm.assert_series_equal(result, s)\n\n df = tm.makeTimeDataFrame()\n store['df'] = df\n result = store.df\n tm.assert_frame_equal(result, df)\n\n # errors\n for x in [\"d\", \"mode\", \"path\", \"handle\", \"complib\"]:\n with pytest.raises(AttributeError):\n getattr(store, x)\n\n # not stores\n for x in ['mode', 'path', 'handle', 'complib']:\n getattr(store, \"_%s\" % x)\n\n def test_put(self):\n\n with ensure_clean_store(self.path) as store:\n\n ts = tm.makeTimeSeries()\n df = tm.makeTimeDataFrame()\n store['a'] = ts\n store['b'] = df[:10]\n store['foo/bar/bah'] = df[:10]\n store['foo'] = df[:10]\n store['/foo'] = df[:10]\n store.put('c', df[:10], format='table')\n\n # not OK, not a table\n with pytest.raises(ValueError):\n store.put(\"b\", df[10:], append=True)\n\n # node does not currently exist, test _is_table_type returns False\n # in this case\n _maybe_remove(store, 'f')\n with pytest.raises(ValueError):\n store.put(\"f\", df[10:], append=True)\n\n # can't put to a table (use append instead)\n with pytest.raises(ValueError):\n store.put(\"c\", df[10:], append=True)\n\n # overwrite table\n store.put('c', df[:10], format='table', append=False)\n tm.assert_frame_equal(df[:10], store['c'])\n\n def test_put_string_index(self):\n\n with ensure_clean_store(self.path) as store:\n\n index = Index(\n [\"I am a very long string index: %s\" % i for i in range(20)])\n s = Series(np.arange(20), index=index)\n df = DataFrame({'A': s, 'B': s})\n\n store['a'] = s\n tm.assert_series_equal(store['a'], s)\n\n store['b'] = df\n tm.assert_frame_equal(store['b'], df)\n\n # mixed length\n index = Index(['abcdefghijklmnopqrstuvwxyz1234567890'] +\n [\"I am a very long string index: %s\" % i\n for i in range(20)])\n s = Series(np.arange(21), index=index)\n df = DataFrame({'A': s, 'B': s})\n store['a'] = s\n tm.assert_series_equal(store['a'], s)\n\n store['b'] = df\n tm.assert_frame_equal(store['b'], df)\n\n def test_put_compression(self):\n\n with ensure_clean_store(self.path) as store:\n df = tm.makeTimeDataFrame()\n\n store.put('c', df, format='table', complib='zlib')\n tm.assert_frame_equal(store['c'], df)\n\n # can't compress if format='fixed'\n with pytest.raises(ValueError):\n store.put(\"b\", df, format=\"fixed\", complib=\"zlib\")\n\n @td.skip_if_windows_python_3\n def test_put_compression_blosc(self):\n df = tm.makeTimeDataFrame()\n\n with ensure_clean_store(self.path) as store:\n\n # can't compress if format='fixed'\n with pytest.raises(ValueError):\n store.put('b', df, format='fixed', complib='blosc')\n\n store.put('c', df, format='table', complib='blosc')\n tm.assert_frame_equal(store['c'], df)\n\n def test_complibs_default_settings(self):\n # GH15943\n df = tm.makeDataFrame()\n\n # Set complevel and check if complib is automatically set to\n # default value\n with ensure_clean_path(self.path) as tmpfile:\n df.to_hdf(tmpfile, 'df', complevel=9)\n result = pd.read_hdf(tmpfile, 'df')\n tm.assert_frame_equal(result, df)\n\n with tables.open_file(tmpfile, mode='r') as h5file:\n for node in h5file.walk_nodes(where='/df', classname='Leaf'):\n assert node.filters.complevel == 9\n assert node.filters.complib == 'zlib'\n\n # Set complib and check to see if compression is disabled\n with ensure_clean_path(self.path) as tmpfile:\n df.to_hdf(tmpfile, 'df', complib='zlib')\n result = pd.read_hdf(tmpfile, 'df')\n tm.assert_frame_equal(result, df)\n\n with tables.open_file(tmpfile, mode='r') as h5file:\n for node in h5file.walk_nodes(where='/df', classname='Leaf'):\n assert node.filters.complevel == 0\n assert node.filters.complib is None\n\n # Check if not setting complib or complevel results in no compression\n with ensure_clean_path(self.path) as tmpfile:\n df.to_hdf(tmpfile, 'df')\n result = pd.read_hdf(tmpfile, 'df')\n tm.assert_frame_equal(result, df)\n\n with tables.open_file(tmpfile, mode='r') as h5file:\n for node in h5file.walk_nodes(where='/df', classname='Leaf'):\n assert node.filters.complevel == 0\n assert node.filters.complib is None\n\n # Check if file-defaults can be overridden on a per table basis\n with ensure_clean_path(self.path) as tmpfile:\n store = pd.HDFStore(tmpfile)\n store.append('dfc', df, complevel=9, complib='blosc')\n store.append('df', df)\n store.close()\n\n with tables.open_file(tmpfile, mode='r') as h5file:\n for node in h5file.walk_nodes(where='/df', classname='Leaf'):\n assert node.filters.complevel == 0\n assert node.filters.complib is None\n for node in h5file.walk_nodes(where='/dfc', classname='Leaf'):\n assert node.filters.complevel == 9\n assert node.filters.complib == 'blosc'\n\n def test_complibs(self):\n # GH14478\n df = tm.makeDataFrame()\n\n # Building list of all complibs and complevels tuples\n all_complibs = tables.filters.all_complibs\n # Remove lzo if its not available on this platform\n if not tables.which_lib_version('lzo'):\n all_complibs.remove('lzo')\n # Remove bzip2 if its not available on this platform\n if not tables.which_lib_version(\"bzip2\"):\n all_complibs.remove(\"bzip2\")\n\n all_levels = range(0, 10)\n all_tests = [(lib, lvl) for lib in all_complibs for lvl in all_levels]\n\n for (lib, lvl) in all_tests:\n with ensure_clean_path(self.path) as tmpfile:\n gname = 'foo'\n\n # Write and read file to see if data is consistent\n df.to_hdf(tmpfile, gname, complib=lib, complevel=lvl)\n result = pd.read_hdf(tmpfile, gname)\n tm.assert_frame_equal(result, df)\n\n # Open file and check metadata\n # for correct amount of compression\n h5table = tables.open_file(tmpfile, mode='r')\n for node in h5table.walk_nodes(where='/' + gname,\n classname='Leaf'):\n assert node.filters.complevel == lvl\n if lvl == 0:\n assert node.filters.complib is None\n else:\n assert node.filters.complib == lib\n h5table.close()\n\n def test_put_integer(self):\n # non-date, non-string index\n df = DataFrame(np.random.randn(50, 100))\n self._check_roundtrip(df, tm.assert_frame_equal)\n\n @xfail_non_writeable\n def test_put_mixed_type(self):\n df = tm.makeTimeDataFrame()\n df['obj1'] = 'foo'\n df['obj2'] = 'bar'\n df['bool1'] = df['A'] > 0\n df['bool2'] = df['B'] > 0\n df['bool3'] = True\n df['int1'] = 1\n df['int2'] = 2\n df['timestamp1'] = Timestamp('20010102')\n df['timestamp2'] = Timestamp('20010103')\n df['datetime1'] = datetime.datetime(2001, 1, 2, 0, 0)\n df['datetime2'] = datetime.datetime(2001, 1, 3, 0, 0)\n df.loc[3:6, ['obj1']] = np.nan\n df = df._consolidate()._convert(datetime=True)\n\n with ensure_clean_store(self.path) as store:\n _maybe_remove(store, 'df')\n\n # PerformanceWarning\n with catch_warnings(record=True):\n simplefilter(\"ignore\", pd.errors.PerformanceWarning)\n store.put('df', df)\n\n expected = store.get('df')\n tm.assert_frame_equal(expected, df)\n\n @pytest.mark.filterwarnings(\n \"ignore:object name:tables.exceptions.NaturalNameWarning\"\n )\n def test_append(self):\n\n with ensure_clean_store(self.path) as store:\n\n # this is allowed by almost always don't want to do it\n # tables.NaturalNameWarning):\n with catch_warnings(record=True):\n\n df = tm.makeTimeDataFrame()\n _maybe_remove(store, 'df1')\n store.append('df1', df[:10])\n store.append('df1', df[10:])\n tm.assert_frame_equal(store['df1'], df)\n\n _maybe_remove(store, 'df2')\n store.put('df2', df[:10], format='table')\n store.append('df2', df[10:])\n tm.assert_frame_equal(store['df2'], df)\n\n _maybe_remove(store, 'df3')\n store.append('/df3', df[:10])\n store.append('/df3', df[10:])\n tm.assert_frame_equal(store['df3'], df)\n\n # this is allowed by almost always don't want to do it\n # tables.NaturalNameWarning\n _maybe_remove(store, '/df3 foo')\n store.append('/df3 foo', df[:10])\n store.append('/df3 foo', df[10:])\n tm.assert_frame_equal(store['df3 foo'], df)\n\n # dtype issues - mizxed type in a single object column\n df = DataFrame(data=[[1, 2], [0, 1], [1, 2], [0, 0]])\n df['mixed_column'] = 'testing'\n df.loc[2, 'mixed_column'] = np.nan\n _maybe_remove(store, 'df')\n store.append('df', df)\n tm.assert_frame_equal(store['df'], df)\n\n # uints - test storage of uints\n uint_data = DataFrame({\n 'u08': Series(np.random.randint(0, high=255, size=5),\n dtype=np.uint8),\n 'u16': Series(np.random.randint(0, high=65535, size=5),\n dtype=np.uint16),\n 'u32': Series(np.random.randint(0, high=2**30, size=5),\n dtype=np.uint32),\n 'u64': Series([2**58, 2**59, 2**60, 2**61, 2**62],\n dtype=np.uint64)}, index=np.arange(5))\n _maybe_remove(store, 'uints')\n store.append('uints', uint_data)\n tm.assert_frame_equal(store['uints'], uint_data)\n\n # uints - test storage of uints in indexable columns\n _maybe_remove(store, 'uints')\n # 64-bit indices not yet supported\n store.append('uints', uint_data, data_columns=[\n 'u08', 'u16', 'u32'])\n tm.assert_frame_equal(store['uints'], uint_data)\n\n def test_append_series(self):\n\n with ensure_clean_store(self.path) as store:\n\n # basic\n ss = tm.makeStringSeries()\n ts = tm.makeTimeSeries()\n ns = Series(np.arange(100))\n\n store.append('ss', ss)\n result = store['ss']\n tm.assert_series_equal(result, ss)\n assert result.name is None\n\n store.append('ts', ts)\n result = store['ts']\n tm.assert_series_equal(result, ts)\n assert result.name is None\n\n ns.name = 'foo'\n store.append('ns', ns)\n result = store['ns']\n tm.assert_series_equal(result, ns)\n assert result.name == ns.name\n\n # select on the values\n expected = ns[ns > 60]\n result = store.select('ns', 'foo>60')\n tm.assert_series_equal(result, expected)\n\n # select on the index and values\n expected = ns[(ns > 70) & (ns.index < 90)]\n result = store.select('ns', 'foo>70 and index<90')\n tm.assert_series_equal(result, expected)\n\n # multi-index\n mi = DataFrame(np.random.randn(5, 1), columns=['A'])\n mi['B'] = np.arange(len(mi))\n mi['C'] = 'foo'\n mi.loc[3:5, 'C'] = 'bar'\n mi.set_index(['C', 'B'], inplace=True)\n s = mi.stack()\n s.index = s.index.droplevel(2)\n store.append('mi', s)\n tm.assert_series_equal(store['mi'], s)\n\n def test_store_index_types(self):\n # GH5386\n # test storing various index types\n\n with ensure_clean_store(self.path) as store:\n\n def check(format, index):\n df = DataFrame(np.random.randn(10, 2), columns=list('AB'))\n df.index = index(len(df))\n\n _maybe_remove(store, 'df')\n store.put('df', df, format=format)\n assert_frame_equal(df, store['df'])\n\n for index in [tm.makeFloatIndex, tm.makeStringIndex,\n tm.makeIntIndex, tm.makeDateIndex]:\n\n check('table', index)\n check('fixed', index)\n\n # period index currently broken for table\n # seee GH7796 FIXME\n check('fixed', tm.makePeriodIndex)\n # check('table',tm.makePeriodIndex)\n\n # unicode\n index = tm.makeUnicodeIndex\n check('table', index)\n check('fixed', index)\n\n @pytest.mark.skipif(not is_platform_little_endian(),\n reason=\"reason platform is not little endian\")\n def test_encoding(self):\n\n with ensure_clean_store(self.path) as store:\n df = DataFrame(dict(A='foo', B='bar'), index=range(5))\n df.loc[2, 'A'] = np.nan\n df.loc[3, 'B'] = np.nan\n _maybe_remove(store, 'df')\n store.append('df', df, encoding='ascii')\n tm.assert_frame_equal(store['df'], df)\n\n expected = df.reindex(columns=['A'])\n result = store.select('df', Term('columns=A', encoding='ascii'))\n tm.assert_frame_equal(result, expected)\n\n def test_latin_encoding(self):\n\n values = [[b'E\\xc9, 17', b'', b'a', b'b', b'c'],\n [b'E\\xc9, 17', b'a', b'b', b'c'],\n [b'EE, 17', b'', b'a', b'b', b'c'],\n [b'E\\xc9, 17', b'\\xf8\\xfc', b'a', b'b', b'c'],\n [b'', b'a', b'b', b'c'],\n [b'\\xf8\\xfc', b'a', b'b', b'c'],\n [b'A\\xf8\\xfc', b'', b'a', b'b', b'c'],\n [np.nan, b'', b'b', b'c'],\n [b'A\\xf8\\xfc', np.nan, b'', b'b', b'c']]\n\n def _try_decode(x, encoding='latin-1'):\n try:\n return x.decode(encoding)\n except AttributeError:\n return x\n # not sure how to remove latin-1 from code in python 2 and 3\n values = [[_try_decode(x) for x in y] for y in values]\n\n examples = []\n for dtype in ['category', object]:\n for val in values:\n examples.append(pd.Series(val, dtype=dtype))\n\n def roundtrip(s, key='data', encoding='latin-1', nan_rep=''):\n with ensure_clean_path(self.path) as store:\n s.to_hdf(store, key, format='table', encoding=encoding,\n nan_rep=nan_rep)\n retr = read_hdf(store, key)\n s_nan = s.replace(nan_rep, np.nan)\n if is_categorical_dtype(s_nan):\n assert is_categorical_dtype(retr)\n assert_series_equal(s_nan, retr, check_dtype=False,\n check_categorical=False)\n else:\n assert_series_equal(s_nan, retr)\n\n for s in examples:\n roundtrip(s)\n\n # fails:\n # for x in examples:\n # roundtrip(s, nan_rep=b'\\xf8\\xfc')\n\n def test_append_some_nans(self):\n\n with ensure_clean_store(self.path) as store:\n df = DataFrame({'A': Series(np.random.randn(20)).astype('int32'),\n 'A1': np.random.randn(20),\n 'A2': np.random.randn(20),\n 'B': 'foo', 'C': 'bar',\n 'D': Timestamp(\"20010101\"),\n 'E': datetime.datetime(2001, 1, 2, 0, 0)},\n index=np.arange(20))\n # some nans\n _maybe_remove(store, 'df1')\n df.loc[0:15, ['A1', 'B', 'D', 'E']] = np.nan\n store.append('df1', df[:10])\n store.append('df1', df[10:])\n tm.assert_frame_equal(store['df1'], df)\n\n # first column\n df1 = df.copy()\n df1.loc[:, 'A1'] = np.nan\n _maybe_remove(store, 'df1')\n store.append('df1', df1[:10])\n store.append('df1', df1[10:])\n tm.assert_frame_equal(store['df1'], df1)\n\n # 2nd column\n df2 = df.copy()\n df2.loc[:, 'A2'] = np.nan\n _maybe_remove(store, 'df2')\n store.append('df2', df2[:10])\n store.append('df2', df2[10:])\n tm.assert_frame_equal(store['df2'], df2)\n\n # datetimes\n df3 = df.copy()\n df3.loc[:, 'E'] = np.nan\n _maybe_remove(store, 'df3')\n store.append('df3', df3[:10])\n store.append('df3', df3[10:])\n tm.assert_frame_equal(store['df3'], df3)\n\n def test_append_all_nans(self):\n\n with ensure_clean_store(self.path) as store:\n\n df = DataFrame({'A1': np.random.randn(20),\n 'A2': np.random.randn(20)},\n index=np.arange(20))\n df.loc[0:15, :] = np.nan\n\n # nan some entire rows (dropna=True)\n _maybe_remove(store, 'df')\n store.append('df', df[:10], dropna=True)\n store.append('df', df[10:], dropna=True)\n tm.assert_frame_equal(store['df'], df[-4:])\n\n # nan some entire rows (dropna=False)\n _maybe_remove(store, 'df2')\n store.append('df2', df[:10], dropna=False)\n store.append('df2', df[10:], dropna=False)\n tm.assert_frame_equal(store['df2'], df)\n\n # tests the option io.hdf.dropna_table\n pd.set_option('io.hdf.dropna_table', False)\n _maybe_remove(store, 'df3')\n store.append('df3', df[:10])\n store.append('df3', df[10:])\n tm.assert_frame_equal(store['df3'], df)\n\n pd.set_option('io.hdf.dropna_table', True)\n _maybe_remove(store, 'df4')\n store.append('df4', df[:10])\n store.append('df4', df[10:])\n tm.assert_frame_equal(store['df4'], df[-4:])\n\n # nan some entire rows (string are still written!)\n df = DataFrame({'A1': np.random.randn(20),\n 'A2': np.random.randn(20),\n 'B': 'foo', 'C': 'bar'},\n index=np.arange(20))\n\n df.loc[0:15, :] = np.nan\n\n _maybe_remove(store, 'df')\n store.append('df', df[:10], dropna=True)\n store.append('df', df[10:], dropna=True)\n tm.assert_frame_equal(store['df'], df)\n\n _maybe_remove(store, 'df2')\n store.append('df2', df[:10], dropna=False)\n store.append('df2', df[10:], dropna=False)\n tm.assert_frame_equal(store['df2'], df)\n\n # nan some entire rows (but since we have dates they are still\n # written!)\n df = DataFrame({'A1': np.random.randn(20),\n 'A2': np.random.randn(20),\n 'B': 'foo', 'C': 'bar',\n 'D': Timestamp(\"20010101\"),\n 'E': datetime.datetime(2001, 1, 2, 0, 0)},\n index=np.arange(20))\n\n df.loc[0:15, :] = np.nan\n\n _maybe_remove(store, 'df')\n store.append('df', df[:10], dropna=True)\n store.append('df', df[10:], dropna=True)\n tm.assert_frame_equal(store['df'], df)\n\n _maybe_remove(store, 'df2')\n store.append('df2', df[:10], dropna=False)\n store.append('df2', df[10:], dropna=False)\n tm.assert_frame_equal(store['df2'], df)\n\n # Test to make sure defaults are to not drop.\n # Corresponding to Issue 9382\n df_with_missing = DataFrame(\n {'col1': [0, np.nan, 2], 'col2': [1, np.nan, np.nan]})\n\n with ensure_clean_path(self.path) as path:\n df_with_missing.to_hdf(path, 'df_with_missing', format='table')\n reloaded = read_hdf(path, 'df_with_missing')\n tm.assert_frame_equal(df_with_missing, reloaded)\n\n def test_read_missing_key_close_store(self):\n # GH 25766\n with ensure_clean_path(self.path) as path:\n df = pd.DataFrame({'a': range(2), 'b': range(2)})\n df.to_hdf(path, 'k1')\n\n with pytest.raises(KeyError):\n pd.read_hdf(path, 'k2')\n\n # smoke test to test that file is properly closed after\n # read with KeyError before another write\n df.to_hdf(path, 'k2')\n\n def test_append_frame_column_oriented(self):\n\n with ensure_clean_store(self.path) as store:\n\n # column oriented\n df = tm.makeTimeDataFrame()\n _maybe_remove(store, 'df1')\n store.append('df1', df.iloc[:, :2], axes=['columns'])\n store.append('df1', df.iloc[:, 2:])\n tm.assert_frame_equal(store['df1'], df)\n\n result = store.select('df1', 'columns=A')\n expected = df.reindex(columns=['A'])\n tm.assert_frame_equal(expected, result)\n\n # selection on the non-indexable\n result = store.select(\n 'df1', ('columns=A', 'index=df.index[0:4]'))\n expected = df.reindex(columns=['A'], index=df.index[0:4])\n tm.assert_frame_equal(expected, result)\n\n # this isn't supported\n with pytest.raises(TypeError):\n store.select('df1',\n 'columns=A and index>df.index[4]')\n\n def test_append_with_different_block_ordering(self):\n\n # GH 4096; using same frames, but different block orderings\n with ensure_clean_store(self.path) as store:\n\n for i in range(10):\n\n df = DataFrame(np.random.randn(10, 2), columns=list('AB'))\n df['index'] = range(10)\n df['index'] += i * 10\n df['int64'] = Series([1] * len(df), dtype='int64')\n df['int16'] = Series([1] * len(df), dtype='int16')\n\n if i % 2 == 0:\n del df['int64']\n df['int64'] = Series([1] * len(df), dtype='int64')\n if i % 3 == 0:\n a = df.pop('A')\n df['A'] = a\n\n df.set_index('index', inplace=True)\n\n store.append('df', df)\n\n # test a different ordering but with more fields (like invalid\n # combinate)\n with ensure_clean_store(self.path) as store:\n\n df = DataFrame(np.random.randn(10, 2),\n columns=list('AB'), dtype='float64')\n df['int64'] = Series([1] * len(df), dtype='int64')\n df['int16'] = Series([1] * len(df), dtype='int16')\n store.append('df', df)\n\n # store additional fields in different blocks\n df['int16_2'] = Series([1] * len(df), dtype='int16')\n with pytest.raises(ValueError):\n store.append('df', df)\n\n # store multile additional fields in different blocks\n df['float_3'] = Series([1.] * len(df), dtype='float64')\n with pytest.raises(ValueError):\n store.append('df', df)\n\n def test_append_with_strings(self):\n\n with ensure_clean_store(self.path) as store:\n with catch_warnings(record=True):\n\n def check_col(key, name, size):\n assert getattr(store.get_storer(key)\n .table.description, name).itemsize == size\n\n # avoid truncation on elements\n df = DataFrame([[123, 'asdqwerty'], [345, 'dggnhebbsdfbdfb']])\n store.append('df_big', df)\n tm.assert_frame_equal(store.select('df_big'), df)\n check_col('df_big', 'values_block_1', 15)\n\n # appending smaller string ok\n df2 = DataFrame([[124, 'asdqy'], [346, 'dggnhefbdfb']])\n store.append('df_big', df2)\n expected = concat([df, df2])\n tm.assert_frame_equal(store.select('df_big'), expected)\n check_col('df_big', 'values_block_1', 15)\n\n # avoid truncation on elements\n df = DataFrame([[123, 'asdqwerty'], [345, 'dggnhebbsdfbdfb']])\n store.append('df_big2', df, min_itemsize={'values': 50})\n tm.assert_frame_equal(store.select('df_big2'), df)\n check_col('df_big2', 'values_block_1', 50)\n\n # bigger string on next append\n store.append('df_new', df)\n df_new = DataFrame(\n [[124, 'abcdefqhij'], [346, 'abcdefghijklmnopqrtsuvwxyz']])\n with pytest.raises(ValueError):\n store.append('df_new', df_new)\n\n # min_itemsize on Series index (GH 11412)\n df = tm.makeMixedDataFrame().set_index('C')\n store.append('ss', df['B'], min_itemsize={'index': 4})\n tm.assert_series_equal(store.select('ss'), df['B'])\n\n # same as above, with data_columns=True\n store.append('ss2', df['B'], data_columns=True,\n min_itemsize={'index': 4})\n tm.assert_series_equal(store.select('ss2'), df['B'])\n\n # min_itemsize in index without appending (GH 10381)\n store.put('ss3', df, format='table',\n min_itemsize={'index': 6})\n # just make sure there is a longer string:\n df2 = df.copy().reset_index().assign(C='longer').set_index('C')\n store.append('ss3', df2)\n tm.assert_frame_equal(store.select('ss3'),\n pd.concat([df, df2]))\n\n # same as above, with a Series\n store.put('ss4', df['B'], format='table',\n min_itemsize={'index': 6})\n store.append('ss4', df2['B'])\n tm.assert_series_equal(store.select('ss4'),\n pd.concat([df['B'], df2['B']]))\n\n # with nans\n _maybe_remove(store, 'df')\n df = tm.makeTimeDataFrame()\n df['string'] = 'foo'\n df.loc[1:4, 'string'] = np.nan\n df['string2'] = 'bar'\n df.loc[4:8, 'string2'] = np.nan\n df['string3'] = 'bah'\n df.loc[1:, 'string3'] = np.nan\n store.append('df', df)\n result = store.select('df')\n tm.assert_frame_equal(result, df)\n\n with ensure_clean_store(self.path) as store:\n\n def check_col(key, name, size):\n assert getattr(store.get_storer(key)\n .table.description, name).itemsize, size\n\n df = DataFrame(dict(A='foo', B='bar'), index=range(10))\n\n # a min_itemsize that creates a data_column\n _maybe_remove(store, 'df')\n store.append('df', df, min_itemsize={'A': 200})\n check_col('df', 'A', 200)\n assert store.get_storer('df').data_columns == ['A']\n\n # a min_itemsize that creates a data_column2\n _maybe_remove(store, 'df')\n store.append('df', df, data_columns=['B'], min_itemsize={'A': 200})\n check_col('df', 'A', 200)\n assert store.get_storer('df').data_columns == ['B', 'A']\n\n # a min_itemsize that creates a data_column2\n _maybe_remove(store, 'df')\n store.append('df', df, data_columns=[\n 'B'], min_itemsize={'values': 200})\n check_col('df', 'B', 200)\n check_col('df', 'values_block_0', 200)\n assert store.get_storer('df').data_columns == ['B']\n\n # infer the .typ on subsequent appends\n _maybe_remove(store, 'df')\n store.append('df', df[:5], min_itemsize=200)\n store.append('df', df[5:], min_itemsize=200)\n tm.assert_frame_equal(store['df'], df)\n\n # invalid min_itemsize keys\n df = DataFrame(['foo', 'foo', 'foo', 'barh',\n 'barh', 'barh'], columns=['A'])\n _maybe_remove(store, 'df')\n with pytest.raises(ValueError):\n store.append('df', df, min_itemsize={'foo': 20, 'foobar': 20})\n\n def test_append_with_empty_string(self):\n\n with ensure_clean_store(self.path) as store:\n\n # with all empty strings (GH 12242)\n df = DataFrame({'x': ['a', 'b', 'c', 'd', 'e', 'f', '']})\n store.append('df', df[:-1], min_itemsize={'x': 1})\n store.append('df', df[-1:], min_itemsize={'x': 1})\n tm.assert_frame_equal(store.select('df'), df)\n\n def test_to_hdf_with_min_itemsize(self):\n\n with ensure_clean_path(self.path) as path:\n\n # min_itemsize in index with to_hdf (GH 10381)\n df = tm.makeMixedDataFrame().set_index('C')\n df.to_hdf(path, 'ss3', format='table', min_itemsize={'index': 6})\n # just make sure there is a longer string:\n df2 = df.copy().reset_index().assign(C='longer').set_index('C')\n df2.to_hdf(path, 'ss3', append=True, format='table')\n tm.assert_frame_equal(pd.read_hdf(path, 'ss3'),\n pd.concat([df, df2]))\n\n # same as above, with a Series\n df['B'].to_hdf(path, 'ss4', format='table',\n min_itemsize={'index': 6})\n df2['B'].to_hdf(path, 'ss4', append=True, format='table')\n tm.assert_series_equal(pd.read_hdf(path, 'ss4'),\n pd.concat([df['B'], df2['B']]))\n\n @pytest.mark.parametrize(\n \"format\",\n [pytest.param('fixed', marks=xfail_non_writeable),\n 'table'])\n def test_to_hdf_errors(self, format):\n\n data = ['\\ud800foo']\n ser = pd.Series(data, index=pd.Index(data))\n with ensure_clean_path(self.path) as path:\n # GH 20835\n ser.to_hdf(path, 'table', format=format, errors='surrogatepass')\n\n result = pd.read_hdf(path, 'table', errors='surrogatepass')\n tm.assert_series_equal(result, ser)\n\n def test_append_with_data_columns(self):\n\n with ensure_clean_store(self.path) as store:\n df = tm.makeTimeDataFrame()\n df.iloc[0, df.columns.get_loc('B')] = 1.\n _maybe_remove(store, 'df')\n store.append('df', df[:2], data_columns=['B'])\n store.append('df', df[2:])\n tm.assert_frame_equal(store['df'], df)\n\n # check that we have indices created\n assert(store._handle.root.df.table.cols.index.is_indexed is True)\n assert(store._handle.root.df.table.cols.B.is_indexed is True)\n\n # data column searching\n result = store.select('df', 'B>0')\n expected = df[df.B > 0]\n tm.assert_frame_equal(result, expected)\n\n # data column searching (with an indexable and a data_columns)\n result = store.select(\n 'df', 'B>0 and index>df.index[3]')\n df_new = df.reindex(index=df.index[4:])\n expected = df_new[df_new.B > 0]\n tm.assert_frame_equal(result, expected)\n\n # data column selection with a string data_column\n df_new = df.copy()\n df_new['string'] = 'foo'\n df_new.loc[1:4, 'string'] = np.nan\n df_new.loc[5:6, 'string'] = 'bar'\n _maybe_remove(store, 'df')\n store.append('df', df_new, data_columns=['string'])\n result = store.select('df', \"string='foo'\")\n expected = df_new[df_new.string == 'foo']\n tm.assert_frame_equal(result, expected)\n\n # using min_itemsize and a data column\n def check_col(key, name, size):\n assert getattr(store.get_storer(key)\n .table.description, name).itemsize == size\n\n with ensure_clean_store(self.path) as store:\n _maybe_remove(store, 'df')\n store.append('df', df_new, data_columns=['string'],\n min_itemsize={'string': 30})\n check_col('df', 'string', 30)\n _maybe_remove(store, 'df')\n store.append(\n 'df', df_new, data_columns=['string'], min_itemsize=30)\n check_col('df', 'string', 30)\n _maybe_remove(store, 'df')\n store.append('df', df_new, data_columns=['string'],\n min_itemsize={'values': 30})\n check_col('df', 'string', 30)\n\n with ensure_clean_store(self.path) as store:\n df_new['string2'] = 'foobarbah'\n df_new['string_block1'] = 'foobarbah1'\n df_new['string_block2'] = 'foobarbah2'\n _maybe_remove(store, 'df')\n store.append('df', df_new, data_columns=['string', 'string2'],\n min_itemsize={'string': 30, 'string2': 40,\n 'values': 50})\n check_col('df', 'string', 30)\n check_col('df', 'string2', 40)\n check_col('df', 'values_block_1', 50)\n\n with ensure_clean_store(self.path) as store:\n # multiple data columns\n df_new = df.copy()\n df_new.iloc[0, df_new.columns.get_loc('A')] = 1.\n df_new.iloc[0, df_new.columns.get_loc('B')] = -1.\n df_new['string'] = 'foo'\n\n sl = df_new.columns.get_loc('string')\n df_new.iloc[1:4, sl] = np.nan\n df_new.iloc[5:6, sl] = 'bar'\n\n df_new['string2'] = 'foo'\n sl = df_new.columns.get_loc('string2')\n df_new.iloc[2:5, sl] = np.nan\n df_new.iloc[7:8, sl] = 'bar'\n _maybe_remove(store, 'df')\n store.append(\n 'df', df_new, data_columns=['A', 'B', 'string', 'string2'])\n result = store.select('df',\n \"string='foo' and string2='foo'\"\n \" and A>0 and B<0\")\n expected = df_new[(df_new.string == 'foo') & (\n df_new.string2 == 'foo') & (df_new.A > 0) & (df_new.B < 0)]\n tm.assert_frame_equal(result, expected, check_index_type=False)\n\n # yield an empty frame\n result = store.select('df', \"string='foo' and string2='cool'\")\n expected = df_new[(df_new.string == 'foo') & (\n df_new.string2 == 'cool')]\n tm.assert_frame_equal(result, expected, check_index_type=False)\n\n with ensure_clean_store(self.path) as store:\n # doc example\n df_dc = df.copy()\n df_dc['string'] = 'foo'\n df_dc.loc[4:6, 'string'] = np.nan\n df_dc.loc[7:9, 'string'] = 'bar'\n df_dc['string2'] = 'cool'\n df_dc['datetime'] = Timestamp('20010102')\n df_dc = df_dc._convert(datetime=True)\n df_dc.loc[3:5, ['A', 'B', 'datetime']] = np.nan\n\n _maybe_remove(store, 'df_dc')\n store.append('df_dc', df_dc,\n data_columns=['B', 'C', 'string',\n 'string2', 'datetime'])\n result = store.select('df_dc', 'B>0')\n\n expected = df_dc[df_dc.B > 0]\n tm.assert_frame_equal(result, expected, check_index_type=False)\n\n result = store.select(\n 'df_dc', ['B > 0', 'C > 0', 'string == foo'])\n expected = df_dc[(df_dc.B > 0) & (df_dc.C > 0) & (\n df_dc.string == 'foo')]\n tm.assert_frame_equal(result, expected, check_index_type=False)\n\n with ensure_clean_store(self.path) as store:\n # doc example part 2\n np.random.seed(1234)\n index = date_range('1/1/2000', periods=8)\n df_dc = DataFrame(np.random.randn(8, 3), index=index,\n columns=['A', 'B', 'C'])\n df_dc['string'] = 'foo'\n df_dc.loc[4:6, 'string'] = np.nan\n df_dc.loc[7:9, 'string'] = 'bar'\n df_dc.loc[:, ['B', 'C']] = df_dc.loc[:, ['B', 'C']].abs()\n df_dc['string2'] = 'cool'\n\n # on-disk operations\n store.append('df_dc', df_dc, data_columns=[\n 'B', 'C', 'string', 'string2'])\n\n result = store.select('df_dc', 'B>0')\n expected = df_dc[df_dc.B > 0]\n tm.assert_frame_equal(result, expected)\n\n result = store.select(\n 'df_dc', ['B > 0', 'C > 0', 'string == \"foo\"'])\n expected = df_dc[(df_dc.B > 0) & (df_dc.C > 0) &\n (df_dc.string == 'foo')]\n tm.assert_frame_equal(result, expected)\n\n def test_create_table_index(self):\n\n with ensure_clean_store(self.path) as store:\n\n with catch_warnings(record=True):\n def col(t, column):\n return getattr(store.get_storer(t).table.cols, column)\n\n # data columns\n df = tm.makeTimeDataFrame()\n df['string'] = 'foo'\n df['string2'] = 'bar'\n store.append('f', df, data_columns=['string', 'string2'])\n assert(col('f', 'index').is_indexed is True)\n assert(col('f', 'string').is_indexed is True)\n assert(col('f', 'string2').is_indexed is True)\n\n # specify index=columns\n store.append(\n 'f2', df, index=['string'],\n data_columns=['string', 'string2'])\n assert(col('f2', 'index').is_indexed is False)\n assert(col('f2', 'string').is_indexed is True)\n assert(col('f2', 'string2').is_indexed is False)\n\n # try to index a non-table\n _maybe_remove(store, 'f2')\n store.put('f2', df)\n with pytest.raises(TypeError):\n store.create_table_index('f2')\n\n def test_append_hierarchical(self):\n index = MultiIndex(levels=[['foo', 'bar', 'baz', 'qux'],\n ['one', 'two', 'three']],\n codes=[[0, 0, 0, 1, 1, 2, 2, 3, 3, 3],\n [0, 1, 2, 0, 1, 1, 2, 0, 1, 2]],\n names=['foo', 'bar'])\n df = DataFrame(np.random.randn(10, 3), index=index,\n columns=['A', 'B', 'C'])\n\n with ensure_clean_store(self.path) as store:\n store.append('mi', df)\n result = store.select('mi')\n tm.assert_frame_equal(result, df)\n\n # GH 3748\n result = store.select('mi', columns=['A', 'B'])\n expected = df.reindex(columns=['A', 'B'])\n tm.assert_frame_equal(result, expected)\n\n with ensure_clean_path('test.hdf') as path:\n df.to_hdf(path, 'df', format='table')\n result = read_hdf(path, 'df', columns=['A', 'B'])\n expected = df.reindex(columns=['A', 'B'])\n tm.assert_frame_equal(result, expected)\n\n def test_column_multiindex(self):\n # GH 4710\n # recreate multi-indexes properly\n\n index = MultiIndex.from_tuples([('A', 'a'), ('A', 'b'),\n ('B', 'a'), ('B', 'b')],\n names=['first', 'second'])\n df = DataFrame(np.arange(12).reshape(3, 4), columns=index)\n expected = df.copy()\n if isinstance(expected.index, RangeIndex):\n expected.index = Int64Index(expected.index)\n\n with ensure_clean_store(self.path) as store:\n\n store.put('df', df)\n tm.assert_frame_equal(store['df'], expected,\n check_index_type=True,\n check_column_type=True)\n\n store.put('df1', df, format='table')\n tm.assert_frame_equal(store['df1'], expected,\n check_index_type=True,\n check_column_type=True)\n\n with pytest.raises(ValueError):\n store.put('df2', df, format='table', data_columns=['A'])\n with pytest.raises(ValueError):\n store.put('df3', df, format='table', data_columns=True)\n\n # appending multi-column on existing table (see GH 6167)\n with ensure_clean_store(self.path) as store:\n store.append('df2', df)\n store.append('df2', df)\n\n tm.assert_frame_equal(store['df2'], concat((df, df)))\n\n # non_index_axes name\n df = DataFrame(np.arange(12).reshape(3, 4),\n columns=Index(list('ABCD'), name='foo'))\n expected = df.copy()\n if isinstance(expected.index, RangeIndex):\n expected.index = Int64Index(expected.index)\n\n with ensure_clean_store(self.path) as store:\n\n store.put('df1', df, format='table')\n tm.assert_frame_equal(store['df1'], expected,\n check_index_type=True,\n check_column_type=True)\n\n def test_store_multiindex(self):\n\n # validate multi-index names\n # GH 5527\n with ensure_clean_store(self.path) as store:\n\n def make_index(names=None):\n return MultiIndex.from_tuples([(datetime.datetime(2013, 12, d),\n s, t)\n for d in range(1, 3)\n for s in range(2)\n for t in range(3)],\n names=names)\n\n # no names\n _maybe_remove(store, 'df')\n df = DataFrame(np.zeros((12, 2)), columns=[\n 'a', 'b'], index=make_index())\n store.append('df', df)\n tm.assert_frame_equal(store.select('df'), df)\n\n # partial names\n _maybe_remove(store, 'df')\n df = DataFrame(np.zeros((12, 2)), columns=[\n 'a', 'b'], index=make_index(['date', None, None]))\n store.append('df', df)\n tm.assert_frame_equal(store.select('df'), df)\n\n # series\n _maybe_remove(store, 's')\n s = Series(np.zeros(12), index=make_index(['date', None, None]))\n store.append('s', s)\n xp = Series(np.zeros(12), index=make_index(\n ['date', 'level_1', 'level_2']))\n tm.assert_series_equal(store.select('s'), xp)\n\n # dup with column\n _maybe_remove(store, 'df')\n df = DataFrame(np.zeros((12, 2)), columns=[\n 'a', 'b'], index=make_index(['date', 'a', 't']))\n with pytest.raises(ValueError):\n store.append('df', df)\n\n # dup within level\n _maybe_remove(store, 'df')\n df = DataFrame(np.zeros((12, 2)), columns=['a', 'b'],\n index=make_index(['date', 'date', 'date']))\n with pytest.raises(ValueError):\n store.append('df', df)\n\n # fully names\n _maybe_remove(store, 'df')\n df = DataFrame(np.zeros((12, 2)), columns=[\n 'a', 'b'], index=make_index(['date', 's', 't']))\n store.append('df', df)\n tm.assert_frame_equal(store.select('df'), df)\n\n def test_select_columns_in_where(self):\n\n # GH 6169\n # recreate multi-indexes when columns is passed\n # in the `where` argument\n index = MultiIndex(levels=[['foo', 'bar', 'baz', 'qux'],\n ['one', 'two', 'three']],\n codes=[[0, 0, 0, 1, 1, 2, 2, 3, 3, 3],\n [0, 1, 2, 0, 1, 1, 2, 0, 1, 2]],\n names=['foo_name', 'bar_name'])\n\n # With a DataFrame\n df = DataFrame(np.random.randn(10, 3), index=index,\n columns=['A', 'B', 'C'])\n\n with ensure_clean_store(self.path) as store:\n store.put('df', df, format='table')\n expected = df[['A']]\n\n tm.assert_frame_equal(store.select('df', columns=['A']), expected)\n\n tm.assert_frame_equal(store.select(\n 'df', where=\"columns=['A']\"), expected)\n\n # With a Series\n s = Series(np.random.randn(10), index=index,\n name='A')\n with ensure_clean_store(self.path) as store:\n store.put('s', s, format='table')\n tm.assert_series_equal(store.select('s', where=\"columns=['A']\"), s)\n\n def test_mi_data_columns(self):\n # GH 14435\n idx = pd.MultiIndex.from_arrays([date_range('2000-01-01', periods=5),\n range(5)], names=['date', 'id'])\n df = pd.DataFrame({'a': [1.1, 1.2, 1.3, 1.4, 1.5]}, index=idx)\n\n with ensure_clean_store(self.path) as store:\n store.append('df', df, data_columns=True)\n\n actual = store.select('df', where='id == 1')\n expected = df.iloc[[1], :]\n tm.assert_frame_equal(actual, expected)\n\n def test_pass_spec_to_storer(self):\n\n df = tm.makeDataFrame()\n\n with ensure_clean_store(self.path) as store:\n store.put('df', df)\n with pytest.raises(TypeError):\n store.select('df', columns=['A'])\n with pytest.raises(TypeError):\n store.select('df', where=[('columns=A')])\n\n @xfail_non_writeable\n def test_append_misc(self):\n\n with ensure_clean_store(self.path) as store:\n df = tm.makeDataFrame()\n store.append('df', df, chunksize=1)\n result = store.select('df')\n tm.assert_frame_equal(result, df)\n\n store.append('df1', df, expectedrows=10)\n result = store.select('df1')\n tm.assert_frame_equal(result, df)\n\n # more chunksize in append tests\n def check(obj, comparator):\n for c in [10, 200, 1000]:\n with ensure_clean_store(self.path, mode='w') as store:\n store.append('obj', obj, chunksize=c)\n result = store.select('obj')\n comparator(result, obj)\n\n df = tm.makeDataFrame()\n df['string'] = 'foo'\n df['float322'] = 1.\n df['float322'] = df['float322'].astype('float32')\n df['bool'] = df['float322'] > 0\n df['time1'] = Timestamp('20130101')\n df['time2'] = Timestamp('20130102')\n check(df, tm.assert_frame_equal)\n\n # empty frame, GH4273\n with ensure_clean_store(self.path) as store:\n\n # 0 len\n df_empty = DataFrame(columns=list('ABC'))\n store.append('df', df_empty)\n with pytest.raises(KeyError):\n store.select('df')\n\n # repeated append of 0/non-zero frames\n df = DataFrame(np.random.rand(10, 3), columns=list('ABC'))\n store.append('df', df)\n assert_frame_equal(store.select('df'), df)\n store.append('df', df_empty)\n assert_frame_equal(store.select('df'), df)\n\n # store\n df = DataFrame(columns=list('ABC'))\n store.put('df2', df)\n assert_frame_equal(store.select('df2'), df)\n\n def test_append_raise(self):\n\n with ensure_clean_store(self.path) as store:\n\n # test append with invalid input to get good error messages\n\n # list in column\n df = tm.makeDataFrame()\n df['invalid'] = [['a']] * len(df)\n assert df.dtypes['invalid'] == np.object_\n with pytest.raises(TypeError):\n store.append('df', df)\n\n # multiple invalid columns\n df['invalid2'] = [['a']] * len(df)\n df['invalid3'] = [['a']] * len(df)\n with pytest.raises(TypeError):\n store.append('df', df)\n\n # datetime with embedded nans as object\n df = tm.makeDataFrame()\n s = Series(datetime.datetime(2001, 1, 2), index=df.index)\n s = s.astype(object)\n s[0:5] = np.nan\n df['invalid'] = s\n assert df.dtypes['invalid'] == np.object_\n with pytest.raises(TypeError):\n store.append('df', df)\n\n # directly ndarray\n with pytest.raises(TypeError):\n store.append('df', np.arange(10))\n\n # series directly\n with pytest.raises(TypeError):\n store.append('df', Series(np.arange(10)))\n\n # appending an incompatible table\n df = tm.makeDataFrame()\n store.append('df', df)\n\n df['foo'] = 'foo'\n with pytest.raises(ValueError):\n store.append('df', df)\n\n def test_table_index_incompatible_dtypes(self):\n df1 = DataFrame({'a': [1, 2, 3]})\n df2 = DataFrame({'a': [4, 5, 6]},\n index=date_range('1/1/2000', periods=3))\n\n with ensure_clean_store(self.path) as store:\n store.put('frame', df1, format='table')\n with pytest.raises(TypeError):\n store.put('frame', df2, format='table', append=True)\n\n def test_table_values_dtypes_roundtrip(self):\n\n with ensure_clean_store(self.path) as store:\n df1 = DataFrame({'a': [1, 2, 3]}, dtype='f8')\n store.append('df_f8', df1)\n assert_series_equal(df1.dtypes, store['df_f8'].dtypes)\n\n df2 = DataFrame({'a': [1, 2, 3]}, dtype='i8')\n store.append('df_i8', df2)\n assert_series_equal(df2.dtypes, store['df_i8'].dtypes)\n\n # incompatible dtype\n with pytest.raises(ValueError):\n store.append('df_i8', df1)\n\n # check creation/storage/retrieval of float32 (a bit hacky to\n # actually create them thought)\n df1 = DataFrame(\n np.array([[1], [2], [3]], dtype='f4'), columns=['A'])\n store.append('df_f4', df1)\n assert_series_equal(df1.dtypes, store['df_f4'].dtypes)\n assert df1.dtypes[0] == 'float32'\n\n # check with mixed dtypes\n df1 = DataFrame({c: Series(np.random.randint(5), dtype=c)\n for c in ['float32', 'float64', 'int32',\n 'int64', 'int16', 'int8']})\n df1['string'] = 'foo'\n df1['float322'] = 1.\n df1['float322'] = df1['float322'].astype('float32')\n df1['bool'] = df1['float32'] > 0\n df1['time1'] = Timestamp('20130101')\n df1['time2'] = Timestamp('20130102')\n\n store.append('df_mixed_dtypes1', df1)\n result = store.select('df_mixed_dtypes1').get_dtype_counts()\n expected = Series({'float32': 2, 'float64': 1, 'int32': 1,\n 'bool': 1, 'int16': 1, 'int8': 1,\n 'int64': 1, 'object': 1, 'datetime64[ns]': 2})\n result = result.sort_index()\n expected = expected.sort_index()\n tm.assert_series_equal(result, expected)\n\n def test_table_mixed_dtypes(self):\n\n # frame\n df = tm.makeDataFrame()\n df['obj1'] = 'foo'\n df['obj2'] = 'bar'\n df['bool1'] = df['A'] > 0\n df['bool2'] = df['B'] > 0\n df['bool3'] = True\n df['int1'] = 1\n df['int2'] = 2\n df['timestamp1'] = Timestamp('20010102')\n df['timestamp2'] = Timestamp('20010103')\n df['datetime1'] = datetime.datetime(2001, 1, 2, 0, 0)\n df['datetime2'] = datetime.datetime(2001, 1, 3, 0, 0)\n df.loc[3:6, ['obj1']] = np.nan\n df = df._consolidate()._convert(datetime=True)\n\n with ensure_clean_store(self.path) as store:\n store.append('df1_mixed', df)\n tm.assert_frame_equal(store.select('df1_mixed'), df)\n\n def test_unimplemented_dtypes_table_columns(self):\n\n with ensure_clean_store(self.path) as store:\n\n dtypes = [('date', datetime.date(2001, 1, 2))]\n\n # currently not supported dtypes ####\n for n, f in dtypes:\n df = tm.makeDataFrame()\n df[n] = f\n with pytest.raises(TypeError):\n store.append('df1_%s' % n, df)\n\n # frame\n df = tm.makeDataFrame()\n df['obj1'] = 'foo'\n df['obj2'] = 'bar'\n df['datetime1'] = datetime.date(2001, 1, 2)\n df = df._consolidate()._convert(datetime=True)\n\n with ensure_clean_store(self.path) as store:\n # this fails because we have a date in the object block......\n with pytest.raises(TypeError):\n store.append('df_unimplemented', df)\n\n @xfail_non_writeable\n @pytest.mark.skipif(\n LooseVersion(np.__version__) == LooseVersion('1.15.0'),\n reason=(\"Skipping pytables test when numpy version is \"\n \"exactly equal to 1.15.0: gh-22098\"))\n def test_calendar_roundtrip_issue(self):\n\n # 8591\n # doc example from tseries holiday section\n weekmask_egypt = 'Sun Mon Tue Wed Thu'\n holidays = ['2012-05-01',\n datetime.datetime(2013, 5, 1), np.datetime64('2014-05-01')]\n bday_egypt = pd.offsets.CustomBusinessDay(\n holidays=holidays, weekmask=weekmask_egypt)\n dt = datetime.datetime(2013, 4, 30)\n dts = date_range(dt, periods=5, freq=bday_egypt)\n\n s = (Series(dts.weekday, dts).map(\n Series('Mon Tue Wed Thu Fri Sat Sun'.split())))\n\n with ensure_clean_store(self.path) as store:\n\n store.put('fixed', s)\n result = store.select('fixed')\n assert_series_equal(result, s)\n\n store.append('table', s)\n result = store.select('table')\n assert_series_equal(result, s)\n\n def test_roundtrip_tz_aware_index(self):\n # GH 17618\n time = pd.Timestamp('2000-01-01 01:00:00', tz='US/Eastern')\n df = pd.DataFrame(data=[0], index=[time])\n\n with ensure_clean_store(self.path) as store:\n store.put('frame', df, format='fixed')\n recons = store['frame']\n tm.assert_frame_equal(recons, df)\n assert recons.index[0].value == 946706400000000000\n\n def test_append_with_timedelta(self):\n # GH 3577\n # append timedelta\n\n df = DataFrame(dict(A=Timestamp('20130101'), B=[Timestamp(\n '20130101') + timedelta(days=i, seconds=10) for i in range(10)]))\n df['C'] = df['A'] - df['B']\n df.loc[3:5, 'C'] = np.nan\n\n with ensure_clean_store(self.path) as store:\n\n # table\n _maybe_remove(store, 'df')\n store.append('df', df, data_columns=True)\n result = store.select('df')\n assert_frame_equal(result, df)\n\n result = store.select('df', where=\"C<100000\")\n assert_frame_equal(result, df)\n\n result = store.select('df', where=\"C<pd.Timedelta('-3D')\")\n assert_frame_equal(result, df.iloc[3:])\n\n result = store.select('df', \"C<'-3D'\")\n assert_frame_equal(result, df.iloc[3:])\n\n # a bit hacky here as we don't really deal with the NaT properly\n\n result = store.select('df', \"C<'-500000s'\")\n result = result.dropna(subset=['C'])\n assert_frame_equal(result, df.iloc[6:])\n\n result = store.select('df', \"C<'-3.5D'\")\n result = result.iloc[1:]\n assert_frame_equal(result, df.iloc[4:])\n\n # fixed\n _maybe_remove(store, 'df2')\n store.put('df2', df)\n result = store.select('df2')\n assert_frame_equal(result, df)\n\n def test_remove(self):\n\n with ensure_clean_store(self.path) as store:\n\n ts = tm.makeTimeSeries()\n df = tm.makeDataFrame()\n store['a'] = ts\n store['b'] = df\n _maybe_remove(store, 'a')\n assert len(store) == 1\n tm.assert_frame_equal(df, store['b'])\n\n _maybe_remove(store, 'b')\n assert len(store) == 0\n\n # nonexistence\n with pytest.raises(KeyError):\n store.remove('a_nonexistent_store')\n\n # pathing\n store['a'] = ts\n store['b/foo'] = df\n _maybe_remove(store, 'foo')\n _maybe_remove(store, 'b/foo')\n assert len(store) == 1\n\n store['a'] = ts\n store['b/foo'] = df\n _maybe_remove(store, 'b')\n assert len(store) == 1\n\n # __delitem__\n store['a'] = ts\n store['b'] = df\n del store['a']\n del store['b']\n assert len(store) == 0\n\n def test_invalid_terms(self):\n\n with ensure_clean_store(self.path) as store:\n\n with catch_warnings(record=True):\n\n df = tm.makeTimeDataFrame()\n df['string'] = 'foo'\n df.loc[0:4, 'string'] = 'bar'\n\n store.put('df', df, format='table')\n\n # some invalid terms\n with pytest.raises(TypeError):\n Term()\n\n # more invalid\n with pytest.raises(ValueError):\n store.select('df', 'df.index[3]')\n\n with pytest.raises(SyntaxError):\n store.select('df', 'index>')\n\n # from the docs\n with ensure_clean_path(self.path) as path:\n dfq = DataFrame(np.random.randn(10, 4), columns=list(\n 'ABCD'), index=date_range('20130101', periods=10))\n dfq.to_hdf(path, 'dfq', format='table', data_columns=True)\n\n # check ok\n read_hdf(path, 'dfq',\n where=\"index>Timestamp('20130104') & columns=['A', 'B']\")\n read_hdf(path, 'dfq', where=\"A>0 or C>0\")\n\n # catch the invalid reference\n with ensure_clean_path(self.path) as path:\n dfq = DataFrame(np.random.randn(10, 4), columns=list(\n 'ABCD'), index=date_range('20130101', periods=10))\n dfq.to_hdf(path, 'dfq', format='table')\n\n with pytest.raises(ValueError):\n read_hdf(path, 'dfq', where=\"A>0 or C>0\")\n\n def test_same_name_scoping(self):\n\n with ensure_clean_store(self.path) as store:\n\n import pandas as pd\n df = DataFrame(np.random.randn(20, 2),\n index=pd.date_range('20130101', periods=20))\n store.put('df', df, format='table')\n expected = df[df.index > pd.Timestamp('20130105')]\n\n import datetime # noqa\n result = store.select('df', 'index>datetime.datetime(2013,1,5)')\n assert_frame_equal(result, expected)\n\n from datetime import datetime # noqa\n\n # technically an error, but allow it\n result = store.select('df', 'index>datetime.datetime(2013,1,5)')\n assert_frame_equal(result, expected)\n\n result = store.select('df', 'index>datetime(2013,1,5)')\n assert_frame_equal(result, expected)\n\n def test_series(self):\n\n s = tm.makeStringSeries()\n self._check_roundtrip(s, tm.assert_series_equal)\n\n ts = tm.makeTimeSeries()\n self._check_roundtrip(ts, tm.assert_series_equal)\n\n ts2 = Series(ts.index, Index(ts.index, dtype=object))\n self._check_roundtrip(ts2, tm.assert_series_equal)\n\n ts3 = Series(ts.values, Index(np.asarray(ts.index, dtype=object),\n dtype=object))\n self._check_roundtrip(ts3, tm.assert_series_equal,\n check_index_type=False)\n\n def test_sparse_series(self):\n\n s = tm.makeStringSeries()\n s.iloc[3:5] = np.nan\n ss = s.to_sparse()\n self._check_roundtrip(ss, tm.assert_series_equal,\n check_series_type=True)\n\n ss2 = s.to_sparse(kind='integer')\n self._check_roundtrip(ss2, tm.assert_series_equal,\n check_series_type=True)\n\n ss3 = s.to_sparse(fill_value=0)\n self._check_roundtrip(ss3, tm.assert_series_equal,\n check_series_type=True)\n\n def test_sparse_frame(self):\n\n s = tm.makeDataFrame()\n s.iloc[3:5, 1:3] = np.nan\n s.iloc[8:10, -2] = np.nan\n ss = s.to_sparse()\n\n self._check_double_roundtrip(ss, tm.assert_frame_equal,\n check_frame_type=True)\n\n ss2 = s.to_sparse(kind='integer')\n self._check_double_roundtrip(ss2, tm.assert_frame_equal,\n check_frame_type=True)\n\n ss3 = s.to_sparse(fill_value=0)\n self._check_double_roundtrip(ss3, tm.assert_frame_equal,\n check_frame_type=True)\n\n def test_float_index(self):\n\n # GH #454\n index = np.random.randn(10)\n s = Series(np.random.randn(10), index=index)\n self._check_roundtrip(s, tm.assert_series_equal)\n\n @xfail_non_writeable\n def test_tuple_index(self):\n\n # GH #492\n col = np.arange(10)\n idx = [(0., 1.), (2., 3.), (4., 5.)]\n data = np.random.randn(30).reshape((3, 10))\n DF = DataFrame(data, index=idx, columns=col)\n\n with catch_warnings(record=True):\n simplefilter(\"ignore\", pd.errors.PerformanceWarning)\n self._check_roundtrip(DF, tm.assert_frame_equal)\n\n @xfail_non_writeable\n @pytest.mark.filterwarnings(\"ignore::pandas.errors.PerformanceWarning\")\n def test_index_types(self):\n\n with catch_warnings(record=True):\n values = np.random.randn(2)\n\n func = lambda l, r: tm.assert_series_equal(l, r,\n check_dtype=True,\n check_index_type=True,\n check_series_type=True)\n\n with catch_warnings(record=True):\n ser = Series(values, [0, 'y'])\n self._check_roundtrip(ser, func)\n\n with catch_warnings(record=True):\n ser = Series(values, [datetime.datetime.today(), 0])\n self._check_roundtrip(ser, func)\n\n with catch_warnings(record=True):\n ser = Series(values, ['y', 0])\n self._check_roundtrip(ser, func)\n\n with catch_warnings(record=True):\n ser = Series(values, [datetime.date.today(), 'a'])\n self._check_roundtrip(ser, func)\n\n with catch_warnings(record=True):\n\n ser = Series(values, [0, 'y'])\n self._check_roundtrip(ser, func)\n\n ser = Series(values, [datetime.datetime.today(), 0])\n self._check_roundtrip(ser, func)\n\n ser = Series(values, ['y', 0])\n self._check_roundtrip(ser, func)\n\n ser = Series(values, [datetime.date.today(), 'a'])\n self._check_roundtrip(ser, func)\n\n ser = Series(values, [1.23, 'b'])\n self._check_roundtrip(ser, func)\n\n ser = Series(values, [1, 1.53])\n self._check_roundtrip(ser, func)\n\n ser = Series(values, [1, 5])\n self._check_roundtrip(ser, func)\n\n ser = Series(values, [datetime.datetime(\n 2012, 1, 1), datetime.datetime(2012, 1, 2)])\n self._check_roundtrip(ser, func)\n\n def test_timeseries_preepoch(self):\n\n dr = bdate_range('1/1/1940', '1/1/1960')\n ts = Series(np.random.randn(len(dr)), index=dr)\n try:\n self._check_roundtrip(ts, tm.assert_series_equal)\n except OverflowError:\n pytest.skip('known failer on some windows platforms')\n\n @xfail_non_writeable\n @pytest.mark.parametrize(\"compression\", [\n False, pytest.param(True, marks=td.skip_if_windows_python_3)\n ])\n def test_frame(self, compression):\n\n df = tm.makeDataFrame()\n\n # put in some random NAs\n df.values[0, 0] = np.nan\n df.values[5, 3] = np.nan\n\n self._check_roundtrip_table(df, tm.assert_frame_equal,\n compression=compression)\n self._check_roundtrip(df, tm.assert_frame_equal,\n compression=compression)\n\n tdf = tm.makeTimeDataFrame()\n self._check_roundtrip(tdf, tm.assert_frame_equal,\n compression=compression)\n\n with ensure_clean_store(self.path) as store:\n # not consolidated\n df['foo'] = np.random.randn(len(df))\n store['df'] = df\n recons = store['df']\n assert recons._data.is_consolidated()\n\n # empty\n self._check_roundtrip(df[:0], tm.assert_frame_equal)\n\n @xfail_non_writeable\n def test_empty_series_frame(self):\n s0 = Series()\n s1 = Series(name='myseries')\n df0 = DataFrame()\n df1 = DataFrame(index=['a', 'b', 'c'])\n df2 = DataFrame(columns=['d', 'e', 'f'])\n\n self._check_roundtrip(s0, tm.assert_series_equal)\n self._check_roundtrip(s1, tm.assert_series_equal)\n self._check_roundtrip(df0, tm.assert_frame_equal)\n self._check_roundtrip(df1, tm.assert_frame_equal)\n self._check_roundtrip(df2, tm.assert_frame_equal)\n\n @xfail_non_writeable\n @pytest.mark.parametrize(\n 'dtype', [np.int64, np.float64, np.object, 'm8[ns]', 'M8[ns]'])\n def test_empty_series(self, dtype):\n s = Series(dtype=dtype)\n self._check_roundtrip(s, tm.assert_series_equal)\n\n def test_can_serialize_dates(self):\n\n rng = [x.date() for x in bdate_range('1/1/2000', '1/30/2000')]\n frame = DataFrame(np.random.randn(len(rng), 4), index=rng)\n\n self._check_roundtrip(frame, tm.assert_frame_equal)\n\n def test_store_hierarchical(self):\n index = MultiIndex(levels=[['foo', 'bar', 'baz', 'qux'],\n ['one', 'two', 'three']],\n codes=[[0, 0, 0, 1, 1, 2, 2, 3, 3, 3],\n [0, 1, 2, 0, 1, 1, 2, 0, 1, 2]],\n names=['foo', 'bar'])\n frame = DataFrame(np.random.randn(10, 3), index=index,\n columns=['A', 'B', 'C'])\n\n self._check_roundtrip(frame, tm.assert_frame_equal)\n self._check_roundtrip(frame.T, tm.assert_frame_equal)\n self._check_roundtrip(frame['A'], tm.assert_series_equal)\n\n # check that the names are stored\n with ensure_clean_store(self.path) as store:\n store['frame'] = frame\n recons = store['frame']\n tm.assert_frame_equal(recons, frame)\n\n def test_store_index_name(self):\n df = tm.makeDataFrame()\n df.index.name = 'foo'\n\n with ensure_clean_store(self.path) as store:\n store['frame'] = df\n recons = store['frame']\n tm.assert_frame_equal(recons, df)\n\n def test_store_index_name_with_tz(self):\n # GH 13884\n df = pd.DataFrame({'A': [1, 2]})\n df.index = pd.DatetimeIndex([1234567890123456787, 1234567890123456788])\n df.index = df.index.tz_localize('UTC')\n df.index.name = 'foo'\n\n with ensure_clean_store(self.path) as store:\n store.put('frame', df, format='table')\n recons = store['frame']\n tm.assert_frame_equal(recons, df)\n\n @pytest.mark.parametrize('table_format', ['table', 'fixed'])\n def test_store_index_name_numpy_str(self, table_format):\n # GH #13492\n idx = pd.Index(pd.to_datetime([datetime.date(2000, 1, 1),\n datetime.date(2000, 1, 2)]),\n name='cols\\u05d2')\n idx1 = pd.Index(pd.to_datetime([datetime.date(2010, 1, 1),\n datetime.date(2010, 1, 2)]),\n name='rows\\u05d0')\n df = pd.DataFrame(np.arange(4).reshape(2, 2), columns=idx, index=idx1)\n\n # This used to fail, returning numpy strings instead of python strings.\n with ensure_clean_path(self.path) as path:\n df.to_hdf(path, 'df', format=table_format)\n df2 = read_hdf(path, 'df')\n\n assert_frame_equal(df, df2, check_names=True)\n\n assert type(df2.index.name) == str\n assert type(df2.columns.name) == str\n\n def test_store_series_name(self):\n df = tm.makeDataFrame()\n series = df['A']\n\n with ensure_clean_store(self.path) as store:\n store['series'] = series\n recons = store['series']\n tm.assert_series_equal(recons, series)\n\n @xfail_non_writeable\n @pytest.mark.parametrize(\"compression\", [\n False, pytest.param(True, marks=td.skip_if_windows_python_3)\n ])\n def test_store_mixed(self, compression):\n\n def _make_one():\n df = tm.makeDataFrame()\n df['obj1'] = 'foo'\n df['obj2'] = 'bar'\n df['bool1'] = df['A'] > 0\n df['bool2'] = df['B'] > 0\n df['int1'] = 1\n df['int2'] = 2\n return df._consolidate()\n\n df1 = _make_one()\n df2 = _make_one()\n\n self._check_roundtrip(df1, tm.assert_frame_equal)\n self._check_roundtrip(df2, tm.assert_frame_equal)\n\n with ensure_clean_store(self.path) as store:\n store['obj'] = df1\n tm.assert_frame_equal(store['obj'], df1)\n store['obj'] = df2\n tm.assert_frame_equal(store['obj'], df2)\n\n # check that can store Series of all of these types\n self._check_roundtrip(df1['obj1'], tm.assert_series_equal,\n compression=compression)\n self._check_roundtrip(df1['bool1'], tm.assert_series_equal,\n compression=compression)\n self._check_roundtrip(df1['int1'], tm.assert_series_equal,\n compression=compression)\n\n @pytest.mark.filterwarnings(\n \"ignore:\\\\nduplicate:pandas.io.pytables.DuplicateWarning\"\n )\n def test_select_with_dups(self):\n\n # single dtypes\n df = DataFrame(np.random.randn(10, 4), columns=['A', 'A', 'B', 'B'])\n df.index = date_range('20130101 9:30', periods=10, freq='T')\n\n with ensure_clean_store(self.path) as store:\n store.append('df', df)\n\n result = store.select('df')\n expected = df\n assert_frame_equal(result, expected, by_blocks=True)\n\n result = store.select('df', columns=df.columns)\n expected = df\n assert_frame_equal(result, expected, by_blocks=True)\n\n result = store.select('df', columns=['A'])\n expected = df.loc[:, ['A']]\n assert_frame_equal(result, expected)\n\n # dups across dtypes\n df = concat([DataFrame(np.random.randn(10, 4),\n columns=['A', 'A', 'B', 'B']),\n DataFrame(np.random.randint(0, 10, size=20)\n .reshape(10, 2),\n columns=['A', 'C'])],\n axis=1)\n df.index = date_range('20130101 9:30', periods=10, freq='T')\n\n with ensure_clean_store(self.path) as store:\n store.append('df', df)\n\n result = store.select('df')\n expected = df\n assert_frame_equal(result, expected, by_blocks=True)\n\n result = store.select('df', columns=df.columns)\n expected = df\n assert_frame_equal(result, expected, by_blocks=True)\n\n expected = df.loc[:, ['A']]\n result = store.select('df', columns=['A'])\n assert_frame_equal(result, expected, by_blocks=True)\n\n expected = df.loc[:, ['B', 'A']]\n result = store.select('df', columns=['B', 'A'])\n assert_frame_equal(result, expected, by_blocks=True)\n\n # duplicates on both index and columns\n with ensure_clean_store(self.path) as store:\n store.append('df', df)\n store.append('df', df)\n\n expected = df.loc[:, ['B', 'A']]\n expected = concat([expected, expected])\n result = store.select('df', columns=['B', 'A'])\n assert_frame_equal(result, expected, by_blocks=True)\n\n def test_overwrite_node(self):\n\n with ensure_clean_store(self.path) as store:\n store['a'] = tm.makeTimeDataFrame()\n ts = tm.makeTimeSeries()\n store['a'] = ts\n\n tm.assert_series_equal(store['a'], ts)\n\n def test_sparse_with_compression(self):\n\n # GH 2931\n\n # make sparse dataframe\n arr = np.random.binomial(n=1, p=.01, size=(1000, 10))\n df = DataFrame(arr).to_sparse(fill_value=0)\n\n # case 1: store uncompressed\n self._check_double_roundtrip(df, tm.assert_frame_equal,\n compression=False,\n check_frame_type=True)\n\n # case 2: store compressed (works)\n self._check_double_roundtrip(df, tm.assert_frame_equal,\n compression='zlib',\n check_frame_type=True)\n\n # set one series to be completely sparse\n df[0] = np.zeros(1000)\n\n # case 3: store df with completely sparse series uncompressed\n self._check_double_roundtrip(df, tm.assert_frame_equal,\n compression=False,\n check_frame_type=True)\n\n # case 4: try storing df with completely sparse series compressed\n # (fails)\n self._check_double_roundtrip(df, tm.assert_frame_equal,\n compression='zlib',\n check_frame_type=True)\n\n def test_select(self):\n\n with ensure_clean_store(self.path) as store:\n\n with catch_warnings(record=True):\n\n # select with columns=\n df = tm.makeTimeDataFrame()\n _maybe_remove(store, 'df')\n store.append('df', df)\n result = store.select('df', columns=['A', 'B'])\n expected = df.reindex(columns=['A', 'B'])\n tm.assert_frame_equal(expected, result)\n\n # equivalentsly\n result = store.select('df', [(\"columns=['A', 'B']\")])\n expected = df.reindex(columns=['A', 'B'])\n tm.assert_frame_equal(expected, result)\n\n # with a data column\n _maybe_remove(store, 'df')\n store.append('df', df, data_columns=['A'])\n result = store.select('df', ['A > 0'], columns=['A', 'B'])\n expected = df[df.A > 0].reindex(columns=['A', 'B'])\n tm.assert_frame_equal(expected, result)\n\n # all a data columns\n _maybe_remove(store, 'df')\n store.append('df', df, data_columns=True)\n result = store.select('df', ['A > 0'], columns=['A', 'B'])\n expected = df[df.A > 0].reindex(columns=['A', 'B'])\n tm.assert_frame_equal(expected, result)\n\n # with a data column, but different columns\n _maybe_remove(store, 'df')\n store.append('df', df, data_columns=['A'])\n result = store.select('df', ['A > 0'], columns=['C', 'D'])\n expected = df[df.A > 0].reindex(columns=['C', 'D'])\n tm.assert_frame_equal(expected, result)\n\n def test_select_dtypes(self):\n\n with ensure_clean_store(self.path) as store:\n # with a Timestamp data column (GH #2637)\n df = DataFrame(dict(\n ts=bdate_range('2012-01-01', periods=300),\n A=np.random.randn(300)))\n _maybe_remove(store, 'df')\n store.append('df', df, data_columns=['ts', 'A'])\n\n result = store.select('df', \"ts>=Timestamp('2012-02-01')\")\n expected = df[df.ts >= Timestamp('2012-02-01')]\n tm.assert_frame_equal(expected, result)\n\n # bool columns (GH #2849)\n df = DataFrame(np.random.randn(5, 2), columns=['A', 'B'])\n df['object'] = 'foo'\n df.loc[4:5, 'object'] = 'bar'\n df['boolv'] = df['A'] > 0\n _maybe_remove(store, 'df')\n store.append('df', df, data_columns=True)\n\n expected = (df[df.boolv == True] # noqa\n .reindex(columns=['A', 'boolv']))\n for v in [True, 'true', 1]:\n result = store.select('df', 'boolv == %s' % str(v),\n columns=['A', 'boolv'])\n tm.assert_frame_equal(expected, result)\n\n expected = (df[df.boolv == False] # noqa\n .reindex(columns=['A', 'boolv']))\n for v in [False, 'false', 0]:\n result = store.select(\n 'df', 'boolv == %s' % str(v), columns=['A', 'boolv'])\n tm.assert_frame_equal(expected, result)\n\n # integer index\n df = DataFrame(dict(A=np.random.rand(20), B=np.random.rand(20)))\n _maybe_remove(store, 'df_int')\n store.append('df_int', df)\n result = store.select(\n 'df_int', \"index<10 and columns=['A']\")\n expected = df.reindex(index=list(df.index)[0:10], columns=['A'])\n tm.assert_frame_equal(expected, result)\n\n # float index\n df = DataFrame(dict(A=np.random.rand(\n 20), B=np.random.rand(20), index=np.arange(20, dtype='f8')))\n _maybe_remove(store, 'df_float')\n store.append('df_float', df)\n result = store.select(\n 'df_float', \"index<10.0 and columns=['A']\")\n expected = df.reindex(index=list(df.index)[0:10], columns=['A'])\n tm.assert_frame_equal(expected, result)\n\n with ensure_clean_store(self.path) as store:\n\n # floats w/o NaN\n df = DataFrame(\n dict(cols=range(11), values=range(11)), dtype='float64')\n df['cols'] = (df['cols'] + 10).apply(str)\n\n store.append('df1', df, data_columns=True)\n result = store.select(\n 'df1', where='values>2.0')\n expected = df[df['values'] > 2.0]\n tm.assert_frame_equal(expected, result)\n\n # floats with NaN\n df.iloc[0] = np.nan\n expected = df[df['values'] > 2.0]\n\n store.append('df2', df, data_columns=True, index=False)\n result = store.select(\n 'df2', where='values>2.0')\n tm.assert_frame_equal(expected, result)\n\n # https://github.com/PyTables/PyTables/issues/282\n # bug in selection when 0th row has a np.nan and an index\n # store.append('df3',df,data_columns=True)\n # result = store.select(\n # 'df3', where='values>2.0')\n # tm.assert_frame_equal(expected, result)\n\n # not in first position float with NaN ok too\n df = DataFrame(\n dict(cols=range(11), values=range(11)), dtype='float64')\n df['cols'] = (df['cols'] + 10).apply(str)\n\n df.iloc[1] = np.nan\n expected = df[df['values'] > 2.0]\n\n store.append('df4', df, data_columns=True)\n result = store.select(\n 'df4', where='values>2.0')\n tm.assert_frame_equal(expected, result)\n\n # test selection with comparison against numpy scalar\n # GH 11283\n with ensure_clean_store(self.path) as store:\n df = tm.makeDataFrame()\n\n expected = df[df['A'] > 0]\n\n store.append('df', df, data_columns=True)\n np_zero = np.float64(0) # noqa\n result = store.select('df', where=[\"A>np_zero\"])\n tm.assert_frame_equal(expected, result)\n\n def test_select_with_many_inputs(self):\n\n with ensure_clean_store(self.path) as store:\n\n df = DataFrame(dict(ts=bdate_range('2012-01-01', periods=300),\n A=np.random.randn(300),\n B=range(300),\n users=['a'] * 50 + ['b'] * 50 + ['c'] * 100 +\n ['a%03d' % i for i in range(100)]))\n _maybe_remove(store, 'df')\n store.append('df', df, data_columns=['ts', 'A', 'B', 'users'])\n\n # regular select\n result = store.select('df', \"ts>=Timestamp('2012-02-01')\")\n expected = df[df.ts >= Timestamp('2012-02-01')]\n tm.assert_frame_equal(expected, result)\n\n # small selector\n result = store.select(\n 'df',\n \"ts>=Timestamp('2012-02-01') & users=['a','b','c']\")\n expected = df[(df.ts >= Timestamp('2012-02-01')) &\n df.users.isin(['a', 'b', 'c'])]\n tm.assert_frame_equal(expected, result)\n\n # big selector along the columns\n selector = ['a', 'b', 'c'] + ['a%03d' % i for i in range(60)]\n result = store.select(\n 'df',\n \"ts>=Timestamp('2012-02-01') and users=selector\")\n expected = df[(df.ts >= Timestamp('2012-02-01')) &\n df.users.isin(selector)]\n tm.assert_frame_equal(expected, result)\n\n selector = range(100, 200)\n result = store.select('df', 'B=selector')\n expected = df[df.B.isin(selector)]\n tm.assert_frame_equal(expected, result)\n assert len(result) == 100\n\n # big selector along the index\n selector = Index(df.ts[0:100].values)\n result = store.select('df', 'ts=selector')\n expected = df[df.ts.isin(selector.values)]\n tm.assert_frame_equal(expected, result)\n assert len(result) == 100\n\n def test_select_iterator(self):\n\n # single table\n with ensure_clean_store(self.path) as store:\n\n df = tm.makeTimeDataFrame(500)\n _maybe_remove(store, 'df')\n store.append('df', df)\n\n expected = store.select('df')\n\n results = [s for s in store.select('df', iterator=True)]\n result = concat(results)\n tm.assert_frame_equal(expected, result)\n\n results = [s for s in store.select('df', chunksize=100)]\n assert len(results) == 5\n result = concat(results)\n tm.assert_frame_equal(expected, result)\n\n results = [s for s in store.select('df', chunksize=150)]\n result = concat(results)\n tm.assert_frame_equal(result, expected)\n\n with ensure_clean_path(self.path) as path:\n\n df = tm.makeTimeDataFrame(500)\n df.to_hdf(path, 'df_non_table')\n\n with pytest.raises(TypeError):\n read_hdf(path, 'df_non_table', chunksize=100)\n\n with pytest.raises(TypeError):\n read_hdf(path, 'df_non_table', iterator=True)\n\n with ensure_clean_path(self.path) as path:\n\n df = tm.makeTimeDataFrame(500)\n df.to_hdf(path, 'df', format='table')\n\n results = [s for s in read_hdf(path, 'df', chunksize=100)]\n result = concat(results)\n\n assert len(results) == 5\n tm.assert_frame_equal(result, df)\n tm.assert_frame_equal(result, read_hdf(path, 'df'))\n\n # multiple\n\n with ensure_clean_store(self.path) as store:\n\n df1 = tm.makeTimeDataFrame(500)\n store.append('df1', df1, data_columns=True)\n df2 = tm.makeTimeDataFrame(500).rename(\n columns=lambda x: \"%s_2\" % x)\n df2['foo'] = 'bar'\n store.append('df2', df2)\n\n df = concat([df1, df2], axis=1)\n\n # full selection\n expected = store.select_as_multiple(\n ['df1', 'df2'], selector='df1')\n results = [s for s in store.select_as_multiple(\n ['df1', 'df2'], selector='df1', chunksize=150)]\n result = concat(results)\n tm.assert_frame_equal(expected, result)\n\n def test_select_iterator_complete_8014(self):\n\n # GH 8014\n # using iterator and where clause\n chunksize = 1e4\n\n # no iterator\n with ensure_clean_store(self.path) as store:\n\n expected = tm.makeTimeDataFrame(100064, 'S')\n _maybe_remove(store, 'df')\n store.append('df', expected)\n\n beg_dt = expected.index[0]\n end_dt = expected.index[-1]\n\n # select w/o iteration and no where clause works\n result = store.select('df')\n tm.assert_frame_equal(expected, result)\n\n # select w/o iterator and where clause, single term, begin\n # of range, works\n where = \"index >= '%s'\" % beg_dt\n result = store.select('df', where=where)\n tm.assert_frame_equal(expected, result)\n\n # select w/o iterator and where clause, single term, end\n # of range, works\n where = \"index <= '%s'\" % end_dt\n result = store.select('df', where=where)\n tm.assert_frame_equal(expected, result)\n\n # select w/o iterator and where clause, inclusive range,\n # works\n where = \"index >= '%s' & index <= '%s'\" % (beg_dt, end_dt)\n result = store.select('df', where=where)\n tm.assert_frame_equal(expected, result)\n\n # with iterator, full range\n with ensure_clean_store(self.path) as store:\n\n expected = tm.makeTimeDataFrame(100064, 'S')\n _maybe_remove(store, 'df')\n store.append('df', expected)\n\n beg_dt = expected.index[0]\n end_dt = expected.index[-1]\n\n # select w/iterator and no where clause works\n results = [s for s in store.select('df', chunksize=chunksize)]\n result = concat(results)\n tm.assert_frame_equal(expected, result)\n\n # select w/iterator and where clause, single term, begin of range\n where = \"index >= '%s'\" % beg_dt\n results = [s for s in store.select(\n 'df', where=where, chunksize=chunksize)]\n result = concat(results)\n tm.assert_frame_equal(expected, result)\n\n # select w/iterator and where clause, single term, end of range\n where = \"index <= '%s'\" % end_dt\n results = [s for s in store.select(\n 'df', where=where, chunksize=chunksize)]\n result = concat(results)\n tm.assert_frame_equal(expected, result)\n\n # select w/iterator and where clause, inclusive range\n where = \"index >= '%s' & index <= '%s'\" % (beg_dt, end_dt)\n results = [s for s in store.select(\n 'df', where=where, chunksize=chunksize)]\n result = concat(results)\n tm.assert_frame_equal(expected, result)\n\n def test_select_iterator_non_complete_8014(self):\n\n # GH 8014\n # using iterator and where clause\n chunksize = 1e4\n\n # with iterator, non complete range\n with ensure_clean_store(self.path) as store:\n\n expected = tm.makeTimeDataFrame(100064, 'S')\n _maybe_remove(store, 'df')\n store.append('df', expected)\n\n beg_dt = expected.index[1]\n end_dt = expected.index[-2]\n\n # select w/iterator and where clause, single term, begin of range\n where = \"index >= '%s'\" % beg_dt\n results = [s for s in store.select(\n 'df', where=where, chunksize=chunksize)]\n result = concat(results)\n rexpected = expected[expected.index >= beg_dt]\n tm.assert_frame_equal(rexpected, result)\n\n # select w/iterator and where clause, single term, end of range\n where = \"index <= '%s'\" % end_dt\n results = [s for s in store.select(\n 'df', where=where, chunksize=chunksize)]\n result = concat(results)\n rexpected = expected[expected.index <= end_dt]\n tm.assert_frame_equal(rexpected, result)\n\n # select w/iterator and where clause, inclusive range\n where = \"index >= '%s' & index <= '%s'\" % (beg_dt, end_dt)\n results = [s for s in store.select(\n 'df', where=where, chunksize=chunksize)]\n result = concat(results)\n rexpected = expected[(expected.index >= beg_dt) &\n (expected.index <= end_dt)]\n tm.assert_frame_equal(rexpected, result)\n\n # with iterator, empty where\n with ensure_clean_store(self.path) as store:\n\n expected = tm.makeTimeDataFrame(100064, 'S')\n _maybe_remove(store, 'df')\n store.append('df', expected)\n\n end_dt = expected.index[-1]\n\n # select w/iterator and where clause, single term, begin of range\n where = \"index > '%s'\" % end_dt\n results = [s for s in store.select(\n 'df', where=where, chunksize=chunksize)]\n assert 0 == len(results)\n\n def test_select_iterator_many_empty_frames(self):\n\n # GH 8014\n # using iterator and where clause can return many empty\n # frames.\n chunksize = int(1e4)\n\n # with iterator, range limited to the first chunk\n with ensure_clean_store(self.path) as store:\n\n expected = tm.makeTimeDataFrame(100000, 'S')\n _maybe_remove(store, 'df')\n store.append('df', expected)\n\n beg_dt = expected.index[0]\n end_dt = expected.index[chunksize - 1]\n\n # select w/iterator and where clause, single term, begin of range\n where = \"index >= '%s'\" % beg_dt\n results = [s for s in store.select(\n 'df', where=where, chunksize=chunksize)]\n result = concat(results)\n rexpected = expected[expected.index >= beg_dt]\n tm.assert_frame_equal(rexpected, result)\n\n # select w/iterator and where clause, single term, end of range\n where = \"index <= '%s'\" % end_dt\n results = [s for s in store.select(\n 'df', where=where, chunksize=chunksize)]\n\n assert len(results) == 1\n result = concat(results)\n rexpected = expected[expected.index <= end_dt]\n tm.assert_frame_equal(rexpected, result)\n\n # select w/iterator and where clause, inclusive range\n where = \"index >= '%s' & index <= '%s'\" % (beg_dt, end_dt)\n results = [s for s in store.select(\n 'df', where=where, chunksize=chunksize)]\n\n # should be 1, is 10\n assert len(results) == 1\n result = concat(results)\n rexpected = expected[(expected.index >= beg_dt) &\n (expected.index <= end_dt)]\n tm.assert_frame_equal(rexpected, result)\n\n # select w/iterator and where clause which selects\n # *nothing*.\n #\n # To be consistent with Python idiom I suggest this should\n # return [] e.g. `for e in []: print True` never prints\n # True.\n\n where = \"index <= '%s' & index >= '%s'\" % (beg_dt, end_dt)\n results = [s for s in store.select(\n 'df', where=where, chunksize=chunksize)]\n\n # should be []\n assert len(results) == 0\n\n @pytest.mark.filterwarnings(\n \"ignore:\\\\nthe :pandas.io.pytables.AttributeConflictWarning\"\n )\n def test_retain_index_attributes(self):\n\n # GH 3499, losing frequency info on index recreation\n df = DataFrame(dict(\n A=Series(lrange(3),\n index=date_range('2000-1-1', periods=3, freq='H'))))\n\n with ensure_clean_store(self.path) as store:\n _maybe_remove(store, 'data')\n store.put('data', df, format='table')\n\n result = store.get('data')\n tm.assert_frame_equal(df, result)\n\n for attr in ['freq', 'tz', 'name']:\n for idx in ['index', 'columns']:\n assert (getattr(getattr(df, idx), attr, None) ==\n getattr(getattr(result, idx), attr, None))\n\n # try to append a table with a different frequency\n with catch_warnings(record=True):\n df2 = DataFrame(dict(\n A=Series(lrange(3),\n index=date_range('2002-1-1',\n periods=3, freq='D'))))\n store.append('data', df2)\n\n assert store.get_storer('data').info['index']['freq'] is None\n\n # this is ok\n _maybe_remove(store, 'df2')\n df2 = DataFrame(dict(\n A=Series(lrange(3),\n index=[Timestamp('20010101'), Timestamp('20010102'),\n Timestamp('20020101')])))\n store.append('df2', df2)\n df3 = DataFrame(dict(\n A=Series(lrange(3),\n index=date_range('2002-1-1', periods=3,\n freq='D'))))\n store.append('df2', df3)\n\n @pytest.mark.filterwarnings(\n \"ignore:\\\\nthe :pandas.io.pytables.AttributeConflictWarning\"\n )\n def test_retain_index_attributes2(self):\n with ensure_clean_path(self.path) as path:\n\n with catch_warnings(record=True):\n\n df = DataFrame(dict(\n A=Series(lrange(3),\n index=date_range('2000-1-1',\n periods=3, freq='H'))))\n df.to_hdf(path, 'data', mode='w', append=True)\n df2 = DataFrame(dict(\n A=Series(lrange(3),\n index=date_range('2002-1-1', periods=3,\n freq='D'))))\n df2.to_hdf(path, 'data', append=True)\n\n idx = date_range('2000-1-1', periods=3, freq='H')\n idx.name = 'foo'\n df = DataFrame(dict(A=Series(lrange(3), index=idx)))\n df.to_hdf(path, 'data', mode='w', append=True)\n\n assert read_hdf(path, 'data').index.name == 'foo'\n\n with catch_warnings(record=True):\n\n idx2 = date_range('2001-1-1', periods=3, freq='H')\n idx2.name = 'bar'\n df2 = DataFrame(dict(A=Series(lrange(3), index=idx2)))\n df2.to_hdf(path, 'data', append=True)\n\n assert read_hdf(path, 'data').index.name is None\n\n def test_frame_select(self):\n\n df = tm.makeTimeDataFrame()\n\n with ensure_clean_store(self.path) as store:\n store.put('frame', df, format='table')\n date = df.index[len(df) // 2]\n\n crit1 = Term('index>=date')\n assert crit1.env.scope['date'] == date\n\n crit2 = (\"columns=['A', 'D']\")\n crit3 = ('columns=A')\n\n result = store.select('frame', [crit1, crit2])\n expected = df.loc[date:, ['A', 'D']]\n tm.assert_frame_equal(result, expected)\n\n result = store.select('frame', [crit3])\n expected = df.loc[:, ['A']]\n tm.assert_frame_equal(result, expected)\n\n # invalid terms\n df = tm.makeTimeDataFrame()\n store.append('df_time', df)\n with pytest.raises(ValueError):\n store.select('df_time', \"index>0\")\n\n # can't select if not written as table\n # store['frame'] = df\n # with pytest.raises(ValueError):\n # store.select('frame', [crit1, crit2])\n\n def test_frame_select_complex(self):\n # select via complex criteria\n\n df = tm.makeTimeDataFrame()\n df['string'] = 'foo'\n df.loc[df.index[0:4], 'string'] = 'bar'\n\n with ensure_clean_store(self.path) as store:\n store.put('df', df, format='table', data_columns=['string'])\n\n # empty\n result = store.select('df', 'index>df.index[3] & string=\"bar\"')\n expected = df.loc[(df.index > df.index[3]) & (df.string == 'bar')]\n tm.assert_frame_equal(result, expected)\n\n result = store.select('df', 'index>df.index[3] & string=\"foo\"')\n expected = df.loc[(df.index > df.index[3]) & (df.string == 'foo')]\n tm.assert_frame_equal(result, expected)\n\n # or\n result = store.select('df', 'index>df.index[3] | string=\"bar\"')\n expected = df.loc[(df.index > df.index[3]) | (df.string == 'bar')]\n tm.assert_frame_equal(result, expected)\n\n result = store.select('df', '(index>df.index[3] & '\n 'index<=df.index[6]) | string=\"bar\"')\n expected = df.loc[((df.index > df.index[3]) & (\n df.index <= df.index[6])) | (df.string == 'bar')]\n tm.assert_frame_equal(result, expected)\n\n # invert\n result = store.select('df', 'string!=\"bar\"')\n expected = df.loc[df.string != 'bar']\n tm.assert_frame_equal(result, expected)\n\n # invert not implemented in numexpr :(\n with pytest.raises(NotImplementedError):\n store.select('df', '~(string=\"bar\")')\n\n # invert ok for filters\n result = store.select('df', \"~(columns=['A','B'])\")\n expected = df.loc[:, df.columns.difference(['A', 'B'])]\n tm.assert_frame_equal(result, expected)\n\n # in\n result = store.select(\n 'df', \"index>df.index[3] & columns in ['A','B']\")\n expected = df.loc[df.index > df.index[3]].reindex(columns=[\n 'A', 'B'])\n tm.assert_frame_equal(result, expected)\n\n def test_frame_select_complex2(self):\n\n with ensure_clean_path(['parms.hdf', 'hist.hdf']) as paths:\n\n pp, hh = paths\n\n # use non-trivial selection criteria\n parms = DataFrame({'A': [1, 1, 2, 2, 3]})\n parms.to_hdf(pp, 'df', mode='w',\n format='table', data_columns=['A'])\n\n selection = read_hdf(pp, 'df', where='A=[2,3]')\n hist = DataFrame(np.random.randn(25, 1),\n columns=['data'],\n index=MultiIndex.from_tuples(\n [(i, j) for i in range(5)\n for j in range(5)],\n names=['l1', 'l2']))\n\n hist.to_hdf(hh, 'df', mode='w', format='table')\n\n expected = read_hdf(hh, 'df', where='l1=[2, 3, 4]')\n\n # sccope with list like\n l = selection.index.tolist() # noqa\n store = HDFStore(hh)\n result = store.select('df', where='l1=l')\n assert_frame_equal(result, expected)\n store.close()\n\n result = read_hdf(hh, 'df', where='l1=l')\n assert_frame_equal(result, expected)\n\n # index\n index = selection.index # noqa\n result = read_hdf(hh, 'df', where='l1=index')\n assert_frame_equal(result, expected)\n\n result = read_hdf(hh, 'df', where='l1=selection.index')\n assert_frame_equal(result, expected)\n\n result = read_hdf(hh, 'df', where='l1=selection.index.tolist()')\n assert_frame_equal(result, expected)\n\n result = read_hdf(hh, 'df', where='l1=list(selection.index)')\n assert_frame_equal(result, expected)\n\n # sccope with index\n store = HDFStore(hh)\n\n result = store.select('df', where='l1=index')\n assert_frame_equal(result, expected)\n\n result = store.select('df', where='l1=selection.index')\n assert_frame_equal(result, expected)\n\n result = store.select('df', where='l1=selection.index.tolist()')\n assert_frame_equal(result, expected)\n\n result = store.select('df', where='l1=list(selection.index)')\n assert_frame_equal(result, expected)\n\n store.close()\n\n def test_invalid_filtering(self):\n\n # can't use more than one filter (atm)\n\n df = tm.makeTimeDataFrame()\n\n with ensure_clean_store(self.path) as store:\n store.put('df', df, format='table')\n\n # not implemented\n with pytest.raises(NotImplementedError):\n store.select('df', \"columns=['A'] | columns=['B']\")\n\n # in theory we could deal with this\n with pytest.raises(NotImplementedError):\n store.select('df', \"columns=['A','B'] & columns=['C']\")\n\n def test_string_select(self):\n # GH 2973\n with ensure_clean_store(self.path) as store:\n\n df = tm.makeTimeDataFrame()\n\n # test string ==/!=\n df['x'] = 'none'\n df.loc[2:7, 'x'] = ''\n\n store.append('df', df, data_columns=['x'])\n\n result = store.select('df', 'x=none')\n expected = df[df.x == 'none']\n assert_frame_equal(result, expected)\n\n try:\n result = store.select('df', 'x!=none')\n expected = df[df.x != 'none']\n assert_frame_equal(result, expected)\n except Exception as detail:\n pprint_thing(\"[{0}]\".format(detail))\n pprint_thing(store)\n pprint_thing(expected)\n\n df2 = df.copy()\n df2.loc[df2.x == '', 'x'] = np.nan\n\n store.append('df2', df2, data_columns=['x'])\n result = store.select('df2', 'x!=none')\n expected = df2[isna(df2.x)]\n assert_frame_equal(result, expected)\n\n # int ==/!=\n df['int'] = 1\n df.loc[2:7, 'int'] = 2\n\n store.append('df3', df, data_columns=['int'])\n\n result = store.select('df3', 'int=2')\n expected = df[df.int == 2]\n assert_frame_equal(result, expected)\n\n result = store.select('df3', 'int!=2')\n expected = df[df.int != 2]\n assert_frame_equal(result, expected)\n\n def test_read_column(self):\n\n df = tm.makeTimeDataFrame()\n\n with ensure_clean_store(self.path) as store:\n _maybe_remove(store, 'df')\n\n # GH 17912\n # HDFStore.select_column should raise a KeyError\n # exception if the key is not a valid store\n with pytest.raises(KeyError,\n match='No object named df in the file'):\n store.select_column('df', 'index')\n\n store.append('df', df)\n # error\n with pytest.raises(KeyError):\n store.select_column('df', 'foo')\n\n with pytest.raises(Exception):\n store.select_column('df', 'index', where=['index>5'])\n\n # valid\n result = store.select_column('df', 'index')\n tm.assert_almost_equal(result.values, Series(df.index).values)\n assert isinstance(result, Series)\n\n # not a data indexable column\n with pytest.raises(ValueError):\n store.select_column('df', 'values_block_0')\n\n # a data column\n df2 = df.copy()\n df2['string'] = 'foo'\n store.append('df2', df2, data_columns=['string'])\n result = store.select_column('df2', 'string')\n tm.assert_almost_equal(result.values, df2['string'].values)\n\n # a data column with NaNs, result excludes the NaNs\n df3 = df.copy()\n df3['string'] = 'foo'\n df3.loc[4:6, 'string'] = np.nan\n store.append('df3', df3, data_columns=['string'])\n result = store.select_column('df3', 'string')\n tm.assert_almost_equal(result.values, df3['string'].values)\n\n # start/stop\n result = store.select_column('df3', 'string', start=2)\n tm.assert_almost_equal(result.values, df3['string'].values[2:])\n\n result = store.select_column('df3', 'string', start=-2)\n tm.assert_almost_equal(result.values, df3['string'].values[-2:])\n\n result = store.select_column('df3', 'string', stop=2)\n tm.assert_almost_equal(result.values, df3['string'].values[:2])\n\n result = store.select_column('df3', 'string', stop=-2)\n tm.assert_almost_equal(result.values, df3['string'].values[:-2])\n\n result = store.select_column('df3', 'string', start=2, stop=-2)\n tm.assert_almost_equal(result.values, df3['string'].values[2:-2])\n\n result = store.select_column('df3', 'string', start=-2, stop=2)\n tm.assert_almost_equal(result.values, df3['string'].values[-2:2])\n\n # GH 10392 - make sure column name is preserved\n df4 = DataFrame({'A': np.random.randn(10), 'B': 'foo'})\n store.append('df4', df4, data_columns=True)\n expected = df4['B']\n result = store.select_column('df4', 'B')\n tm.assert_series_equal(result, expected)\n\n def test_coordinates(self):\n df = tm.makeTimeDataFrame()\n\n with ensure_clean_store(self.path) as store:\n\n _maybe_remove(store, 'df')\n store.append('df', df)\n\n # all\n c = store.select_as_coordinates('df')\n assert((c.values == np.arange(len(df.index))).all())\n\n # get coordinates back & test vs frame\n _maybe_remove(store, 'df')\n\n df = DataFrame(dict(A=lrange(5), B=lrange(5)))\n store.append('df', df)\n c = store.select_as_coordinates('df', ['index<3'])\n assert((c.values == np.arange(3)).all())\n result = store.select('df', where=c)\n expected = df.loc[0:2, :]\n tm.assert_frame_equal(result, expected)\n\n c = store.select_as_coordinates('df', ['index>=3', 'index<=4'])\n assert((c.values == np.arange(2) + 3).all())\n result = store.select('df', where=c)\n expected = df.loc[3:4, :]\n tm.assert_frame_equal(result, expected)\n assert isinstance(c, Index)\n\n # multiple tables\n _maybe_remove(store, 'df1')\n _maybe_remove(store, 'df2')\n df1 = tm.makeTimeDataFrame()\n df2 = tm.makeTimeDataFrame().rename(columns=lambda x: \"%s_2\" % x)\n store.append('df1', df1, data_columns=['A', 'B'])\n store.append('df2', df2)\n\n c = store.select_as_coordinates('df1', ['A>0', 'B>0'])\n df1_result = store.select('df1', c)\n df2_result = store.select('df2', c)\n result = concat([df1_result, df2_result], axis=1)\n\n expected = concat([df1, df2], axis=1)\n expected = expected[(expected.A > 0) & (expected.B > 0)]\n tm.assert_frame_equal(result, expected)\n\n # pass array/mask as the coordinates\n with ensure_clean_store(self.path) as store:\n\n df = DataFrame(np.random.randn(1000, 2),\n index=date_range('20000101', periods=1000))\n store.append('df', df)\n c = store.select_column('df', 'index')\n where = c[DatetimeIndex(c).month == 5].index\n expected = df.iloc[where]\n\n # locations\n result = store.select('df', where=where)\n tm.assert_frame_equal(result, expected)\n\n # boolean\n result = store.select('df', where=where)\n tm.assert_frame_equal(result, expected)\n\n # invalid\n with pytest.raises(ValueError):\n store.select('df', where=np.arange(len(df), dtype='float64'))\n\n with pytest.raises(ValueError):\n store.select('df', where=np.arange(len(df) + 1))\n\n with pytest.raises(ValueError):\n store.select('df', where=np.arange(len(df)), start=5)\n\n with pytest.raises(ValueError):\n store.select('df', where=np.arange(len(df)), start=5, stop=10)\n\n # selection with filter\n selection = date_range('20000101', periods=500)\n result = store.select('df', where='index in selection')\n expected = df[df.index.isin(selection)]\n tm.assert_frame_equal(result, expected)\n\n # list\n df = DataFrame(np.random.randn(10, 2))\n store.append('df2', df)\n result = store.select('df2', where=[0, 3, 5])\n expected = df.iloc[[0, 3, 5]]\n tm.assert_frame_equal(result, expected)\n\n # boolean\n where = [True] * 10\n where[-2] = False\n result = store.select('df2', where=where)\n expected = df.loc[where]\n tm.assert_frame_equal(result, expected)\n\n # start/stop\n result = store.select('df2', start=5, stop=10)\n expected = df[5:10]\n tm.assert_frame_equal(result, expected)\n\n def test_append_to_multiple(self):\n df1 = tm.makeTimeDataFrame()\n df2 = tm.makeTimeDataFrame().rename(columns=lambda x: \"%s_2\" % x)\n df2['foo'] = 'bar'\n df = concat([df1, df2], axis=1)\n\n with ensure_clean_store(self.path) as store:\n\n # exceptions\n with pytest.raises(ValueError):\n store.append_to_multiple(\n {'df1': ['A', 'B'], 'df2': None}, df, selector='df3')\n\n with pytest.raises(ValueError):\n store.append_to_multiple(\n {'df1': None, 'df2': None}, df, selector='df3')\n\n with pytest.raises(ValueError):\n store.append_to_multiple('df1', df, 'df1')\n\n # regular operation\n store.append_to_multiple(\n {'df1': ['A', 'B'], 'df2': None}, df, selector='df1')\n result = store.select_as_multiple(\n ['df1', 'df2'], where=['A>0', 'B>0'], selector='df1')\n expected = df[(df.A > 0) & (df.B > 0)]\n tm.assert_frame_equal(result, expected)\n\n def test_append_to_multiple_dropna(self):\n df1 = tm.makeTimeDataFrame()\n df2 = tm.makeTimeDataFrame().rename(columns=lambda x: \"%s_2\" % x)\n df1.iloc[1, df1.columns.get_indexer(['A', 'B'])] = np.nan\n df = concat([df1, df2], axis=1)\n\n with ensure_clean_store(self.path) as store:\n\n # dropna=True should guarantee rows are synchronized\n store.append_to_multiple(\n {'df1': ['A', 'B'], 'df2': None}, df, selector='df1',\n dropna=True)\n result = store.select_as_multiple(['df1', 'df2'])\n expected = df.dropna()\n tm.assert_frame_equal(result, expected)\n tm.assert_index_equal(store.select('df1').index,\n store.select('df2').index)\n\n @pytest.mark.xfail(run=False,\n reason=\"append_to_multiple_dropna_false \"\n \"is not raising as failed\")\n def test_append_to_multiple_dropna_false(self):\n df1 = tm.makeTimeDataFrame()\n df2 = tm.makeTimeDataFrame().rename(columns=lambda x: \"%s_2\" % x)\n df1.iloc[1, df1.columns.get_indexer(['A', 'B'])] = np.nan\n df = concat([df1, df2], axis=1)\n\n with ensure_clean_store(self.path) as store:\n\n # dropna=False shouldn't synchronize row indexes\n store.append_to_multiple(\n {'df1a': ['A', 'B'], 'df2a': None}, df, selector='df1a',\n dropna=False)\n\n with pytest.raises(ValueError):\n store.select_as_multiple(['df1a', 'df2a'])\n\n assert not store.select('df1a').index.equals(\n store.select('df2a').index)\n\n def test_select_as_multiple(self):\n\n df1 = tm.makeTimeDataFrame()\n df2 = tm.makeTimeDataFrame().rename(columns=lambda x: \"%s_2\" % x)\n df2['foo'] = 'bar'\n\n with ensure_clean_store(self.path) as store:\n\n # no tables stored\n with pytest.raises(Exception):\n store.select_as_multiple(\n None, where=['A>0', 'B>0'], selector='df1')\n\n store.append('df1', df1, data_columns=['A', 'B'])\n store.append('df2', df2)\n\n # exceptions\n with pytest.raises(Exception):\n store.select_as_multiple(None, where=['A>0', 'B>0'],\n selector='df1')\n\n with pytest.raises(Exception):\n store.select_as_multiple([None], where=['A>0', 'B>0'],\n selector='df1')\n\n with pytest.raises(KeyError):\n store.select_as_multiple(\n ['df1', 'df3'], where=['A>0', 'B>0'], selector='df1')\n\n with pytest.raises(KeyError):\n store.select_as_multiple(\n ['df3'], where=['A>0', 'B>0'], selector='df1')\n\n with pytest.raises(KeyError):\n store.select_as_multiple(\n ['df1', 'df2'], where=['A>0', 'B>0'], selector='df4')\n\n # default select\n result = store.select('df1', ['A>0', 'B>0'])\n expected = store.select_as_multiple(\n ['df1'], where=['A>0', 'B>0'], selector='df1')\n tm.assert_frame_equal(result, expected)\n expected = store.select_as_multiple(\n 'df1', where=['A>0', 'B>0'], selector='df1')\n tm.assert_frame_equal(result, expected)\n\n # multiple\n result = store.select_as_multiple(\n ['df1', 'df2'], where=['A>0', 'B>0'], selector='df1')\n expected = concat([df1, df2], axis=1)\n expected = expected[(expected.A > 0) & (expected.B > 0)]\n tm.assert_frame_equal(result, expected)\n\n # multiple (diff selector)\n result = store.select_as_multiple(\n ['df1', 'df2'], where='index>df2.index[4]', selector='df2')\n expected = concat([df1, df2], axis=1)\n expected = expected[5:]\n tm.assert_frame_equal(result, expected)\n\n # test exception for diff rows\n store.append('df3', tm.makeTimeDataFrame(nper=50))\n with pytest.raises(ValueError):\n store.select_as_multiple(\n ['df1', 'df3'], where=['A>0', 'B>0'], selector='df1')\n\n @pytest.mark.skipif(\n LooseVersion(tables.__version__) < LooseVersion('3.1.0'),\n reason=(\"tables version does not support fix for nan selection \"\n \"bug: GH 4858\"))\n def test_nan_selection_bug_4858(self):\n\n with ensure_clean_store(self.path) as store:\n\n df = DataFrame(dict(cols=range(6), values=range(6)),\n dtype='float64')\n df['cols'] = (df['cols'] + 10).apply(str)\n df.iloc[0] = np.nan\n\n expected = DataFrame(dict(cols=['13.0', '14.0', '15.0'], values=[\n 3., 4., 5.]), index=[3, 4, 5])\n\n # write w/o the index on that particular column\n store.append('df', df, data_columns=True, index=['cols'])\n result = store.select('df', where='values>2.0')\n assert_frame_equal(result, expected)\n\n def test_start_stop_table(self):\n\n with ensure_clean_store(self.path) as store:\n\n # table\n df = DataFrame(dict(A=np.random.rand(20), B=np.random.rand(20)))\n store.append('df', df)\n\n result = store.select(\n 'df', \"columns=['A']\", start=0, stop=5)\n expected = df.loc[0:4, ['A']]\n tm.assert_frame_equal(result, expected)\n\n # out of range\n result = store.select(\n 'df', \"columns=['A']\", start=30, stop=40)\n assert len(result) == 0\n expected = df.loc[30:40, ['A']]\n tm.assert_frame_equal(result, expected)\n\n def test_start_stop_multiple(self):\n\n # GH 16209\n with ensure_clean_store(self.path) as store:\n\n df = DataFrame({\"foo\": [1, 2], \"bar\": [1, 2]})\n\n store.append_to_multiple({'selector': ['foo'], 'data': None}, df,\n selector='selector')\n result = store.select_as_multiple(['selector', 'data'],\n selector='selector', start=0,\n stop=1)\n expected = df.loc[[0], ['foo', 'bar']]\n tm.assert_frame_equal(result, expected)\n\n def test_start_stop_fixed(self):\n\n with ensure_clean_store(self.path) as store:\n\n # fixed, GH 8287\n df = DataFrame(dict(A=np.random.rand(20),\n B=np.random.rand(20)),\n index=pd.date_range('20130101', periods=20))\n store.put('df', df)\n\n result = store.select(\n 'df', start=0, stop=5)\n expected = df.iloc[0:5, :]\n tm.assert_frame_equal(result, expected)\n\n result = store.select(\n 'df', start=5, stop=10)\n expected = df.iloc[5:10, :]\n tm.assert_frame_equal(result, expected)\n\n # out of range\n result = store.select(\n 'df', start=30, stop=40)\n expected = df.iloc[30:40, :]\n tm.assert_frame_equal(result, expected)\n\n # series\n s = df.A\n store.put('s', s)\n result = store.select('s', start=0, stop=5)\n expected = s.iloc[0:5]\n tm.assert_series_equal(result, expected)\n\n result = store.select('s', start=5, stop=10)\n expected = s.iloc[5:10]\n tm.assert_series_equal(result, expected)\n\n # sparse; not implemented\n df = tm.makeDataFrame()\n df.iloc[3:5, 1:3] = np.nan\n df.iloc[8:10, -2] = np.nan\n dfs = df.to_sparse()\n store.put('dfs', dfs)\n with pytest.raises(NotImplementedError):\n store.select('dfs', start=0, stop=5)\n\n def test_select_filter_corner(self):\n\n df = DataFrame(np.random.randn(50, 100))\n df.index = ['%.3d' % c for c in df.index]\n df.columns = ['%.3d' % c for c in df.columns]\n\n with ensure_clean_store(self.path) as store:\n store.put('frame', df, format='table')\n\n crit = 'columns=df.columns[:75]'\n result = store.select('frame', [crit])\n tm.assert_frame_equal(result, df.loc[:, df.columns[:75]])\n\n crit = 'columns=df.columns[:75:2]'\n result = store.select('frame', [crit])\n tm.assert_frame_equal(result, df.loc[:, df.columns[:75:2]])\n\n def test_path_pathlib(self):\n df = tm.makeDataFrame()\n\n result = tm.round_trip_pathlib(\n lambda p: df.to_hdf(p, 'df'),\n lambda p: pd.read_hdf(p, 'df'))\n tm.assert_frame_equal(df, result)\n\n @pytest.mark.parametrize('start, stop', [(0, 2), (1, 2), (None, None)])\n def test_contiguous_mixed_data_table(self, start, stop):\n # GH 17021\n # ValueError when reading a contiguous mixed-data table ft. VLArray\n df = DataFrame({'a': Series([20111010, 20111011, 20111012]),\n 'b': Series(['ab', 'cd', 'ab'])})\n\n with ensure_clean_store(self.path) as store:\n store.append('test_dataset', df)\n\n result = store.select('test_dataset', start=start, stop=stop)\n assert_frame_equal(df[start:stop], result)\n\n def test_path_pathlib_hdfstore(self):\n df = tm.makeDataFrame()\n\n def writer(path):\n with pd.HDFStore(path) as store:\n df.to_hdf(store, 'df')\n\n def reader(path):\n with pd.HDFStore(path) as store:\n return pd.read_hdf(store, 'df')\n\n result = tm.round_trip_pathlib(writer, reader)\n tm.assert_frame_equal(df, result)\n\n def test_pickle_path_localpath(self):\n df = tm.makeDataFrame()\n result = tm.round_trip_pathlib(\n lambda p: df.to_hdf(p, 'df'),\n lambda p: pd.read_hdf(p, 'df'))\n tm.assert_frame_equal(df, result)\n\n def test_path_localpath_hdfstore(self):\n df = tm.makeDataFrame()\n\n def writer(path):\n with pd.HDFStore(path) as store:\n df.to_hdf(store, 'df')\n\n def reader(path):\n with pd.HDFStore(path) as store:\n return pd.read_hdf(store, 'df')\n\n result = tm.round_trip_localpath(writer, reader)\n tm.assert_frame_equal(df, result)\n\n def _check_roundtrip(self, obj, comparator, compression=False, **kwargs):\n\n options = {}\n if compression:\n options['complib'] = _default_compressor\n\n with ensure_clean_store(self.path, 'w', **options) as store:\n store['obj'] = obj\n retrieved = store['obj']\n comparator(retrieved, obj, **kwargs)\n\n def _check_double_roundtrip(self, obj, comparator, compression=False,\n **kwargs):\n options = {}\n if compression:\n options['complib'] = compression or _default_compressor\n\n with ensure_clean_store(self.path, 'w', **options) as store:\n store['obj'] = obj\n retrieved = store['obj']\n comparator(retrieved, obj, **kwargs)\n store['obj'] = retrieved\n again = store['obj']\n comparator(again, obj, **kwargs)\n\n def _check_roundtrip_table(self, obj, comparator, compression=False):\n options = {}\n if compression:\n options['complib'] = _default_compressor\n\n with ensure_clean_store(self.path, 'w', **options) as store:\n store.put('obj', obj, format='table')\n retrieved = store['obj']\n\n comparator(retrieved, obj)\n\n def test_multiple_open_close(self):\n # gh-4409: open & close multiple times\n\n with ensure_clean_path(self.path) as path:\n\n df = tm.makeDataFrame()\n df.to_hdf(path, 'df', mode='w', format='table')\n\n # single\n store = HDFStore(path)\n assert 'CLOSED' not in store.info()\n assert store.is_open\n\n store.close()\n assert 'CLOSED' in store.info()\n assert not store.is_open\n\n with ensure_clean_path(self.path) as path:\n\n if pytables._table_file_open_policy_is_strict:\n\n # multiples\n store1 = HDFStore(path)\n\n with pytest.raises(ValueError):\n HDFStore(path)\n\n store1.close()\n else:\n\n # multiples\n store1 = HDFStore(path)\n store2 = HDFStore(path)\n\n assert 'CLOSED' not in store1.info()\n assert 'CLOSED' not in store2.info()\n assert store1.is_open\n assert store2.is_open\n\n store1.close()\n assert 'CLOSED' in store1.info()\n assert not store1.is_open\n assert 'CLOSED' not in store2.info()\n assert store2.is_open\n\n store2.close()\n assert 'CLOSED' in store1.info()\n assert 'CLOSED' in store2.info()\n assert not store1.is_open\n assert not store2.is_open\n\n # nested close\n store = HDFStore(path, mode='w')\n store.append('df', df)\n\n store2 = HDFStore(path)\n store2.append('df2', df)\n store2.close()\n assert 'CLOSED' in store2.info()\n assert not store2.is_open\n\n store.close()\n assert 'CLOSED' in store.info()\n assert not store.is_open\n\n # double closing\n store = HDFStore(path, mode='w')\n store.append('df', df)\n\n store2 = HDFStore(path)\n store.close()\n assert 'CLOSED' in store.info()\n assert not store.is_open\n\n store2.close()\n assert 'CLOSED' in store2.info()\n assert not store2.is_open\n\n # ops on a closed store\n with ensure_clean_path(self.path) as path:\n\n df = tm.makeDataFrame()\n df.to_hdf(path, 'df', mode='w', format='table')\n\n store = HDFStore(path)\n store.close()\n\n with pytest.raises(ClosedFileError):\n store.keys()\n\n with pytest.raises(ClosedFileError):\n 'df' in store\n\n with pytest.raises(ClosedFileError):\n len(store)\n\n with pytest.raises(ClosedFileError):\n store['df']\n\n with pytest.raises(AttributeError):\n store.df\n\n with pytest.raises(ClosedFileError):\n store.select('df')\n\n with pytest.raises(ClosedFileError):\n store.get('df')\n\n with pytest.raises(ClosedFileError):\n store.append('df2', df)\n\n with pytest.raises(ClosedFileError):\n store.put('df3', df)\n\n with pytest.raises(ClosedFileError):\n store.get_storer('df2')\n\n with pytest.raises(ClosedFileError):\n store.remove('df2')\n\n with pytest.raises(ClosedFileError, match='file is not open'):\n store.select('df')\n\n def test_pytables_native_read(self, datapath):\n with ensure_clean_store(\n datapath('io', 'data', 'legacy_hdf/pytables_native.h5'),\n mode='r') as store:\n d2 = store['detector/readout']\n assert isinstance(d2, DataFrame)\n\n @pytest.mark.skipif(PY35 and is_platform_windows(),\n reason=\"native2 read fails oddly on windows / 3.5\")\n def test_pytables_native2_read(self, datapath):\n with ensure_clean_store(\n datapath('io', 'data', 'legacy_hdf', 'pytables_native2.h5'),\n mode='r') as store:\n str(store)\n d1 = store['detector']\n assert isinstance(d1, DataFrame)\n\n @xfail_non_writeable\n def test_legacy_table_fixed_format_read_py2(self, datapath):\n # GH 24510\n # legacy table with fixed format written in Python 2\n with ensure_clean_store(\n datapath('io', 'data', 'legacy_hdf',\n 'legacy_table_fixed_py2.h5'),\n mode='r') as store:\n result = store.select('df')\n expected = pd.DataFrame([[1, 2, 3, 'D']],\n columns=['A', 'B', 'C', 'D'],\n index=pd.Index(['ABC'],\n name='INDEX_NAME'))\n assert_frame_equal(expected, result)\n\n def test_legacy_table_read_py2(self, datapath):\n # issue: 24925\n # legacy table written in Python 2\n with ensure_clean_store(\n datapath('io', 'data', 'legacy_hdf',\n 'legacy_table_py2.h5'),\n mode='r') as store:\n result = store.select('table')\n\n expected = pd.DataFrame({\n \"a\": [\"a\", \"b\"],\n \"b\": [2, 3]\n })\n assert_frame_equal(expected, result)\n\n def test_copy(self):\n\n with catch_warnings(record=True):\n\n def do_copy(f, new_f=None, keys=None,\n propindexes=True, **kwargs):\n try:\n store = HDFStore(f, 'r')\n\n if new_f is None:\n import tempfile\n fd, new_f = tempfile.mkstemp()\n\n tstore = store.copy(\n new_f, keys=keys, propindexes=propindexes, **kwargs)\n\n # check keys\n if keys is None:\n keys = store.keys()\n assert set(keys) == set(tstore.keys())\n\n # check indices & nrows\n for k in tstore.keys():\n if tstore.get_storer(k).is_table:\n new_t = tstore.get_storer(k)\n orig_t = store.get_storer(k)\n\n assert orig_t.nrows == new_t.nrows\n\n # check propindixes\n if propindexes:\n for a in orig_t.axes:\n if a.is_indexed:\n assert new_t[a.name].is_indexed\n\n finally:\n safe_close(store)\n safe_close(tstore)\n try:\n os.close(fd)\n except (OSError, ValueError):\n pass\n safe_remove(new_f)\n\n # new table\n df = tm.makeDataFrame()\n\n try:\n path = create_tempfile(self.path)\n st = HDFStore(path)\n st.append('df', df, data_columns=['A'])\n st.close()\n do_copy(f=path)\n do_copy(f=path, propindexes=False)\n finally:\n safe_remove(path)\n\n def test_store_datetime_fractional_secs(self):\n\n with ensure_clean_store(self.path) as store:\n dt = datetime.datetime(2012, 1, 2, 3, 4, 5, 123456)\n series = Series([0], [dt])\n store['a'] = series\n assert store['a'].index[0] == dt\n\n def test_tseries_indices_series(self):\n\n with ensure_clean_store(self.path) as store:\n idx = tm.makeDateIndex(10)\n ser = Series(np.random.randn(len(idx)), idx)\n store['a'] = ser\n result = store['a']\n\n tm.assert_series_equal(result, ser)\n assert result.index.freq == ser.index.freq\n tm.assert_class_equal(result.index, ser.index, obj=\"series index\")\n\n idx = tm.makePeriodIndex(10)\n ser = Series(np.random.randn(len(idx)), idx)\n store['a'] = ser\n result = store['a']\n\n tm.assert_series_equal(result, ser)\n assert result.index.freq == ser.index.freq\n tm.assert_class_equal(result.index, ser.index, obj=\"series index\")\n\n def test_tseries_indices_frame(self):\n\n with ensure_clean_store(self.path) as store:\n idx = tm.makeDateIndex(10)\n df = DataFrame(np.random.randn(len(idx), 3), index=idx)\n store['a'] = df\n result = store['a']\n\n assert_frame_equal(result, df)\n assert result.index.freq == df.index.freq\n tm.assert_class_equal(result.index, df.index,\n obj=\"dataframe index\")\n\n idx = tm.makePeriodIndex(10)\n df = DataFrame(np.random.randn(len(idx), 3), idx)\n store['a'] = df\n result = store['a']\n\n assert_frame_equal(result, df)\n assert result.index.freq == df.index.freq\n tm.assert_class_equal(result.index, df.index,\n obj=\"dataframe index\")\n\n def test_unicode_index(self):\n\n unicode_values = ['\\u03c3', '\\u03c3\\u03c3']\n\n # PerformanceWarning\n with catch_warnings(record=True):\n simplefilter(\"ignore\", pd.errors.PerformanceWarning)\n s = Series(np.random.randn(len(unicode_values)), unicode_values)\n self._check_roundtrip(s, tm.assert_series_equal)\n\n def test_unicode_longer_encoded(self):\n # GH 11234\n char = '\\u0394'\n df = pd.DataFrame({'A': [char]})\n with ensure_clean_store(self.path) as store:\n store.put('df', df, format='table', encoding='utf-8')\n result = store.get('df')\n tm.assert_frame_equal(result, df)\n\n df = pd.DataFrame({'A': ['a', char], 'B': ['b', 'b']})\n with ensure_clean_store(self.path) as store:\n store.put('df', df, format='table', encoding='utf-8')\n result = store.get('df')\n tm.assert_frame_equal(result, df)\n\n @xfail_non_writeable\n def test_store_datetime_mixed(self):\n\n df = DataFrame(\n {'a': [1, 2, 3], 'b': [1., 2., 3.], 'c': ['a', 'b', 'c']})\n ts = tm.makeTimeSeries()\n df['d'] = ts.index[:3]\n self._check_roundtrip(df, tm.assert_frame_equal)\n\n # def test_cant_write_multiindex_table(self):\n # # for now, #1848\n # df = DataFrame(np.random.randn(10, 4),\n # index=[np.arange(5).repeat(2),\n # np.tile(np.arange(2), 5)])\n #\n # with pytest.raises(Exception):\n # store.put('foo', df, format='table')\n\n def test_append_with_diff_col_name_types_raises_value_error(self):\n df = DataFrame(np.random.randn(10, 1))\n df2 = DataFrame({'a': np.random.randn(10)})\n df3 = DataFrame({(1, 2): np.random.randn(10)})\n df4 = DataFrame({('1', 2): np.random.randn(10)})\n df5 = DataFrame({('1', 2, object): np.random.randn(10)})\n\n with ensure_clean_store(self.path) as store:\n name = 'df_%s' % tm.rands(10)\n store.append(name, df)\n\n for d in (df2, df3, df4, df5):\n with pytest.raises(ValueError):\n store.append(name, d)\n\n def test_query_with_nested_special_character(self):\n df = DataFrame({'a': ['a', 'a', 'c', 'b',\n 'test & test', 'c', 'b', 'e'],\n 'b': [1, 2, 3, 4, 5, 6, 7, 8]})\n expected = df[df.a == 'test & test']\n with ensure_clean_store(self.path) as store:\n store.append('test', df, format='table', data_columns=True)\n result = store.select('test', 'a = \"test & test\"')\n tm.assert_frame_equal(expected, result)\n\n def test_categorical(self):\n\n with ensure_clean_store(self.path) as store:\n\n # Basic\n _maybe_remove(store, 's')\n s = Series(Categorical(['a', 'b', 'b', 'a', 'a', 'c'], categories=[\n 'a', 'b', 'c', 'd'], ordered=False))\n store.append('s', s, format='table')\n result = store.select('s')\n tm.assert_series_equal(s, result)\n\n _maybe_remove(store, 's_ordered')\n s = Series(Categorical(['a', 'b', 'b', 'a', 'a', 'c'], categories=[\n 'a', 'b', 'c', 'd'], ordered=True))\n store.append('s_ordered', s, format='table')\n result = store.select('s_ordered')\n tm.assert_series_equal(s, result)\n\n _maybe_remove(store, 'df')\n df = DataFrame({\"s\": s, \"vals\": [1, 2, 3, 4, 5, 6]})\n store.append('df', df, format='table')\n result = store.select('df')\n tm.assert_frame_equal(result, df)\n\n # Dtypes\n _maybe_remove(store, 'si')\n s = Series([1, 1, 2, 2, 3, 4, 5]).astype('category')\n store.append('si', s)\n result = store.select('si')\n tm.assert_series_equal(result, s)\n\n _maybe_remove(store, 'si2')\n s = Series([1, 1, np.nan, 2, 3, 4, 5]).astype('category')\n store.append('si2', s)\n result = store.select('si2')\n tm.assert_series_equal(result, s)\n\n # Multiple\n _maybe_remove(store, 'df2')\n df2 = df.copy()\n df2['s2'] = Series(list('abcdefg')).astype('category')\n store.append('df2', df2)\n result = store.select('df2')\n tm.assert_frame_equal(result, df2)\n\n # Make sure the metadata is OK\n info = store.info()\n assert '/df2 ' in info\n # assert '/df2/meta/values_block_0/meta' in info\n assert '/df2/meta/values_block_1/meta' in info\n\n # unordered\n _maybe_remove(store, 's2')\n s = Series(Categorical(['a', 'b', 'b', 'a', 'a', 'c'], categories=[\n 'a', 'b', 'c', 'd'], ordered=False))\n store.append('s2', s, format='table')\n result = store.select('s2')\n tm.assert_series_equal(result, s)\n\n # Query\n _maybe_remove(store, 'df3')\n store.append('df3', df, data_columns=['s'])\n expected = df[df.s.isin(['b', 'c'])]\n result = store.select('df3', where=['s in [\"b\",\"c\"]'])\n tm.assert_frame_equal(result, expected)\n\n expected = df[df.s.isin(['b', 'c'])]\n result = store.select('df3', where=['s = [\"b\",\"c\"]'])\n tm.assert_frame_equal(result, expected)\n\n expected = df[df.s.isin(['d'])]\n result = store.select('df3', where=['s in [\"d\"]'])\n tm.assert_frame_equal(result, expected)\n\n expected = df[df.s.isin(['f'])]\n result = store.select('df3', where=['s in [\"f\"]'])\n tm.assert_frame_equal(result, expected)\n\n # Appending with same categories is ok\n store.append('df3', df)\n\n df = concat([df, df])\n expected = df[df.s.isin(['b', 'c'])]\n result = store.select('df3', where=['s in [\"b\",\"c\"]'])\n tm.assert_frame_equal(result, expected)\n\n # Appending must have the same categories\n df3 = df.copy()\n df3['s'].cat.remove_unused_categories(inplace=True)\n\n with pytest.raises(ValueError):\n store.append('df3', df3)\n\n # Remove, and make sure meta data is removed (its a recursive\n # removal so should be).\n result = store.select('df3/meta/s/meta')\n assert result is not None\n store.remove('df3')\n\n with pytest.raises(KeyError):\n store.select('df3/meta/s/meta')\n\n def test_categorical_conversion(self):\n\n # GH13322\n # Check that read_hdf with categorical columns doesn't return rows if\n # where criteria isn't met.\n obsids = ['ESP_012345_6789', 'ESP_987654_3210']\n imgids = ['APF00006np', 'APF0001imm']\n data = [4.3, 9.8]\n\n # Test without categories\n df = DataFrame(dict(obsids=obsids, imgids=imgids, data=data))\n\n # We are expecting an empty DataFrame matching types of df\n expected = df.iloc[[], :]\n with ensure_clean_path(self.path) as path:\n df.to_hdf(path, 'df', format='table', data_columns=True)\n result = read_hdf(path, 'df', where='obsids=B')\n tm.assert_frame_equal(result, expected)\n\n # Test with categories\n df.obsids = df.obsids.astype('category')\n df.imgids = df.imgids.astype('category')\n\n # We are expecting an empty DataFrame matching types of df\n expected = df.iloc[[], :]\n with ensure_clean_path(self.path) as path:\n df.to_hdf(path, 'df', format='table', data_columns=True)\n result = read_hdf(path, 'df', where='obsids=B')\n tm.assert_frame_equal(result, expected)\n\n def test_categorical_nan_only_columns(self):\n # GH18413\n # Check that read_hdf with categorical columns with NaN-only values can\n # be read back.\n df = pd.DataFrame({\n 'a': ['a', 'b', 'c', np.nan],\n 'b': [np.nan, np.nan, np.nan, np.nan],\n 'c': [1, 2, 3, 4],\n 'd': pd.Series([None] * 4, dtype=object)\n })\n df['a'] = df.a.astype('category')\n df['b'] = df.b.astype('category')\n df['d'] = df.b.astype('category')\n expected = df\n with ensure_clean_path(self.path) as path:\n df.to_hdf(path, 'df', format='table', data_columns=True)\n result = read_hdf(path, 'df')\n tm.assert_frame_equal(result, expected)\n\n def test_duplicate_column_name(self):\n df = DataFrame(columns=[\"a\", \"a\"], data=[[0, 0]])\n\n with ensure_clean_path(self.path) as path:\n with pytest.raises(ValueError):\n df.to_hdf(path, 'df', format='fixed')\n\n df.to_hdf(path, 'df', format='table')\n other = read_hdf(path, 'df')\n\n tm.assert_frame_equal(df, other)\n assert df.equals(other)\n assert other.equals(df)\n\n def test_round_trip_equals(self):\n # GH 9330\n df = DataFrame({\"B\": [1, 2], \"A\": [\"x\", \"y\"]})\n\n with ensure_clean_path(self.path) as path:\n df.to_hdf(path, 'df', format='table')\n other = read_hdf(path, 'df')\n tm.assert_frame_equal(df, other)\n assert df.equals(other)\n assert other.equals(df)\n\n def test_preserve_timedeltaindex_type(self):\n # GH9635\n # Storing TimedeltaIndexed DataFrames in fixed stores did not preserve\n # the type of the index.\n df = DataFrame(np.random.normal(size=(10, 5)))\n df.index = timedelta_range(\n start='0s', periods=10, freq='1s', name='example')\n\n with ensure_clean_store(self.path) as store:\n\n store['df'] = df\n assert_frame_equal(store['df'], df)\n\n def test_columns_multiindex_modified(self):\n # BUG: 7212\n # read_hdf store.select modified the passed columns parameters\n # when multi-indexed.\n\n df = DataFrame(np.random.rand(4, 5),\n index=list('abcd'),\n columns=list('ABCDE'))\n df.index.name = 'letters'\n df = df.set_index(keys='E', append=True)\n\n data_columns = df.index.names + df.columns.tolist()\n with ensure_clean_path(self.path) as path:\n df.to_hdf(path, 'df',\n mode='a',\n append=True,\n data_columns=data_columns,\n index=False)\n cols2load = list('BCD')\n cols2load_original = list(cols2load)\n df_loaded = read_hdf(path, 'df', columns=cols2load) # noqa\n assert cols2load_original == cols2load\n\n @ignore_natural_naming_warning\n def test_to_hdf_with_object_column_names(self):\n # GH9057\n # Writing HDF5 table format should only work for string-like\n # column types\n\n types_should_fail = [tm.makeIntIndex, tm.makeFloatIndex,\n tm.makeDateIndex, tm.makeTimedeltaIndex,\n tm.makePeriodIndex]\n types_should_run = [tm.makeStringIndex, tm.makeCategoricalIndex,\n tm.makeUnicodeIndex]\n\n for index in types_should_fail:\n df = DataFrame(np.random.randn(10, 2), columns=index(2))\n with ensure_clean_path(self.path) as path:\n with catch_warnings(record=True):\n msg = \"cannot have non-object label DataIndexableCol\"\n with pytest.raises(ValueError, match=msg):\n df.to_hdf(path, 'df', format='table',\n data_columns=True)\n\n for index in types_should_run:\n df = DataFrame(np.random.randn(10, 2), columns=index(2))\n with ensure_clean_path(self.path) as path:\n with catch_warnings(record=True):\n df.to_hdf(path, 'df', format='table', data_columns=True)\n result = pd.read_hdf(\n path, 'df', where=\"index = [{0}]\".format(df.index[0]))\n assert(len(result))\n\n def test_read_hdf_open_store(self):\n # GH10330\n # No check for non-string path_or-buf, and no test of open store\n df = DataFrame(np.random.rand(4, 5),\n index=list('abcd'),\n columns=list('ABCDE'))\n df.index.name = 'letters'\n df = df.set_index(keys='E', append=True)\n\n with ensure_clean_path(self.path) as path:\n df.to_hdf(path, 'df', mode='w')\n direct = read_hdf(path, 'df')\n store = HDFStore(path, mode='r')\n indirect = read_hdf(store, 'df')\n tm.assert_frame_equal(direct, indirect)\n assert store.is_open\n store.close()\n\n def test_read_hdf_iterator(self):\n df = DataFrame(np.random.rand(4, 5),\n index=list('abcd'),\n columns=list('ABCDE'))\n df.index.name = 'letters'\n df = df.set_index(keys='E', append=True)\n\n with ensure_clean_path(self.path) as path:\n df.to_hdf(path, 'df', mode='w', format='t')\n direct = read_hdf(path, 'df')\n iterator = read_hdf(path, 'df', iterator=True)\n assert isinstance(iterator, TableIterator)\n indirect = next(iterator.__iter__())\n tm.assert_frame_equal(direct, indirect)\n iterator.store.close()\n\n def test_read_hdf_errors(self):\n df = DataFrame(np.random.rand(4, 5),\n index=list('abcd'),\n columns=list('ABCDE'))\n\n with ensure_clean_path(self.path) as path:\n with pytest.raises(IOError):\n read_hdf(path, 'key')\n\n df.to_hdf(path, 'df')\n store = HDFStore(path, mode='r')\n store.close()\n\n with pytest.raises(IOError):\n read_hdf(store, 'df')\n\n def test_read_hdf_generic_buffer_errors(self):\n with pytest.raises(NotImplementedError):\n read_hdf(BytesIO(b''), 'df')\n\n def test_invalid_complib(self):\n df = DataFrame(np.random.rand(4, 5),\n index=list('abcd'),\n columns=list('ABCDE'))\n with ensure_clean_path(self.path) as path:\n with pytest.raises(ValueError):\n df.to_hdf(path, 'df', complib='foolib')\n # GH10443\n\n def test_read_nokey(self):\n df = DataFrame(np.random.rand(4, 5),\n index=list('abcd'),\n columns=list('ABCDE'))\n\n # Categorical dtype not supported for \"fixed\" format. So no need\n # to test with that dtype in the dataframe here.\n with ensure_clean_path(self.path) as path:\n df.to_hdf(path, 'df', mode='a')\n reread = read_hdf(path)\n assert_frame_equal(df, reread)\n df.to_hdf(path, 'df2', mode='a')\n\n with pytest.raises(ValueError):\n read_hdf(path)\n\n def test_read_nokey_table(self):\n # GH13231\n df = DataFrame({'i': range(5),\n 'c': Series(list('abacd'), dtype='category')})\n\n with ensure_clean_path(self.path) as path:\n df.to_hdf(path, 'df', mode='a', format='table')\n reread = read_hdf(path)\n assert_frame_equal(df, reread)\n df.to_hdf(path, 'df2', mode='a', format='table')\n\n with pytest.raises(ValueError):\n read_hdf(path)\n\n def test_read_nokey_empty(self):\n with ensure_clean_path(self.path) as path:\n store = HDFStore(path)\n store.close()\n\n with pytest.raises(ValueError):\n read_hdf(path)\n\n @td.skip_if_no('pathlib')\n def test_read_from_pathlib_path(self):\n\n # GH11773\n from pathlib import Path\n\n expected = DataFrame(np.random.rand(4, 5),\n index=list('abcd'),\n columns=list('ABCDE'))\n with ensure_clean_path(self.path) as filename:\n path_obj = Path(filename)\n\n expected.to_hdf(path_obj, 'df', mode='a')\n actual = read_hdf(path_obj, 'df')\n\n tm.assert_frame_equal(expected, actual)\n\n @td.skip_if_no('py.path')\n def test_read_from_py_localpath(self):\n\n # GH11773\n from py.path import local as LocalPath\n\n expected = DataFrame(np.random.rand(4, 5),\n index=list('abcd'),\n columns=list('ABCDE'))\n with ensure_clean_path(self.path) as filename:\n path_obj = LocalPath(filename)\n\n expected.to_hdf(path_obj, 'df', mode='a')\n actual = read_hdf(path_obj, 'df')\n\n tm.assert_frame_equal(expected, actual)\n\n def test_query_long_float_literal(self):\n # GH 14241\n df = pd.DataFrame({'A': [1000000000.0009,\n 1000000000.0011,\n 1000000000.0015]})\n\n with ensure_clean_store(self.path) as store:\n store.append('test', df, format='table', data_columns=True)\n\n cutoff = 1000000000.0006\n result = store.select('test', \"A < %.4f\" % cutoff)\n assert result.empty\n\n cutoff = 1000000000.0010\n result = store.select('test', \"A > %.4f\" % cutoff)\n expected = df.loc[[1, 2], :]\n tm.assert_frame_equal(expected, result)\n\n exact = 1000000000.0011\n result = store.select('test', 'A == %.4f' % exact)\n expected = df.loc[[1], :]\n tm.assert_frame_equal(expected, result)\n\n def test_query_compare_column_type(self):\n # GH 15492\n df = pd.DataFrame({'date': ['2014-01-01', '2014-01-02'],\n 'real_date': date_range('2014-01-01', periods=2),\n 'float': [1.1, 1.2],\n 'int': [1, 2]},\n columns=['date', 'real_date', 'float', 'int'])\n\n with ensure_clean_store(self.path) as store:\n store.append('test', df, format='table', data_columns=True)\n\n ts = pd.Timestamp('2014-01-01') # noqa\n result = store.select('test', where='real_date > ts')\n expected = df.loc[[1], :]\n tm.assert_frame_equal(expected, result)\n\n for op in ['<', '>', '==']:\n # non strings to string column always fail\n for v in [2.1, True, pd.Timestamp('2014-01-01'),\n pd.Timedelta(1, 's')]:\n query = 'date {op} v'.format(op=op)\n with pytest.raises(TypeError):\n store.select('test', where=query)\n\n # strings to other columns must be convertible to type\n v = 'a'\n for col in ['int', 'float', 'real_date']:\n query = '{col} {op} v'.format(op=op, col=col)\n with pytest.raises(ValueError):\n store.select('test', where=query)\n\n for v, col in zip(['1', '1.1', '2014-01-01'],\n ['int', 'float', 'real_date']):\n query = '{col} {op} v'.format(op=op, col=col)\n result = store.select('test', where=query)\n\n if op == '==':\n expected = df.loc[[0], :]\n elif op == '>':\n expected = df.loc[[1], :]\n else:\n expected = df.loc[[], :]\n tm.assert_frame_equal(expected, result)\n\n @pytest.mark.parametrize('format', ['fixed', 'table'])\n def test_read_hdf_series_mode_r(self, format):\n # GH 16583\n # Tests that reading a Series saved to an HDF file\n # still works if a mode='r' argument is supplied\n series = tm.makeFloatSeries()\n with ensure_clean_path(self.path) as path:\n series.to_hdf(path, key='data', format=format)\n result = pd.read_hdf(path, key='data', mode='r')\n tm.assert_series_equal(result, series)\n\n @pytest.mark.skipif(not PY36, reason=\"Need python 3.6\")\n def test_fspath(self):\n with tm.ensure_clean('foo.h5') as path:\n with pd.HDFStore(path) as store:\n assert os.fspath(store) == str(path)\n\n def test_read_py2_hdf_file_in_py3(self, datapath):\n # GH 16781\n\n # tests reading a PeriodIndex DataFrame written in Python2 in Python3\n\n # the file was generated in Python 2.7 like so:\n #\n # df = pd.DataFrame([1.,2,3], index=pd.PeriodIndex(\n # ['2015-01-01', '2015-01-02', '2015-01-05'], freq='B'))\n # df.to_hdf('periodindex_0.20.1_x86_64_darwin_2.7.13.h5', 'p')\n\n expected = pd.DataFrame([1., 2, 3], index=pd.PeriodIndex(\n ['2015-01-01', '2015-01-02', '2015-01-05'], freq='B'))\n\n with ensure_clean_store(\n datapath('io', 'data', 'legacy_hdf',\n 'periodindex_0.20.1_x86_64_darwin_2.7.13.h5'),\n mode='r') as store:\n result = store['p']\n assert_frame_equal(result, expected)\n\n\nclass TestHDFComplexValues(Base):\n # GH10447\n\n def test_complex_fixed(self):\n df = DataFrame(np.random.rand(4, 5).astype(np.complex64),\n index=list('abcd'),\n columns=list('ABCDE'))\n\n with ensure_clean_path(self.path) as path:\n df.to_hdf(path, 'df')\n reread = read_hdf(path, 'df')\n assert_frame_equal(df, reread)\n\n df = DataFrame(np.random.rand(4, 5).astype(np.complex128),\n index=list('abcd'),\n columns=list('ABCDE'))\n with ensure_clean_path(self.path) as path:\n df.to_hdf(path, 'df')\n reread = read_hdf(path, 'df')\n assert_frame_equal(df, reread)\n\n def test_complex_table(self):\n df = DataFrame(np.random.rand(4, 5).astype(np.complex64),\n index=list('abcd'),\n columns=list('ABCDE'))\n\n with ensure_clean_path(self.path) as path:\n df.to_hdf(path, 'df', format='table')\n reread = read_hdf(path, 'df')\n assert_frame_equal(df, reread)\n\n df = DataFrame(np.random.rand(4, 5).astype(np.complex128),\n index=list('abcd'),\n columns=list('ABCDE'))\n\n with ensure_clean_path(self.path) as path:\n df.to_hdf(path, 'df', format='table', mode='w')\n reread = read_hdf(path, 'df')\n assert_frame_equal(df, reread)\n\n @xfail_non_writeable\n def test_complex_mixed_fixed(self):\n complex64 = np.array([1.0 + 1.0j, 1.0 + 1.0j,\n 1.0 + 1.0j, 1.0 + 1.0j], dtype=np.complex64)\n complex128 = np.array([1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j],\n dtype=np.complex128)\n df = DataFrame({'A': [1, 2, 3, 4],\n 'B': ['a', 'b', 'c', 'd'],\n 'C': complex64,\n 'D': complex128,\n 'E': [1.0, 2.0, 3.0, 4.0]},\n index=list('abcd'))\n with ensure_clean_path(self.path) as path:\n df.to_hdf(path, 'df')\n reread = read_hdf(path, 'df')\n assert_frame_equal(df, reread)\n\n def test_complex_mixed_table(self):\n complex64 = np.array([1.0 + 1.0j, 1.0 + 1.0j,\n 1.0 + 1.0j, 1.0 + 1.0j], dtype=np.complex64)\n complex128 = np.array([1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j],\n dtype=np.complex128)\n df = DataFrame({'A': [1, 2, 3, 4],\n 'B': ['a', 'b', 'c', 'd'],\n 'C': complex64,\n 'D': complex128,\n 'E': [1.0, 2.0, 3.0, 4.0]},\n index=list('abcd'))\n\n with ensure_clean_store(self.path) as store:\n store.append('df', df, data_columns=['A', 'B'])\n result = store.select('df', where='A>2')\n assert_frame_equal(df.loc[df.A > 2], result)\n\n with ensure_clean_path(self.path) as path:\n df.to_hdf(path, 'df', format='table')\n reread = read_hdf(path, 'df')\n assert_frame_equal(df, reread)\n\n def test_complex_across_dimensions_fixed(self):\n with catch_warnings(record=True):\n complex128 = np.array(\n [1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j])\n s = Series(complex128, index=list('abcd'))\n df = DataFrame({'A': s, 'B': s})\n\n objs = [s, df]\n comps = [tm.assert_series_equal, tm.assert_frame_equal]\n for obj, comp in zip(objs, comps):\n with ensure_clean_path(self.path) as path:\n obj.to_hdf(path, 'obj', format='fixed')\n reread = read_hdf(path, 'obj')\n comp(obj, reread)\n\n def test_complex_across_dimensions(self):\n complex128 = np.array([1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j])\n s = Series(complex128, index=list('abcd'))\n df = DataFrame({'A': s, 'B': s})\n\n with catch_warnings(record=True):\n\n objs = [df]\n comps = [tm.assert_frame_equal]\n for obj, comp in zip(objs, comps):\n with ensure_clean_path(self.path) as path:\n obj.to_hdf(path, 'obj', format='table')\n reread = read_hdf(path, 'obj')\n comp(obj, reread)\n\n def test_complex_indexing_error(self):\n complex128 = np.array([1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j],\n dtype=np.complex128)\n df = DataFrame({'A': [1, 2, 3, 4],\n 'B': ['a', 'b', 'c', 'd'],\n 'C': complex128},\n index=list('abcd'))\n with ensure_clean_store(self.path) as store:\n with pytest.raises(TypeError):\n store.append('df', df, data_columns=['C'])\n\n def test_complex_series_error(self):\n complex128 = np.array([1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j])\n s = Series(complex128, index=list('abcd'))\n\n with ensure_clean_path(self.path) as path:\n with pytest.raises(TypeError):\n s.to_hdf(path, 'obj', format='t')\n\n with ensure_clean_path(self.path) as path:\n s.to_hdf(path, 'obj', format='t', index=False)\n reread = read_hdf(path, 'obj')\n tm.assert_series_equal(s, reread)\n\n def test_complex_append(self):\n df = DataFrame({'a': np.random.randn(100).astype(np.complex128),\n 'b': np.random.randn(100)})\n\n with ensure_clean_store(self.path) as store:\n store.append('df', df, data_columns=['b'])\n store.append('df', df)\n result = store.select('df')\n assert_frame_equal(pd.concat([df, df], 0), result)\n\n\nclass TestTimezones(Base):\n\n def _compare_with_tz(self, a, b):\n tm.assert_frame_equal(a, b)\n\n # compare the zones on each element\n for c in a.columns:\n for i in a.index:\n a_e = a.loc[i, c]\n b_e = b.loc[i, c]\n if not (a_e == b_e and a_e.tz == b_e.tz):\n raise AssertionError(\n \"invalid tz comparison [%s] [%s]\" % (a_e, b_e))\n\n def test_append_with_timezones_dateutil(self):\n\n from datetime import timedelta\n\n # use maybe_get_tz instead of dateutil.tz.gettz to handle the windows\n # filename issues.\n from pandas._libs.tslibs.timezones import maybe_get_tz\n gettz = lambda x: maybe_get_tz('dateutil/' + x)\n\n # as columns\n with ensure_clean_store(self.path) as store:\n\n _maybe_remove(store, 'df_tz')\n df = DataFrame(dict(A=[Timestamp('20130102 2:00:00', tz=gettz(\n 'US/Eastern')) + timedelta(hours=1) * i for i in range(5)]))\n\n store.append('df_tz', df, data_columns=['A'])\n result = store['df_tz']\n self._compare_with_tz(result, df)\n assert_frame_equal(result, df)\n\n # select with tz aware\n expected = df[df.A >= df.A[3]]\n result = store.select('df_tz', where='A>=df.A[3]')\n self._compare_with_tz(result, expected)\n\n # ensure we include dates in DST and STD time here.\n _maybe_remove(store, 'df_tz')\n df = DataFrame(dict(A=Timestamp('20130102',\n tz=gettz('US/Eastern')),\n B=Timestamp('20130603',\n tz=gettz('US/Eastern'))),\n index=range(5))\n store.append('df_tz', df)\n result = store['df_tz']\n self._compare_with_tz(result, df)\n assert_frame_equal(result, df)\n\n df = DataFrame(dict(A=Timestamp('20130102',\n tz=gettz('US/Eastern')),\n B=Timestamp('20130102', tz=gettz('EET'))),\n index=range(5))\n with pytest.raises(ValueError):\n store.append('df_tz', df)\n\n # this is ok\n _maybe_remove(store, 'df_tz')\n store.append('df_tz', df, data_columns=['A', 'B'])\n result = store['df_tz']\n self._compare_with_tz(result, df)\n assert_frame_equal(result, df)\n\n # can't append with diff timezone\n df = DataFrame(dict(A=Timestamp('20130102',\n tz=gettz('US/Eastern')),\n B=Timestamp('20130102', tz=gettz('CET'))),\n index=range(5))\n with pytest.raises(ValueError):\n store.append('df_tz', df)\n\n # as index\n with ensure_clean_store(self.path) as store:\n\n # GH 4098 example\n df = DataFrame(dict(A=Series(lrange(3), index=date_range(\n '2000-1-1', periods=3, freq='H', tz=gettz('US/Eastern')))))\n\n _maybe_remove(store, 'df')\n store.put('df', df)\n result = store.select('df')\n assert_frame_equal(result, df)\n\n _maybe_remove(store, 'df')\n store.append('df', df)\n result = store.select('df')\n assert_frame_equal(result, df)\n\n def test_append_with_timezones_pytz(self):\n\n from datetime import timedelta\n\n # as columns\n with ensure_clean_store(self.path) as store:\n\n _maybe_remove(store, 'df_tz')\n df = DataFrame(dict(A=[Timestamp('20130102 2:00:00',\n tz='US/Eastern') +\n timedelta(hours=1) * i\n for i in range(5)]))\n store.append('df_tz', df, data_columns=['A'])\n result = store['df_tz']\n self._compare_with_tz(result, df)\n assert_frame_equal(result, df)\n\n # select with tz aware\n self._compare_with_tz(store.select(\n 'df_tz', where='A>=df.A[3]'), df[df.A >= df.A[3]])\n\n _maybe_remove(store, 'df_tz')\n # ensure we include dates in DST and STD time here.\n df = DataFrame(dict(A=Timestamp('20130102', tz='US/Eastern'),\n B=Timestamp('20130603', tz='US/Eastern')),\n index=range(5))\n store.append('df_tz', df)\n result = store['df_tz']\n self._compare_with_tz(result, df)\n assert_frame_equal(result, df)\n\n df = DataFrame(dict(A=Timestamp('20130102', tz='US/Eastern'),\n B=Timestamp('20130102', tz='EET')),\n index=range(5))\n with pytest.raises(ValueError):\n store.append('df_tz', df)\n\n # this is ok\n _maybe_remove(store, 'df_tz')\n store.append('df_tz', df, data_columns=['A', 'B'])\n result = store['df_tz']\n self._compare_with_tz(result, df)\n assert_frame_equal(result, df)\n\n # can't append with diff timezone\n df = DataFrame(dict(A=Timestamp('20130102', tz='US/Eastern'),\n B=Timestamp('20130102', tz='CET')),\n index=range(5))\n with pytest.raises(ValueError):\n store.append('df_tz', df)\n\n # as index\n with ensure_clean_store(self.path) as store:\n\n # GH 4098 example\n df = DataFrame(dict(A=Series(lrange(3), index=date_range(\n '2000-1-1', periods=3, freq='H', tz='US/Eastern'))))\n\n _maybe_remove(store, 'df')\n store.put('df', df)\n result = store.select('df')\n assert_frame_equal(result, df)\n\n _maybe_remove(store, 'df')\n store.append('df', df)\n result = store.select('df')\n assert_frame_equal(result, df)\n\n def test_tseries_select_index_column(self):\n # GH7777\n # selecting a UTC datetimeindex column did\n # not preserve UTC tzinfo set before storing\n\n # check that no tz still works\n rng = date_range('1/1/2000', '1/30/2000')\n frame = DataFrame(np.random.randn(len(rng), 4), index=rng)\n\n with ensure_clean_store(self.path) as store:\n store.append('frame', frame)\n result = store.select_column('frame', 'index')\n assert rng.tz == DatetimeIndex(result.values).tz\n\n # check utc\n rng = date_range('1/1/2000', '1/30/2000', tz='UTC')\n frame = DataFrame(np.random.randn(len(rng), 4), index=rng)\n\n with ensure_clean_store(self.path) as store:\n store.append('frame', frame)\n result = store.select_column('frame', 'index')\n assert rng.tz == result.dt.tz\n\n # double check non-utc\n rng = date_range('1/1/2000', '1/30/2000', tz='US/Eastern')\n frame = DataFrame(np.random.randn(len(rng), 4), index=rng)\n\n with ensure_clean_store(self.path) as store:\n store.append('frame', frame)\n result = store.select_column('frame', 'index')\n assert rng.tz == result.dt.tz\n\n def test_timezones_fixed(self):\n with ensure_clean_store(self.path) as store:\n\n # index\n rng = date_range('1/1/2000', '1/30/2000', tz='US/Eastern')\n df = DataFrame(np.random.randn(len(rng), 4), index=rng)\n store['df'] = df\n result = store['df']\n assert_frame_equal(result, df)\n\n # as data\n # GH11411\n _maybe_remove(store, 'df')\n df = DataFrame({'A': rng,\n 'B': rng.tz_convert('UTC').tz_localize(None),\n 'C': rng.tz_convert('CET'),\n 'D': range(len(rng))}, index=rng)\n store['df'] = df\n result = store['df']\n assert_frame_equal(result, df)\n\n def test_fixed_offset_tz(self):\n rng = date_range('1/1/2000 00:00:00-07:00', '1/30/2000 00:00:00-07:00')\n frame = DataFrame(np.random.randn(len(rng), 4), index=rng)\n\n with ensure_clean_store(self.path) as store:\n store['frame'] = frame\n recons = store['frame']\n tm.assert_index_equal(recons.index, rng)\n assert rng.tz == recons.index.tz\n\n @td.skip_if_windows\n def test_store_timezone(self):\n # GH2852\n # issue storing datetime.date with a timezone as it resets when read\n # back in a new timezone\n\n # original method\n with ensure_clean_store(self.path) as store:\n\n today = datetime.date(2013, 9, 10)\n df = DataFrame([1, 2, 3], index=[today, today, today])\n store['obj1'] = df\n result = store['obj1']\n assert_frame_equal(result, df)\n\n # with tz setting\n with ensure_clean_store(self.path) as store:\n\n with set_timezone('EST5EDT'):\n today = datetime.date(2013, 9, 10)\n df = DataFrame([1, 2, 3], index=[today, today, today])\n store['obj1'] = df\n\n with set_timezone('CST6CDT'):\n result = store['obj1']\n\n assert_frame_equal(result, df)\n\n def test_legacy_datetimetz_object(self, datapath):\n # legacy from < 0.17.0\n # 8260\n expected = DataFrame(dict(A=Timestamp('20130102', tz='US/Eastern'),\n B=Timestamp('20130603', tz='CET')),\n index=range(5))\n with ensure_clean_store(\n datapath('io', 'data', 'legacy_hdf', 'datetimetz_object.h5'),\n mode='r') as store:\n result = store['df']\n assert_frame_equal(result, expected)\n\n def test_dst_transitions(self):\n # make sure we are not failing on transaitions\n with ensure_clean_store(self.path) as store:\n times = pd.date_range(\"2013-10-26 23:00\", \"2013-10-27 01:00\",\n tz=\"Europe/London\",\n freq=\"H\",\n ambiguous='infer')\n\n for i in [times, times + pd.Timedelta('10min')]:\n _maybe_remove(store, 'df')\n df = DataFrame({'A': range(len(i)), 'B': i}, index=i)\n store.append('df', df)\n result = store.select('df')\n assert_frame_equal(result, df)\n"
] | [
[
"numpy.array",
"pandas.io.parsers._concat_date_cols",
"pandas.util.testing.assert_frame_equal",
"pandas.DatetimeIndex",
"pandas.DataFrame",
"pandas.MultiIndex.from_tuples",
"pandas.compat.parse_date",
"pandas.Timestamp",
"pandas.compat.lrange",
"pandas.core.indexes.datetimes.date_range",
"pandas._libs.tslib.Timestamp",
"pandas.compat.numpy.np_array_datetime64_compat",
"pandas.util.testing.ensure_clean"
],
[
"pandas.compat.is_platform_little_endian",
"numpy.random.rand",
"pandas.DatetimeIndex",
"pandas.io.formats.printing.pprint_thing",
"pandas.Timestamp",
"pandas.read_hdf",
"pandas.io.pytables.HDFStore",
"pandas.concat",
"pandas.util.testing.ensure_clean",
"pandas.io.pytables.read_hdf",
"pandas.util.testing.round_trip_localpath",
"numpy.random.normal",
"numpy.random.binomial",
"pandas.Timedelta",
"pandas.set_option",
"pandas.util.testing.makePeriodIndex",
"pandas.util.testing.makeStringSeries",
"pandas.DataFrame",
"pandas.util.testing.rands_array",
"pandas.util.testing.set_timezone",
"pandas.compat.is_platform_windows",
"pandas.util.testing.assert_index_equal",
"pandas.timedelta_range",
"pandas.PeriodIndex",
"pandas.util.testing.set_testing_mode",
"numpy.arange",
"pandas.MultiIndex",
"pandas.util.testing.makeTimeSeries",
"pandas.bdate_range",
"pandas.util.testing.makeDataFrame",
"numpy.random.randint",
"pandas.util.testing.makeDateIndex",
"pandas.util.testing.reset_testing_mode",
"numpy.array",
"numpy.zeros",
"pandas.util.testing.assert_almost_equal",
"pandas.MultiIndex.from_tuples",
"numpy.random.randn",
"pandas.util.testing.rands",
"numpy.float64",
"pandas.compat.lrange",
"pandas.util.testing.makeFloatSeries",
"pandas.io.pytables.Term",
"numpy.datetime64",
"pandas._libs.tslibs.timezones.maybe_get_tz",
"pandas.Index",
"pandas.isna",
"pandas.util.testing.assert_frame_equal",
"pandas.util.testing.makeTimeDataFrame",
"pandas.util.testing.round_trip_pathlib",
"numpy.random.seed",
"pandas.Int64Index",
"pandas.date_range",
"numpy.asarray",
"pandas.util.testing.makeMixedDataFrame",
"pandas.util.testing.assert_series_equal",
"pandas.Categorical",
"pandas.util._test_decorators.skip_if_no",
"pandas.Series",
"pandas.HDFStore",
"pandas.core.dtypes.common.is_categorical_dtype",
"pandas.offsets.CustomBusinessDay",
"pandas.util.testing.assert_class_equal"
]
] |
sambuddinc/DLTK | [
"9511b0b9860118a9285c2fe730ea49dfe247cab6"
] | [
"data/IXI_HH/download_IXI_HH.py"
] | [
"# -*- coding: utf-8 -*-\n\"\"\"Download and extract the IXI Hammersmith Hospital 3T dataset\n\nurl: http://brain-development.org/ixi-dataset/\nref: IXI – Information eXtraction from Images (EPSRC GR/S21533/02)\n\n\"\"\"\nfrom __future__ import unicode_literals\nfrom __future__ import print_function\nfrom __future__ import division\nfrom __future__ import absolute_import\nfrom future.standard_library import install_aliases # py 2/3 compatability\ninstall_aliases()\n\nfrom urllib.request import FancyURLopener\n\nimport os.path\nimport tarfile\nimport pandas as pd\nimport glob\nimport SimpleITK as sitk\nimport numpy as np\n\nDOWNLOAD_IMAGES = True\nEXTRACT_IMAGES = True\nPROCESS_OTHER = True\nRESAMPLE_IMAGES = True\nCLEAN_UP = True\n\n\ndef resample_image(itk_image, out_spacing=(1.0, 1.0, 1.0), is_label=False):\n original_spacing = itk_image.GetSpacing()\n original_size = itk_image.GetSize()\n\n out_size = [int(np.round(original_size[0]*(original_spacing[0]/out_spacing[0]))),\n int(np.round(original_size[1]*(original_spacing[1]/out_spacing[1]))),\n int(np.round(original_size[2]*(original_spacing[2]/out_spacing[2])))]\n\n resample = sitk.ResampleImageFilter()\n resample.SetOutputSpacing(out_spacing)\n resample.SetSize(out_size)\n resample.SetOutputDirection(itk_image.GetDirection())\n resample.SetOutputOrigin(itk_image.GetOrigin())\n resample.SetTransform(sitk.Transform())\n resample.SetDefaultPixelValue(itk_image.GetPixelIDValue())\n\n if is_label:\n resample.SetInterpolator(sitk.sitkNearestNeighbor)\n else:\n resample.SetInterpolator(sitk.sitkBSpline)\n\n return resample.Execute(itk_image)\n\n\ndef reslice_image(itk_image, itk_ref, is_label=False):\n resample = sitk.ResampleImageFilter()\n resample.SetReferenceImage(itk_ref)\n\n if is_label:\n resample.SetInterpolator(sitk.sitkNearestNeighbor)\n else:\n resample.SetInterpolator(sitk.sitkBSpline)\n\n return resample.Execute(itk_image)\n\n\nurls = {}\nurls['t1'] = 'http://biomedic.doc.ic.ac.uk/brain-development/downloads/IXI/IXI-T1.tar'\nurls['t2'] = 'http://biomedic.doc.ic.ac.uk/brain-development/downloads/IXI/IXI-T2.tar'\nurls['pd'] = 'http://biomedic.doc.ic.ac.uk/brain-development/downloads/IXI/IXI-PD.tar'\nurls['mra'] = 'http://biomedic.doc.ic.ac.uk/brain-development/downloads/IXI/IXI-MRA.tar'\nurls['demographic'] = 'http://biomedic.doc.ic.ac.uk/brain-development/downloads/IXI/IXI.xls'\n\nfnames = {}\nfnames['t1'] = 't1.tar'\nfnames['t2'] = 't2.tar'\nfnames['pd'] = 'pd.tar'\nfnames['mra'] = 'mra.tar'\nfnames['demographic'] = 'demographic.xls'\n\n\nif DOWNLOAD_IMAGES:\n # Download all IXI data\n for key, url in urls.items():\n\n if not os.path.isfile(fnames[key]):\n print('Downloading {} from {}'.format(fnames[key], url))\n curr_file = FancyURLopener()\n curr_file.retrieve(url, fnames[key])\n else:\n print('File {} already exists. Skipping download.'.format(\n fnames[key]))\n\nif EXTRACT_IMAGES:\n # Extract the HH subset of IXI\n for key, fname in fnames.items():\n\n if (fname.endswith('.tar')):\n print('Extracting IXI HH data from {}.'.format(fnames[key]))\n output_dir = os.path.join('./orig/', key)\n\n if not os.path.exists(output_dir):\n os.makedirs(output_dir)\n\n t = tarfile.open(fname, 'r')\n for member in t.getmembers():\n if '-HH-' in member.name:\n t.extract(member, output_dir)\n\n\nif PROCESS_OTHER:\n # Process the demographic xls data and save to csv\n xls = pd.ExcelFile('demographic.xls')\n print(xls.sheet_names)\n\n df = xls.parse('Table')\n for index, row in df.iterrows():\n IXI_id = 'IXI{:03d}'.format(row['IXI_ID'])\n df.loc[index, 'IXI_ID'] = IXI_id\n\n t1_exists = len(glob.glob('./orig/t1/{}*.nii.gz'.format(IXI_id)))\n t2_exists = len(glob.glob('./orig/t2/{}*.nii.gz'.format(IXI_id)))\n pd_exists = len(glob.glob('./orig/pd/{}*.nii.gz'.format(IXI_id)))\n mra_exists = len(glob.glob('./orig/mra/{}*.nii.gz'.format(IXI_id)))\n\n # Check if each entry is complete and drop if not\n # if not t1_exists and not t2_exists and not pd_exists and not mra\n # exists:\n if not (t1_exists and t2_exists and pd_exists and mra_exists):\n df.drop(index, inplace=True)\n\n # Write to csv file\n df.to_csv('demographic_HH.csv', index=False)\n\nif RESAMPLE_IMAGES:\n # Resample the IXI HH T2 images to 1mm isotropic and reslice all\n # others to it\n df = pd.read_csv('demographic_HH.csv', dtype=object, keep_default_na=False,\n na_values=[]).as_matrix()\n\n for i in df:\n IXI_id = i[0]\n print('Resampling {}'.format(IXI_id))\n\n t1_fn = glob.glob('./orig/t1/{}*.nii.gz'.format(IXI_id))[0]\n t2_fn = glob.glob('./orig/t2/{}*.nii.gz'.format(IXI_id))[0]\n pd_fn = glob.glob('./orig/pd/{}*.nii.gz'.format(IXI_id))[0]\n mra_fn = glob.glob('./orig/mra/{}*.nii.gz'.format(IXI_id))[0]\n\n t1 = sitk.ReadImage(t1_fn)\n t2 = sitk.ReadImage(t2_fn)\n pd = sitk.ReadImage(pd_fn)\n mra = sitk.ReadImage(mra_fn)\n\n # Resample to 1mm isotropic resolution\n t2_1mm = resample_image(t2)\n t1_1mm = reslice_image(t1, t2_1mm)\n pd_1mm = reslice_image(pd, t2_1mm)\n mra_1mm = reslice_image(mra, t2_1mm)\n\n output_dir = os.path.join('./1mm/', IXI_id)\n if not os.path.exists(output_dir):\n os.makedirs(output_dir)\n\n print('T1: {} {}'.format(t1_1mm.GetSize(), t1_1mm.GetSpacing()))\n print('T2: {} {}'.format(t2_1mm.GetSize(), t2_1mm.GetSpacing()))\n print('PD: {} {}'.format(pd_1mm.GetSize(), pd_1mm.GetSpacing()))\n print('MRA: {} {}'.format(mra_1mm.GetSize(), mra_1mm.GetSpacing()))\n\n sitk.WriteImage(t1_1mm, os.path.join(output_dir, 'T1_1mm.nii.gz'))\n sitk.WriteImage(t2_1mm, os.path.join(output_dir, 'T2_1mm.nii.gz'))\n sitk.WriteImage(pd_1mm, os.path.join(output_dir, 'PD_1mm.nii.gz'))\n sitk.WriteImage(mra_1mm, os.path.join(output_dir, 'MRA_1mm.nii.gz'))\n\n # Resample to 2mm isotropic resolution\n t2_2mm = resample_image(t2, out_spacing=[2.0, 2.0, 2.0])\n t1_2mm = reslice_image(t1, t2_2mm)\n pd_2mm = reslice_image(pd, t2_2mm)\n mra_2mm = reslice_image(mra, t2_2mm)\n\n output_dir = os.path.join('./2mm/', IXI_id)\n if not os.path.exists(output_dir):\n os.makedirs(output_dir)\n\n print('T1: {} {}'.format(t2_2mm.GetSize(), t1_2mm.GetSpacing()))\n print('T2: {} {}'.format(t2_2mm.GetSize(), t2_2mm.GetSpacing()))\n print('PD: {} {}'.format(pd_2mm.GetSize(), pd_2mm.GetSpacing()))\n print('MRA: {} {}'.format(mra_2mm.GetSize(), mra_2mm.GetSpacing()))\n\n sitk.WriteImage(t1_2mm, os.path.join(output_dir, 'T1_2mm.nii.gz'))\n sitk.WriteImage(t2_2mm, os.path.join(output_dir, 'T2_2mm.nii.gz'))\n sitk.WriteImage(pd_2mm, os.path.join(output_dir, 'PD_2mm.nii.gz'))\n sitk.WriteImage(mra_2mm, os.path.join(output_dir, 'MRA_2mm.nii.gz'))\n\n\nif CLEAN_UP:\n # Remove the .tar files\n for key, fname in fnames.items():\n if (fname.endswith('.tar')):\n os.remove(fname)\n\n # Remove all data in original resolution\n os.system('rm -rf orig')\n"
] | [
[
"numpy.round"
]
] |
klarman-cell-observatory/scCloud.py | [
"5a04a2f22574db044d018656ac4705ec83840226",
"5a04a2f22574db044d018656ac4705ec83840226",
"5a04a2f22574db044d018656ac4705ec83840226"
] | [
"sccloud/misc/misc.py",
"sccloud/__init__.py",
"sccloud/tools/visualization.py"
] | [
"import numpy as np\nimport pandas as pd\nfrom typing import List\nfrom anndata import AnnData\n\nfrom sccloud.io import read_input\n\n\ndef search_genes(\n data: AnnData,\n gene_list: List[str],\n rec_key: str = \"de_res\",\n measure: str = \"percentage\",\n) -> pd.DataFrame:\n \"\"\"Extract and display gene expressions for each cluster from an `anndata` object.\n\n This function helps to see marker expressions in clusters via the interactive python environment.\n\n Parameters\n ----------\n\n data: ``anndata.AnnData``\n Annotated data matrix containing the expression matrix and differential expression results.\n\n gene_list: ``List[str]``\n A list of gene symbols.\n\n rec_key: ``str``, optional, default: ``\"de_res\"``\n Keyword of DE analysis result stored in ``data.varm``.\n\n measure : ``str``, optional, default: ``\"percentage\"``\n Can be either ``\"percentage\"`` or ``\"mean_logExpr\"``:\n * ``percentage`` shows the percentage of cells expressed the genes;\n * ``mean_logExpr`` shows the mean log expression.\n\n Returns\n -------\n ``pandas.DataFrame``\n A data frame containing marker expressions in each cluster.\n\n Examples\n --------\n >>> results = scc.search_genes(adata, ['CD3E', 'CD4', 'CD8'])\n \"\"\"\n\n columns = [x for x in data.varm[rec_key].dtype.names if x.startswith(measure + \":\")]\n df = pd.DataFrame(data=data.varm[rec_key][columns], index=data.var_names)\n return df.reindex(index=gene_list)\n\n\ndef search_de_genes(\n data: AnnData,\n gene_list: List[str],\n rec_key: str = \"de_res\",\n de_test: str = \"fisher\",\n de_alpha: float = 0.05,\n thre: float = 1.5,\n) -> pd.DataFrame:\n \"\"\"Extract and display differential expression analysis results of markers for each cluster.\n\n This function helps to see if markers are up or down regulated in each cluster via the interactive python environment: \n * ``++`` indicates up-regulated and fold change >= threshold;\n * ``+`` indicates up-regulated but fold change < threshold;\n * ``--`` indicates down-regulated and fold change <= 1 / threshold; \n * ``-`` indicates down-regulated but fold change > 1 / threshold;\n * ``?`` indicates not differentially expressed.\n\n Parameters\n ----------\n data: ``anndata.Anndata``\n Annotated data matrix containing the expression matrix and differential expression results.\n\n gene_list: ``List[str]``\n A list of gene symbols.\n\n rec_key: ``str``, optional, default: ``\"de_res\"``\n Keyword of DE analysis result stored in ``data.varm``.\n\n de_test : ``str``, optional, default: ``\"fisher\"``\n Differential expression test to look at, could be either ``t``, ``fisher`` or ``mwu``.\n\n de_alpha : ``float``, optional, default: ``0.05``\n False discovery rate.\n\n thre : ``float``, optional, default: ``1.5``\n Fold change threshold to determine if the marker is a strong DE (``++`` or ``--``) or weak DE (``+`` or ``-``).\n\n Returns\n -------\n ``pandas.DataFrame``\n A data frame containing marker differential expression results for each cluster.\n\n Examples\n --------\n >>> df = sccloud.misc.search_de_genes(adata, ['CD3E', 'CD4', 'CD8'], thre = 2.0)\n \"\"\"\n\n columns = [\n x for x in data.varm[rec_key].dtype.names if x.startswith(de_test + \"_qval:\")\n ]\n df_de = pd.DataFrame(data.varm[rec_key][columns], index=data.var_names)\n df_de = df_de.reindex(index=gene_list)\n\n columns = [\n x\n for x in data.varm[rec_key].dtype.names\n if (\n x.startswith(\"percentage_fold_change:\")\n if de_test == \"fisher\"\n else x.startswith(\"log_fold_change:\")\n )\n ]\n df_fc = pd.DataFrame(data.varm[rec_key][columns], index=data.var_names)\n df_fc = df_fc.reindex(index=gene_list)\n if de_test != \"fisher\":\n df_fc = np.exp(df_fc)\n\n results = np.zeros((len(gene_list), len(columns)), dtype=np.dtype(\"U4\"))\n results[:] = \"?\"\n results[np.isnan(df_de)] = \"NaN\"\n results[(df_de <= de_alpha).values & (df_fc > 1.0).values] = \"+\"\n results[(df_de <= de_alpha).values & (df_fc >= thre).values] = \"++\"\n results[(df_de <= de_alpha).values & (df_fc < 1.0).values] = \"-\"\n results[(df_de <= de_alpha).values & (df_fc <= 1.0 / thre).values] = \"--\"\n\n clusts = [x.rpartition(\":\")[2] for x in columns]\n df = pd.DataFrame(data=results, index=gene_list, columns=clusts)\n return df\n\n\ndef show_attributes(\n input_file: str,\n show_attributes: bool,\n show_gene_attributes: bool,\n show_values_for_attributes: str,\n) -> None:\n \"\"\" Show data attributes. For command line use.\n \"\"\"\n\n data = read_input(input_file, h5ad_mode=\"r\")\n if show_attributes:\n print(\n \"Available sample attributes in input dataset: {0}\".format(\n \", \".join(data.obs.columns.values)\n )\n )\n if show_gene_attributes:\n print(\n \"Available gene attributes in input dataset: {0}\".format(\n \", \".join(data.var.columns.values)\n )\n )\n if not show_values_for_attributes is None:\n for attr in show_values_for_attributes.split(\",\"):\n print(\n \"Available values for attribute {0}: {1}.\".format(\n attr, \", \".join(np.unique(data.obs[attr]))\n )\n )\n\n\ndef perform_oneway_anova(\n data: AnnData,\n glist: List[str],\n restriction_vec: List[str],\n group_str: str,\n fdr_alpha: float = 0.05,\n res_key: str = None,\n) -> pd.DataFrame:\n \"\"\"Perform one way ANOVA on a subset of cells (restricted by restriction_vec) grouped by group_str and control FDR at fdr_alpha.\n Parameters\n ----------\n\n data : `anndata` object\n An `anndata` object containing the expression matrix.\n glist : `list[str]`\n A list of gene symbols.\n restriction_vec : `list[str]`\n A vector of restrictions for selecting cells. Each restriction takes the format of attr:value,value,value\n group_str : `str`\n How to group selected cells for ANOVA analysis. If group_str is for pseudotime, it has two formats. 1) 'pseudotime:time:n', which divides cells by equal pseudotime invertal; 2) 'pseudotime:size:n' divides cells by equal number of cells.\n fdr_alpha : `float`, optional (default: 0.05)\n False discovery rate.\n res_key : `str`, optional (default: None)\n Store results into data using res_key, the grouping information is stored in obs and the results is stored in uns.\n\n Returns\n -------\n `pandas.DataFrame`\n Results for genes that pass FDR control.\n\n Examples\n --------\n >>> results = misc.perform_oneway_anova(data, ['CD3E', 'CD4', 'CD8'], [], 'pseudotime:size:10')\n \"\"\"\n\n from scipy.stats import f_oneway\n from statsmodels.stats.multitest import fdrcorrection as fdr\n\n selected = np.ones(data.shape[0], dtype=bool)\n for rest_str in restriction_vec:\n attr, value_str = rest_str.split(\":\")\n values = value_str.split(\",\")\n selected = selected & np.isin(data.obs[attr], values)\n\n gene_list = np.array(glist)\n gene_list = gene_list[np.isin(gene_list, data.var_names)]\n ngene = gene_list.size\n\n newdat = data[selected, :][:, gene_list].copy()\n newdat.X = newdat.X.toarray()\n\n group_values = group_str.split(\":\")\n group_names = []\n col_names = []\n\n ngr = 0\n group_idx = None\n\n if group_values[0] == \"pseudotime\":\n assert len(group_values) == 3\n div_by = group_values[1]\n ngr = int(group_values[2])\n\n group_idx = np.zeros((ngr, newdat.shape[0]), dtype=bool)\n pseudotimes = newdat.obs[\"pseudotime\"].values\n\n min_t = pseudotimes.min()\n max_t = pseudotimes.max()\n\n if div_by == \"time\":\n interval = (max_t - min_t) / ngr\n left = min_t - 1e-5\n for i in range(ngr):\n right = min_t + interval * (i + 1)\n name = \"({:.2f}, {:.2f}]\".format(left if left >= 0 else 0.0, right)\n group_names.append(name)\n group_idx[i] = (pseudotimes > left) & (pseudotimes <= right)\n left = right\n else:\n assert div_by == \"size\"\n ords = np.argsort(pseudotimes)\n quotient = ords.size // ngr\n residule = ords.size % ngr\n\n fr = 0\n for i in range(ngr):\n to = fr + quotient + (i < residule)\n name = \"[{:.2f}, {:.2f}]\".format(\n pseudotimes[ords[fr]], pseudotimes[ords[to - 1]]\n )\n group_names.append(name)\n group_idx[i][ords[fr:to]] = True\n fr = to\n\n else:\n assert len(group_values) == 2\n group_attr = group_values[0]\n tmp_str = group_values[1]\n groups_str = tmp_str.split(\";\")\n\n ngr = len(groups_str)\n group_idx = np.zeros((ngr, newdat.shape[0]), dtype=bool)\n\n for i, gstr in enumerate(groups_str):\n name, values = gstr.split(\"~\")\n group_names.append(name)\n group_idx[i] = np.isin(newdat.obs[group_attr], values.split(\",\"))\n\n for i in range(ngr):\n print(\"Group {} has {} cells.\".format(group_names[i], group_idx[i].sum()))\n\n np.warnings.filterwarnings(\"ignore\")\n stats = np.zeros((ngene, 3 + ngr * 2))\n for i in range(ngene):\n arr_list = []\n for j in range(ngr):\n arr = newdat.X[group_idx[j], i]\n stats[i, 3 + j * 2] = arr.mean()\n stats[i, 3 + j * 2 + 1] = (arr > 0).sum() * 100.0 / arr.size\n arr_list.append(arr)\n stats[i, 0], stats[i, 1] = f_oneway(*arr_list)\n if np.isnan(stats[i, 0]):\n stats[i, 0] = 0.0\n stats[i, 1] = 1.0\n passed, stats[:, 2] = fdr(stats[:, 1])\n\n cols = [\"fstat\", \"pval\", \"qval\"]\n for i in range(ngr):\n cols.extend([group_names[i] + \"_mean\", group_names[i] + \"_percent\"])\n raw_results = pd.DataFrame(stats, columns=cols, index=gene_list)\n\n results = raw_results[raw_results[\"qval\"] <= fdr_alpha]\n results = results.sort_values(\"qval\")\n\n if res_key is not None:\n data.uns[res_key] = raw_results\n data.obs[res_key] = \"background\"\n for i in range(ngr):\n idx = np.zeros(data.shape[0], dtype=bool)\n idx[selected] = group_idx[i]\n data.obs.loc[idx, res_key] = group_names[i]\n\n return results\n",
"try:\n get_ipython\nexcept NameError:\n import matplotlib\n\n matplotlib.use(\"Agg\")\n\nimport sys\nimport logging\nimport warnings\n\nlogger = logging.getLogger(\"sccloud\")\nlogger.setLevel(logging.DEBUG)\nch = logging.StreamHandler(sys.stdout)\nch.setLevel(logging.INFO)\nformatter = logging.Formatter(\"%(asctime)s - %(name)s - %(levelname)s - %(message)s\")\nch.setFormatter(formatter)\nlogger.addHandler(ch)\n\nwarnings.filterwarnings(\"ignore\", category=UserWarning, module='lightgbm')\n\nfrom .io import infer_file_format, read_input, write_output\nfrom .tools import (\n aggregate_matrices,\n qc_metrics,\n get_filter_stats,\n filter_data,\n log_norm,\n select_features,\n pca,\n highly_variable_features,\n set_group_attribute,\n correct_batch,\n neighbors,\n calc_kBET,\n calc_kSIM,\n diffmap,\n reduce_diffmap_to_3d,\n calc_pseudotime,\n louvain,\n leiden,\n spectral_louvain,\n spectral_leiden,\n tsne,\n fitsne,\n umap,\n fle,\n net_tsne,\n net_fitsne,\n net_umap,\n net_fle,\n de_analysis,\n markers,\n write_results_to_excel,\n find_markers,\n infer_path,\n)\nfrom .annotate_cluster import infer_cell_types, annotate, infer_cluster_names\nfrom .demuxEM import estimate_background_probs, demultiplex\nfrom .misc import search_genes, search_de_genes\n\nfrom scplot import (\n violin,\n heatmap,\n scatter,\n line,\n dotplot,\n scatter_matrix,\n embedding,\n composition_plot,\n variable_feature_plot,\n volcano,\n)\n\nfrom ._version import get_versions\n\n__version__ = get_versions()[\"version\"]\ndel get_versions\n",
"import time\nimport numpy as np\nimport scipy\nimport logging\nimport umap as umap_module\nimport forceatlas2 as fa2\nimport uuid\n\nfrom anndata import AnnData\nfrom joblib import effective_n_jobs\ntry:\n from MulticoreTSNE import MulticoreTSNE as TSNE\nexcept ImportError:\n print(\"Need Multicore-TSNE!\")\n\nfrom sccloud.tools import (\n update_rep,\n X_from_rep,\n W_from_rep,\n knn_is_cached,\n neighbors,\n net_train_and_predict,\n calculate_nearest_neighbors,\n calculate_affinity_matrix,\n construct_graph,\n)\n\nlogger = logging.getLogger(\"sccloud\")\n\n\ndef calc_tsne(\n X,\n n_jobs,\n n_components,\n perplexity,\n early_exaggeration,\n learning_rate,\n random_state,\n init=\"random\",\n n_iter=1000,\n n_iter_early_exag=250,\n):\n \"\"\"\n TODO: Typing\n \"\"\"\n tsne = TSNE(\n n_jobs=n_jobs,\n n_components=n_components,\n perplexity=perplexity,\n early_exaggeration=early_exaggeration,\n learning_rate=learning_rate,\n random_state=random_state,\n verbose=1,\n init=init,\n n_iter=n_iter,\n n_iter_early_exag=n_iter_early_exag,\n )\n X_tsne = tsne.fit_transform(X)\n logger.info(\"Final error = {}\".format(tsne.kl_divergence_))\n return X_tsne\n\n\ndef calc_fitsne(\n X,\n nthreads,\n no_dims,\n perplexity,\n early_exag_coeff,\n learning_rate,\n rand_seed,\n initialization=None,\n max_iter=1000,\n stop_early_exag_iter=250,\n mom_switch_iter=250,\n):\n \"\"\"\n TODO: Typing\n \"\"\"\n # FItSNE will change X content\n\n # Check if fftw3 is installed.\n import ctypes.util\n\n fftw3_loc = ctypes.util.find_library(\"fftw3\")\n if fftw3_loc is None:\n raise Exception(\"Please install 'fftw3' first to use the FIt-SNE feature!\")\n\n from fitsne import FItSNE\n\n return FItSNE(\n X.astype(\"float64\"),\n nthreads=nthreads,\n no_dims=no_dims,\n perplexity=perplexity,\n early_exag_coeff=early_exag_coeff,\n learning_rate=learning_rate,\n rand_seed=rand_seed,\n initialization=initialization,\n max_iter=max_iter,\n stop_early_exag_iter=stop_early_exag_iter,\n mom_switch_iter=mom_switch_iter,\n )\n\n\n# Running umap using our own kNN indices\ndef calc_umap(\n X,\n n_components,\n n_neighbors,\n min_dist,\n spread,\n random_state,\n init=\"spectral\",\n n_epochs=None,\n learning_rate=1.0,\n knn_indices=None,\n knn_dists=None,\n):\n \"\"\"\n TODO: Typing\n \"\"\"\n umap_obj = umap_module.UMAP(\n n_components=n_components,\n n_neighbors=n_neighbors,\n min_dist=min_dist,\n spread=spread,\n random_state=random_state,\n init=init,\n n_epochs=n_epochs,\n learning_rate=learning_rate,\n verbose=True,\n )\n\n embedding = None\n if X.shape[0] < 4096 or knn_indices is None:\n embedding = umap_obj.fit_transform(X)\n logger.info(\"using umap kNN graph {}\".format(X.shape[0]))\n else:\n assert knn_dists is not None\n # preprocessing codes adopted from UMAP's umap_.py fit function in order to use our own kNN graphs\n from sklearn.utils import check_random_state, check_array\n\n X = check_array(X, dtype=np.float32, accept_sparse=\"csr\")\n umap_obj._raw_data = X\n if umap_obj.a is None or umap_obj.b is None:\n umap_obj._a, umap_obj._b = umap_module.umap_.find_ab_params(\n umap_obj.spread, umap_obj.min_dist\n )\n else:\n umap_obj._a = umap_obj.a\n umap_obj._b = umap_obj.b\n umap_obj._metric_kwds = (\n umap_obj.metric_kwds if umap_obj.metric_kwds is not None else {}\n )\n umap_obj._target_metric_kwds = {}\n _init = (\n check_array(umap_obj.init, dtype=np.float32, accept_sparse=False)\n if isinstance(umap_obj.init, np.ndarray)\n else umap_obj.init\n )\n umap_obj._initial_alpha = umap_obj.learning_rate\n umap_obj._validate_parameters()\n\n if umap_obj.verbose:\n logger.info(str(umap_obj))\n\n if scipy.sparse.isspmatrix_csr(X):\n if not X.has_sorted_indices:\n X.sort_indices()\n umap_obj._sparse_data = True\n else:\n umap_obj._sparse_data = False\n\n _random_state = check_random_state(umap_obj.random_state)\n\n if umap_obj.verbose:\n logger.info(\"Construct fuzzy simplicial set\")\n\n umap_obj._small_data = False\n umap_obj.graph_ = umap_module.umap_.fuzzy_simplicial_set(\n X,\n umap_obj.n_neighbors,\n _random_state,\n umap_obj.metric,\n umap_obj._metric_kwds,\n knn_indices,\n knn_dists,\n umap_obj.angular_rp_forest,\n umap_obj.set_op_mix_ratio,\n umap_obj.local_connectivity,\n umap_obj.verbose,\n )\n\n _n_epochs = umap_obj.n_epochs if umap_obj.n_epochs is not None else 0\n if umap_obj.verbose:\n logger.info(\"Construct embedding\")\n embedding = umap_module.umap_.simplicial_set_embedding(\n X,\n umap_obj.graph_,\n umap_obj.n_components,\n umap_obj._initial_alpha,\n umap_obj._a,\n umap_obj._b,\n umap_obj.repulsion_strength,\n umap_obj.negative_sample_rate,\n _n_epochs,\n _init,\n _random_state,\n umap_obj.metric,\n umap_obj._metric_kwds,\n umap_obj.verbose,\n )\n\n return embedding\n\n\ndef calc_force_directed_layout(\n W,\n file_name,\n n_jobs,\n target_change_per_node,\n target_steps,\n is3d,\n memory,\n random_state,\n init=None,\n):\n \"\"\"\n TODO: Typing\n \"\"\"\n G = construct_graph(W)\n return fa2.forceatlas2(\n file_name,\n graph=G,\n n_jobs=n_jobs,\n target_change_per_node=target_change_per_node,\n target_steps=target_steps,\n is3d=is3d,\n memory=memory,\n random_state=random_state,\n init=init,\n )\n\n\ndef tsne(\n data: AnnData,\n rep: str = \"pca\",\n n_jobs: int = -1,\n n_components: int = 2,\n perplexity: float = 30,\n early_exaggeration: int = 12,\n learning_rate: float = 1000,\n random_state: int = 0,\n out_basis: str = \"tsne\",\n) -> None:\n \"\"\"Calculate tSNE embedding using MulticoreTSNE_ package.\n\n .. _MulticoreTSNE: https://github.com/DmitryUlyanov/Multicore-TSNE\n\n Parameters\n ----------\n data: ``anndata.AnnData``\n Annotated data matrix with rows for cells and columns for genes.\n\n rep: ``str``, optional, default: ``\"pca\"``\n Representation of data used for the calculation. By default, use PCA coordinates. If ``None``, use the count matrix ``data.X``.\n\n n_jobs: ``int``, optional, default: ``-1``\n Number of threads to use. If ``-1``, use all available threads.\n\n n_components: ``int``, optional, default: ``2``\n Dimension of calculated tSNE coordinates. By default, generate 2-dimensional data for 2D visualization.\n\n perplexity: ``float``, optional, default: ``30``\n The perplexity is related to the number of nearest neighbors used in other manifold learning algorithms. Larger datasets usually require a larger perplexity.\n\n early_exaggeration: ``int``, optional, default: ``12``\n Controls how tight natural clusters in the original space are in the embedded space, and how much space will be between them.\n\n learning_rate: ``float``, optional, default: ``1000``\n The learning rate can be a critical parameter, which should be between 100 and 1000.\n\n random_state: ``int``, optional, default: ``0``\n Random seed set for reproducing results.\n\n out_basis: ``str``, optional, default: ``\"tsne\"``\n Key name for calculated tSNE coordinates to store.\n\n Returns\n -------\n ``None``\n\n Update ``data.obsm``:\n * ``data.obsm['X_' + out_basis]``: tSNE coordinates of the data.\n\n Examples\n --------\n >>> scc.tsne(adata)\n \"\"\"\n start = time.time()\n rep = update_rep(rep)\n n_jobs = effective_n_jobs(n_jobs)\n\n data.obsm[\"X_\" + out_basis] = calc_tsne(\n X_from_rep(data, rep),\n n_jobs,\n n_components,\n perplexity,\n early_exaggeration,\n learning_rate,\n random_state,\n )\n\n end = time.time()\n logger.info(\"t-SNE is calculated. Time spent = {:.2f}s.\".format(end - start))\n\n\ndef fitsne(\n data: AnnData,\n rep: str = \"pca\",\n n_jobs: int = -1,\n n_components: int = 2,\n perplexity: float = 30,\n early_exaggeration: int = 12,\n learning_rate: float = 1000,\n random_state: int = 0,\n out_basis: str = \"fitsne\",\n) -> None:\n \"\"\"Calculate FIt-SNE embedding using fitsne_ package.\n\n .. _fitsne: https://github.com/KlugerLab/FIt-SNE\n\n Parameters\n ----------\n data: ``anndata.AnnData``\n Annotated data matrix with rows for cells and columns for genes.\n\n rep: ``str``, optional, default: ``\"pca\"``\n Representation of data used for the calculation. By default, use PCA coordinates. If ``None``, use the count matrix ``data.X``.\n\n n_jobs: ``int``, optional, default: ``-1``\n Number of threads to use. If ``-1``, use all available threads.\n\n n_components: ``int``, optional, default: ``2``\n Dimension of calculated FI-tSNE coordinates. By default, generate 2-dimensional data for 2D visualization.\n\n perplexity: ``float``, optional, default: ``30``\n The perplexity is related to the number of nearest neighbors used in other manifold learning algorithms. Larger datasets usually require a larger perplexity.\n\n early_exaggeration: ``int``, optional, default: ``12``\n Controls how tight natural clusters in the original space are in the embedded space, and how much space will be between them.\n\n learning_rate: ``float``, optional, default: ``1000``\n The learning rate can be a critical parameter, which should be between 100 and 1000.\n\n random_state: ``int``, optional, default: ``0``\n Random seed set for reproducing results.\n\n out_basis: ``str``, optional, default: ``\"fitsne\"``\n Key name for calculated FI-tSNE coordinates to store.\n\n Returns\n -------\n ``None``\n\n Update ``data.obsm``:\n * ``data.obsm['X_' + out_basis]``: FI-tSNE coordinates of the data.\n\n Examples\n --------\n >>> scc.fitsne(adata)\n \"\"\"\n start = time.time()\n\n rep = update_rep(rep)\n n_jobs = effective_n_jobs(n_jobs)\n\n data.obsm[\"X_\" + out_basis] = calc_fitsne(\n X_from_rep(data, rep),\n n_jobs,\n n_components,\n perplexity,\n early_exaggeration,\n learning_rate,\n random_state,\n )\n\n end = time.time()\n logger.info(\"FIt-SNE is calculated. Time spent = {:.2f}s.\".format(end - start))\n\n\ndef umap(\n data: AnnData,\n rep: str = \"pca\",\n n_components: int = 2,\n n_neighbors: int = 15,\n min_dist: float = 0.5,\n spread: float = 1.0,\n random_state: int = 0,\n out_basis: str = \"umap\",\n) -> None:\n \"\"\"Calculate UMAP embedding using umap-learn_ package.\n\n .. _umap-learn: https://github.com/lmcinnes/umap\n\n Parameters\n ----------\n data: ``anndata.AnnData``\n Annotated data matrix with rows for cells and columns for genes.\n\n rep: ``str``, optional, default: ``\"pca\"``\n Representation of data used for the calculation. By default, use PCA coordinates. If ``None``, use the count matrix ``data.X``.\n\n n_components: ``int``, optional, default: ``2``\n Dimension of calculated UMAP coordinates. By default, generate 2-dimensional data for 2D visualization.\n\n n_neighbors: ``int``, optional, default: ``15``\n Number of nearest neighbors considered during the computation.\n\n min_dist: ``float``, optional, default: ``0.5``\n The effective minimum distance between embedded data points.\n\n spread: ``float``, optional, default: ``1.0``\n The effective scale of embedded data points.\n\n random_state: ``int``, optional, default: ``0``\n Random seed set for reproducing results.\n\n out_basis: ``str``, optional, default: ``\"umap\"``\n Key name for calculated UMAP coordinates to store.\n\n Returns\n -------\n ``None``\n\n Update ``data.obsm``:\n * ``data.obsm['X_' + out_basis]``: UMAP coordinates of the data.\n\n Examples\n --------\n >>> scc.umap(adata)\n \"\"\"\n start = time.time()\n\n rep = update_rep(rep)\n indices_key = rep + \"_knn_indices\"\n distances_key = rep + \"_knn_distances\"\n\n X = X_from_rep(data, rep)\n if not knn_is_cached(data, indices_key, distances_key, n_neighbors):\n raise ValueError(\"Please run neighbors first!\")\n\n knn_indices = np.insert(\n data.uns[indices_key][:, 0 : n_neighbors - 1], 0, range(data.shape[0]), axis=1\n )\n knn_dists = np.insert(\n data.uns[distances_key][:, 0 : n_neighbors - 1], 0, 0.0, axis=1\n )\n data.obsm[\"X_\" + out_basis] = calc_umap(\n X,\n n_components,\n n_neighbors,\n min_dist,\n spread,\n random_state,\n knn_indices=knn_indices,\n knn_dists=knn_dists,\n )\n\n end = time.time()\n logger.info(\"UMAP is calculated. Time spent = {:.2f}s.\".format(end - start))\n\n\ndef fle(\n data: AnnData,\n file_name: str = None,\n n_jobs: int = -1,\n rep: str = \"diffmap\",\n K: int = 50,\n full_speed: bool = False,\n target_change_per_node: float = 2.0,\n target_steps: int = 5000,\n is3d: bool = False,\n memory: int = 8,\n random_state: int = 0,\n out_basis: str = \"fle\",\n) -> None:\n \"\"\"Construct the Force-directed (FLE) graph using ForceAtlas2_ implementation, with Python wrapper as forceatlas2-python_.\n\n .. _ForceAtlas2: https://github.com/klarman-cell-observatory/forceatlas2\n .. _forceatlas2-python: https://github.com/klarman-cell-observatory/forceatlas2-python\n\n Parameters\n ----------\n data: ``anndata.AnnData``\n Annotated data matrix with rows for cells and columns for genes.\n\n file_name: ``str``, optional, default: ``None``\n Temporary file to store the coordinates as the input to forceatlas2. If ``None``, use ``tempfile.mkstemp`` to generate file name.\n\n n_jobs: ``int``, optional, default: ``-1``\n Number of threads to use. If ``-1``, use all available threads.\n\n rep: ``str``, optional, default: ``\"diffmap\"``\n Representation of data used for the calculation. By default, use Diffusion Map coordinates. If ``None``, use the count matrix ``data.X``.\n\n K: ``int``, optional, default: ``50``\n Number of nearest neighbors to be considered during the computation.\n\n full_speed: ``bool``, optional, default: ``False``\n * If ``True``, use multiple threads in constructing ``hnsw`` index. However, the kNN results are not reproducible.\n * Otherwise, use only one thread to make sure results are reproducible.\n\n target_change_per_node: ``float``, optional, default: ``2.0``\n Target change per node to stop ForceAtlas2.\n\n target_steps: ``int``, optional, default: ``5000``\n Maximum number of iterations before stopping the ForceAtlas2 algorithm.\n\n is3d: ``bool``, optional, default: ``False``\n If ``True``, calculate 3D force-directed layout.\n\n memory: ``int``, optional, default: ``8``\n Memory size in GB for the Java FA2 component. By default, use 8GB memory.\n\n random_state: ``int``, optional, default: ``0``\n Random seed set for reproducing results.\n\n out_basis: ``str``, optional, default: ``\"fle\"``\n Key name for calculated FLE coordinates to store.\n\n Returns\n -------\n ``None``\n\n Update ``data.obsm``:\n * ``data.obsm['X_' + out_basis]``: FLE coordinates of the data.\n\n Examples\n --------\n >>> scc.fle(adata)\n \"\"\"\n start = time.time()\n\n if file_name is None:\n import tempfile\n\n _, file_name = tempfile.mkstemp()\n\n n_jobs = effective_n_jobs(n_jobs)\n rep = update_rep(rep)\n\n if (\"W_\" + rep) not in data.uns:\n neighbors(\n data,\n K=K,\n rep=rep,\n n_jobs=n_jobs,\n random_state=random_state,\n full_speed=full_speed,\n )\n\n data.obsm[\"X_\" + out_basis] = calc_force_directed_layout(\n W_from_rep(data, rep),\n file_name,\n n_jobs,\n target_change_per_node,\n target_steps,\n is3d,\n memory,\n random_state,\n )\n\n end = time.time()\n logger.info(\n \"Force-directed layout is calculated. Time spent = {:.2f}s.\".format(end - start)\n )\n\n\ndef select_cells(distances, frac, K=25, alpha=1.0, random_state=0):\n \"\"\"\n TODO: documentation (not user API)\n \"\"\"\n\n start_time = time.time()\n\n nsample = distances.shape[0]\n\n if K > distances.shape[1]:\n logger.info(\n \"Warning: in select_cells, K = {} > the number of calculated nearest neighbors!\\nSet K to {}\".format(\n K, distances.shape[1]\n )\n )\n K = distances.shape[1]\n\n probs = np.zeros(nsample)\n if alpha == 0.0:\n probs[:] = 1.0 # uniform\n elif alpha == 1.0:\n probs[:] = distances[:, K - 1]\n else:\n probs[:] = distances[:, K - 1] ** alpha\n probs /= probs.sum()\n\n np.random.seed(random_state)\n selected = np.zeros(nsample, dtype=bool)\n selected[\n np.random.choice(nsample, size=int(nsample * frac), replace=False, p=probs)\n ] = True\n\n end_time = time.time()\n logger.info(\n \"select_cells finished. Time spent = {:.2}s.\".format(end_time - start_time)\n )\n\n return selected\n\n\ndef net_tsne(\n data: AnnData,\n rep: str = \"pca\",\n n_jobs: int = -1,\n n_components: int = 2,\n perplexity: float = 30,\n early_exaggeration: int = 12,\n learning_rate: float = 1000,\n random_state: int = 0,\n select_frac: float = 0.1,\n select_K: int = 25,\n select_alpha: float = 1.0,\n net_alpha: float = 0.1,\n polish_learning_frac: float = 0.33,\n polish_n_iter: int = 150,\n out_basis: str = \"net_tsne\",\n) -> None:\n \"\"\"Calculate approximated tSNE embedding using Deep Learning model to improve the speed.\n\n In specific, the deep model used is MLPRegressor_, the *scikit-learn* implementation of Multi-layer Perceptron regressor.\n\n .. _MLPRegressor: https://scikit-learn.org/stable/modules/generated/sklearn.neural_network.MLPRegressor.html\n\n Parameters\n ----------\n data: ``anndata.AnnData``\n Annotated data matrix with rows for cells (``n_obs``) and columns for genes (``n_feature``).\n\n rep: ``str``, optional, default: ``\"pca\"``\n Representation of data used for the calculation. By default, use PCA coordinates. If ``None``, use the count matrix ``data.X``.\n\n n_jobs: ``int``, optional, default: ``-1``\n Number of threads to use. If ``-1``, use all available threads.\n\n n_components: ``int``, optional, default: ``2``\n Dimension of calculated tSNE coordinates. By default, generate 2-dimensional data for 2D visualization.\n\n perplexity: ``float``, optional, default: ``30``\n The perplexity is related to the number of nearest neighbors used in other manifold learning algorithms. Larger datasets usually require a larger perplexity.\n\n early_exaggeration: ``int``, optional, default: ``12``\n Controls how tight natural clusters in the original space are in the embedded space, and how much space will be between them.\n\n learning_rate: ``float``, optional, default: ``1000``\n The learning rate can be a critical parameter, which should be between 100 and 1000.\n\n random_state: ``int``, optional, default: ``0``\n Random seed set for reproducing results.\n\n select_frac: ``float``, optional, default: ``0.1``\n Down sampling fraction on the cells.\n\n select_K: ``int``, optional, default: ``25``\n Number of neighbors to be used to estimate local density for each data point for down sampling.\n\n select_alpha: ``float``, optional, default: ``1.0``\n Weight the down sample to be proportional to ``radius ** select_alpha``.\n\n net_alpha: ``float``, optional, default: ``0.1``\n L2 penalty (regularization term) parameter of the deep regressor.\n\n polish_learning_frac: ``float``, optional, default: ``0.33``\n After running the deep regressor to predict new coordinates, use ``polish_learning_frac`` * ``n_obs`` as the learning rate to polish the coordinates.\n\n polish_n_iter: ``int``, optional, default: ``150``\n Number of iterations for polishing tSNE run.\n\n out_basis: ``str``, optional, default: ``\"net_tsne\"``\n Key name for the approximated tSNE coordinates calculated.\n\n Returns\n -------\n ``None``\n\n Update ``data.obsm``:\n * ``data.obsm['X_' + out_basis]``: Net tSNE coordinates of the data.\n\n Update ``data.obs``:\n * ``data.obs['ds_selected']``: Boolean array to indicate which cells are selected during the down sampling phase.\n\n Examples\n --------\n >>> scc.net_tsne(adata)\n \"\"\"\n start = time.time()\n\n rep = update_rep(rep)\n indices_key = rep + \"_knn_indices\"\n distances_key = rep + \"_knn_distances\"\n\n if not knn_is_cached(data, indices_key, distances_key, select_K):\n raise ValueError(\"Please run neighbors first!\")\n\n n_jobs = effective_n_jobs(n_jobs)\n\n selected = select_cells(\n data.uns[distances_key],\n select_frac,\n K=select_K,\n alpha=select_alpha,\n random_state=random_state,\n )\n\n X_full = X_from_rep(data, rep)\n X = X_full[selected, :]\n X_tsne = calc_tsne(\n X,\n n_jobs,\n n_components,\n perplexity,\n early_exaggeration,\n learning_rate,\n random_state,\n )\n\n data.uns[\"X_\" + out_basis + \"_small\"] = X_tsne\n data.obs[\"ds_selected\"] = selected\n\n Y_init = np.zeros((data.shape[0], 2), dtype=np.float64)\n Y_init[selected, :] = X_tsne\n Y_init[~selected, :] = net_train_and_predict(\n X, X_tsne, X_full[~selected, :], net_alpha, random_state, verbose=True\n )\n\n data.obsm[\"X_\" + out_basis + \"_pred\"] = Y_init\n\n polish_learning_rate = polish_learning_frac * data.shape[0]\n data.obsm[\"X_\" + out_basis] = calc_tsne(\n X_full,\n n_jobs,\n n_components,\n perplexity,\n early_exaggeration,\n polish_learning_rate,\n random_state,\n init=Y_init,\n n_iter=polish_n_iter,\n n_iter_early_exag=0,\n )\n\n end = time.time()\n logger.info(\"Net tSNE is calculated. Time spent = {:.2f}s.\".format(end - start))\n\n\ndef net_fitsne(\n data: AnnData,\n rep: str = \"pca\",\n n_jobs: int = -1,\n n_components: int = 2,\n perplexity: float = 30,\n early_exaggeration: int = 12,\n learning_rate: float = 1000,\n random_state: int = 0,\n select_frac: float = 0.1,\n select_K: int = 25,\n select_alpha: float = 1.0,\n net_alpha: float = 0.1,\n polish_learning_frac: float = 0.5,\n polish_n_iter: int = 150,\n out_basis: \"str\" = \"net_fitsne\",\n) -> None:\n \"\"\"Calculate approximated FI-tSNE embedding using Deep Learning model to improve the speed.\n\n In specific, the deep model used is MLPRegressor_, the *scikit-learn* implementation of Multi-layer Perceptron regressor.\n\n .. _MLPRegressor: https://scikit-learn.org/stable/modules/generated/sklearn.neural_network.MLPRegressor.html\n\n Parameters\n ----------\n data: ``anndata.AnnData``\n Annotated data matrix with rows for cells (``n_obs``) and columns for genes (``n_feature``).\n\n rep: ``str``, optional, default: ``\"pca\"``\n Representation of data used for the calculation. By default, use PCA coordinates. If ``None``, use the count matrix ``data.X``.\n\n n_jobs: ``int``, optional, default: ``-1``\n Number of threads to use. If ``-1``, use all available threads.\n\n n_components: ``int``, optional, default: ``2``\n Dimension of calculated tSNE coordinates. By default, generate 2-dimensional data for 2D visualization.\n\n perplexity: ``float``, optional, default: ``30``\n The perplexity is related to the number of nearest neighbors used in other manifold learning algorithms. Larger datasets usually require a larger perplexity.\n\n early_exaggeration: ``int``, optional, default: ``12``\n Controls how tight natural clusters in the original space are in the embedded space, and how much space will be between them.\n\n learning_rate: ``float``, optional, default: ``1000``\n The learning rate can be a critical parameter, which should be between 100 and 1000.\n\n random_state: ``int``, optional, default: ``0``\n Random seed set for reproducing results.\n\n select_frac: ``float``, optional, default: ``0.1``\n Down sampling fraction on the cells.\n\n select_K: ``int``, optional, default: ``25``\n Number of neighbors to be used to estimate local density for each data point for down sampling.\n\n select_alpha: ``float``, optional, default: ``1.0``\n Weight the down sample to be proportional to ``radius ** select_alpha``.\n\n net_alpha: ``float``, optional, default: ``0.1``\n L2 penalty (regularization term) parameter of the deep regressor.\n\n polish_learning_frac: ``float``, optional, default: ``0.5``\n After running the deep regressor to predict new coordinates, use ``polish_learning_frac`` * ``n_obs`` as the learning rate to polish the coordinates.\n\n polish_n_iter: ``int``, optional, default: ``150``\n Number of iterations for polishing FI-tSNE run.\n\n out_basis: ``str``, optional, default: ``\"net_fitsne\"``\n Key name for the approximated FI-tSNE coordinates calculated.\n\n Returns\n -------\n ``None``\n\n Update ``data.obsm``:\n * ``data.obsm['X_' + out_basis]``: Net FI-tSNE coordinates of the data.\n\n Update ``data.obs``:\n * ``data.obs['ds_selected']``: Boolean array to indicate which cells are selected during the down sampling phase.\n\n Examples\n --------\n >>> scc.net_fitsne(adata)\n \"\"\"\n start = time.time()\n\n rep = update_rep(rep)\n indices_key = rep + \"_knn_indices\"\n distances_key = rep + \"_knn_distances\"\n\n if not knn_is_cached(data, indices_key, distances_key, select_K):\n raise ValueError(\"Please run neighbors first!\")\n\n n_jobs = effective_n_jobs(n_jobs)\n\n selected = select_cells(\n data.uns[distances_key],\n select_frac,\n K=select_K,\n alpha=select_alpha,\n random_state=random_state,\n )\n X_full = X_from_rep(data, rep)\n X = X_full[selected, :]\n X_fitsne = calc_fitsne(\n X,\n n_jobs,\n n_components,\n perplexity,\n early_exaggeration,\n learning_rate,\n random_state,\n )\n\n data.uns[\"X_\" + out_basis + \"_small\"] = X_fitsne\n data.obs[\"ds_selected\"] = selected\n\n Y_init = np.zeros((data.shape[0], 2), dtype=np.float64)\n Y_init[selected, :] = X_fitsne\n Y_init[~selected, :] = net_train_and_predict(\n X, X_fitsne, X_full[~selected, :], net_alpha, random_state, verbose=True\n )\n\n data.obsm[\"X_\" + out_basis + \"_pred\"] = Y_init\n\n polish_learning_rate = polish_learning_frac * data.shape[0]\n data.obsm[\"X_\" + out_basis] = calc_fitsne(\n X_full,\n n_jobs,\n n_components,\n perplexity,\n early_exaggeration,\n polish_learning_rate,\n random_state,\n initialization=Y_init,\n max_iter=polish_n_iter,\n stop_early_exag_iter=0,\n mom_switch_iter=0,\n )\n\n end = time.time()\n logger.info(\"Net FItSNE is calculated. Time spent = {:.2f}s.\".format(end - start))\n\n\ndef net_umap(\n data: AnnData,\n rep: str = \"pca\",\n n_jobs: int = -1,\n n_components: int = 2,\n n_neighbors: int = 15,\n min_dist: float = 0.5,\n spread: float = 1.0,\n random_state: int = 0,\n select_frac: float = 0.1,\n select_K: int = 25,\n select_alpha: float = 1.0,\n full_speed: bool = False,\n net_alpha: float = 0.1,\n polish_learning_rate: float = 10.0,\n polish_n_epochs: int = 30,\n out_basis: str = \"net_umap\",\n) -> None:\n \"\"\"Calculate approximated UMAP embedding using Deep Learning model to improve the speed.\n\n In specific, the deep model used is MLPRegressor_, the *scikit-learn* implementation of Multi-layer Perceptron regressor.\n\n .. _MLPRegressor: https://scikit-learn.org/stable/modules/generated/sklearn.neural_network.MLPRegressor.html\n\n Parameters\n ----------\n data: ``anndata.AnnData``\n Annotated data matrix with rows for cells and columns for genes.\n\n rep: ``str``, optional, default: ``\"pca\"``\n Representation of data used for the calculation. By default, use PCA coordinates. If ``None``, use the count matrix ``data.X``.\n\n n_components: ``int``, optional, default: ``2``\n Dimension of calculated UMAP coordinates. By default, generate 2-dimensional data for 2D visualization.\n\n n_neighbors: ``int``, optional, default: ``15``\n Number of nearest neighbors considered during the computation.\n\n min_dist: ``float``, optional, default: ``0.5``\n The effective minimum distance between embedded data points.\n\n spread: ``float``, optional, default: ``1.0``\n The effective scale of embedded data points.\n\n random_state: ``int``, optional, default: ``0``\n Random seed set for reproducing results.\n\n select_frac: ``float``, optional, default: ``0.1``\n Down sampling fraction on the cells.\n\n select_K: ``int``, optional, default: ``25``\n Number of neighbors to be used to estimate local density for each data point for down sampling.\n\n select_alpha: ``float``, optional, default: ``1.0``\n Weight the down sample to be proportional to ``radius ** select_alpha``.\n\n full_speed: ``bool``, optional, default: ``False``\n * If ``True``, use multiple threads in constructing ``hnsw`` index. However, the kNN results are not reproducible.\n * Otherwise, use only one thread to make sure results are reproducible.\n\n net_alpha: ``float``, optional, default: ``0.1``\n L2 penalty (regularization term) parameter of the deep regressor.\n\n polish_learning_frac: ``float``, optional, default: ``10.0``\n After running the deep regressor to predict new coordinates, use ``polish_learning_frac`` * ``n_obs`` as the learning rate to polish the coordinates.\n\n polish_n_iter: ``int``, optional, default: ``30``\n Number of iterations for polishing UMAP run.\n\n out_basis: ``str``, optional, default: ``\"net_umap\"``\n Key name for calculated UMAP coordinates to store.\n\n Returns\n -------\n ``None``\n\n Update ``data.obsm``:\n * ``data.obsm['X_' + out_basis]``: Net UMAP coordinates of the data.\n\n Update ``data.obs``:\n * ``data.obs['ds_selected']``: Boolean array to indicate which cells are selected during the down sampling phase.\n\n Examples\n --------\n >>> scc.net_umap(adata)\n \"\"\"\n start = time.time()\n\n rep = update_rep(rep)\n indices_key = rep + \"_knn_indices\"\n distances_key = rep + \"_knn_distances\"\n\n if not knn_is_cached(data, indices_key, distances_key, select_K):\n raise ValueError(\"Please run neighbors first!\")\n\n n_jobs = effective_n_jobs(n_jobs)\n\n selected = select_cells(\n data.uns[distances_key],\n select_frac,\n K=select_K,\n alpha=select_alpha,\n random_state=random_state,\n )\n X_full = X_from_rep(data, rep)\n X = X_full[selected, :]\n\n ds_indices_key = \"ds_\" + rep + \"_knn_indices\" # ds refers to down-sampling\n ds_distances_key = \"ds_\" + rep + \"_knn_distances\"\n indices, distances = calculate_nearest_neighbors(\n X,\n K=n_neighbors,\n n_jobs=n_jobs,\n random_state=random_state,\n full_speed=full_speed,\n )\n data.uns[ds_indices_key] = indices\n data.uns[ds_distances_key] = distances\n\n knn_indices = np.insert(\n data.uns[ds_indices_key][:, 0 : n_neighbors - 1], 0, range(X.shape[0]), axis=1\n )\n knn_dists = np.insert(\n data.uns[ds_distances_key][:, 0 : n_neighbors - 1], 0, 0.0, axis=1\n )\n\n X_umap = calc_umap(\n X,\n n_components,\n n_neighbors,\n min_dist,\n spread,\n random_state,\n knn_indices=knn_indices,\n knn_dists=knn_dists,\n )\n\n data.uns[\"X_\" + out_basis + \"_small\"] = X_umap\n data.obs[\"ds_selected\"] = selected\n\n Y_init = np.zeros((data.shape[0], 2), dtype=np.float64)\n Y_init[selected, :] = X_umap\n Y_init[~selected, :] = net_train_and_predict(\n X, X_umap, X_full[~selected, :], net_alpha, random_state, verbose=True\n )\n\n data.obsm[\"X_\" + out_basis + \"_pred\"] = Y_init\n\n knn_indices = np.insert(\n data.uns[indices_key][:, 0 : n_neighbors - 1], 0, range(data.shape[0]), axis=1\n )\n knn_dists = np.insert(\n data.uns[distances_key][:, 0 : n_neighbors - 1], 0, 0.0, axis=1\n )\n\n data.obsm[\"X_\" + out_basis] = calc_umap(\n X_full,\n n_components,\n n_neighbors,\n min_dist,\n spread,\n random_state,\n init=Y_init,\n n_epochs=polish_n_epochs,\n learning_rate=polish_learning_rate,\n knn_indices=knn_indices,\n knn_dists=knn_dists,\n )\n\n end = time.time()\n logger.info(\"Net UMAP is calculated. Time spent = {:.2f}s.\".format(end - start))\n\n\ndef net_fle(\n data: AnnData,\n file_name: str = None,\n n_jobs: int = -1,\n rep: str = \"diffmap\",\n K: int = 50,\n full_speed: bool = False,\n target_change_per_node: float = 2.0,\n target_steps: int = 5000,\n is3d: bool = False,\n memory: int = 8,\n random_state: int = 0,\n select_frac: float = 0.1,\n select_K: int = 25,\n select_alpha: float = 1.0,\n net_alpha: float = 0.1,\n polish_target_steps: int = 1500,\n out_basis: str = \"net_fle\",\n) -> None:\n \"\"\"Construct the approximated Force-directed (FLE) graph using Deep Learning model to improve the speed.\n\n In specific, the deep model used is MLPRegressor_, the *scikit-learn* implementation of Multi-layer Perceptron regressor.\n\n .. _MLPRegressor: https://scikit-learn.org/stable/modules/generated/sklearn.neural_network.MLPRegressor.html\n\n Parameters\n ----------\n data: ``anndata.AnnData``\n Annotated data matrix with rows for cells and columns for genes.\n\n file_name: ``str``, optional, default: ``None``\n Temporary file to store the coordinates as the input to forceatlas2. If ``None``, use ``tempfile.mkstemp`` to generate file name.\n\n n_jobs: ``int``, optional, default: ``-1``\n Number of threads to use. If ``-1``, use all available threads.\n\n rep: ``str``, optional, default: ``\"diffmap\"``\n Representation of data used for the calculation. By default, use Diffusion Map coordinates. If ``None``, use the count matrix ``data.X``.\n\n K: ``int``, optional, default: ``50``\n Number of nearest neighbors to be considered during the computation.\n\n full_speed: ``bool``, optional, default: ``False``\n * If ``True``, use multiple threads in constructing ``hnsw`` index. However, the kNN results are not reproducible.\n * Otherwise, use only one thread to make sure results are reproducible.\n\n target_change_per_node: ``float``, optional, default: ``2.0``\n Target change per node to stop ForceAtlas2.\n\n target_steps: ``int``, optional, default: ``5000``\n Maximum number of iterations before stopping the ForceAtlas2 algorithm.\n\n is3d: ``bool``, optional, default: ``False``\n If ``True``, calculate 3D force-directed layout.\n\n memory: ``int``, optional, default: ``8``\n Memory size in GB for the Java FA2 component. By default, use 8GB memory.\n\n random_state: ``int``, optional, default: ``0``\n Random seed set for reproducing results.\n\n select_frac: ``float``, optional, default: ``0.1``\n Down sampling fraction on the cells.\n\n select_K: ``int``, optional, default: ``25``\n Number of neighbors to be used to estimate local density for each data point for down sampling.\n\n select_alpha: ``float``, optional, default: ``1.0``\n Weight the down sample to be proportional to ``radius ** select_alpha``.\n\n net_alpha: ``float``, optional, default: ``0.1``\n L2 penalty (regularization term) parameter of the deep regressor.\n\n polish_target_steps: ``int``, optional, default: ``1500``\n After running the deep regressor to predict new coordinate, Number of ForceAtlas2 iterations.\n\n out_basis: ``str``, optional, default: ``\"net_fle\"``\n Key name for calculated FLE coordinates to store.\n\n Returns\n -------\n ``None``\n\n Update ``data.obsm``:\n * ``data.obsm['X_' + out_basis]``: Net FLE coordinates of the data.\n\n Update ``data.obs``:\n * ``data.obs['ds_selected']``: Boolean array to indicate which cells are selected during the down sampling phase.\n\n Examples\n --------\n >>> scc.net_fle(adata)\n \"\"\"\n start = time.time()\n\n if file_name is None:\n if file_name is None:\n import tempfile\n\n _, file_name = tempfile.mkstemp()\n\n n_jobs = effective_n_jobs(n_jobs)\n rep = update_rep(rep)\n\n if (\"W_\" + rep) not in data.uns:\n neighbors(\n data,\n K=K,\n rep=rep,\n n_jobs=n_jobs,\n random_state=random_state,\n full_speed=full_speed,\n )\n\n indices_key = rep + \"_knn_indices\"\n distances_key = rep + \"_knn_distances\"\n\n if not knn_is_cached(data, indices_key, distances_key, select_K):\n raise ValueError(\"Please run neighbors first!\")\n\n selected = select_cells(\n data.uns[distances_key],\n select_frac,\n K=select_K,\n alpha=select_alpha,\n random_state=random_state,\n )\n\n X_full = X_from_rep(data, rep)\n X = X_full[selected, :]\n\n ds_indices_key = \"ds_\" + rep + \"_knn_indices\"\n ds_distances_key = \"ds_\" + rep + \"_knn_distances\"\n indices, distances = calculate_nearest_neighbors(\n X, K=K, n_jobs=n_jobs, random_state=random_state, full_speed=full_speed\n )\n data.uns[ds_indices_key] = indices\n data.uns[ds_distances_key] = distances\n\n W = calculate_affinity_matrix(indices, distances)\n\n X_fle = calc_force_directed_layout(\n W,\n file_name + \".small\",\n n_jobs,\n target_change_per_node,\n target_steps,\n is3d,\n memory,\n random_state,\n )\n\n data.uns[\"X_\" + out_basis + \"_small\"] = X_fle\n data.obs[\"ds_diffmap_selected\"] = selected\n\n Y_init = np.zeros((data.shape[0], 2), dtype=np.float64)\n Y_init[selected, :] = X_fle\n Y_init[~selected, :] = net_train_and_predict(\n X, X_fle, X_full[~selected, :], net_alpha, random_state, verbose=True\n )\n\n data.obsm[\"X_\" + out_basis + \"_pred\"] = Y_init\n\n data.obsm[\"X_\" + out_basis] = calc_force_directed_layout(\n W_from_rep(data, rep),\n file_name,\n n_jobs,\n target_change_per_node,\n polish_target_steps,\n is3d,\n memory,\n random_state,\n init=Y_init,\n )\n\n end = time.time()\n logger.info(\"Net FLE is calculated. Time spent = {:.2f}s.\".format(end - start))\n"
] | [
[
"scipy.stats.f_oneway",
"numpy.array",
"numpy.isnan",
"numpy.zeros",
"numpy.warnings.filterwarnings",
"pandas.DataFrame",
"numpy.ones",
"numpy.exp",
"numpy.argsort",
"numpy.dtype",
"numpy.unique",
"numpy.isin"
],
[
"matplotlib.use"
],
[
"numpy.zeros",
"numpy.random.seed",
"scipy.sparse.isspmatrix_csr",
"sklearn.utils.check_random_state",
"sklearn.utils.check_array",
"numpy.insert"
]
] |
waldo2590/thunder | [
"967ff8f3e7c2fabe1705743d95eb2746d4329786",
"967ff8f3e7c2fabe1705743d95eb2746d4329786"
] | [
"test/test_series_io.py",
"thunder/series/series.py"
] | [
"import pytest\nimport os\nimport glob\nimport json\nfrom numpy import arange, array, allclose, save, savetxt\n\nfrom bolt import array as barray\nfrom thunder.series.readers import fromarray, fromtext, frombinary, fromexample\n\npytestmark = pytest.mark.usefixtures(\"eng\")\n\n\ndef test_from_array(eng):\n a = arange(8, dtype='int16').reshape((4, 2))\n data = fromarray(a, engine=eng)\n assert data.shape == (4, 2)\n assert data.dtype == 'int16'\n assert allclose(data.index, [0, 1])\n assert allclose(data.toarray(), a)\n\n\ndef test_from_array_bolt(eng):\n a = arange(8, dtype='int16').reshape((4, 2))\n if eng is not None:\n b = barray(a, context=eng)\n else:\n b = barray(a)\n data = fromarray(b, engine=eng)\n assert data.shape == (4, 2)\n assert data.dtype == 'int16'\n assert allclose(data.index, [0, 1])\n assert allclose(data.toarray(), a)\n\n\ndef test_from_array_vector(eng):\n a = arange(8, dtype='int16').reshape((4, 2))\n data = fromarray(a, engine=eng)\n assert data.shape == (4, 2)\n assert data.dtype == 'int16'\n assert allclose(data.index, [0, 1])\n assert allclose(data.toarray(), a)\n\n\ndef test_from_array_index(eng):\n a = arange(8, dtype='int16').reshape((4, 2))\n data = fromarray(a, index=[2, 3], engine=eng)\n assert allclose(data.index, [2, 3])\n\n\ndef test_from_text(tmpdir, eng):\n v = [[0, i] for i in range(10)]\n f = os.path.join(str(tmpdir), 'data.txt')\n savetxt(f, v, fmt='%.02g')\n data = fromtext(f, engine=eng)\n assert allclose(data.shape, (10, 2))\n assert data.dtype == 'float64'\n assert allclose(data.toarray(), v)\n\n\ndef test_from_text_skip(tmpdir):\n k = [[i] for i in range(10)]\n v = [[0, i] for i in range(10)]\n a = [kv[0] + kv[1] for kv in zip(k, v)]\n f = os.path.join(str(tmpdir), 'data.txt')\n savetxt(f, a, fmt='%.02g')\n data = fromtext(f, skip=1)\n assert allclose(data.shape, (10, 2))\n assert data.dtype == 'float64'\n assert allclose(data.toarray(), v)\n\n\ndef test_from_binary(tmpdir, eng):\n a = arange(8, dtype='int16').reshape((4, 2))\n p = os.path.join(str(tmpdir), 'data.bin')\n a.tofile(p)\n data = frombinary(p, shape=[4, 2], dtype='int16', engine=eng)\n assert allclose(data.shape, (4, 2))\n assert allclose(data.index, [0, 1])\n assert allclose(data.toarray(), a)\n\n\ndef test_from_binary_skip(tmpdir, eng):\n k = [[i] for i in range(10)]\n v = [[0, i] for i in range(10)]\n a = array([kv[0] + kv[1] for kv in zip(k, v)], dtype='int16')\n p = os.path.join(str(tmpdir), 'data.bin')\n a.tofile(p)\n data = frombinary(p, shape=[10, 2], dtype='int16', skip=1, engine=eng)\n assert allclose(data.shape, (10, 2))\n assert allclose(data.index, [0, 1])\n assert allclose(data.toarray(), v)\n\n\ndef test_to_binary(tmpdir, eng):\n a = arange(8, dtype='int16').reshape((4, 2))\n p = str(tmpdir) + '/data'\n fromarray(a, npartitions=1, engine=eng).tobinary(p)\n files = [os.path.basename(f) for f in glob.glob(str(tmpdir) + '/data/*')]\n assert sorted(files) == ['SUCCESS', 'conf.json', 'series-00000.bin']\n with open(str(tmpdir) + '/data/conf.json', 'r') as f:\n conf = json.load(f)\n assert conf['shape'] == [4, 2]\n assert conf['dtype'] == 'int16'\n\n\ndef test_to_binary_roundtrip(tmpdir, eng):\n a = arange(8, dtype='int16').reshape((4, 2))\n p = str(tmpdir) + '/data'\n data = fromarray(a, npartitions=1, engine=eng)\n data.tobinary(p)\n loaded = frombinary(p)\n assert allclose(data.toarray(), loaded.toarray())\n\n\ndef test_to_binary_roundtrip_partitioned(tmpdir, eng):\n a = arange(8, dtype='int16').reshape((4, 2))\n p = str(tmpdir) + '/data'\n data = fromarray([a, a], npartitions=4, engine=eng)\n data.tobinary(p)\n loaded = frombinary(p)\n assert allclose(data.toarray(), loaded.toarray())\n\n\ndef test_to_binary_roundtrip_3d(tmpdir, eng):\n a = arange(16, dtype='int16').reshape((4, 2, 2))\n p = str(tmpdir) + '/data'\n data = fromarray(a, npartitions=1, engine=eng)\n data.tobinary(p)\n loaded = frombinary(p, engine=eng)\n assert allclose(data.toarray(), loaded.toarray())\n\n\ndef test_from_example(eng):\n return\n data = fromexample('fish', engine=eng)\n assert allclose(data.toarray().shape, (76, 87, 2, 20))\n data = fromexample('mouse', engine=eng)\n assert allclose(data.toarray().shape, (64, 64, 20))\n data = fromexample('iris', engine=eng)\n assert allclose(data.toarray().shape, (150, 4))\n",
"from numpy import array, mean, median, std, size, arange, percentile,\\\n asarray, zeros, corrcoef, where, unique, array_equal, delete, \\\n ravel, logical_not, unravel_index, prod, random, shape, \\\n dot, outer, expand_dims, ScalarType, ndarray, sqrt, pi, angle, fft, \\\n roll, polyfit, polyval, ceil, float64, fix, floor\nimport logging\nfrom itertools import product\nfrom bolt.utils import tupleize\nfrom six import string_types\nfrom ..utils import check_options\n\n\nfrom ..base import Data\n\n\nclass Series(Data):\n \"\"\"\n Collection of indexed 1d array data.\n\n Backed by an array-like object, including a numpy array\n (for local computation) or a bolt array (for spark computation).\n\n Attributes\n ----------\n values : array-like\n numpy array or bolt array\n\n index : array-like or one-dimensional list\n Values must be unique, same length as the arrays in the input data.\n Defaults to arange(len(data)) if not provided.\n\n labels : array-like\n A set of labels, one per series record.\n \"\"\"\n _metadata = Data._metadata\n _attributes = Data._attributes + ['index']\n\n def __init__(self, values, index=None, labels=None, mode='local'):\n super(Series, self).__init__(values, mode=mode)\n self.labels = labels\n self._index = None\n if index is not None:\n self._index = index\n\n @property\n def index(self):\n if self._index is None:\n self._index = arange(self.shape[-1])\n return self._index\n\n @index.setter\n def index(self, value):\n lenself = len(self.index)\n if type(value) is str:\n value = [value]\n try:\n value[0]\n except:\n value = [value]\n try:\n lenvalue = len(value)\n except:\n raise TypeError('Index must be an object with a length')\n if lenvalue != lenself:\n raise ValueError(\"Length of new index '%g' must match length of original index '%g'\"\n .format(lenvalue, lenself))\n self._index = value\n\n @property\n def length(self):\n return len(self.index)\n\n @property\n def baseaxes(self):\n return tuple(range(0, len(self.shape)-1))\n\n @property\n def _constructor(self):\n return Series\n\n def flatten(self):\n \"\"\"\n Reshape all dimensions but the last into a single dimension\n \"\"\"\n size = prod(self.shape[:-1])\n return self.reshape(size, self.shape[-1])\n\n def count(self):\n \"\"\"\n Count the number of records.\n\n For lazy or distributed data, will force a computation.\n \"\"\"\n if self.mode == 'local':\n return prod(self.shape[:-1])\n\n if self.mode == 'spark':\n return self.tordd().count()\n\n def first(self):\n \"\"\"\n Return the first element.\n \"\"\"\n if self.mode == 'local':\n return self.values[tuple(zeros(len(self.baseaxes))) + (slice(None, None),)]\n\n if self.mode == 'spark':\n return self.values.first().toarray()\n\n def tolocal(self):\n \"\"\"\n Convert to local mode.\n \"\"\"\n from thunder.series.readers import fromarray\n\n if self.mode == 'local':\n logging.getLogger('thunder').warn('images already in local mode')\n pass\n\n return fromarray(self.toarray(), index=self.index, labels=self.labels)\n\n def tospark(self, engine=None):\n \"\"\"\n Convert to spark mode.\n \"\"\"\n from thunder.series.readers import fromarray\n\n if self.mode == 'spark':\n logging.getLogger('thunder').warn('images already in local mode')\n pass\n\n if engine is None:\n raise ValueError('Must provide SparkContext')\n\n return fromarray(self.toarray(), index=self.index, labels=self.labels, engine=engine)\n\n def sample(self, n=100, seed=None):\n \"\"\"\n Extract random sample of records.\n\n Parameters\n ----------\n n : int, optional, default = 100\n The number of data points to sample.\n\n seed : int, optional, default = None\n Random seed.\n \"\"\"\n if n < 1:\n raise ValueError(\"Number of samples must be larger than 0, got '%g'\" % n)\n\n if seed is None:\n seed = random.randint(0, 2 ** 32)\n\n if self.mode == 'spark':\n result = asarray(self.values.tordd().values().takeSample(False, n, seed))\n\n else:\n basedims = [self.shape[d] for d in self.baseaxes]\n inds = [unravel_index(int(k), basedims) for k in random.rand(n) * prod(basedims)]\n result = asarray([self.values[tupleize(i) + (slice(None, None),)] for i in inds])\n\n return self._constructor(result, index=self.index)\n\n def map(self, func, index=None, value_shape=None, dtype=None, with_keys=False):\n \"\"\"\n Map an array -> array function over each record.\n\n Parameters\n ----------\n func : function\n A function of a single record.\n\n index : array-like, optional, default = None\n If known, the index to be used following function evaluation.\n\n value_shape : int, optional, default=None\n Known shape of values resulting from operation. Only\n valid in spark mode.\n\n dtype : numpy.dtype, optional, default = None\n If known, the type of the data following function evaluation.\n\n with_keys : boolean, optional, default = False\n If true, function should be of both tuple indices and series values.\n \"\"\"\n # if new index is given, can infer missing value_shape\n if value_shape is None and index is not None:\n value_shape = len(index)\n\n if isinstance(value_shape, int):\n values_shape = (value_shape, )\n new = super(Series, self).map(func, value_shape=value_shape, dtype=dtype, with_keys=with_keys)\n\n if index is not None:\n new.index = index\n # if series shape did not change and no index was supplied, propagate original index\n else:\n if len(new.index) == len(self.index):\n new.index = self.index\n\n return new\n\n def reduce(self, func):\n \"\"\"\n Reduce a function over records.\n\n Parameters\n ----------\n func : function\n A function of two records.\n \"\"\"\n return self._reduce(func, axis=self.baseaxes)\n\n def mean(self):\n \"\"\"\n Compute the mean across records\n \"\"\"\n return self._constructor(self.values.mean(axis=self.baseaxes, keepdims=True))\n\n def var(self):\n \"\"\"\n Compute the variance across records\n \"\"\"\n return self._constructor(self.values.var(axis=self.baseaxes, keepdims=True))\n\n def std(self):\n \"\"\"\n Compute the standard deviation across records.\n \"\"\"\n return self._constructor(self.values.std(axis=self.baseaxes, keepdims=True))\n\n def sum(self):\n \"\"\"\n Compute the sum across records.\n \"\"\"\n return self._constructor(self.values.sum(axis=self.baseaxes, keepdims=True))\n\n def max(self):\n \"\"\"\n Compute the max across records.\n \"\"\"\n return self._constructor(self.values.max(axis=self.baseaxes, keepdims=True))\n\n def min(self):\n \"\"\"\n Compute the min across records.\n \"\"\"\n return self._constructor(self.values.min(axis=self.baseaxes, keepdims=True))\n\n def reshape(self, *shape):\n \"\"\"\n Reshape the Series object\n\n Cannot change the last dimension.\n\n Parameters\n ----------\n shape: one or more ints\n New shape\n \"\"\"\n if prod(self.shape) != prod(shape):\n raise ValueError(\"Reshaping must leave the number of elements unchanged\")\n\n if self.shape[-1] != shape[-1]:\n raise ValueError(\"Reshaping cannot change the size of the constituent series (last dimension)\")\n\n if self.labels is not None:\n newlabels = self.labels.reshape(*shape[:-1])\n else:\n newlabels = None\n\n return self._constructor(self.values.reshape(shape), labels=newlabels).__finalize__(self, noprop=('labels',))\n\n def between(self, left, right):\n \"\"\"\n Select subset of values within the given index range.\n\n Inclusive on the left; exclusive on the right.\n\n Parameters\n ----------\n left : int\n Left-most index in the desired range.\n\n right: int\n Right-most index in the desired range.\n \"\"\"\n crit = lambda x: left <= x < right\n return self.select(crit)\n\n def select(self, crit):\n \"\"\"\n Select subset of values that match a given index criterion.\n\n Parameters\n ----------\n crit : function, list, str, int\n Criterion function to map to indices, specific index value,\n or list of indices.\n \"\"\"\n import types\n\n # handle lists, strings, and ints\n if not isinstance(crit, types.FunctionType):\n # set(\"foo\") -> {\"f\", \"o\"}; wrap in list to prevent:\n if isinstance(crit, string_types):\n critlist = set([crit])\n else:\n try:\n critlist = set(crit)\n except TypeError:\n # typically means crit is not an iterable type; for instance, crit is an int\n critlist = set([crit])\n crit = lambda x: x in critlist\n\n # if only one index, return it directly or throw an error\n index = self.index\n if size(index) == 1:\n if crit(index[0]):\n return self\n else:\n raise Exception('No indices found matching criterion')\n\n # determine new index and check the result\n newindex = [i for i in index if crit(i)]\n if len(newindex) == 0:\n raise Exception('No indices found matching criterion')\n if array(newindex == index).all():\n return self\n\n # use fast logical indexing to get the new values\n subinds = where([crit(i) for i in index])\n new = self.map(lambda x: x[subinds], index=newindex)\n\n # if singleton, need to check whether it's an array or a scalar/int\n # if array, recompute a new set of indices\n if len(newindex) == 1:\n new = new.map(lambda x: x[0], index=newindex)\n val = new.first()\n if size(val) == 1:\n newindex = [newindex[0]]\n else:\n newindex = arange(0, size(val))\n\n new._index = newindex\n\n return new\n\n def center(self, axis=1):\n \"\"\"\n Subtract the mean either within or across records.\n\n Parameters\n ----------\n axis : int, optional, default = 1\n Which axis to center along, within (1) or across (0) records.\n \"\"\"\n if axis == 1:\n return self.map(lambda x: x - mean(x))\n elif axis == 0:\n meanval = self.mean().toarray()\n return self.map(lambda x: x - meanval)\n else:\n raise Exception('Axis must be 0 or 1')\n\n def standardize(self, axis=1):\n \"\"\"\n Divide by standard deviation either within or across records.\n\n Parameters\n ----------\n axis : int, optional, default = 0\n Which axis to standardize along, within (1) or across (0) records\n \"\"\"\n if axis == 1:\n return self.map(lambda x: x / std(x))\n elif axis == 0:\n stdval = self.std().toarray()\n return self.map(lambda x: x / stdval)\n else:\n raise Exception('Axis must be 0 or 1')\n\n def zscore(self, axis=1):\n \"\"\"\n Subtract the mean and divide by standard deviation within or across records.\n\n Parameters\n ----------\n axis : int, optional, default = 0\n Which axis to zscore along, within (1) or across (0) records\n \"\"\"\n if axis == 1:\n return self.map(lambda x: (x - mean(x)) / std(x))\n elif axis == 0:\n meanval = self.mean().toarray()\n stdval = self.std().toarray()\n return self.map(lambda x: (x - meanval) / stdval)\n else:\n raise Exception('Axis must be 0 or 1')\n\n def squelch(self, threshold):\n \"\"\"\n Set all records that do not exceed the given threhsold to 0.\n\n Parameters\n ----------\n threshold : scalar\n Level below which to set records to zero\n \"\"\"\n func = lambda x: zeros(x.shape) if max(x) < threshold else x\n return self.map(func)\n\n def correlate(self, signal):\n \"\"\"\n Correlate records against one or many one-dimensional arrays.\n\n Parameters\n ----------\n signal : array-like\n One or more signals to correlate against.\n \"\"\"\n s = asarray(signal)\n\n if s.ndim == 1:\n if size(s) != self.shape[-1]:\n raise ValueError(\"Length of signal '%g' does not match record length '%g'\"\n % (size(s), self.shape[-1]))\n\n return self.map(lambda x: corrcoef(x, s)[0, 1], index=[1])\n\n elif s.ndim == 2:\n if s.shape[1] != self.shape[-1]:\n raise ValueError(\"Length of signal '%g' does not match record length '%g'\"\n % (s.shape[1], self.shape[-1]))\n newindex = arange(0, s.shape[0])\n return self.map(lambda x: array([corrcoef(x, y)[0, 1] for y in s]), index=newindex)\n\n else:\n raise Exception('Signal to correlate with must have 1 or 2 dimensions')\n\n def _check_panel(self, length):\n \"\"\"\n Check that given fixed panel length evenly divides index.\n\n Parameters\n ----------\n length : int\n Fixed length with which to subdivide index\n \"\"\"\n n = len(self.index)\n if divmod(n, length)[1] != 0:\n raise ValueError(\"Panel length '%g' must evenly divide length of series '%g'\"\n % (length, n))\n if n == length:\n raise ValueError(\"Panel length '%g' cannot be length of series '%g'\"\n % (length, n))\n\n def mean_by_panel(self, length):\n \"\"\"\n Compute the mean across fixed sized panels of each record.\n\n Splits each record into panels of size `length`,\n and then computes the mean across panels.\n Panel length must subdivide record exactly.\n\n Parameters\n ----------\n length : int\n Fixed length with which to subdivide.\n \"\"\"\n self._check_panel(length)\n func = lambda v: v.reshape(-1, length).mean(axis=0)\n newindex = arange(length)\n return self.map(func, index=newindex)\n\n def _makemasks(self, index=None, level=0):\n \"\"\"\n Internal function for generating masks for selecting values based on multi-index values.\n\n As all other multi-index functions will call this function, basic type-checking is also\n performed at this stage.\n \"\"\"\n if index is None:\n index = self.index\n\n try:\n dims = len(array(index).shape)\n if dims == 1:\n index = array(index, ndmin=2).T\n except:\n raise TypeError('A multi-index must be convertible to a numpy ndarray')\n\n try:\n index = index[:, level]\n except:\n raise ValueError(\"Levels must be indices into individual elements of the index\")\n\n lenIdx = index.shape[0]\n nlevels = index.shape[1]\n\n combs = product(*[unique(index.T[i, :]) for i in range(nlevels)])\n combs = array([l for l in combs])\n\n masks = array([[array_equal(index[i], c) for i in range(lenIdx)] for c in combs])\n\n return zip(*[(masks[x], combs[x]) for x in range(len(masks)) if masks[x].any()])\n\n def _map_by_index(self, function, level=0):\n \"\"\"\n An internal function for maping a function to groups of values based on a multi-index\n\n Elements of each record are grouped according to unique value combinations of the multi-\n index across the given levels of the multi-index. Then the given function is applied\n to to each of these groups separately. If this function is many-to-one, the result\n can be recast as a Series indexed by the unique index values used for grouping.\n \"\"\"\n\n if type(level) is int:\n level = [level]\n\n masks, ind = self._makemasks(index=self.index, level=level)\n nMasks = len(masks)\n newindex = array(ind)\n if len(newindex[0]) == 1:\n newindex = ravel(newindex)\n return self.map(lambda v: asarray([array(function(v[masks[x]])) for x in range(nMasks)]),\n index=newindex)\n\n def select_by_index(self, val, level=0, squeeze=False, filter=False, return_mask=False):\n \"\"\"\n Select or filter elements of the Series by index values (across levels, if multi-index).\n\n The index is a property of a Series object that assigns a value to each position within\n the arrays stored in the records of the Series. This function returns a new Series where,\n within each record, only the elements indexed by a given value(s) are retained. An index\n where each value is a list of a fixed length is referred to as a 'multi-index',\n as it provides multiple labels for each index location. Each of the dimensions in these\n sublists is a 'level' of the multi-index. If the index of the Series is a multi-index, then\n the selection can proceed by first selecting one or more levels, and then selecting one\n or more values at each level.\n\n Parameters\n ----------\n val : list of lists\n Specifies the selected index values. List must contain one list for each level of the\n multi-index used in the selection. For any singleton lists, the list may be replaced\n with just the integer.\n\n level : list of ints, optional, default=0\n Specifies which levels in the multi-index to use when performing selection. If a single\n level is selected, the list can be replaced with an integer. Must be the same length\n as val.\n\n squeeze : bool, optional, default=False\n If True, the multi-index of the resulting Series will drop any levels that contain\n only a single value because of the selection. Useful if indices are used as unique\n identifiers.\n\n filter : bool, optional, default=False\n If True, selection process is reversed and all index values EXCEPT those specified\n are selected.\n\n return_mask : bool, optional, default=False\n If True, return the mask used to implement the selection.\n \"\"\"\n try:\n level[0]\n except:\n level = [level]\n try:\n val[0]\n except:\n val = [val]\n\n remove = []\n if len(level) == 1:\n try:\n val[0][0]\n except:\n val = [val]\n if squeeze and not filter and len(val) == 1:\n remove.append(level[0])\n else:\n for i in range(len(val)):\n try:\n val[i][0]\n except:\n val[i] = [val[i]]\n if squeeze and not filter and len(val[i]) == 1:\n remove.append(level[i])\n\n if len(level) != len(val):\n raise ValueError(\"List of levels must be same length as list of corresponding values\")\n\n p = product(*val)\n selected = set([x for x in p])\n\n masks, ind = self._makemasks(index=self.index, level=level)\n nmasks = len(masks)\n masks = array([masks[x] for x in range(nmasks) if tuple(ind[x]) in selected])\n\n final_mask = masks.any(axis=0)\n if filter:\n final_mask = logical_not(final_mask)\n\n indFinal = array(self.index)\n if len(indFinal.shape) == 1:\n indFinal = array(indFinal, ndmin=2).T\n indFinal = indFinal[final_mask]\n\n if squeeze:\n indFinal = delete(indFinal, remove, axis=1)\n\n if len(indFinal[0]) == 1:\n indFinal = ravel(indFinal)\n\n elif len(indFinal[1]) == 0:\n indFinal = arange(sum(final_mask))\n\n result = self.map(lambda v: v[final_mask], index=indFinal)\n\n if return_mask:\n return result, final_mask\n else:\n return result\n\n def aggregate_by_index(self, function, level=0):\n \"\"\"\n Aggregrate data in each record, grouping by index values.\n\n For each unique value of the index, applies a function to the group\n indexed by that value. Returns a Series indexed by those unique values.\n For the result to be a valid Series object, the aggregating function should\n return a simple numeric type. Also allows selection of levels within a\n multi-index. See select_by_index for more info on indices and multi-indices.\n\n Parameters\n ----------\n function : function\n Aggregating function to map to Series values. Should take a list or ndarray\n as input and return a simple numeric value.\n\n level : list of ints, optional, default=0\n Specifies the levels of the multi-index to use when determining unique index values.\n If only a single level is desired, can be an int.\n \"\"\"\n result = self._map_by_index(function, level=level)\n return result.map(lambda v: array(v), index=result.index)\n\n def stat_by_index(self, stat, level=0):\n \"\"\"\n Compute the desired statistic for each uniue index values (across levels, if multi-index)\n\n Parameters\n ----------\n stat : string\n Statistic to be computed: sum, mean, median, stdev, max, min, count\n\n level : list of ints, optional, default=0\n Specifies the levels of the multi-index to use when determining unique index values.\n If only a single level is desired, can be an int.\n \"\"\"\n from numpy import sum, min, max\n\n STATS = {\n 'sum': sum,\n 'mean': mean,\n 'median': median,\n 'stdev': std,\n 'max': max,\n 'min': min,\n 'count': size\n }\n func = STATS[stat.lower()]\n return self.aggregate_by_index(level=level, function=func)\n\n def sum_by_index(self, level=0):\n \"\"\"\n Compute sums for each unique index value (across levels, if multi-index)\n \"\"\"\n return self.stat_by_index(level=level, stat='sum')\n\n def mean_by_index(self, level=0):\n \"\"\"\n Compute means for each unique index value (across levels, if multi-index)\n \"\"\"\n return self.stat_by_index(level=level, stat='mean')\n\n def median_by_index(self, level=0):\n \"\"\"\n Compute medians for each unique index value (across levels, if multi-index)\n \"\"\"\n return self.stat_by_index(level=level, stat='median')\n\n def std_by_index(self, level=0):\n \"\"\"\n Compute means for each unique index value (across levels, if multi-index)\n \"\"\"\n return self.stat_by_index(level=level, stat='stdev')\n\n def max_by_index(self, level=0):\n \"\"\"\n Compute maximum values for each unique index value (across levels, if multi-index)\n \"\"\"\n return self.stat_by_index(level=level, stat='max')\n\n def min_by_index(self, level=0):\n \"\"\"\n Compute minimum values for each unique index value (across level, if multi-index)\n \"\"\"\n return self.stat_by_index(level=level, stat='min')\n\n def count_by_index(self, level=0):\n \"\"\"\n Count the number for each unique index value (across levels, if multi-index)\n \"\"\"\n return self.stat_by_index(level=level, stat='count')\n\n def cov(self):\n \"\"\"\n Compute covariance of a distributed matrix.\n\n Parameters\n ----------\n axis : int, optional, default = None\n Axis for performing mean subtraction, None (no subtraction), 0 (rows) or 1 (columns)\n \"\"\"\n return self.center(axis=0).gramian().times(1.0 / (self.shape[0] - 1))\n\n def gramian(self):\n \"\"\"\n Compute gramian of a distributed matrix.\n\n The gramian is defined as the product of the matrix\n with its transpose, i.e. A^T * A.\n \"\"\"\n if self.mode == 'spark':\n rdd = self.values.tordd()\n\n from pyspark.accumulators import AccumulatorParam\n\n class MatrixAccumulator(AccumulatorParam):\n def zero(self, value):\n return zeros(shape(value))\n\n def addInPlace(self, val1, val2):\n val1 += val2\n return val1\n\n global mat\n init = zeros((self.shape[1], self.shape[1]))\n mat = rdd.context.accumulator(init, MatrixAccumulator())\n\n def outer_sum(x):\n global mat\n mat += outer(x, x)\n\n rdd.values().foreach(outer_sum)\n return self._constructor(mat.value, index=self.index)\n\n if self.mode == 'local':\n return self._constructor(dot(self.values.T, self.values), index=self.index)\n\n def times(self, other):\n \"\"\"\n Multiply a matrix by another one.\n\n Other matrix must be a numpy array, a scalar,\n or another matrix in local mode.\n\n Parameters\n ----------\n other : Matrix, scalar, or numpy array\n A matrix to multiply with\n \"\"\"\n if isinstance(other, ScalarType):\n other = asarray(other)\n index = self.index\n else:\n if isinstance(other, list):\n other = asarray(other)\n if isinstance(other, ndarray) and other.ndim < 2:\n other = expand_dims(other, 1)\n if not self.shape[1] == other.shape[0]:\n raise ValueError('shapes %s and %s are not aligned' % (self.shape, other.shape))\n index = arange(other.shape[1])\n\n if self.mode == 'local' and isinstance(other, Series) and other.mode == 'spark':\n raise NotImplementedError\n\n if self.mode == 'spark' and isinstance(other, Series) and other.mode == 'spark':\n raise NotImplementedError\n\n if self.mode == 'local' and isinstance(other, (ndarray, ScalarType)):\n return self._constructor(dot(self.values, other), index=index)\n\n if self.mode == 'local' and isinstance(other, Series):\n return self._constructor(dot(self.values, other.values), index=index)\n\n if self.mode == 'spark' and isinstance(other, (ndarray, ScalarType)):\n return self.map(lambda x: dot(x, other), index=index)\n\n if self.mode == 'spark' and isinstance(other, Series):\n return self.map(lambda x: dot(x, other.values), index=index)\n\n def _makewindows(self, indices, window):\n \"\"\"\n Make masks used by windowing functions\n\n Given a list of indices specifying window centers,\n and a window size, construct a list of index arrays,\n one per window, that index into the target array\n\n Parameters\n ----------\n indices : array-like\n List of times specifying window centers\n\n window : int\n Window size\n \"\"\"\n div = divmod(window, 2)\n before = div[0]\n after = div[0] + div[1]\n index = asarray(self.index)\n indices = asarray(indices)\n if where(index == max(indices))[0][0] + after > len(index):\n raise ValueError(\"Maximum requested index %g, with window %g, exceeds length %g\"\n % (max(indices), window, len(index)))\n if where(index == min(indices))[0][0] - before < 0:\n raise ValueError(\"Minimum requested index %g, with window %g, is less than 0\"\n % (min(indices), window))\n masks = [arange(where(index == i)[0][0]-before, where(index == i)[0][0]+after, dtype='int') for i in indices]\n return masks\n\n def mean_by_window(self, indices, window):\n \"\"\"\n Average series across multiple windows specified by their centers.\n\n Parameters\n ----------\n indices : array-like\n List of times specifying window centers\n\n window : int\n Window size\n \"\"\"\n masks = self._makewindows(indices, window)\n newindex = arange(0, len(masks[0]))\n return self.map(lambda x: mean([x[m] for m in masks], axis=0), index=newindex)\n\n def subsample(self, sample_factor=2):\n \"\"\"\n Subsample series by an integer factor.\n\n Parameters\n ----------\n sample_factor : positive integer, optional, default=2\n Factor for downsampling.\n \"\"\"\n if sample_factor < 0:\n raise Exception('Factor for subsampling must be postive, got %g' % sample_factor)\n s = slice(0, len(self.index), sample_factor)\n newindex = self.index[s]\n return self.map(lambda v: v[s], index=newindex)\n\n def downsample(self, sample_factor=2):\n \"\"\"\n Downsample series by an integer factor by averaging.\n\n Parameters\n ----------\n sample_factor : positive integer, optional, default=2\n Factor for downsampling.\n \"\"\"\n if sample_factor < 0:\n raise Exception('Factor for subsampling must be postive, got %g' % sample_factor)\n newlength = floor(len(self.index) / sample_factor)\n func = lambda v: v[0:int(newlength * sample_factor)].reshape(-1, sample_factor).mean(axis=1)\n newindex = arange(newlength)\n return self.map(func, index=newindex)\n\n def fourier(self, freq=None):\n \"\"\"\n Compute statistics of a Fourier decomposition on series data.\n\n Parameters\n ----------\n freq : int\n Digital frequency at which to compute coherence and phase\n \"\"\"\n def get(y, freq):\n y = y - mean(y)\n nframes = len(y)\n ft = fft.fft(y)\n ft = ft[0:int(fix(nframes/2))]\n ampFt = 2*abs(ft)/nframes\n amp = ampFt[freq]\n ampSum = sqrt(sum(ampFt**2))\n co = amp / ampSum\n ph = -(pi/2) - angle(ft[freq])\n if ph < 0:\n ph += pi * 2\n return array([co, ph])\n\n if freq >= int(fix(size(self.index)/2)):\n raise Exception('Requested frequency, %g, is too high, '\n 'must be less than half the series duration' % freq)\n\n index = ['coherence', 'phase']\n return self.map(lambda x: get(x, freq), index=index)\n\n def convolve(self, signal, mode='full'):\n \"\"\"\n Convolve series data against another signal.\n\n Parameters\n ----------\n signal : array\n Signal to convolve with (must be 1D)\n\n mode : str, optional, default='full'\n Mode of convolution, options are 'full', 'same', and 'valid'\n \"\"\"\n\n from numpy import convolve\n\n s = asarray(signal)\n\n n = size(self.index)\n m = size(s)\n\n # use expected lengths to make a new index\n if mode == 'same':\n newmax = max(n, m)\n elif mode == 'valid':\n newmax = max(m, n) - min(m, n) + 1\n else:\n newmax = n+m-1\n newindex = arange(0, newmax)\n\n return self.map(lambda x: convolve(x, signal, mode), index=newindex)\n\n def crosscorr(self, signal, lag=0):\n \"\"\"\n Cross correlate series data against another signal.\n\n Parameters\n ----------\n signal : array\n Signal to correlate against (must be 1D).\n\n lag : int\n Range of lags to consider, will cover (-lag, +lag).\n \"\"\"\n from scipy.linalg import norm\n\n s = asarray(signal)\n s = s - mean(s)\n s = s / norm(s)\n\n if size(s) != size(self.index):\n raise Exception('Size of signal to cross correlate with, %g, '\n 'does not match size of series' % size(s))\n\n # created a matrix with lagged signals\n if lag is not 0:\n shifts = range(-lag, lag+1)\n d = len(s)\n m = len(shifts)\n sshifted = zeros((m, d))\n for i in range(0, len(shifts)):\n tmp = roll(s, shifts[i])\n if shifts[i] < 0:\n tmp[(d+shifts[i]):] = 0\n if shifts[i] > 0:\n tmp[:shifts[i]] = 0\n sshifted[i, :] = tmp\n s = sshifted\n else:\n shifts = [0]\n\n def get(y, s):\n y = y - mean(y)\n n = norm(y)\n if n == 0:\n b = zeros((s.shape[0],))\n else:\n y /= n\n b = dot(s, y)\n return b\n\n return self.map(lambda x: get(x, s), index=shifts)\n\n def detrend(self, method='linear', order=5):\n \"\"\"\n Detrend series data with linear or nonlinear detrending.\n\n Preserve intercept so that subsequent operations can adjust the baseline.\n\n Parameters\n ----------\n method : str, optional, default = 'linear'\n Detrending method\n\n order : int, optional, default = 5\n Order of polynomial, for non-linear detrending only\n \"\"\"\n check_options(method, ['linear', 'nonlinear'])\n\n if method == 'linear':\n order = 1\n\n def func(y):\n x = arange(len(y))\n p = polyfit(x, y, order)\n p[-1] = 0\n yy = polyval(p, x)\n return y - yy\n\n return self.map(func)\n\n def normalize(self, method='percentile', window=None, perc=20, offset=0.1):\n \"\"\"\n Normalize by subtracting and dividing by a baseline.\n\n Baseline can be derived from a global mean or percentile,\n or a smoothed percentile estimated within a rolling window.\n Windowed baselines may only be well-defined for\n temporal series data.\n\n Parameters\n ----------\n baseline : str, optional, default = 'percentile'\n Quantity to use as the baseline, options are 'mean', 'percentile',\n 'window', or 'window-exact'.\n\n window : int, optional, default = 6\n Size of window for baseline estimation,\n for 'window' and 'window-exact' baseline only.\n\n perc : int, optional, default = 20\n Percentile value to use, for 'percentile',\n 'window', or 'window-exact' baseline only.\n\n offset : float, optional, default = 0.1\n Scalar added to baseline during division to avoid division by 0.\n \"\"\"\n\n check_options(method, ['mean', 'percentile', 'window', 'window-exact'])\n\n from warnings import warn\n if not (method == 'window' or method == 'window-exact') and window is not None:\n warn('Setting window without using method \"window\" has no effect')\n\n if method == 'mean':\n baseFunc = mean\n\n if method == 'percentile':\n baseFunc = lambda x: percentile(x, perc)\n\n if method == 'window':\n from scipy.ndimage.filters import percentile_filter\n baseFunc = lambda x: percentile_filter(x.astype(float64), perc, window, mode='nearest')\n\n if method == 'window-exact':\n if window & 0x1:\n left, right = (ceil(window/2), ceil(window/2) + 1)\n else:\n left, right = (window/2, window/2)\n\n n = len(self.index)\n baseFunc = lambda x: asarray([percentile(x[max(ix-left, 0):min(ix+right+1, n)], perc)\n for ix in arange(0, n)])\n\n def get(y):\n b = baseFunc(y)\n return (y - b) / (b + offset)\n\n return self.map(get)\n\n def toimages(self, chunk_size='auto'):\n \"\"\"\n Converts to images data.\n\n This method is equivalent to series.toblocks(size).toimages().\n\n Parameters\n ----------\n chunk_size : str or tuple, size of series chunk used during conversion, default = 'auto'\n String interpreted as memory size (in kilobytes, e.g. '64').\n The exception is the string 'auto', which will choose a chunk size to make the\n resulting blocks ~100 MB in size. Int interpreted as 'number of elements'.\n Only valid in spark mode.\n \"\"\"\n from thunder.images.images import Images\n\n if chunk_size is 'auto':\n chunk_size = str(max([int(1e5/prod(self.baseshape)), 1]))\n\n n = len(self.shape) - 1\n\n if self.mode == 'spark':\n return Images(self.values.swap(tuple(range(n)), (0,), size=chunk_size))\n\n if self.mode == 'local':\n return Images(self.values.transpose((n,) + tuple(range(0, n))))\n\n def tobinary(self, path, prefix='series', overwrite=False, credentials=None):\n \"\"\"\n Write data to binary files.\n\n Parameters\n ----------\n path : string path or URI to directory to be created\n Output files will be written underneath path.\n Directory will be created as a result of this call.\n\n prefix : str, optional, default = 'series'\n String prefix for files.\n\n overwrite : bool\n If true, path and all its contents will be deleted and\n recreated as partof this call.\n \"\"\"\n from thunder.series.writers import tobinary\n tobinary(self, path, prefix=prefix, overwrite=overwrite, credentials=credentials)\n"
] | [
[
"numpy.allclose",
"numpy.arange",
"numpy.savetxt"
],
[
"numpy.dot",
"numpy.array_equal",
"numpy.random.rand",
"numpy.min",
"numpy.mean",
"numpy.where",
"numpy.fft.fft",
"numpy.outer",
"numpy.max",
"numpy.angle",
"numpy.polyval",
"numpy.prod",
"numpy.arange",
"numpy.random.randint",
"numpy.polyfit",
"numpy.expand_dims",
"numpy.convolve",
"numpy.fix",
"numpy.array",
"numpy.delete",
"numpy.zeros",
"numpy.percentile",
"numpy.roll",
"numpy.shape",
"numpy.std",
"numpy.corrcoef",
"scipy.linalg.norm",
"numpy.logical_not",
"numpy.ceil",
"numpy.asarray",
"numpy.sum",
"numpy.ravel",
"numpy.unique"
]
] |
hx-Tang/GANet | [
"8935c9d3d82189fa6f940c2a877534a398a041e4",
"8935c9d3d82189fa6f940c2a877534a398a041e4"
] | [
"libs/sync_bn/src/__init__.py",
"view.py"
] | [
"import os\nimport torch\nfrom torch.utils.cpp_extension import load\n\ncwd = os.path.dirname(os.path.realpath(__file__))\ncpu_path = os.path.join(cwd, 'cpu')\ngpu_path = os.path.join(cwd, 'gpu')\n\ncpu = load('sync_bn_cpu', [\n os.path.join(cpu_path, 'operator.cpp'),\n os.path.join(cpu_path, 'sync_bn.cpp'),\n], build_directory=cpu_path, verbose=False)\n\nif torch.cuda.is_available():\n gpu = load('sync_bn_gpu', [\n os.path.join(gpu_path, 'operator.cpp'),\n os.path.join(gpu_path, 'sync_bn_cuda.cu'),\n ], build_directory=gpu_path, verbose=False)\n",
"# # from models.MyGANet4 import GANet\n# #\n# # model = GANet()\n# # for name, module in model.named_children():\n# # print(name)\n#\n# import torch\n# import torch.nn as nn\n#\n# a = torch.randn(2, 3, 2, 2) # 右图\n# b = torch.ones(2, 1, 2, 2) # disp\n# print(a)\n#\n# def warp(x, disp):\n# \"\"\"\n# warp an image/tensor (im2) back to im1, according to the optical flow\n# x: [B, C, H, W] (im2)\n# flo: [B, 2, H, W] flow\n# \"\"\"\n# B, C, H, W = x.size()\n# # mesh grid\n# xx = torch.arange(0, W).view(1, -1).repeat(H, 1)\n# yy = torch.arange(0, H).view(-1, 1).repeat(1, W)\n# xx = xx.view(1, 1, H, W).repeat(B, 1, 1, 1)\n# yy = yy.view(1, 1, H, W).repeat(B, 1, 1, 1)\n# vgrid = torch.cat((xx, yy), 1).float()\n#\n# # vgrid = Variable(grid)\n# vgrid[:, :1, :, :] = vgrid[:, :1, :, :] + disp\n#\n# # scale grid to [-1,1]\n# vgrid[:, 0, :, :] = 2.0 * vgrid[:, 0, :, :].clone() / max(W - 1, 1) - 1.0\n# vgrid[:, 1, :, :] = 2.0 * vgrid[:, 1, :, :].clone() / max(H - 1, 1) - 1.0\n#\n# vgrid = vgrid.permute(0, 2, 3, 1)\n# output = nn.functional.grid_sample(x, vgrid,align_corners=True)\n# return output\n#\n# o = warp(a,b)\n#\n# print(o)\n\nfrom models.CasGANet10 import GANet\nfrom models.MyGANet9 import GANet\nfrom models.GANet11 import GANet\nimport numpy as np\nimport datetime\nimport torch\n\nmodel = GANet()\n\nprint('parameters:{}'.format(np.sum([p.numel() for p in model.parameters()]).item()))\n\nmodel = torch.nn.DataParallel(model).cuda()\nmodel.eval()\ninput1 = torch.randn(1, 3, 384, 768).cuda()\ninput2 = torch.randn(1, 3, 384, 768).cuda()\n\nt = 0.\nfor i in range(10):\n with torch.no_grad():\n start = datetime.datetime.now()\n out1 = model(input1, input2)\n end = datetime.datetime.now()\n t += (end - start).total_seconds()\nprint(t/10)\n\n"
] | [
[
"torch.cuda.is_available"
],
[
"torch.no_grad",
"torch.randn",
"torch.nn.DataParallel"
]
] |
scottfredericks/PyXtal_Old | [
"3fa39b2f188197b42576087c6f4c3bca14b2e8f3"
] | [
"examples/LJ_38_Oh.py"
] | [
"from pyxtal.crystal import random_cluster\nfrom copy import deepcopy\nfrom optparse import OptionParser\nfrom random import randint, choice\nfrom scipy.optimize import minimize\nfrom scipy.spatial.distance import pdist, cdist\nfrom pyxtal.molecule import PointGroupAnalyzer\nfrom pymatgen import Molecule\nfrom pyxtal.database.collection import Collection\nfrom time import time\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport warnings\nplt.style.use(\"bmh\")\nwarnings.filterwarnings(\"ignore\")\n\n\"\"\"\nThis is a script to \n1, generate random clusters\n2, perform optimization\n\"\"\"\ndef LJ(pos, dim, mu=0.1):\n \"\"\"\n Calculate the total energy\n Args:\n pos: 1D array with N*dim numbers representing the atomic positions\n dim: dimension of the hyper/normal space\n output\n E: the total energy with punishing function\n \"\"\"\n N_atom = int(len(pos)/dim)\n pos = np.reshape(pos, (N_atom, dim))\n \n distance = pdist(pos) \n r6 = np.power(distance, 6)\n r12 = np.multiply(r6, r6)\n Eng = np.sum(4*(1/r12 - 1/r6))\n\n if dim > 3:\n norm = 0\n for i in range(3,dim):\n #diff = pos[:, i] - np.mean(pos[:, i])\n diff = pos[:, i] \n norm += np.sum(np.multiply(diff, diff))\n Eng += 0.5*mu*norm\n return Eng\n\ndef LJ_force(pos, dim, mu=0.1):\n N_atom = int(len(pos)/dim)\n pos = np.reshape(pos,[N_atom, dim])\n force = np.zeros([N_atom, dim])\n for i, pos0 in enumerate(pos):\n pos1 = deepcopy(pos)\n pos1 = np.delete(pos1, i, 0)\n distance = cdist([pos0], pos1)\n r = pos1 - pos0\n r2 = np.power(distance, 2)\n r6 = np.power(r2, 3)\n r12 = np.power(r6, 2)\n force[i] = np.dot((48/r12-24/r6)/r2, r)\n # force from the punish function mu*sum([x-mean(x)]^2)\n if dim > 3:\n for j in range(3,dim):\n #force[i, j] += mu*(pos[i, j] - np.mean(pos[:, j]))\n force[i, j] += mu*pos[i, j] #- np.mean(pos[:, j]))\n return force.flatten()\n\ndef single_optimize(pos, dim=3, kt=0.5, mu=0.1):\n \"\"\"\n perform optimization for a given cluster\n Args: \n pos: N*dim0 array representing the atomic positions\n dim: dimension of the hyper/normal space\n kt: perturbation factors\n\n output:\n energy: optmized energy\n pos: optimized positions\n \"\"\"\n N_atom = len(pos)\n diff = dim - np.shape(pos)[1]\n # if the input pos has less dimensions, we insert a random array for the extra dimension\n # if the input pos has more dimensions, we delete the array for the extra dimension\n if diff > 0:\n pos = np.hstack((pos, 0.5*(np.random.random([N_atom, diff])-0.5) ))\n elif diff < 0:\n pos = pos[:, :dim]\n\n pos = pos.flatten()\n res = minimize(LJ, pos, args=(dim, mu), jac=LJ_force, method='CG', tol=1e-3)\n pos = np.reshape(res.x, (N_atom, dim))\n energy = res.fun\n return energy, pos\n\n\ndef parse_symmetry(pos):\n mol = Molecule(['C']*len(pos), pos)\n try:\n symbol = PointGroupAnalyzer(mol, tolerance=0.1).sch_symbol\n except:\n symbol = 'N/A'\n return symbol\n\n\nclass LJ_prediction():\n \"\"\"\n A class to perform global optimization on LJ clusters\n Args:\n\n Attributes:\n\n \"\"\"\n\n def __init__(self, numIons):\n self.numIons = numIons\n ref = Collection('clusters')[str(numIons)]\n print('\\nReference for LJ {0:3d} is {1:12.3f} eV, PG: {2:4s}'.\\\n format(numIons, ref['energy'], ref['pointgroup']))\n self.reference = ref\n self.time0 = time()\n\n def generate_cluster(self, pgs = range(2, 33)):\n run = True\n while run:\n pg = choice(pgs)\n cluster = random_cluster(pg, ['Mo'], [self.numIons], 1.0)\n if cluster.valid:\n run = False\n return cluster.cart_coords\n \n def predict(self, dim=3, maxN=100, ncpu=2, pgs=range(2, 33)):\n\n print('\\nPerforming random search at {0:d}D space\\n'.format(dim))\n cycle = range(maxN)\n if ncpu > 1:\n from multiprocessing import Pool\n from functools import partial\n\n with Pool(ncpu) as p:\n func = partial(self.relaxation, dim, pgs)\n res = p.map(func, cycle)\n p.close()\n p.join()\n else:\n res=[]\n for i in cycle:\n res.append(self.relaxation(dim, pgs, i))\n \n N_success = 0\n for dct in res:\n if dct['ground']:\n N_success +=1\n print('\\nHit the ground state {0:4d} times out of {1:4d} attempts\\n'.\\\n format(N_success, maxN))\n return res\n\n def relaxation(self, dim, pgs, ind):\n pos = self.generate_cluster(pgs)\n pg1 = parse_symmetry(pos)\n if dim == 3:\n [energy, pos] = single_optimize(pos, 3)\n else:\n do = True\n while do:\n [energy1, pos1] = single_optimize(pos, 3)\n [energy2, pos2] = single_optimize(pos1, dim)\n [energy3, pos3] = single_optimize(pos2, 3)\n #print(energy1, energy2, energy3)\n if abs(energy3-energy1) < 1e-3 or energy3 > energy1:\n pos = pos1\n energy = energy1\n do = False\n #print('stop')\n else:\n pos = pos3\n if abs(energy-self.reference['energy']) <1e-3:\n ground = True\n elif energy < self.reference['energy']:\n ground = True\n print(\" --- ENERGY LOWER THAN REFERENCE FOUND ---\")\n else:\n ground = False\n\n pg2 = parse_symmetry(pos)\n res = {'pos': pos,\n 'energy': energy,\n 'pg_init': pg1,\n 'pg_finial': pg2,\n 'ground': ground,\n 'id': ind,\n }\n if ground:\n print('ID: {0:4d} PG initial: {1:4s} relaxed: {2:4s} Energy: {3:12.3f} Time: {4:6.1f} ++++++'.\\\n format(ind, pg1, pg2, energy, (time()-self.time0)/60))\n elif ind%10 == 0:\n print('ID: {0:4d} PG initial: {1:4s} relaxed: {2:4s} Energy: {3:12.3f} Time: {4:6.1f} '.\\\n format(ind, pg1, pg2, energy, (time()-self.time0)/60))\n return res\n\nif __name__ == \"__main__\":\n #-------------------------------- Options -------------------------\n parser = OptionParser()\n parser.add_option(\"-d\", \"--dimension\", dest=\"dim\", metavar='dim', default=3, type=int,\n help=\"dimension, 3 or higher\")\n parser.add_option(\"-n\", \"--numIons\", dest=\"numIons\", default=16, type=int,\n help=\"desired numbers of atoms: 16\")\n parser.add_option(\"-m\", \"--max\", dest=\"max\", default=100, type=int,\n help=\"maximum number of attempts\")\n parser.add_option(\"-p\", \"--proc\", dest=\"proc\", default=1, type=int,\n help=\"number of processors, default 1\")\n\n (options, args) = parser.parse_args()\n\n N = options.numIons #38\n maxN = options.max #1000\n dim = options.dim #4\n ncpu = options.proc\n\n lj_run = LJ_prediction(N)\n eng_min = lj_run.reference['energy']\n t0 = time()\n print(\"---No symmetry---\")\n results1 = lj_run.predict(dim=dim, maxN=maxN, ncpu=ncpu, pgs=[1])\n print('time: {0:6.2f} seconds'.format(time()-t0))\n\n print(\"---Random symmetry---\")\n results2 = lj_run.predict(dim=dim, maxN=maxN, ncpu=ncpu, pgs=range(2, 33))\n print('time: {0:6.2f} seconds'.format(time()-t0))\n\n print(\"---Oh only---\")\n results3 = lj_run.predict(dim=dim, maxN=maxN, ncpu=ncpu, pgs=[32])\n print('time: {0:6.2f} seconds'.format(time()-t0))\n\n print(\"---Random symmetry (not Oh)---\")\n results4 = lj_run.predict(dim=dim, maxN=maxN, ncpu=ncpu, pgs=range(2, 32))\n print('time: {0:6.2f} seconds'.format(time()-t0))\n eng1 = []\n eng2 = []\n eng3 = []\n eng4 = []\n ground1 = 0\n ground2 = 0\n ground3 = 0\n ground4 = 0\n for dct in results1:\n if dct['ground']:\n ground1 += 1\n eng1.append(dct['energy']) \n for dct in results2:\n if dct['ground']:\n ground2 += 1\n eng2.append(dct['energy']) \n for dct in results3:\n if dct['ground']:\n ground3 += 1\n eng3.append(dct['energy']) \n for dct in results4:\n if dct['ground']:\n ground4 += 1\n eng4.append(dct['energy']) \n eng1 = np.array(eng1)\n eng2 = np.array(eng2)\n eng3 = np.array(eng3)\n eng4 = np.array(eng4)\n\n eng_max = max([max(eng1), max(eng2)])\n bins = np.linspace(eng_min-0.1, 0.1, 100)\n plt.hist(eng1, bins, alpha=0.5, label='no symmetry: ' + str(ground1) + '/' + str(len(eng1)))\n plt.hist(eng2, bins, alpha=0.5, label='random point groups: ' + str(ground2) + '/' + str(len(eng2)))\n plt.xlabel('Energy (eV)')\n plt.ylabel('Counts')\n plt.legend(loc=1)\n plt.title('LJ cluster: ' + str(N) + ' Ground state: ' + str(eng_min))\n plt.savefig(str(N)+'-'+str(maxN)+'-'+str(dim)+'.pdf')\n plt.close()\n\n eng_max = max([max(eng3), max(eng4)])\n bins = np.linspace(eng_min-0.1, 0.1, 100)\n plt.hist(eng3, bins, alpha=0.5, label='Oh only: ' + str(ground3) + '/' + str(len(eng3)))\n plt.hist(eng4, bins, alpha=0.5, label='random point groups (excluding Oh): ' + str(ground4) + '/' + str(len(eng4)))\n plt.xlabel('Energy (eV)')\n plt.ylabel('Counts')\n plt.legend(loc=1)\n plt.title('LJ cluster: ' + str(N) + ' Ground state: ' + str(eng_min))\n plt.savefig(str(N)+'-'+str(maxN)+'-'+str(dim)+'_single.pdf')\n plt.close()\n"
] | [
[
"numpy.dot",
"numpy.multiply",
"numpy.random.random",
"scipy.optimize.minimize",
"numpy.array",
"numpy.delete",
"numpy.reshape",
"numpy.zeros",
"matplotlib.pyplot.close",
"numpy.shape",
"numpy.power",
"matplotlib.pyplot.style.use",
"scipy.spatial.distance.cdist",
"scipy.spatial.distance.pdist",
"numpy.sum",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.legend",
"matplotlib.pyplot.ylabel",
"numpy.linspace"
]
] |
quantapix/qnarre.com | [
"f51d5945c20ef8182c4aa11f1b407d064c190c70",
"f51d5945c20ef8182c4aa11f1b407d064c190c70",
"f51d5945c20ef8182c4aa11f1b407d064c190c70"
] | [
"qnarre/models/ibert_quant_modules.py",
"qnarre/prep/convert/roberta.py",
"qnarre/prep/convert/gpt_neo.py"
] | [
"import decimal\n\nimport numpy as np\nimport torch\nfrom torch import nn\nfrom torch.autograd import Function\n\nfrom ...utils import logging\n\n\nlogger = logging.get_logger(__name__)\n\n\nclass QuantEmbedding(qc.Module):\n def __init__(\n self,\n num_embeddings,\n embedding_dim,\n padding_idx=None,\n max_norm=None,\n norm_type=2.0,\n scale_grad_by_freq=False,\n sparse=False,\n _weight=None,\n weight_bit=8,\n momentum=0.95,\n quant_mode=False,\n ):\n super().__init__()\n self.num_ = num_embeddings\n self.dim = embedding_dim\n self.padding_idx = padding_idx\n self.max_norm = max_norm\n self.norm_type = norm_type\n self.scale_grad_by_freq = scale_grad_by_freq\n self.sparse = sparse\n\n self.weight = nn.Parameter(torch.zeros([num_embeddings, embedding_dim]))\n self.register_buffer(\"weight_scaling_factor\", torch.zeros(1))\n self.register_buffer(\"weight_integer\", torch.zeros_like(self.weight))\n\n self.weight_bit = weight_bit\n self.momentum = momentum\n self.quant_mode = quant_mode\n self.percentile_mode = False\n self.weight_function = SymmetricQuantFunction.apply\n\n def forward(self, x, positions=None, incremental_state=None):\n if not self.quant_mode:\n return (\n F.embedding(\n x,\n self.weight,\n self.padding_idx,\n self.max_norm,\n self.norm_type,\n self.scale_grad_by_freq,\n self.sparse,\n ),\n None,\n )\n\n w = self.weight\n w_transform = w.data.detach()\n w_min = w_transform.min().expand(1)\n w_max = w_transform.max().expand(1)\n\n self.weight_scaling_factor = symmetric_linear_quantization_params(\n self.weight_bit, w_min, w_max, False\n )\n self.weight_integer = self.weight_function(\n self.weight, self.weight_bit, self.percentile_mode, self.weight_scaling_factor\n )\n\n emb_int = F.embedding(\n x,\n self.weight_integer,\n self.padding_idx,\n self.max_norm,\n self.norm_type,\n self.scale_grad_by_freq,\n self.sparse,\n )\n return emb_int * self.weight_scaling_factor, self.weight_scaling_factor\n\n\nclass QuantAct(qc.Module):\n def __init__(\n self,\n activation_bit,\n act_range_momentum=0.95,\n per_channel=False,\n channel_len=None,\n quant_mode=False,\n ):\n super().__init__()\n\n self.activation_bit = activation_bit\n self.act_range_momentum = act_range_momentum\n self.quant_mode = quant_mode\n self.per_channel = per_channel\n self.percentile = False\n self.act_function = SymmetricQuantFunction.apply\n\n if not self.per_channel:\n self.register_buffer(\"x_min\", torch.zeros(1))\n self.register_buffer(\"x_max\", torch.zeros(1))\n self.register_buffer(\"act_scaling_factor\", torch.zeros(1))\n self.x_min -= 1e-5\n self.x_max += 1e-5\n else:\n raise NotImplementedError(\"per-channel mode is not currently supported for activation.\")\n\n def __repr__(self):\n return (\n f\"{self.__class__.__name__}(activation_bit={self.activation_bit}, \"\n f\"quant_mode: {self.activation_bit}, Act_min: {self.x_min.item():.2f}, \"\n f\"Act_max: {self.x_max.item():.2f})\"\n )\n\n def forward(\n self,\n x,\n pre_act_scaling_factor=None,\n identity=None,\n identity_scaling_factor=None,\n specified_min=None,\n specified_max=None,\n ):\n\n x_act = x if identity is None else identity + x\n # collect running stats if training\n if self.training:\n assert not self.percentile, \"percentile mode is not currently supported for activation.\"\n assert (\n not self.per_channel\n ), \"per-channel mode is not currently supported for activation.\"\n x_min = x_act.data.min()\n x_max = x_act.data.max()\n\n assert (\n x_max.isnan().sum() == 0 and x_min.isnan().sum() == 0\n ), \"NaN detected when computing min/max of the activation\"\n\n # Initialization\n if self.x_min.min() > -1.1e-5 and self.x_max.max() < 1.1e-5:\n self.x_min = self.x_min + x_min\n self.x_max = self.x_max + x_max\n\n # exponential moving average (EMA)\n # use momentum to prevent the quantized values change greatly every iteration\n elif self.act_range_momentum == -1:\n self.x_min = torch.min(self.x_min, x_min)\n self.x_max = torch.max(self.x_max, x_max)\n else:\n self.x_min = self.x_min * self.act_range_momentum + x_min * (\n 1 - self.act_range_momentum\n )\n self.x_max = self.x_max * self.act_range_momentum + x_max * (\n 1 - self.act_range_momentum\n )\n\n if not self.quant_mode:\n return x_act, None\n\n x_min = self.x_min if specified_min is None else specified_min\n x_max = self.x_max if specified_max is None else specified_max\n\n self.act_scaling_factor = symmetric_linear_quantization_params(\n self.activation_bit, x_min, x_max, per_channel=self.per_channel\n )\n\n if pre_act_scaling_factor is None:\n # this is for the input quantization\n quant_act_int = self.act_function(\n x, self.activation_bit, self.percentile, self.act_scaling_factor\n )\n else:\n quant_act_int = FixedPointMul.apply(\n x,\n pre_act_scaling_factor,\n self.activation_bit,\n self.act_scaling_factor,\n identity,\n identity_scaling_factor,\n )\n\n correct_output_scale = self.act_scaling_factor.view(-1)\n\n return quant_act_int * correct_output_scale, self.act_scaling_factor\n\n\nclass QuantLinear(qc.Module):\n def __init__(\n self,\n in_features,\n out_features,\n bias=True,\n weight_bit=8,\n bias_bit=32,\n per_channel=False,\n quant_mode=False,\n ):\n super().__init__()\n self.in_features = in_features\n self.out_features = out_features\n\n self.weight = nn.Parameter(torch.zeros([out_features, in_features]))\n self.register_buffer(\"weight_integer\", torch.zeros_like(self.weight))\n self.register_buffer(\"fc_scaling_factor\", torch.zeros(self.out_features))\n if bias:\n self.bias = nn.Parameter(torch.zeros(out_features))\n self.register_buffer(\"bias_integer\", torch.zeros_like(self.bias))\n\n self.weight_bit = weight_bit\n self.quant_mode = quant_mode\n self.per_channel = per_channel\n self.bias_bit = bias_bit\n self.quant_mode = quant_mode\n self.percentile_mode = False\n self.weight_function = SymmetricQuantFunction.apply\n\n def __repr__(self):\n s = super().__repr__()\n s = f\"({s} weight_bit={self.weight_bit}, quant_mode={self.quant_mode})\"\n return s\n\n def forward(self, x, prev_act_scaling_factor=None):\n if not self.quant_mode:\n return F.linear(x, weight=self.weight, bias=self.bias), None\n\n # assert that prev_act_scaling_factor is a scalar tensor\n assert prev_act_scaling_factor is not None and prev_act_scaling_factor.shape == (1,), (\n \"Input activation to the QuantLinear layer should be globally (non-channel-wise) quantized. \"\n \"Please add a QuantAct layer with `per_channel = True` before this QuantAct layer\"\n )\n\n w = self.weight\n w_transform = w.data.detach()\n if self.per_channel:\n w_min, _ = torch.min(w_transform, dim=1, out=None)\n w_max, _ = torch.max(w_transform, dim=1, out=None)\n else:\n w_min = w_transform.min().expand(1)\n w_max = w_transform.max().expand(1)\n\n self.fc_scaling_factor = symmetric_linear_quantization_params(\n self.weight_bit, w_min, w_max, self.per_channel\n )\n self.weight_integer = self.weight_function(\n self.weight, self.weight_bit, self.percentile_mode, self.fc_scaling_factor\n )\n\n bias_scaling_factor = self.fc_scaling_factor * prev_act_scaling_factor\n\n if self.bias is not None:\n self.bias_integer = self.weight_function(\n self.bias, self.bias_bit, False, bias_scaling_factor\n )\n\n prev_act_scaling_factor = prev_act_scaling_factor.view(1, -1)\n x_int = x / prev_act_scaling_factor\n\n return (\n F.linear(x_int, weight=self.weight_integer, bias=self.bias_integer)\n * bias_scaling_factor,\n bias_scaling_factor,\n )\n\n\nclass IntGELU(qc.Module):\n def __init__(self, quant_mode=True, force_dequant=\"none\"):\n super().__init__()\n self.quant_mode = quant_mode\n\n if force_dequant in [\"nonlinear\", \"gelu\"]:\n logger.info(\"Force dequantize gelu\")\n self.quant_mode = False\n\n if not self.quant_mode:\n self.activation_fn = nn.GELU()\n\n self.k = 1.4142\n self.const = 14 # dummy integer constant\n self.coeff = [-0.2888, -1.769, 1] # a(x+b)**2 + c\n self.coeff[2] /= self.coeff[0]\n\n def int_erf(self, x_int, scaling_factor):\n b_int = torch.floor(self.coeff[1] / scaling_factor)\n c_int = torch.floor(self.coeff[2] / scaling_factor**2)\n sign = torch.sign(x_int)\n\n abs_int = torch.min(torch.abs(x_int), -b_int)\n y_int = sign * ((abs_int + b_int) ** 2 + c_int)\n scaling_factor = scaling_factor**2 * self.coeff[0]\n\n # avoid overflow\n y_int = floor_ste.apply(y_int / 2**self.const)\n scaling_factor = scaling_factor * 2**self.const\n\n return y_int, scaling_factor\n\n def forward(self, x, scaling_factor=None):\n if not self.quant_mode:\n return self.activation_fn(x), None\n\n x_int = x / scaling_factor\n sigmoid_int, sigmoid_scaling_factor = self.int_erf(x_int, scaling_factor / self.k)\n\n shift_int = 1.0 // sigmoid_scaling_factor\n\n x_int = x_int * (sigmoid_int + shift_int)\n scaling_factor = scaling_factor * sigmoid_scaling_factor / 2\n\n return x_int * scaling_factor, scaling_factor\n\n\nclass IntSoftmax(qc.Module):\n def __init__(self, output_bit, quant_mode=False, force_dequant=\"none\"):\n super().__init__()\n self.output_bit = output_bit\n self.max_bit = 32\n self.quant_mode = quant_mode\n\n if force_dequant in [\"nonlinear\", \"softmax\"]:\n logger.info(\"Force dequantize softmax\")\n self.quant_mode = False\n\n self.act = QuantAct(16, quant_mode=self.quant_mode)\n self.x0 = -0.6931 # -ln2\n self.const = 30 # dummy integer constant\n self.coef = [0.35815147, 0.96963238, 1.0] # ax**2 + bx + c\n self.coef[1] /= self.coef[0]\n self.coef[2] /= self.coef[0]\n\n def int_polynomial(self, x_int, scaling_factor):\n with torch.no_grad():\n b_int = torch.floor(self.coef[1] / scaling_factor)\n c_int = torch.floor(self.coef[2] / scaling_factor**2)\n z = (x_int + b_int) * x_int + c_int\n scaling_factor = self.coef[0] * scaling_factor**2\n return z, scaling_factor\n\n def int_exp(self, x_int, scaling_factor):\n with torch.no_grad():\n x0_int = torch.floor(self.x0 / scaling_factor)\n x_int = torch.max(x_int, self.const * x0_int)\n\n q = floor_ste.apply(x_int / x0_int)\n r = x_int - x0_int * q\n exp_int, exp_scaling_factor = self.int_polynomial(r, scaling_factor)\n exp_int = torch.clamp(floor_ste.apply(exp_int * 2 ** (self.const - q)), min=0)\n scaling_factor = exp_scaling_factor / 2**self.const\n return exp_int, scaling_factor\n\n def forward(self, x, scaling_factor):\n if not self.quant_mode:\n return F.softmax(x, dim=-1), None\n\n x_int = x / scaling_factor\n\n x_int_max, _ = x_int.max(dim=-1, keepdim=True)\n x_int = x_int - x_int_max\n exp_int, exp_scaling_factor = self.int_exp(x_int, scaling_factor)\n\n # Avoid overflow\n exp, exp_scaling_factor = self.act(exp_int, exp_scaling_factor)\n exp_int = exp / exp_scaling_factor\n\n exp_int_sum = exp_int.sum(dim=-1, keepdim=True)\n factor = floor_ste.apply(2**self.max_bit / exp_int_sum)\n exp_int = floor_ste.apply(exp_int * factor / 2 ** (self.max_bit - self.output_bit))\n scaling_factor = 1 / 2**self.output_bit\n return exp_int * scaling_factor, scaling_factor\n\n\nclass IntLayerNorm(qc.Module):\n def __init__(self, normalized_shape, eps, output_bit=8, quant_mode=False, force_dequant=\"none\"):\n super().__init__()\n self.normalized_shape = normalized_shape\n self.eps = eps\n\n self.weight = nn.Parameter(torch.zeros(normalized_shape))\n self.bias = nn.Parameter(torch.zeros(normalized_shape))\n\n self.quant_mode = quant_mode\n if force_dequant in [\"nonlinear\", \"layernorm\"]:\n logger.info(\"Force dequantize layernorm\")\n self.quant_mode = False\n\n self.register_buffer(\"shift\", torch.zeros(1))\n self.output_bit = output_bit\n self.max_bit = 32\n self.dim_sqrt = None\n self.activation = QuantAct(self.output_bit, quant_mode=self.quant_mode)\n\n def set_shift(self, y_int):\n with torch.no_grad():\n y_sq_int = y_int**2\n var_int = torch.sum(y_sq_int, axis=2, keepdim=True)\n shift = (torch.log2(torch.sqrt(var_int / 2**self.max_bit)).ceil()).max()\n shift_old = self.shift\n self.shift = torch.max(self.shift, shift)\n logger.info(f\"Dynamic shift adjustment: {int(shift_old)} to {int(self.shift)}\")\n\n def overflow_fallback(self, y_int):\n self.set_shift(y_int) # adjusts `self.shift`\n y_int_shifted = floor_ste.apply(y_int / 2**self.shift)\n y_sq_int = y_int_shifted**2\n var_int = torch.sum(y_sq_int, axis=2, keepdim=True)\n return var_int\n\n def forward(self, x, scaling_factor=None):\n if not self.quant_mode:\n mean = x.mean(axis=2, keepdim=True)\n y = x - mean\n var = torch.mean(y**2, axis=2, keepdim=True)\n x = y / torch.sqrt(self.eps + var)\n x = x * self.weight + self.bias\n return x, None\n\n # compute sqrt of the feature dimension if it is the first run\n if self.dim_sqrt is None:\n n = torch.tensor(x.shape[2], dtype=torch.float)\n self.dim_sqrt = torch.sqrt(n).to(x.device)\n\n # Normalization: computes mean and variance(std)\n x_int = x / scaling_factor\n mean_int = round_ste.apply(x_int.mean(axis=2, keepdim=True))\n y_int = x_int - mean_int\n y_int_shifted = floor_ste.apply(y_int / 2**self.shift)\n y_sq_int = y_int_shifted**2\n var_int = torch.sum(y_sq_int, axis=2, keepdim=True)\n\n # overflow handling in training time\n if self.training:\n # if overflow is detected\n if var_int.max() >= 2**self.max_bit:\n var_int = self.overflow_fallback(y_int)\n assert var_int.max() < 2**self.max_bit + 0.1, (\n \"Error detected in overflow handling: \"\n \"`var_int` exceeds `self.max_bit` (the maximum possible bit width)\"\n )\n\n # To be replaced with integer-sqrt kernel that produces the same output\n std_int = floor_ste.apply(torch.sqrt(var_int)) * 2**self.shift\n factor = floor_ste.apply(2**31 / std_int)\n y_int = floor_ste.apply(y_int * factor / 2)\n scaling_factor = self.dim_sqrt / 2**30\n\n # scaling and shifting\n bias = self.bias.data.detach() / (self.weight.data.detach())\n bias_int = floor_ste.apply(bias / scaling_factor)\n\n y_int = y_int + bias_int\n scaling_factor = scaling_factor * self.weight\n x = y_int * scaling_factor\n\n return x, scaling_factor\n\n\ndef get_percentile_min_max(input, lower_percentile, upper_percentile, output_tensor=False):\n input_length = input.shape[0]\n\n lower_index = round(input_length * (1 - lower_percentile * 0.01))\n upper_index = round(input_length * upper_percentile * 0.01)\n\n upper_bound = torch.kthvalue(input, k=upper_index).values\n\n if lower_percentile == 0:\n lower_bound = upper_bound * 0\n # lower_index += 1\n else:\n lower_bound = -torch.kthvalue(-input, k=lower_index).values\n\n if not output_tensor:\n lower_bound = lower_bound.item()\n upper_bound = upper_bound.item()\n return lower_bound, upper_bound\n\n\ndef linear_quantize(input, scale, zero_point, inplace=False):\n if len(input.shape) == 4:\n scale = scale.view(-1, 1, 1, 1)\n zero_point = zero_point.view(-1, 1, 1, 1)\n # reshape scale and zeropoint for linear weights\n elif len(input.shape) == 2:\n scale = scale.view(-1, 1)\n zero_point = zero_point.view(-1, 1)\n else:\n scale = scale.view(-1)\n zero_point = zero_point.view(-1)\n # quantized = float / scale + zero_point\n if inplace:\n input.mul_(1.0 / scale).add_(zero_point).round_()\n return input\n return torch.round(1.0 / scale * input + zero_point)\n\n\ndef symmetric_linear_quantization_params(\n num_bits, saturation_min, saturation_max, per_channel=False\n):\n with torch.no_grad():\n n = 2 ** (num_bits - 1) - 1\n\n if per_channel:\n scale, _ = torch.max(\n torch.stack([saturation_min.abs(), saturation_max.abs()], dim=1), dim=1\n )\n scale = torch.clamp(scale, min=1e-8) / n\n\n else:\n scale = max(saturation_min.abs(), saturation_max.abs())\n scale = torch.clamp(scale, min=1e-8) / n\n\n return scale\n\n\nclass SymmetricQuantFunction(Function):\n @staticmethod\n def forward(ctx, x, k, percentile_mode, scale):\n zero_point = torch.tensor(0.0).to(scale.device)\n\n n = 2 ** (k - 1) - 1\n new_quant_x = linear_quantize(x, scale, zero_point, inplace=False)\n new_quant_x = torch.clamp(new_quant_x, -n, n - 1)\n\n ctx.scale = scale\n return new_quant_x\n\n @staticmethod\n def backward(ctx, grad_output):\n\n scale = ctx.scale\n if len(grad_output.shape) == 4:\n scale = scale.view(-1, 1, 1, 1)\n # reshape scale and zeropoint for linear weights\n elif len(grad_output.shape) == 2:\n scale = scale.view(-1, 1)\n else:\n scale = scale.view(-1)\n\n return grad_output.clone() / scale, None, None, None, None\n\n\nclass floor_ste(Function):\n @staticmethod\n def forward(ctx, x):\n return torch.floor(x)\n\n @staticmethod\n def backward(ctx, grad_output):\n return grad_output.clone()\n\n\nclass round_ste(Function):\n @staticmethod\n def forward(ctx, x):\n return torch.round(x)\n\n @staticmethod\n def backward(ctx, grad_output):\n return grad_output.clone()\n\n\ndef batch_frexp(inputs, max_bit=31):\n shape_of_input = inputs.size()\n\n # trans the input to be a 1-d tensor\n inputs = inputs.view(-1)\n\n output_m, output_e = np.frexp(inputs.cpu().numpy())\n tmp_m = []\n for m in output_m:\n int_m_shifted = int(\n decimal.Decimal(m * (2**max_bit)).quantize(\n decimal.Decimal(\"1\"), rounding=decimal.ROUND_HALF_UP\n )\n )\n tmp_m.append(int_m_shifted)\n output_m = np.array(tmp_m)\n\n output_e = float(max_bit) - output_e\n\n return (\n torch.from_numpy(output_m).to(inputs.device).view(shape_of_input),\n torch.from_numpy(output_e).to(inputs.device).view(shape_of_input),\n )\n\n\nclass FixedPointMul(Function):\n @staticmethod\n def forward(\n ctx,\n pre_act,\n pre_act_scaling_factor,\n bit_num,\n z_scaling_factor,\n identity=None,\n identity_scaling_factor=None,\n ):\n\n if len(pre_act_scaling_factor.shape) == 3:\n reshape = lambda x: x # noqa: E731\n else:\n reshape = lambda x: x.view(1, 1, -1) # noqa: E731\n ctx.identity = identity\n\n n = 2 ** (bit_num - 1) - 1\n\n with torch.no_grad():\n pre_act_scaling_factor = reshape(pre_act_scaling_factor)\n if identity is not None:\n identity_scaling_factor = reshape(identity_scaling_factor)\n\n ctx.z_scaling_factor = z_scaling_factor\n\n z_int = torch.round(pre_act / pre_act_scaling_factor)\n _A = pre_act_scaling_factor.type(torch.double)\n _B = (z_scaling_factor.type(torch.float)).type(torch.double)\n new_scale = _A / _B\n new_scale = reshape(new_scale)\n\n m, e = batch_frexp(new_scale)\n\n output = z_int.type(torch.double) * m.type(torch.double)\n output = torch.round(output / (2.0**e))\n\n if identity is not None:\n # needs addition of identity activation\n wx_int = torch.round(identity / identity_scaling_factor)\n\n _A = identity_scaling_factor.type(torch.double)\n _B = (z_scaling_factor.type(torch.float)).type(torch.double)\n new_scale = _A / _B\n new_scale = reshape(new_scale)\n\n m1, e1 = batch_frexp(new_scale)\n output1 = wx_int.type(torch.double) * m1.type(torch.double)\n output1 = torch.round(output1 / (2.0**e1))\n\n output = output1 + output\n\n return torch.clamp(output.type(torch.float), -n - 1, n)\n\n @staticmethod\n def backward(ctx, grad_output):\n identity_grad = None\n if ctx.identity is not None:\n identity_grad = grad_output.clone() / ctx.z_scaling_factor\n return (\n grad_output.clone() / ctx.z_scaling_factor,\n None,\n None,\n None,\n None,\n identity_grad,\n None,\n )\n",
"# Copyright 2022 Quantapix 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\nimport pathlib\nimport torch\n\nfrom argparse import ArgumentParser\nfrom fairseq.models.roberta import RobertaModel as FairseqRobertaModel\nfrom fairseq.modules import TransformerSentenceEncLayer\n\nfrom transformers.utils import logging\n\nfrom ..config.bert import PreTrained\nfrom ...models.bert import ForMasked, ForSeqClassifier\n\n\nlogging.set_verbosity_info()\n\nlog = logging.get_logger(__name__)\n\nSAMPLE_TEXT = \"Hello world! cécé herlolip\"\n\n\ndef to_pytorch(src_path, save_path, classification_head):\n roberta = FairseqRobertaModel.from_pretrained(src_path)\n roberta.eval() # disable drop\n roberta_sent_encoder = roberta.model.encoder.sentence_encoder\n cfg = PreTrained(\n s_vocab=roberta_sent_encoder.embed_tokens.num_embeddings,\n d_hidden=roberta.args.encoder_embed_dim,\n n_lays=roberta.args.n_enc_lays,\n n_heads=roberta.args.n_enc_heads,\n d_ffnet=roberta.args.encoder_ffn_embed_dim,\n n_pos=514,\n n_typ=1,\n norm_eps=1e-5,\n )\n if classification_head:\n cfg.n_labels = roberta.model.classification_heads[\"mnli\"].out_proj.weight.shape[0]\n print(\"Our BERT config:\", cfg)\n m = ForSeqClassifier(cfg) if classification_head else ForMasked(cfg)\n m.eval()\n m.roberta.embeddings.tok_embed.weight = roberta_sent_encoder.embed_tokens.weight\n m.roberta.embeddings.pos_embed.weight = roberta_sent_encoder.embed_positions.weight\n m.roberta.embeddings.token_type_embeddings.weight.data = torch.zeros_like(\n m.roberta.embeddings.token_type_embeddings.weight\n )\n m.roberta.embeddings.LayerNorm.weight = roberta_sent_encoder.emb_layer_norm.weight\n m.roberta.embeddings.LayerNorm.bias = roberta_sent_encoder.emb_layer_norm.bias\n for i in range(cfg.n_lays):\n layer = m.roberta.encoder.layer[i]\n roberta_layer: TransformerSentenceEncLayer = roberta_sent_encoder.layers[i]\n self_attn = layer.attention.self\n assert (\n roberta_layer.self_attn.k_proj.weight.data.shape\n == roberta_layer.self_attn.q_proj.weight.data.shape\n == roberta_layer.self_attn.v_proj.weight.data.shape\n == torch.Size((cfg.d_hidden, cfg.d_hidden))\n )\n self_attn.query.weight.data = roberta_layer.self_attn.q_proj.weight\n self_attn.query.bias.data = roberta_layer.self_attn.q_proj.bias\n self_attn.key.weight.data = roberta_layer.self_attn.k_proj.weight\n self_attn.key.bias.data = roberta_layer.self_attn.k_proj.bias\n self_attn.value.weight.data = roberta_layer.self_attn.v_proj.weight\n self_attn.value.bias.data = roberta_layer.self_attn.v_proj.bias\n self_output = layer.attention.output\n assert self_output.dense.weight.shape == roberta_layer.self_attn.out_proj.weight.shape\n self_output.dense.weight = roberta_layer.self_attn.out_proj.weight\n self_output.dense.bias = roberta_layer.self_attn.out_proj.bias\n self_output.LayerNorm.weight = roberta_layer.self_attn_layer_norm.weight\n self_output.LayerNorm.bias = roberta_layer.self_attn_layer_norm.bias\n intermediate = layer.intermediate\n assert intermediate.dense.weight.shape == roberta_layer.fc1.weight.shape\n intermediate.dense.weight = roberta_layer.fc1.weight\n intermediate.dense.bias = roberta_layer.fc1.bias\n bert_output = layer.output\n assert bert_output.dense.weight.shape == roberta_layer.fc2.weight.shape\n bert_output.dense.weight = roberta_layer.fc2.weight\n bert_output.dense.bias = roberta_layer.fc2.bias\n bert_output.LayerNorm.weight = roberta_layer.final_layer_norm.weight\n bert_output.LayerNorm.bias = roberta_layer.final_layer_norm.bias\n if classification_head:\n m.classifier.dense.weight = roberta.model.classification_heads[\"mnli\"].dense.weight\n m.classifier.dense.bias = roberta.model.classification_heads[\"mnli\"].dense.bias\n m.classifier.out_proj.weight = roberta.model.classification_heads[\"mnli\"].out_proj.weight\n m.classifier.out_proj.bias = roberta.model.classification_heads[\"mnli\"].out_proj.bias\n else:\n m.lm_head.dense.weight = roberta.model.encoder.lm_head.dense.weight\n m.lm_head.dense.bias = roberta.model.encoder.lm_head.dense.bias\n m.lm_head.layer_norm.weight = roberta.model.encoder.lm_head.layer_norm.weight\n m.lm_head.layer_norm.bias = roberta.model.encoder.lm_head.layer_norm.bias\n m.lm_head.decoder.weight = roberta.model.encoder.lm_head.weight\n m.lm_head.decoder.bias = roberta.model.encoder.lm_head.bias\n input_ids = roberta.encode(SAMPLE_TEXT).unsqueeze(0) # batch of size 1\n our_output = m(input_ids)[0]\n if classification_head:\n their_output = roberta.model.classification_heads[\"mnli\"](\n roberta.extract_features(input_ids)\n )\n else:\n their_output = roberta.model(input_ids)[0]\n print(our_output.shape, their_output.shape)\n max_absolute_diff = torch.max(torch.abs(our_output - their_output)).item()\n print(f\"max_absolute_diff = {max_absolute_diff}\") # ~ 1e-7\n success = torch.allclose(our_output, their_output, atol=1e-3)\n print(\"Do both models output the same tensors?\", \"🔥\" if success else \"💩\")\n if not success:\n raise Exception(\"Something went wRoNg\")\n pathlib.Path(save_path).mkdir(parents=True, exist_ok=True)\n print(f\"Saving model to {save_path}\")\n m.save_pretrained(save_path)\n\n\nif __name__ == \"__main__\":\n x = ArgumentParser()\n x.add_argument(\"--roberta_checkpoint_path\", default=None, type=str, required=True)\n x.add_argument(\"--save_path\", default=None, type=str, required=True)\n x.add_argument(\"--classification_head\", action=\"store_true\")\n y = x.parse_args()\n to_pytorch(y.roberta_checkpoint_path, y.save_path, y.classification_head)\n",
"# Copyright 2022 Quantapix 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\nimport json\nimport re\nimport tensorflow as tf\nimport torch\n\nfrom argparse import ArgumentParser\nfrom os.path import abspath\nfrom transformers.utils import logging\n\nfrom ..config.gpt_neo import PreTrained\nfrom ...models.gpt_neo import ForCausal\n\n\nlogging.set_verbosity_info()\n\nlog = logging.get_logger(__name__)\n\n\ndef load_src_weights(model, config, gpt_neo_checkpoint_path):\n tf_path = abspath(gpt_neo_checkpoint_path)\n log.info(f\"Converting TensorFlow checkpoint from {tf_path}\")\n init_vars = tf.train.list_variables(tf_path)\n names = []\n arrays = []\n for name, shape in init_vars:\n if \"global_step\" not in name and \"adam\" not in name:\n array = tf.train.load_variable(tf_path, name)\n array = tf.dtypes.cast(array.squeeze(), tf.float32).numpy()\n name = name.replace(\"attn/q\", \"attn/attention/q_proj/w\")\n name = name.replace(\"attn/k\", \"attn/attention/k_proj/w\")\n name = name.replace(\"attn/v\", \"attn/attention/v_proj/w\")\n name = name.replace(\"attn/o\", \"attn/attention/out_proj/w\")\n name = name.replace(\"norm_1\", \"ln_1\")\n name = name.replace(\"norm_2\", \"ln_2\")\n name = name.replace(\"attn/compute_output_bias/o_b\", \"attn/attention/out_proj/b\")\n name = name.replace(\"conv1d_main/c_fc/kernel\", \"c_fc/w\")\n name = name.replace(\"conv1d_main/c_fc/bias\", \"c_fc/b\")\n name = name.replace(\"conv1d_main/c_proj/kernel\", \"c_proj/w\")\n name = name.replace(\"conv1d_main/c_proj/bias\", \"c_proj/b\")\n names.append(name)\n arrays.append(array)\n for name, array in zip(names, arrays):\n name = name[5:] # skip \"gpt2/\"\n name = name.split(\"/\")\n pointer = model.transformer\n for m_name in name:\n if re.fullmatch(r\"[A-Za-z]+\\d+\", m_name):\n scope_names = re.split(r\"(\\d+)\", m_name)\n else:\n scope_names = [m_name]\n if scope_names[0] == \"w\" or scope_names[0] == \"g\":\n pointer = getattr(pointer, \"weight\")\n elif scope_names[0] == \"b\":\n pointer = getattr(pointer, \"bias\")\n elif scope_names[0] == \"wpe\" or scope_names[0] == \"wte\":\n pointer = getattr(pointer, scope_names[0])\n pointer = getattr(pointer, \"weight\")\n else:\n pointer = getattr(pointer, scope_names[0])\n if len(scope_names) >= 2:\n num = int(scope_names[1])\n pointer = pointer[num]\n if name[-1] == \"w\" and name[-2] in [\n \"out_proj\",\n \"k_proj\",\n \"q_proj\",\n \"v_proj\",\n \"c_proj\",\n \"c_fc\",\n ]:\n array = array.transpose()\n if name == [\"wte\"]:\n array = array[: config.s_vocab]\n if pointer.shape != array.shape:\n raise ValueError(\n f\"Pointer shape {pointer.shape} and array shape {array.shape} mismatched {name}\"\n )\n print(f\"Initialize PyTorch weight {name}\")\n pointer.data = torch.from_numpy(array)\n embs = model.transformer.wte.weight\n lin = nn.Linear(embs.size()[1], embs.size()[0], bias=False)\n lin.weight = embs\n model.set_output_embeddings(lin)\n return model\n\n\ndef to_pytorch(tf_checkpoint_path, config_file, pytorch_dump_path):\n config_json = json.load(open(config_file, \"r\"))\n cfg = GPTNeoConfig(\n d_hidden=config_json[\"n_embd\"],\n n_lays=config_json[\"n_lays\"],\n n_heads=config_json[\"n_heads\"],\n attention_types=config_json[\"attention_types\"],\n n_pos=config_json[\"n_pos\"],\n drop_resid=config_json[\"res_dropout\"],\n drop_embed=config_json[\"drop_embed\"],\n drop_attn=config_json[\"attn_dropout\"],\n )\n print(f\"Building from config: {cfg}\")\n m = ForCausal(cfg)\n load_src_weights(m, cfg, tf_checkpoint_path)\n print(f\"Saving to: {pytorch_dump_path}\")\n m.save_pretrained(pytorch_dump_path)\n\n\nif __name__ == \"__main__\":\n x = ArgumentParser()\n x.add_argument(\"--src_path\", default=None, type=str, required=True)\n x.add_argument(\"--cfg_path\", default=None, type=str, required=True)\n x.add_argument(\"--save_path\", default=None, type=str, required=True)\n y = x.parse_args()\n to_pytorch(y.src_path, y.cfg_path, y.save_path)\n"
] | [
[
"torch.zeros",
"torch.round",
"numpy.array",
"torch.sqrt",
"torch.kthvalue",
"torch.min",
"torch.max",
"torch.no_grad",
"torch.sign",
"torch.clamp",
"torch.abs",
"torch.from_numpy",
"torch.tensor",
"torch.zeros_like",
"torch.floor",
"torch.nn.GELU",
"torch.mean",
"torch.sum"
],
[
"torch.zeros_like",
"torch.allclose",
"torch.abs",
"torch.Size"
],
[
"tensorflow.train.load_variable",
"torch.from_numpy",
"tensorflow.train.list_variables"
]
] |
frezaeix/evaluating_bdl | [
"bd0a464981c18de8479b6be2d91867527016c8d3"
] | [
"toyClassification/MC-Dropout-MAP-01-Adam/eval.py"
] | [
"# code-checked\n# server-checked\n\nfrom model import ToyNet\n\nimport torch\nimport torch.utils.data\nimport torch.nn as nn\nfrom torch.autograd import Variable\nimport torch.optim as optim\nimport torch.nn.functional as F\n\nimport numpy as np\nimport pickle\nimport matplotlib\nmatplotlib.use(\"Agg\")\nimport matplotlib.pyplot as plt\nimport matplotlib.cm as cm\nimport cv2\n\nbatch_size = 32\n\nM = 4\n\nx_min = -6.0\nx_max = 6.0\nnum_points = 60\n\nnetwork = ToyNet(\"Farzaneh_eval_MC-Dropout-MAP-01-Adam_1_M10_0\", project_dir=\"../\").cuda()\nnetwork.load_state_dict(torch.load(\"../training_logs/model_Farzaneh_MC-Dropout-MAP-01-Adam_1_M10_0/checkpoints/model_Farzaneh_MC-Dropout-MAP-01-Adam_1_M10_epoch_300.pth\"))\n\nM_float = float(M)\nprint (M_float)\n\nnetwork.eval()\n\nfalse_prob_values = np.zeros((num_points, num_points))\nx_values = np.linspace(x_min, x_max, num_points, dtype=np.float32)\nfor x_1_i, x_1_value in enumerate(x_values):\n for x_2_i, x_2_value in enumerate(x_values):\n x = torch.from_numpy(np.array([x_1_value, x_2_value])).unsqueeze(0).cuda() # (shape: (1, 2))\n\n mean_prob_vector = np.zeros((2, ))\n for i in range(M):\n logits = network(x) # (shape: (1, num_classes)) (num_classes==2)\n prob_vector = F.softmax(logits, dim=1) # (shape: (1, num_classes))\n\n prob_vector = prob_vector.data.cpu().numpy()[0] # (shape: (2, ))\n\n mean_prob_vector += prob_vector/M_float\n\n false_prob_values[x_2_i, x_1_i] = mean_prob_vector[0]\n\nplt.figure(1)\nx_1, x_2 = np.meshgrid(x_values, x_values)\nplt.pcolormesh(x_1, x_2, false_prob_values, cmap=\"RdBu\")\nplt.xlabel(\"x_1\")\nplt.ylabel(\"x_2\")\nplt.title(\"Predictive Density\")\nplt.colorbar()\nplt.savefig(\"%s/predictive_density.png\" % network.model_dir)\nplt.close(1)\nplt.figure(1)\nplt.pcolormesh(x_1, x_2, false_prob_values, cmap=\"binary\")\nplt.xlabel(\"x_1\")\nplt.ylabel(\"x_2\")\nplt.title(\"Predictive Density\")\nplt.colorbar()\nplt.savefig(\"%s/predictive_density_gray.png\" % network.model_dir)\nplt.close(1)\n\nx_values = np.linspace(x_min, x_max, 1000, dtype=np.float32)\nx_1, x_2 = np.meshgrid(x_values, x_values)\ndist = np.sqrt(x_1**2 + x_2**2)\nfalse_prob_values_GT = np.zeros(dist.shape)\nfalse_prob_values_GT[dist < 2.4] = 1.0\nplt.figure(1)\nplt.pcolormesh(x_1, x_2, false_prob_values_GT, cmap=\"RdBu\")\nplt.xlabel(\"x_1\")\nplt.ylabel(\"x_2\")\nplt.title(\"Predictive Density - Ground Truth\")\nplt.colorbar()\nplt.savefig(\"%s/predictive_density_GT.png\" % network.model_dir)\nplt.close(1)\nplt.figure(1)\nplt.pcolormesh(x_1, x_2, false_prob_values_GT, cmap=\"binary\")\nplt.xlabel(\"x_1\")\nplt.ylabel(\"x_2\")\nplt.title(\"Predictive Density - Ground Truth\")\nplt.colorbar()\nplt.savefig(\"%s/predictive_density_gray_GT.png\" % network.model_dir)\nplt.close(1)\n\nwith open(\"../HMC/false_prob_values.pkl\", \"rb\") as file: # (needed for python3)\n false_prob_values_HMC = pickle.load(file) # (shape: (60, 60))\nx_values = np.linspace(x_min, x_max, num_points, dtype=np.float32)\nx_1, x_2 = np.meshgrid(x_values, x_values)\nx_values_GT = np.linspace(x_min, x_max, 1000, dtype=np.float32)\nx_1_GT, x_2_GT = np.meshgrid(x_values_GT, x_values_GT)\nfig, axes = plt.subplots(nrows=1, ncols=2, constrained_layout=True, sharex=True, sharey=True, figsize=(11.0, 5.0))\nim = axes.flat[0].pcolormesh(x_1, x_2, false_prob_values_HMC, cmap=\"RdBu\", vmin=0, vmax=1)\nim = axes.flat[1].pcolormesh(x_1, x_2, false_prob_values, cmap=\"RdBu\", vmin=0, vmax=1)\nfig.colorbar(im, ax=axes.flat)\nplt.savefig(\"%s/predictive_density_comparison.png\" % network.model_dir)\nplt.close()\n"
] | [
[
"matplotlib.use",
"matplotlib.pyplot.colorbar",
"matplotlib.pyplot.pcolormesh",
"numpy.array",
"numpy.zeros",
"torch.nn.functional.softmax",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.savefig",
"matplotlib.pyplot.title",
"matplotlib.pyplot.close",
"matplotlib.pyplot.subplots",
"matplotlib.pyplot.figure",
"matplotlib.pyplot.ylabel",
"numpy.sqrt",
"torch.load",
"numpy.linspace",
"numpy.meshgrid"
]
] |
drunkpig/rlcard | [
"db8a410bbfefb7f9fd958239aae8d79a8bfb29d3"
] | [
"examples/uno_single.py"
] | [
"''' A toy example of training single-agent algorithm on Leduc Hold'em\n The environment can be treated as normal OpenAI gym style single-agent environment\n'''\n\nimport tensorflow as tf\nimport os\nimport numpy as np\n\nimport rlcard\nfrom rlcard.agents.dqn_agent import DQNAgent\nfrom rlcard.agents.random_agent import RandomAgent\nfrom rlcard.utils.utils import set_global_seed, tournament\nfrom rlcard.utils.logger import Logger\n\n# Make environment\nenv = rlcard.make('uno', config={'single_agent_mode':True})\neval_env = rlcard.make('uno', config={'single_agent_mode':True})\n\n# Set the iterations numbers and how frequently we evaluate the performance\nevaluate_every = 1000\nevaluate_num = 10000\ntimesteps = 100000\n\n# The intial memory size\nmemory_init_size = 1000\n\n# Train the agent every X steps\ntrain_every = 1\n\n# The paths for saving the logs and learning curves\nlog_dir = './experiments/uno_single_dqn_result/'\n\n# Set a global seed\nset_global_seed(0)\n\nwith tf.Session() as sess:\n\n # Initialize a global step\n global_step = tf.Variable(0, name='global_step', trainable=False)\n\n # Set up the agents\n agent = DQNAgent(sess,\n scope='dqn',\n action_num=env.action_num,\n replay_memory_init_size=memory_init_size,\n train_every=train_every,\n state_shape=env.state_shape,\n mlp_layers=[128,128])\n # Initialize global variables\n sess.run(tf.global_variables_initializer())\n\n # Init a Logger to plot the learning curve\n logger = Logger(log_dir)\n\n state = env.reset()\n\n for timestep in range(timesteps):\n action = agent.step(state)\n next_state, reward, done = env.step(action)\n ts = (state, action, reward, next_state, done)\n agent.feed(ts)\n\n if timestep % evaluate_every == 0:\n rewards = []\n state = eval_env.reset()\n for _ in range(evaluate_num):\n action, _ = agent.eval_step(state)\n _, reward, done = env.step(action)\n if done:\n rewards.append(reward)\n logger.log_performance(env.timestep, np.mean(rewards))\n\n # Close files in the logger\n logger.close_files()\n\n # Plot the learning curve\n logger.plot('DQN')\n \n # Save model\n save_dir = 'models/uno_single_dqn'\n if not os.path.exists(save_dir):\n os.makedirs(save_dir)\n saver = tf.train.Saver()\n saver.save(sess, os.path.join(save_dir, 'model'))\n \n"
] | [
[
"tensorflow.Session",
"tensorflow.Variable",
"tensorflow.train.Saver",
"numpy.mean",
"tensorflow.global_variables_initializer"
]
] |
noashin/local_global_attention_model | [
"531e6a4cc1dc364a6a4168de1b9f972727a8aeb1"
] | [
"src/LocalChoiceModel/vel_param.py"
] | [
"import sys\n\nimport numpy as np\nfrom scipy.stats import multivariate_normal\n\nsys.path.append('./../../')\nfrom src.HMC.hmcparameter import HMCParameter\n\nclass VelParam(HMCParameter):\n def __init__(self, init_val):\n super().__init__(np.array(init_val))\n dim = np.array(init_val).shape\n self.mu = np.zeros(dim)\n self.sigma = 1\n\n def gen_init_value(self):\n self.value = multivariate_normal.rvs(self.mu, self.sigma)\n\n def get_energy_grad(self):\n return self.value\n\n def get_energy(self):\n return np.dot(self.value, self.value) / 2\n\n def get_energy_for_value(self, value):\n return np.dot(value, value) / 2\n"
] | [
[
"numpy.array",
"numpy.dot",
"scipy.stats.multivariate_normal.rvs",
"numpy.zeros"
]
] |
ruriboshi/propnet | [
"770703fb4fc344f785f89c02f26b31ea5733d2bd"
] | [
"propnet/models/python/electromechanical_coupling.py"
] | [
"import numpy as np\n\n\ndef plug_in(symbol_values):\n\n req_symbols = [\"S\", \"e\", \"d\"]\n data = {}\n if all(s in symbol_values for s in req_symbols):\n e = symbol_values[\"e\"]\n S = symbol_values[\"S\"]\n d = symbol_values[\"d\"]\n\n data[\"k\"] = np.abs(d[2][2] / np.sqrt(e[2][2] * S[2][2]))\n\n return data\n\n\nDESCRIPTION = \"\"\"\nModel calculating the electromechanical coupling factor,\nwhich is the efficiency of converting eletrical energy\nto acoustic energy in a piezoeletric transducer or filter\n\"\"\"\n\ntest_data = [{\n \"inputs\": {\n \"S\": [[0.007482236755310126, -0.002827041595205337, -0.002827041595205337, 0.0, 0.0, 0.0],\n [-0.002827041595205337, 0.007482236755310125, -0.002827041595205337, 0.0, 0.0, 0.0],\n [-0.0028270415952053366, -0.002827041595205337, 0.007482236755310125, 0.0, 0.0, 0.0],\n [0.0, 0.0, 0.0, 0.010309278350515464, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.010309278350515464, 0.0],\n [0.0, 0.0, 0.0, 0.0, 0.0, 0.010309278350515464]],\n \"e\": [[18.65, 0.00, 0.00], [-0.00, 18.65, 0.00], [-0.00, 0.00, 7.88]],\n \"d\": [[-0.0412497, -0.28686697, 0.06342802], [0.05065159, 0.26064878, -0.04828778],\n [0.08828203, 0.5660897, -0.11520665], [-0.16218673, -0.92468949, 0.2109461],\n [0.02485558, 0.03232004, -0.02421919], [0.06636329, 0.46541895, -0.09526407]]\n },\n \"outputs\": {\n \"k\": 0.47445902984\n }\n}]\n\nconfig = {\n \"name\": \"electromechanical_coupling\",\n \"connections\": [{\n \"inputs\": [\"e\", \"S\", \"d\"],\n \"outputs\": [\"k\"]\n }],\n \"categories\": [\"mechanical\", \"electrical\"],\n \"variable_symbol_map\": {\n \"S\": \"compliance_tensor_voigt\",\n \"e\": \"dielectric_tensor\",\n \"d\": \"piezoelectric_tensor_converse\",\n \"k\": \"electromechanical_coupling\"\n },\n \"description\": DESCRIPTION,\n \"implemented_by\": [\"shyamd\"],\n \"references\": [],\n \"plug_in\": plug_in,\n \"test_data\": test_data\n}\n"
] | [
[
"numpy.sqrt"
]
] |
eduardojdiniz/Buzznauts | [
"8ac242a8d5309b4090a0f0b148ec275cac762bc0"
] | [
"analysis/baseline/s02_perform_encoding.py"
] | [
"#!/usr/bin/env python\n# coding=utf-8\n\nimport numpy as np\nimport os\nimport os.path as op\nimport argparse\nimport torch\nfrom Buzznauts.utils import load_dict, saveasnii, get_fmri, set_device\nfrom Buzznauts.analysis.baseline import get_activations, predict_fmri_fast\nfrom tqdm import tqdm\n\n\ndef main():\n description = 'Encoding model analysis for Algonauts 2021'\n parser = argparse.ArgumentParser(description=description)\n\n buzz_root = '/home/[email protected]/proj/Buzznauts'\n baseline = op.join(buzz_root, 'models/baseline')\n parser.add_argument('-rd', '--result_dir',\n help='saves predicted fMRI activity',\n default=op.join(baseline, 'results'),\n type=str)\n parser.add_argument('-ad', '--activations_dir',\n help='directory containing DNN activations',\n default=op.join(baseline, 'activations'),\n type=str)\n parser.add_argument('-model', '--model',\n help='model under which predicted fMRI will be saved',\n default='alexnet',\n type=str)\n _help = 'layer from which activations will be used to train & predict fMRI'\n parser.add_argument('-l', '--layer',\n help=_help,\n default='layer_5',\n type=str)\n parser.add_argument(\n '-sub', '--sub',\n help='subject number from which fMRI data will be used',\n default='sub04', type=str)\n parser.add_argument('-r', '--roi',\n help='brain region from which fMRI data will be used',\n default='EBA',\n type=str)\n _help = 'test or val, val returns mean correlation ' + \\\n 'by using 10% of training data for validation'\n parser.add_argument('-m', '--mode',\n help=_help,\n default='val',\n type=str)\n parser.add_argument('-fd', '--fmri_dir',\n help='directory containing fMRI activity',\n default=op.join(buzz_root, 'data/fmri'),\n type=str)\n parser.add_argument('-v', '--visualize',\n help='visualize whole brain in MNI space or not',\n default=True,\n type=bool)\n _help = 'number of voxel to fit at one time in case of memory constraints'\n parser.add_argument('-b', '--batch_size',\n help=_help,\n default=1000,\n type=int)\n args = vars(parser.parse_args())\n\n mode = args['mode']\n sub = args['sub']\n ROI = args['roi']\n model = args['model']\n layer = args['layer']\n visualize_results = args['visualize']\n batch_size = args['batch_size']\n\n device = set_device()\n\n if ROI == \"WB\":\n track = \"full_track\"\n else:\n track = \"mini_track\"\n\n activations_dir = op.join(args['activations_dir'], 'pca_100')\n fmri_dir = op.join(args['fmri_dir'], track)\n\n sub_fmri_dir = op.join(fmri_dir, sub)\n results_dir = op.join(args['result_dir'], model, layer, track, sub)\n if not op.exists(results_dir):\n os.makedirs(results_dir)\n\n print(\"ROi is : \", ROI)\n\n features_train, features_test = get_activations(activations_dir,\n layer)\n if track == \"full_track\":\n fmri_train_all, voxel_mask = get_fmri(sub_fmri_dir, ROI)\n else:\n fmri_train_all = get_fmri(sub_fmri_dir, ROI)\n num_voxels = fmri_train_all.shape[1]\n\n if mode == 'val':\n # Here as an example we use first 900 videos as training and rest of\n # the videos as validation\n features_test = features_train[900:, :]\n features_train = features_train[:900, :]\n fmri_train = fmri_train_all[:900, :]\n fmri_test = fmri_train_all[900:, :]\n pred_fmri = np.zeros_like(fmri_test)\n pred_fmri_save_path = op.join(results_dir, ROI + '_val.npy')\n else:\n fmri_train = fmri_train_all\n num_test_videos = 102\n pred_fmri = np.zeros((num_test_videos, num_voxels))\n pred_fmri_save_path = op.join(results_dir, ROI + '_test.npy')\n\n print(\"number of voxels is \", num_voxels)\n i = 0\n with tqdm(total=100) as pbar:\n while i < num_voxels - batch_size:\n j = i + batch_size\n pred_fmri[:, i:j] = predict_fmri_fast(features_train,\n features_test,\n fmri_train[:, i:j],\n device=device)\n i = j\n pbar.update((100*i) // num_voxels)\n pred_fmri[:, i:] = predict_fmri_fast(features_train,\n features_test,\n fmri_train[:, i:i + batch_size],\n device=device)\n\n if mode == 'val':\n score = vectorized_correlation(fmri_test, pred_fmri)\n print(\"Mean correlation for ROI : \", ROI, \"in \", sub, \" is :\",\n round(score.mean(), 6))\n\n # result visualization for whole brain (full_track)\n if track == \"full_track\" and visualize_results:\n brain_mask = op.join(buzz_root, 'data/fmri/example.nii')\n nii_save_path = op.join(results_dir, ROI + '_val.nii')\n\n view_args = {'brain_mask': brain_mask,\n 'nii_save_path': nii_save_path,\n 'score': score,\n 'voxel_mask': voxel_mask}\n\n view = visualize_activity_surf(sub, **view_args)\n view_save_path = op.join(results_dir, ROI + '_val.html')\n view.save_as_html(view_save_path)\n print(\"Results saved in this directory: \", results_dir)\n view.open_in_browser()\n\n np.save(pred_fmri_save_path, pred_fmri)\n\n print(\"ROI done : \", ROI)\n\n\nif __name__ == \"__main__\":\n main()\n"
] | [
[
"numpy.zeros_like",
"numpy.zeros",
"numpy.save"
]
] |
Anders-Holst/Bonsai | [
"841aa4e12c8bea8945396bd232c2006260127507"
] | [
"datapreparation/analyze.py"
] | [
"#! /usr/bin/env python3\n\n\n\"\"\" -------------------------------\n\n analyse.py\n\n Copyright (C) 2018 RISE\n This code was produced by RISE\n The 2013-04-10 version\n\n bonsai/src_v02/analyze.py\n\n simple analysis of pandas dataframes data\n such as \n\n 1. find duplicated rows\n\n 2. number of unique values in a column\n\n 3. number of unique values in common \n between two columns in two different\n files\n \n 4. \n \n------------------------------------\"\"\"\n\n\nimport global_settings as gs\nimport numpy as np\nimport pandas as pd\nimport bonsai_io as bio\nimport common\nimport copy\n\ndef nr_of_unique_rows(df):\n d = df.drop_duplicates()\n return len(d)\n\ndef nr_of_unique_values_in_cols(df, cols):\n c = df.drop_duplicates(subset = cols)\n return len(c)\n\n\ndef nr_of_unique_values(df, col):\n c = df[col].dropna()\n c = c.drop_duplicates()\n return len(c)\n\n\"\"\"\ndef nr_of_unique_numeric_values(df, col):\n\n c = df[col].dropna()\n c = c.drop_duplicates()\n c = c.str.isnumeric() \n c = c[c].index.values\n\"\"\"\n\n\ndef nr_of_nonnan_values(df, col):\n\n c = df[col].dropna()\n return len(c)\n \ndef nr_of_unique_digital_values(df, col):\n\n c = df[col].dropna()\n c = c.drop_duplicates()\n c = c.str.isdigit() \n c = c[c].index.values\n # df = df.drop_duplicates(subset = col)\n # df = df[ df[col].dropna().str.isdigit() ]\n # df = df[ df[col].str.contains('\\d', regex=True) ]\n return len(c)\n\ndef duplicated_rows(df):\n df['dup'] = df.duplicated()\n df = df[df['dup'] == True]\n return df\n\ndef print_duplicated_rows(df, nr):\n dup = duplicated_rows(df)\n print('Nr of rows in total', len(df))\n print('Nr of duplicated rows', len(dup))\n nr = min( nr,len(dup) )\n if nr > 0:\n print('the first', nr,' of them')\n print(dup[0:nr])\n return dup\n\ndef unique_number_values(df, col):\n df = df.drop_duplicates(subset = col)\n df = df[ df[col].str.contains('\\d', regex=True) ]\n return df\n\n\ndef info(df, name = ''):\n print()\n if name != '':\n print()\n print('--------------------------------------------------')\n print()\n print('\\tInfo on the file\\n\\t' + name)\n print()\n print('--------------------------------------------------')\n print()\n df_unique_nr = nr_of_unique_rows(df)\n print(' shape', df.shape)\n print(' unique rows', df_unique_nr)\n\n for c in df.columns:\n print()\n print('\\tInfo on non-nan values of column', c)\n print()\n nonnan_nr = nr_of_nonnan_values(df, c)\n unique_nr = nr_of_unique_values(df, c)\n digital_nr = nr_of_unique_digital_values(df, c)\n # numeric_nr = nr_of_unique_numeric_values(df, c)\n print('non-nan values', nonnan_nr)\n print(' unique values', unique_nr)\n print('digital values', digital_nr)\n # print('numeric values', unique_nr)\n \n print()\n # return unique_number_values(df, 'ICD10')\n\n# df = df[ df[c].str.contains('\\d', regex=True) ]\n\n\n\ndef readall():\n dia = bio.read_generated_dia()\n dgr = bio.read_diagroups()\n per = bio.readperson()\n ctr = bio.readcontrol()\n inc = bio.readincare()\n nic = bio.readnicare()\n dru = bio.readdrug()\n dcl = bio.readdrugclasses()\n tre = bio.readtreatment()\n sur = bio.readsurgery()\n cau = bio.readcause()\n\n data = [\n dia, \n dgr, \n per,\n ctr, \n inc, \n nic, \n dru, \n dcl, \n tre,\n sur,\n cau\n]\n\n name = [\n 'diagnos ',\n 'diagnosgrupp ',\n 'person ',\n 'kontrollgrupp ',\n 'sluten v_rd ',\n '_ppen v_rd ',\n 'l_kemedel ',\n 'l_kemedelsgrupper',\n 'behandling ',\n 'kirurgi ',\n 'orsak ',\n ]\n\n return data, name\n\n\ndef info_on_all():\n\n data, name = readall()\n \n for i in range(0, len(name)):\n info(data[i], name[i])\n\n\ndef compare_lopnr(dfx, dfy, namex = 'data 1', namey = 'data 2'):\n\n xs = list(dfx['LopNr'].values)\n ys = list(dfy['LopNr'].values)\n\n sx = set(xs)\n sy = set(ys)\n cut = sx & sy\n ux = sx - sy\n uy = sy - sx\n\n print()\n # print('shape ' + namex + '\\t\\t', dfx.shape)\n # print('shape ' + namey + '\\t\\t', dfy.shape)\n # print('unique Lopnr ' + namex + '\\t', len(xs))\n # print('unique Lopnr ' + namey + '\\t', len(ys))\n\n print('common Lopnr\\t\\t\\t', len(cut))\n print('Lopnr in ' + namex + ' only\\t', len(ux))\n print('Lopnr in ' + namey + ' only\\t', len(uy))\n print()\n\n ux = list(ux)\n uy = list(uy)\n ux.sort\n uy.sort\n return ux, uy\n\n\ndef readlopnr():\n dia = bio.read_generated_dia()\n per = bio.readperson()\n ctr = bio.readcontrol()\n inc = bio.readincare()\n nic = bio.readnicare()\n dru = bio.readdrug()\n tre = bio.readtreatment()\n sur = bio.readsurgery()\n cau = bio.readcause()\n\n data = [dia, per, ctr, inc, nic, dru, tre, sur, cau]\n\n name = [\n 'diagnos ',\n 'person ',\n 'kontrollgrupp',\n 'sluten v_rd ',\n '_ppen v_rd ',\n 'l_kemedel ',\n 'behandling ',\n 'kirurgi ',\n 'orsak ',\n ]\n\n return data, name\n\n\ndef pairwise_lopnr_comparisions():\n\n data, name = readlopnr()\n\n for i in range(0, len(name)):\n for j in range(i+1, len(name)):\n print()\n print('--------------------------------------------------')\n print()\n print('\\tComparing ' + name[i] + ' with ' + name[j])\n print()\n print('--------------------------------------------------')\n print()\n\n compare_lopnr(data[i], data[j], name[i], name[j])\n\n\n\n\n\n\"\"\" -------------------------------\n \n 4. count amd list various types of diagnosis\n codes in care data\n \n------------------------------------\"\"\"\n\n\"\"\"\ndef is_icd10_class(x):\n if not common.isstr(x):\n return False\n if common.is_icd10(x):\n return False\n if len(x) < 3:\n return False\n if not x[0].isupper():\n return False\n return x[1].isdigit() and x[2].isdigit()\n\"\"\"\n\n\ndef code_count(xs):\n if not isinstance(xs, str):\n return 0\n return len(xs.split())\n\ndef icd10_count(xs):\n if not isinstance(xs, str):\n return 0\n count = 0\n for x in xs.split():\n if common.is_icd10(x):\n # print(x)\n count += 1\n return count\n\ndef not_icd10_count(xs):\n if not isinstance(xs, str):\n return 0\n count = 0\n for x in xs.split():\n if not common.is_icd10(x):\n # print(x)\n count += 1\n return count\n\ndef icd10_class_count(xs):\n if not isinstance(xs, str):\n return 0\n count = 0\n for x in xs.split():\n if common.is_icd10_class(x):\n # print(x)\n count += 1\n return count\n\n\"\"\"\ndef code_list(xs):\n if not isinstance(xs, str):\n return 0\n return len(xs.split())\n\"\"\"\n\ndef count_and_print(df, table = False):\n dia = 'DIAGNOS'\n dfc = copy.copy(df)\n dfc['code_count'] = df[dia].apply(code_count)\n dfc['icd10_count'] = df[dia].apply(icd10_count)\n dfc['not_icd10_count'] = df[dia].apply(not_icd10_count)\n dfc['icd10_class_count'] = df[dia].apply(icd10_class_count)\n nr_of_codes = dfc['code_count'].sum()\n nr_of_icd10 = dfc['icd10_count'].sum()\n nr_of_not_icd10 = dfc['not_icd10_count'].sum()\n nr_of_class_codes = dfc['icd10_class_count'].sum()\n\n if table:\n print('nr_of_lines\\t', len(df))\n print('nr_of_codes\\t', nr_of_codes)\n print('nr_of_icd10\\t', nr_of_icd10)\n print('nr_of_not_icd10\\t', nr_of_not_icd10)\n print('nr_of_icd10_class_codes\\t', nr_of_class_codes)\n \n else:\n \n \n print(' nr_of_lines', len(df))\n print(' nr_of_codes', nr_of_codes)\n print(' nr_of_icd10', nr_of_icd10)\n print(' nr_of_not_icd10', nr_of_not_icd10)\n print(' nr_of_icd10_class_codes', nr_of_class_codes)\n\n\n \"\"\"\n for c in df1[dia].values:\n print('\\t', c)\n \"\"\"\n\n\ndef print_dates(df, table = False):\n date = 'INDATUM'\n\n if table:\n\n print('first date\\t', df[date].min())\n print('last date\\t', df[date].max())\n\n else:\n\n print(' first date', df[date].min())\n print(' last date', df[date].max())\n \n\ndef icd10_class_list(xs):\n if not isinstance(xs, str):\n return []\n codes = []\n for x in xs.split():\n if common.is_icd10_class(x):\n codes += [x]\n #print(codes)\n return codes\n\ndef flat(xs):\n ys = []\n for x in xs:\n ys += x\n return ys\n\n \n\ndef print_class_codes(df):\n dia = 'DIAGNOS'\n dfc = copy.copy(df)\n dfc['icd10_class'] = df[dia].apply(icd10_class_list)\n dfc['is_class'] = dfc['icd10_class'].apply(lambda x: x != [])\n dfc = dfc[dfc['is_class']]\n codes = np.unique(flat(list(dfc['icd10_class'].values)))\n for c in codes:\n print('\\t', c)\n \n\ndef diagnosis_code_count(df, print_class = False, table = False):\n \n date = 'INDATUM'\n nr = 'LopNr'\n icd10_start = np.datetime64('1998-01-01')\n\n \"\"\"\n size0 = len(df)\n df = df.dropna().reset_index(drop=True)\n print('nr of empty lines:', size0- len(df))\n \"\"\"\n \n df[date] = df[date].apply(bio.str2time)\n df = df.sort_values(date).dropna().reset_index(drop=True)\n\n df1 = df[df[date] < icd10_start] \n df2 = df[df[date] >= icd10_start]\n\n print() \n print('code counts before 1998_01_01:')\n print()\n \n print_dates(df1, table = table)\n count_and_print(df1, table = table)\n\n print() \n print('code counts from 1998_01_01')\n print()\n \n print_dates(df2, table = table)\n count_and_print(df2, table = table)\n if print_class:\n print()\n print(' all icd10_class_codes:')\n print_class_codes(df2)\n\n print()\n"
] | [
[
"numpy.datetime64"
]
] |
vinayak1998/Data_Driven_Astronomy | [
"1d0dd82b2e9066759c442807c30c70bef096d719"
] | [
"Week1/brightest_pixel_position_fits.py"
] | [
"import numpy as np\nimport time\nfrom astropy.io import fits\nimport matplotlib.pyplot as plt\n\ndef load_fits(filename):\n start = time.perf_counter()\n hdulist = fits.open(filename)\n data = hdulist[0].data\n result = np.where(data == np.amax(data))\n coornidates = list(zip(result[0],result[1]))\n end = time.perf_counter() - start\n return coornidates[0]\n \nif __name__ == '__main__':\n # Run your `load_fits` function with examples:\n bright = load_fits('image1.fits')\n print(bright)\n\n # You can also confirm your result visually:\n from astropy.io import fits\n import matplotlib.pyplot as plt\n\n hdulist = fits.open('image1.fits')\n data = hdulist[0].data\n\n # Plot the 2D image data\n plt.imshow(data.T, cmap=plt.cm.viridis)\n plt.colorbar()\n plt.show()"
] | [
[
"matplotlib.pyplot.show",
"matplotlib.pyplot.colorbar",
"numpy.amax",
"matplotlib.pyplot.imshow"
]
] |
anaikawadi/svbrdf-estimation | [
"6c169b12210d2a92495c1ab1218dd3e4da0314a5"
] | [
"development/multiImage_pytorch/persistence.py"
] | [
"import gc\nimport json\nimport pathlib\nimport torch\n\nclass Checkpoint:\n def __init__(self, checkpoint=None):\n self.checkpoint = checkpoint\n\n @staticmethod\n def get_checkpoint_path(checkpoint_dir):\n return checkpoint_dir.joinpath(\"checkpoint.tar\")\n\n @staticmethod\n def load_legacy(model_dir):\n model_path = model_dir.joinpath(\"model.data\")\n state_path = model_dir.joinpath(\"state.json\")\n if not model_path.exists():\n return None\n \n checkpoint = {\n 'model_state_dict' : torch.load(model_path),\n }\n print(\"Loaded legacy model state\")\n\n if state_path.exists():\n with open(state_path, 'r') as f:\n state = json.load(f)\n checkpoint['epoch'] = state['epoch']\n print(\"Loaded legacy training state\")\n\n return checkpoint \n\n @classmethod\n def load(cls, checkpoint_dir):\n if not isinstance(checkpoint_dir, pathlib.Path):\n checkpoint_dir = pathlib.Path(checkpoint_dir)\n \n checkpoint_path = Checkpoint.get_checkpoint_path(checkpoint_dir)\n\n if not checkpoint_path.exists():\n # If there is no checkpoint file we try to perform a legacy load\n checkpoint = Checkpoint.load_legacy(checkpoint_dir)\n\n if checkpoint is None:\n print(\"No checkpoint found in directory '{}'\".format(checkpoint_dir))\n\n return cls(checkpoint)\n\n return cls(torch.load(checkpoint_path))\n\n @staticmethod\n def save(checkpoint_dir, args, model, optimizer, epoch):\n if not isinstance(checkpoint_dir, pathlib.Path):\n checkpoint_dir = pathlib.Path(checkpoint_dir)\n\n checkpoint_dir.mkdir(parents=True, exist_ok=True)\n\n checkpoint = {\n 'model_type' : args.model_type,\n 'use_coords' : True if args.use_coords else False,\n 'epoch' : epoch,\n 'model_state_dict': model.state_dict(),\n }\n\n if not args.omit_optimizer_state_save:\n checkpoint['optimizer_state_dict'] = optimizer.state_dict()\n\n torch.save(checkpoint, Checkpoint.get_checkpoint_path(checkpoint_dir))\n\n def purge(self):\n self.checkpoint = None\n gc.collect()\n\n def is_valid(self):\n return self.checkpoint is not None\n\n def restore_args(self, args):\n # Restore checkpoint relevant arguments\n\n if 'model_type' in self.checkpoint:\n args.model_type = self.checkpoint['model_type']\n print(\"Restored model type '{}'\".format(args.model_type))\n else:\n print(\"Failed to restore model type\")\n\n \n if 'use_coords' in self.checkpoint:\n args.use_coords = self.checkpoint['use_coords']\n print(\"Restored use coords flag '{}'\".format(args.use_coords))\n else:\n print(\"Failed to restore use coords flag\")\n\n return args\n\n def restore_model_state(self, model):\n if 'model_state_dict' in self.checkpoint:\n model.load_state_dict(self.checkpoint['model_state_dict'])\n print(\"Restored model state\")\n else:\n print(\"Failed to restore model state\")\n\n return model\n\n def restore_epoch(self, epoch):\n if 'epoch' in self.checkpoint:\n epoch = self.checkpoint['epoch']\n print(\"Restored epoch {}\".format(epoch))\n else:\n print(\"Failed to restore epoch\")\n \n return epoch\n\n def restore_optimizer_state(self, optimizer):\n if 'optimizer_state_dict' in self.checkpoint:\n optimizer.load_state_dict(self.checkpoint['optimizer_state_dict'])\n print(\"Restored optimizer state\")\n else:\n print(\"Failed to restore optimizer state\")\n\n return optimizer\n\n"
] | [
[
"torch.load"
]
] |
kobakobashu/posenet-python | [
"52290733504fd0a130cc2301bad5db761c14a4e9"
] | [
"models/helper.py"
] | [
"# -*- coding: utf-8 -*-\n\"\"\"Models helper\n\nThese are helper functions for models.\n\n\"\"\"\n\nimport torch.optim as optim\nimport torch.nn as nn\n\nfrom configs.supported_info import SUPPORTED_OPTIMIZER, SUPPORTED_CRITERION\n\n\ndef get_optimizer(cfg: object, network: object) -> object:\n \"\"\"Get optimizer function\n\n This is function to get optimizer.\n\n Args:\n cfg: Config of optimizer.\n network: Network of model.\n\n Returns:\n Optimizer object.\n\n Raises:\n NotImplementedError: If the optimizer you want to use is not suppoeted.\n\n \"\"\"\n \n optimizer_name = cfg.name\n\n if not optimizer_name:\n return None\n\n if optimizer_name not in SUPPORTED_OPTIMIZER:\n raise NotImplementedError('The optimizer is not supported.')\n\n if optimizer_name == \"adam\":\n return optim.Adam(network.parameters(),\n lr=cfg.lr,\n weight_decay=cfg.decay)\n\n\ndef get_criterion(cfg: object) -> object:\n \"\"\"Get criterion function\n\n This is function to get criterion.\n\n Args:\n cfg: Config of criterion.\n\n Returns:\n Criterion object.\n\n Raises:\n NotImplementedError: If the criterion you want to use is not suppoeted.\n\n \"\"\"\n \n criterion_name = cfg.name\n\n if not criterion_name:\n return None\n\n if criterion_name not in SUPPORTED_CRITERION:\n raise NotImplementedError('The loss function is not supported.')\n\n if criterion_name == \"cross_entropy\":\n return nn.CrossEntropyLoss()\n\n elif criterion_name == \"nll_loss\":\n return nn.NLLLoss()"
] | [
[
"torch.nn.NLLLoss",
"torch.nn.CrossEntropyLoss"
]
] |
zhangziyezzy/DeepLearningMugenKnock | [
"26830fe049c7da8001977ca0df12e946c0f030eb",
"26830fe049c7da8001977ca0df12e946c0f030eb"
] | [
"Scripts_Model/scripts_pytorch/VGG19_pytorch.py",
"Scripts_Model/scripts_pytorch/DenseNet169_pytorch.py"
] | [
"import torch\nimport torch.nn.functional as F\nimport numpy as np\nfrom collections import OrderedDict\nfrom easydict import EasyDict\nfrom _main_base import main\nimport os\n\n#---\n# config\n#---\ncfg = EasyDict()\n\n# class\ncfg.CLASS_LABEL = ['akahara', 'madara']\ncfg.CLASS_NUM = len(cfg.CLASS_LABEL)\n\n# model\ncfg.INPUT_HEIGHT = 64\ncfg.INPUT_WIDTH = 64\ncfg.INPUT_CHANNEL = 3\n\ncfg.GPU = False\ncfg.DEVICE = torch.device(\"cuda\" if cfg.GPU and torch.cuda.is_available() else \"cpu\")\n\ncfg.MODEL_SAVE_PATH = 'models/VGG16_{}.pt'\ncfg.MODEL_SAVE_INTERVAL = 200\ncfg.ITERATION = 1000\ncfg.MINIBATCH = 8\ncfg.OPTIMIZER = torch.optim.SGD\ncfg.LEARNING_RATE = 0.1\ncfg.MOMENTUM = 0.9\ncfg.LOSS_FUNCTION = loss_fn = torch.nn.NLLLoss()\n\ncfg.TRAIN = EasyDict()\ncfg.TRAIN.DISPAY_ITERATION_INTERVAL = 50\n\ncfg.TRAIN.DATA_PATH = '../Dataset/train/images/'\ncfg.TRAIN.DATA_HORIZONTAL_FLIP = True\ncfg.TRAIN.DATA_VERTICAL_FLIP = True\ncfg.TRAIN.DATA_ROTATION = False\n\ncfg.TEST = EasyDict()\ncfg.TEST.MODEL_PATH = cfg.MODEL_SAVE_PATH.format('final')\ncfg.TEST.DATA_PATH = '../Dataset/test/images/'\ncfg.TEST.MINIBATCH = 2\n\n# random seed\ntorch.manual_seed(0)\n\n\nclass VGG19(torch.nn.Module):\n def __init__(self):\n super(VGG19, self).__init__()\n\n self.conv1 = torch.nn.Sequential(OrderedDict({\n 'conv1_1' : torch.nn.Conv2d(cfg.INPUT_CHANNEL, 64, kernel_size=3, padding=1, stride=1),\n 'conv1_1_relu' : torch.nn.ReLU(),\n 'conv1_1_bn' : torch.nn.BatchNorm2d(64),\n 'conv1_2' : torch.nn.Conv2d(64, 64, kernel_size=3, padding=1, stride=1),\n 'conv1_2_relu' : torch.nn.ReLU(),\n 'conv1_2_bn' : torch.nn.BatchNorm2d(64),\n }))\n\n self.conv2 = torch.nn.Sequential(OrderedDict({\n 'conv2_1' : torch.nn.Conv2d(64, 128, kernel_size=3, padding=1, stride=1),\n 'conv2_1_relu' : torch.nn.ReLU(),\n 'conv2_1_bn' : torch.nn.BatchNorm2d(128),\n 'conv2_2' : torch.nn.Conv2d(128, 128, kernel_size=3, padding=1, stride=1),\n 'conv2_2_relu' : torch.nn.ReLU(),\n 'conv2_2_bn' : torch.nn.BatchNorm2d(128),\n }))\n\n self.conv3 = torch.nn.Sequential(OrderedDict({\n 'conv3_1' : torch.nn.Conv2d(128, 256, kernel_size=3, padding=1, stride=1),\n 'conv3_1_relu' : torch.nn.ReLU(),\n 'conv3_1_bn' : torch.nn.BatchNorm2d(256),\n 'conv3_2' : torch.nn.Conv2d(256, 256, kernel_size=3, padding=1, stride=1),\n 'conv3_2_relu' : torch.nn.ReLU(),\n 'conv3_2_bn' : torch.nn.BatchNorm2d(256),\n 'conv3_3' : torch.nn.Conv2d(256, 256, kernel_size=3, padding=1, stride=1),\n 'conv3_3_relu' : torch.nn.ReLU(),\n 'conv3_3_bn' : torch.nn.BatchNorm2d(256),\n 'conv3_4' : torch.nn.Conv2d(256, 256, kernel_size=3, padding=1, stride=1),\n 'conv3_4_relu' : torch.nn.ReLU(),\n 'conv3_4_bn' : torch.nn.BatchNorm2d(256),\n }))\n\n self.conv4 = torch.nn.Sequential(OrderedDict({\n 'conv4_1' : torch.nn.Conv2d(256, 512, kernel_size=3, padding=1, stride=1),\n 'conv4_1_relu' : torch.nn.ReLU(),\n 'conv4_1_bn' : torch.nn.BatchNorm2d(512),\n 'conv4_2' : torch.nn.Conv2d(512, 512, kernel_size=3, padding=1, stride=1),\n 'conv4_2_relu' : torch.nn.ReLU(),\n 'conv4_2_bn' : torch.nn.BatchNorm2d(512),\n 'conv4_3' : torch.nn.Conv2d(512, 512, kernel_size=3, padding=1, stride=1),\n 'conv4_3_relu' : torch.nn.ReLU(),\n 'conv4_3_bn' : torch.nn.BatchNorm2d(512),\n 'conv4_4' : torch.nn.Conv2d(512, 512, kernel_size=3, padding=1, stride=1),\n 'conv4_4_relu' : torch.nn.ReLU(),\n 'conv4_4_bn' : torch.nn.BatchNorm2d(512),\n }))\n\n self.conv5 = torch.nn.Sequential(OrderedDict({\n 'conv5_1' : torch.nn.Conv2d(512, 512, kernel_size=3, padding=1, stride=1),\n 'conv5_1_relu' : torch.nn.ReLU(),\n 'conv5_1_bn' : torch.nn.BatchNorm2d(512),\n 'conv5_2' : torch.nn.Conv2d(512, 512, kernel_size=3, padding=1, stride=1),\n 'conv5_2_relu' : torch.nn.ReLU(),\n 'conv5_2_bn' : torch.nn.BatchNorm2d(512),\n 'conv5_3' : torch.nn.Conv2d(512, 512, kernel_size=3, padding=1, stride=1),\n 'conv5_3_relu' : torch.nn.ReLU(),\n 'conv5_3_bn' : torch.nn.BatchNorm2d(512),\n 'conv5_3' : torch.nn.Conv2d(512, 512, kernel_size=3, padding=1, stride=1),\n 'conv5_3_relu' : torch.nn.ReLU(),\n 'conv5_3_bn' : torch.nn.BatchNorm2d(512),\n }))\n \n self.top = torch.nn.Sequential(OrderedDict({\n 'Dense1' : torch.nn.Linear(512 * (cfg.INPUT_HEIGHT // 32) * (cfg.INPUT_WIDTH // 32), 256),\n 'Dense1_relu' : torch.nn.ReLU(),\n 'Dense1_dropout' : torch.nn.Dropout(p=0.5),\n 'Dense2' : torch.nn.Linear(256, 256),\n 'Dense2_relu' : torch.nn.ReLU(),\n 'Dense2_dropout' : torch.nn.Dropout(p=0.5),\n }))\n\n self.fc_out = torch.nn.Linear(256, cfg.CLASS_NUM)\n \n\n def forward(self, x):\n # block conv1\n x = self.conv1(x)\n x = F.max_pool2d(x, 2, stride=2, padding=0)\n\n # block conv2\n x = self.conv2(x)\n x = F.max_pool2d(x, 2, stride=2, padding=0)\n\n # block conv3\n x = self.conv3(x)\n x = F.max_pool2d(x, 2, stride=2, padding=0)\n\n # block conv4\n x = self.conv4(x)\n x = F.max_pool2d(x, 2, stride=2, padding=0)\n\n # block conv5\n x = self.conv5(x)\n x = F.max_pool2d(x, 2, stride=2, padding=0)\n \n x = x.view(x.shape[0], -1)\n x = self.top(x)\n x = self.fc_out(x)\n x = F.softmax(x, dim=1)\n return x\n\n# main\nif __name__ == '__main__':\n\n model_save_dir = '/'.join(cfg.MODEL_SAVE_PATH.split('/')[:-1])\n os.makedirs(model_save_dir, exist_ok=True)\n\n main(cfg, VGG19())",
"import torch\nimport torch.nn.functional as F\nimport numpy as np\nfrom collections import OrderedDict\nfrom easydict import EasyDict\nfrom _main_base import main\nimport os\n\n#---\n# config\n#---\ncfg = EasyDict()\n\n# class\ncfg.CLASS_LABEL = ['akahara', 'madara']\ncfg.CLASS_NUM = len(cfg.CLASS_LABEL)\n\n# model\ncfg.INPUT_HEIGHT = 64\ncfg.INPUT_WIDTH = 64\ncfg.INPUT_CHANNEL = 3\n\ncfg.GPU = False\ncfg.DEVICE = torch.device(\"cuda\" if cfg.GPU and torch.cuda.is_available() else \"cpu\")\n\ncfg.MODEL_SAVE_PATH = 'models/DenseNet169_{}.pt'\ncfg.MODEL_SAVE_INTERVAL = 200\ncfg.ITERATION = 1000\ncfg.MINIBATCH = 8\ncfg.OPTIMIZER = torch.optim.SGD\ncfg.LEARNING_RATE = 0.01\ncfg.MOMENTUM = 0.9\ncfg.LOSS_FUNCTION = loss_fn = torch.nn.NLLLoss()\n\ncfg.TRAIN = EasyDict()\ncfg.TRAIN.DISPAY_ITERATION_INTERVAL = 50\n\ncfg.TRAIN.DATA_PATH = '../Dataset/train/images/'\ncfg.TRAIN.DATA_HORIZONTAL_FLIP = True\ncfg.TRAIN.DATA_VERTICAL_FLIP = True\ncfg.TRAIN.DATA_ROTATION = False\n\ncfg.TEST = EasyDict()\ncfg.TEST.MODEL_PATH = cfg.MODEL_SAVE_PATH.format('final')\ncfg.TEST.DATA_PATH = '../Dataset/test/images/'\ncfg.TEST.MINIBATCH = 2\n\n# random seed\ntorch.manual_seed(0)\n\n\nclass DenseNet169(torch.nn.Module):\n def __init__(self):\n super(DenseNet169, self).__init__()\n\n class Block(torch.nn.Module):\n def __init__(self, first_dim, k=32, L=6):\n super(Block, self).__init__()\n self.L = L\n self.blocks = torch.nn.ModuleList()\n self.blocks.append(torch.nn.Sequential(\n torch.nn.BatchNorm2d(first_dim),\n torch.nn.ReLU(),\n torch.nn.Conv2d(first_dim, k, kernel_size=1, padding=0, stride=1),\n torch.nn.BatchNorm2d(k),\n torch.nn.ReLU(),\n torch.nn.Conv2d(k, k, kernel_size=3, padding=1, stride=1),\n ))\n \n for i in range(1, L):\n self.blocks.append(torch.nn.Sequential(\n torch.nn.BatchNorm2d(k * i + first_dim),\n torch.nn.ReLU(),\n torch.nn.Conv2d(k * i + first_dim, k, kernel_size=1, padding=0, stride=1),\n torch.nn.BatchNorm2d(k),\n torch.nn.ReLU(),\n torch.nn.Conv2d(k, k, kernel_size=3, padding=1, stride=1),\n ))\n \n def forward(self, x):\n xs = [None for _ in range(self.L + 1)]\n xs[0] = x\n xs[1] = self.blocks[0](x)\n \n for i in range(1, self.L):\n x_in = xs[i]\n for j in range(i):\n x_in = torch.cat([x_in, xs[j]], dim=1)\n x = self.blocks[i](x_in)\n xs[i + 1] = x\n \n x = xs[0]\n for i in range(1, (self.L + 1)):\n x = torch.cat([x, xs[i]], dim=1)\n\n return x\n\n k = 32\n theta = 0.5\n self.bn1 = torch.nn.BatchNorm2d(cfg.INPUT_CHANNEL)\n self.conv1 = torch.nn.Conv2d(cfg.INPUT_CHANNEL, k * 2, kernel_size=7, padding=3, stride=2)\n \n # Dense block1\n block1_L = 6\n block1_dim = int(k * block1_L * theta)\n \n self.block1 = Block(first_dim = k * 2, L = block1_L)\n \n # Transition layer1\n self.transition1 = torch.nn.Sequential(\n torch.nn.BatchNorm2d(k * block1_L + k * 2),\n torch.nn.ReLU(),\n torch.nn.Conv2d(k * block1_L + k * 2, block1_dim, kernel_size=1, padding=0, stride=1),\n torch.nn.AvgPool2d(2, stride=2, padding=0)\n )\n \n # Dense block2\n block2_L = 12\n block2_dim = int(k * block2_L * theta)\n \n self.block2 = Block(first_dim = block1_dim, L = block2_L)\n\n # Transition layer2 \n self.transition2 = torch.nn.Sequential(\n torch.nn.BatchNorm2d(k * block2_L + block1_dim),\n torch.nn.ReLU(),\n torch.nn.Conv2d(k * block2_L + block1_dim, block2_dim, kernel_size=1, padding=0, stride=1),\n torch.nn.AvgPool2d(2, stride=2, padding=0)\n )\n \n # Dense block3\n block3_L = 32\n block3_dim = int(k * block3_L * theta)\n \n self.block3 = Block(first_dim = block2_dim, L = block3_L)\n \n # Transition layer3\n self.transition3 = torch.nn.Sequential(\n torch.nn.BatchNorm2d(k * block3_L + block2_dim),\n torch.nn.ReLU(),\n torch.nn.Conv2d(k * block3_L + block2_dim, block3_dim, kernel_size=1, padding=0, stride=1),\n torch.nn.AvgPool2d(2, stride=2, padding=0)\n )\n \n # Dense block4\n block4_L = 32\n self.block4 = Block(first_dim = block3_dim, L = block4_L)\n \n self.linear = torch.nn.Linear(k * block4_L + block3_dim, cfg.CLASS_NUM)\n \n \n def forward(self, x):\n # Entry flow\n x = self.bn1(x)\n x = F.relu(x)\n x = self.conv1(x)\n \n x = F.max_pool2d(x, 3, padding=1, stride=2)\n \n x = self.block1(x)\n \n x = self.transition1(x)\n \n x = self.block2(x)\n \n x = self.transition2(x)\n \n x = self.block3(x)\n \n x = self.transition3(x)\n \n x = self.block4(x)\n\n x = F.avg_pool2d(x, [cfg.INPUT_HEIGHT // 32, cfg.INPUT_WIDTH // 32], padding=0, stride=1)\n x = x.view(x.size()[0], -1)\n x = self.linear(x)\n x = F.softmax(x, dim=1)\n \n return x\n\n# main\nif __name__ == '__main__':\n\n model_save_dir = '/'.join(cfg.MODEL_SAVE_PATH.split('/')[:-1])\n os.makedirs(model_save_dir, exist_ok=True)\n\n main(cfg, DenseNet169())"
] | [
[
"torch.nn.NLLLoss",
"torch.nn.Linear",
"torch.nn.Dropout",
"torch.nn.BatchNorm2d",
"torch.manual_seed",
"torch.nn.ReLU",
"torch.nn.Conv2d",
"torch.cuda.is_available",
"torch.nn.functional.softmax",
"torch.nn.functional.max_pool2d"
],
[
"torch.nn.NLLLoss",
"torch.nn.Linear",
"torch.cat",
"torch.nn.functional.avg_pool2d",
"torch.nn.ModuleList",
"torch.nn.AvgPool2d",
"torch.nn.BatchNorm2d",
"torch.manual_seed",
"torch.nn.ReLU",
"torch.nn.Conv2d",
"torch.cuda.is_available",
"torch.nn.functional.softmax",
"torch.nn.functional.relu",
"torch.nn.functional.max_pool2d"
]
] |
DionysisChristopoulos/google-research | [
"7f59ef421beef32ca16c2a7215be74f7eba01a0f",
"eb2b142f26e39aac1dcbb768417465ae9d4e5af6",
"7cee4b22b925581d912e8d993625c180da2a5a4f",
"7cee4b22b925581d912e8d993625c180da2a5a4f",
"7cee4b22b925581d912e8d993625c180da2a5a4f",
"7cee4b22b925581d912e8d993625c180da2a5a4f",
"7f59ef421beef32ca16c2a7215be74f7eba01a0f",
"7cee4b22b925581d912e8d993625c180da2a5a4f",
"7f59ef421beef32ca16c2a7215be74f7eba01a0f",
"7cee4b22b925581d912e8d993625c180da2a5a4f",
"7cee4b22b925581d912e8d993625c180da2a5a4f",
"7cee4b22b925581d912e8d993625c180da2a5a4f",
"7f59ef421beef32ca16c2a7215be74f7eba01a0f"
] | [
"blur/synapse_util.py",
"scann/scann/scann_ops/py/scann_ops.py",
"social_rl/multiagent_tfagents/multiagent_metrics.py",
"pse/dm_control/run_train_eval.py",
"pse/jumping_task/evaluation_helpers.py",
"dp_multiq/csmooth.py",
"meta_pseudo_labels/training_utils.py",
"es_enas/util.py",
"non_semantic_speech_benchmark/data_prep/count_duration_beam.py",
"covid_epidemiology/colab_utils.py",
"readtwice/layers/transformer.py",
"poem/core/tfe_input_layer.py",
"smu/parser/smu_utils_lib_test.py"
] | [
"# coding=utf-8\n# Copyright 2021 The Google Research 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\"\"\"Utilities for synapse handling.\"\"\"\n\nimport enum\nimport functools as ft\nfrom typing import Callable, List, Sequence, Text, Union, Optional\nimport dataclasses as dc\n\nimport jax.numpy as jp\nimport numpy as np\nimport tensorflow.compat.v1 as tf\n\nfrom blur import blur_env\n\nTensorShape = tf.TensorShape\nTensor = Union[tf.Tensor, np.ndarray, jp.array]\n\n\[email protected]\nclass SynapseInitializerParams:\n shape: TensorShape\n in_neurons: int\n out_neurons: int\n\n\nclass UpdateType(enum.Enum):\n FORWARD = 1\n BACKWARD = 2\n BOTH = 3\n NONE = 4\n\n\nSynapseInitializer = Callable[[SynapseInitializerParams], Tensor]\n\n# A callable that takes a sequence of layers and SynapseInitializer and creates\n# appropriately shaped list of Synapses.\nCreateSynapseFn = Callable[[Sequence[Tensor], SynapseInitializer], List[Tensor]]\n\n\ndef random_uniform_symmetric(shape, seed):\n return (tf.random.uniform(shape, seed=seed) - 0.5) * 2\n\n\ndef random_initializer(start_seed=0, scale_by_channels=False,\n scale=1, bias=0, random_fn=random_uniform_symmetric):\n \"\"\"Returns initializer that generates random sequence.\"\"\"\n seed = [hash(str(start_seed))]\n def impl(params):\n if len(params.shape) >= 3:\n # shape: species x (in+out) x (in+out) x states\n num_channels = int(params.shape[-2])\n seed[0] += 1\n v = random_fn(params.shape, seed[0])\n apply_scale = scale(params) if callable(scale) else scale\n r = v * apply_scale + bias\n if scale_by_channels:\n r = r / (num_channels ** 0.5)\n return r\n return impl\n\n\ndef _random_uniform_fn(start_seed):\n rng = np.random.RandomState(start_seed)\n return lambda shape: tf.constant(rng.uniform( # pylint: disable=g-long-lambda\n low=-1, high=1, size=shape), dtype=np.float32)\n\n\ndef fixed_random_initializer(start_seed=0,\n scale_by_channels=False,\n scale=1,\n bias=0,\n random_fn=None):\n \"\"\"Returns an initializer that generates random (but fixed) sequence.\n\n The resulting tensors are backed by a constant so they produce the same\n value across all calls.\n\n This initializer uses its own random state that is independent of default\n random sequence.\n\n Args:\n start_seed: initial seed passed to np.random.RandomStates\n scale_by_channels: whether to scale by number of channels.\n scale: target scale (default: 1)\n bias: mean of the resulting distribution.\n random_fn: random generator if none will use use _random_uniform_fn\n Returns:\n callable that accepts shape and returns tensorflow constant tensor.\n \"\"\"\n if random_fn is None:\n random_fn = _random_uniform_fn(start_seed)\n\n def impl(params):\n if len(params.shape) >= 3:\n # shape: species x (in+out) x (in+out) x states\n num_channels = int(params.shape[-2])\n v = random_fn(shape=params.shape)\n apply_scale = scale(params) if callable(scale) else scale\n r = v * apply_scale + bias\n if scale_by_channels:\n r = r / (num_channels ** 0.5)\n return r\n\n return impl\n\n\ndef create_synapse_init_fns(\n layers,\n initializer):\n \"\"\"Generates network synapse initializers.\n\n Arguments:\n layers: Sequence of network layers (used for shape calculation).\n initializer: SynapseInitializer used to initialize synapse tensors.\n\n Returns:\n A list of functions that produce synapse tensors for all layers upon\n execution.\n \"\"\"\n synapse_init_fns = []\n for pre, post in zip(layers, layers[1:]):\n # shape: population_dims, batch_size, in_channels, neuron_state\n pop_dims = pre.shape[:-3]\n # -2: is the number of channels\n num_inputs = pre.shape[-2] + post.shape[-2] + 1\n # -1: is the number of states in a single neuron.\n synapse_shape = (*pop_dims, num_inputs, num_inputs, pre.shape[-1])\n params = SynapseInitializerParams(\n shape=synapse_shape,\n in_neurons=pre.shape[-2],\n out_neurons=post.shape[-2])\n synapse_init_fns.append(ft.partial(initializer, params))\n return synapse_init_fns\n\n\ndef create_synapses(layers,\n initializer):\n \"\"\"Generates arbitrary form synapses.\n\n Arguments:\n layers: Sequence of network layers (used for shape calculation).\n initializer: SynapseInitializer used to initialize synapse tensors.\n\n Returns:\n A list of created synapse tensors for all layers.\n \"\"\"\n return [init_fn() for init_fn in create_synapse_init_fns(layers, initializer)]\n\n\ndef transpose_synapse(synapse, env):\n num_batch_dims = len(synapse.shape[:-3])\n perm = [\n *range(num_batch_dims), num_batch_dims + 1, num_batch_dims,\n num_batch_dims + 2\n ]\n return env.transpose(synapse, perm)\n\n\ndef synapse_submatrix(synapse,\n in_channels,\n update_type,\n include_bias = True):\n \"\"\"Returns a submatrix of a synapse matrix given the update type.\"\"\"\n bias = 1 if include_bias else 0\n if update_type == UpdateType.FORWARD:\n return synapse[Ellipsis, :(in_channels + bias), (in_channels + bias):, :]\n if update_type == UpdateType.BACKWARD:\n return synapse[Ellipsis, (in_channels + 1):, :(in_channels + bias), :]\n\n\ndef combine_in_out_synapses(in_out_synapse, out_in_synapse,\n env):\n \"\"\"Combines forward and backward synapses into a single matrix.\"\"\"\n batch_dims = in_out_synapse.shape[:-3]\n out_channels, in_channels, num_states = in_out_synapse.shape[-3:]\n synapse = env.concat([\n env.concat([\n env.zeros((*batch_dims, out_channels, out_channels, num_states)),\n in_out_synapse\n ], axis=-2),\n env.concat([\n out_in_synapse,\n env.zeros((*batch_dims, in_channels, in_channels, num_states))\n ], axis=-2)\n ], axis=-3)\n return synapse\n\n\ndef sync_all_synapses(synapses, layers, env):\n \"\"\"Sync synapses across all layers.\n\n For each synapse, syncs its first state forward synapse with backward synapse\n and copies it arocess all the states.\n\n Args:\n synapses: list of synapses in the network.\n layers: list of layers in the network.\n env: Environment\n Returns:\n Synchronized synapses.\n \"\"\"\n for i in range(len(synapses)):\n synapses[i] = sync_in_and_out_synapse(synapses[i], layers[i].shape[-2], env)\n return synapses\n\n\ndef sync_in_and_out_synapse(synapse, in_channels, env):\n \"\"\"Copies forward synapse to backward one.\"\"\"\n in_out_synapse = synapse_submatrix(\n synapse,\n in_channels=in_channels,\n update_type=UpdateType.FORWARD,\n include_bias=True)\n return combine_in_out_synapses(\n in_out_synapse,\n transpose_synapse(in_out_synapse, env),\n env)\n\n\ndef sync_states_synapse(synapse, env, num_states=None):\n \"\"\"Sync synapse's first state across all the other states.\"\"\"\n if num_states is None:\n num_states = synapse.shape[-1]\n return env.stack(num_states*[synapse[Ellipsis, 0]], axis=-1)\n\n\ndef normalize_synapses(synapses,\n rescale_to,\n env,\n axis = -3):\n \"\"\"Normalizes synapses across a particular axis (across input by def.).\"\"\"\n # Default value axis=-3 corresponds to normalizing across the input neuron\n # dimension.\n squared = env.sum(synapses ** 2, axis=axis, keepdims=True)\n synapses /= env.sqrt(squared + 1e-9)\n if rescale_to is not None:\n synapses *= rescale_to\n return synapses\n",
"# coding=utf-8\n# Copyright 2021 The Google Research 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\"\"\"Python API for ScaNN - single machine, dense vector similarity search.\"\"\"\n\nimport os\nimport uuid\nfrom scann.scann_ops.py import scann_builder\nimport tensorflow as tf\n\n_scann_ops_so = tf.load_op_library(\n os.path.join(\n os.path.dirname(os.path.dirname(os.path.abspath(__file__))),\n \"cc/_scann_ops.so\"))\nscann_create_searcher = _scann_ops_so.scann_scann_create_searcher\nscann_search = _scann_ops_so.scann_scann_search\nscann_search_batched = _scann_ops_so.scann_scann_search_batched\nscann_to_tensors = _scann_ops_so.scann_scann_to_tensors\ntensors_to_scann = _scann_ops_so.scann_tensors_to_scann\n\n\ndef searcher_from_module(module, db=None):\n del db # Unused.\n return ScannSearcher(module.recreate_handle())\n\n\nclass ScannState(tf.Module):\n \"\"\"Class that wraps ScaNN searcher assets for object-based checkpointing.\"\"\"\n\n def __init__(self, tensors):\n super(ScannState, self).__init__()\n scann_config, serialized_partitioner, datapoint_to_token, ah_codebook, hashed_dataset, int8_dataset, int8_multipliers, dp_norms, dataset = tensors\n\n def make_var(v):\n with tf.compat.v1.variable_scope(\n tf.compat.v1.VariableScope(use_resource=True, reuse=False)):\n return tf.Variable(v, validate_shape=False)\n\n self.scann_config = make_var(scann_config)\n self.serialized_partitioner = make_var(serialized_partitioner)\n self.datapoint_to_token = make_var(datapoint_to_token)\n self.ah_codebook = make_var(ah_codebook)\n self.hashed_dataset = make_var(hashed_dataset)\n self.int8_dataset = make_var(int8_dataset)\n self.int8_multipliers = make_var(int8_multipliers)\n self.dp_norms = make_var(dp_norms)\n self.dataset = make_var(dataset)\n\n @tf.function(input_signature=[])\n def recreate_handle(self):\n \"\"\"Creates resource handle to searcher from ScaNN searcher assets.\"\"\"\n return tensors_to_scann(self.dataset, self.scann_config,\n self.serialized_partitioner,\n self.datapoint_to_token, self.ah_codebook,\n self.hashed_dataset, self.int8_dataset,\n self.int8_multipliers, self.dp_norms)\n\n\nclass ScannSearcher(object):\n \"\"\"Wrapper class that holds the ScaNN searcher resource handle.\"\"\"\n\n def __init__(self, searcher_handle):\n self.searcher_handle = searcher_handle\n\n def search(self,\n q,\n final_num_neighbors=None,\n pre_reorder_num_neighbors=None,\n leaves_to_search=None):\n final_nn = -1 if final_num_neighbors is None else final_num_neighbors\n pre_nn = -1 if pre_reorder_num_neighbors is None else pre_reorder_num_neighbors\n leaves = -1 if leaves_to_search is None else leaves_to_search\n return scann_search(self.searcher_handle, q, final_nn, pre_nn, leaves)\n\n def search_batched(self,\n q,\n final_num_neighbors=None,\n pre_reorder_num_neighbors=None,\n leaves_to_search=None):\n final_nn = -1 if final_num_neighbors is None else final_num_neighbors\n pre_nn = -1 if pre_reorder_num_neighbors is None else pre_reorder_num_neighbors\n leaves = -1 if leaves_to_search is None else leaves_to_search\n return scann_search_batched(self.searcher_handle, q, final_nn, pre_nn,\n leaves, False)\n\n def search_batched_parallel(self,\n q,\n final_num_neighbors=None,\n pre_reorder_num_neighbors=None,\n leaves_to_search=None):\n final_nn = -1 if final_num_neighbors is None else final_num_neighbors\n pre_nn = -1 if pre_reorder_num_neighbors is None else pre_reorder_num_neighbors\n leaves = -1 if leaves_to_search is None else leaves_to_search\n return scann_search_batched(self.searcher_handle, q, final_nn, pre_nn,\n leaves, True)\n\n def serialize_to_module(self):\n return ScannState(scann_to_tensors(self.searcher_handle))\n\n\ndef builder(db, num_neighbors, distance_measure):\n \"\"\"Creates a ScannBuilder that returns a TensorFlow ScaNN searcher on build().\n\n Args:\n db: the dataset that ScaNN will search over; a 2d array of 32-bit floats\n with one data point per row.\n num_neighbors: the default # neighbors the searcher will return per query.\n distance_measure: one of \"squared_l2\" or \"dot_product\".\n\n Returns:\n A ScannBuilder object, which builds the ScaNN config via calls such as\n tree() and score_brute_force(). Calling build() on the ScannBuilder will\n return a TensorFlow ScaNN searcher with its specified config.\n \"\"\"\n\n def builder_lambda(db, config, training_threads, **kwargs):\n return create_searcher(db, config, training_threads, **kwargs)\n\n return scann_builder.ScannBuilder(\n db, num_neighbors, distance_measure).set_builder_lambda(builder_lambda)\n\n\ndef create_searcher(db,\n scann_config,\n training_threads=0,\n container=\"\",\n shared_name=None):\n \"\"\"Create a ScaNN searcher given a dataset and text config proto.\"\"\"\n if shared_name is None:\n shared_name = f\"scann-{uuid.uuid4()}\"\n return ScannSearcher(\n scann_create_searcher(\n x=db,\n scann_config=scann_config,\n training_threads=training_threads,\n container=container,\n shared_name=shared_name))\n",
"# coding=utf-8\n# Copyright 2021 The Google Research 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\"\"\"TF metrics that work in the multi-agent case.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport collections\nfrom absl import logging\n\nimport gin\nimport numpy as np\nimport tensorflow as tf # pylint: disable=g-explicit-tensorflow-version-import\n\nfrom tf_agents.drivers import tf_driver\nfrom tf_agents.metrics import py_metrics\nfrom tf_agents.metrics import tf_metric\nfrom tf_agents.metrics.tf_metrics import TFDeque\nfrom tf_agents.utils import common\nfrom tf_agents.utils import numpy_storage\n\nfrom social_rl.multiagent_tfagents.joint_attention import drivers\n\n\ndef zero_out_new_episodes(trajectory, return_accumulator):\n return tf.where(trajectory.is_first(), tf.zeros_like(return_accumulator),\n return_accumulator)\n\n\[email protected]\nclass AverageReturnMetric(tf_metric.TFStepMetric):\n \"\"\"Metric for the average collective return and individual agent returns.\"\"\"\n\n def __init__(self,\n n_agents,\n name='MultiagentAverageReturn',\n prefix='Metrics',\n dtype=tf.float32,\n batch_size=1,\n buffer_size=10):\n super(AverageReturnMetric, self).__init__(name=name, prefix=prefix)\n self.n_agents = n_agents\n self._dtype = dtype\n\n # Accumulator and buffer for the average return of all agents\n self._collective_return_accumulator = common.create_variable(\n initial_value=0, dtype=dtype, shape=(batch_size,), name='Accumulator')\n self._collective_buffer = TFDeque(buffer_size, dtype)\n\n # Accumulators for each agent's independent reward\n self._agent_return_accumulators = []\n for a in range(n_agents):\n self._agent_return_accumulators.append(common.create_variable(\n initial_value=0, dtype=dtype, shape=(batch_size,),\n name='Accumulator' + str(a)))\n\n # Buffers for each agent's independent reward\n self._agent_buffers = []\n for a in range(n_agents):\n self._agent_buffers.append(TFDeque(buffer_size, dtype))\n\n @common.function(autograph=True)\n def call(self, trajectory):\n # Zero out batch indices where a new episode is starting.\n self._collective_return_accumulator.assign(\n zero_out_new_episodes(trajectory, self._collective_return_accumulator))\n for a in range(self.n_agents):\n self._agent_return_accumulators[a].assign(\n zero_out_new_episodes(trajectory, self._agent_return_accumulators[a]))\n\n # Note that trajectory.reward has shape (batch, n_agents)\n\n # Update accumulator with sum of received rewards.\n self._collective_return_accumulator.assign_add(\n tf.reduce_mean(trajectory.reward, axis=1))\n\n # Pull out data for each agent and assign\n for a in range(self.n_agents):\n self._agent_return_accumulators[a].assign_add(trajectory.reward[:, a])\n\n # Add final returns to buffer.\n last_episode_indices = tf.squeeze(tf.where(trajectory.is_last()), axis=-1)\n for indx in last_episode_indices:\n self._collective_buffer.add(self._collective_return_accumulator[indx])\n\n # Agent buffers that use the global done\n for a in range(self.n_agents):\n self._agent_buffers[a].add(self._agent_return_accumulators[a][indx])\n\n return trajectory\n\n def result(self):\n return self._collective_buffer.mean()\n\n def result_for_agent(self, agent_id):\n return self._agent_buffers[agent_id].mean()\n\n @common.function\n def reset(self):\n self._collective_buffer.clear()\n self._collective_return_accumulator.assign(\n tf.zeros_like(self._collective_return_accumulator))\n\n for a in range(self.n_agents):\n self._agent_buffers[a].clear()\n self._agent_return_accumulators[a].assign(\n tf.zeros_like(self._agent_return_accumulators[a]))\n\n def tf_summaries(self, train_step=None, step_metrics=()):\n \"\"\"Generates summaries for all agents & collective summary against steps.\n\n Args:\n train_step: (Optional) Step counter for training iterations. If None, no\n metric is generated against the global step.\n step_metrics: (Optional) Iterable of step metrics to generate summaries\n against.\n\n Returns:\n A list of summaries.\n \"\"\"\n summaries = super(AverageReturnMetric, self).tf_summaries(\n train_step=train_step, step_metrics=step_metrics)\n\n for a in range(self.n_agents):\n summaries.extend(self.single_agent_summary(\n a, train_step, step_metrics))\n\n return summaries\n\n def single_agent_summary(self, agent_id, train_step=None, step_metrics=()):\n summaries = []\n prefix = self._prefix\n name = self.name + '_agent' + str(agent_id)\n tag = common.join_scope(prefix, name)\n\n result = self.result_for_agent(agent_id)\n\n if train_step is not None:\n summaries.append(\n tf.compat.v2.summary.scalar(name=tag, data=result, step=train_step))\n if prefix:\n prefix += '_'\n for step_metric in step_metrics:\n # Skip plotting the metrics against itself.\n if self.name == step_metric.name:\n continue\n step_tag = '{}vs_{}/{}'.format(prefix, step_metric.name, name)\n # Summaries expect the step value to be an int64.\n step = tf.cast(step_metric.result(), tf.int64)\n summaries.append(tf.compat.v2.summary.scalar(\n name=step_tag,\n data=result,\n step=step))\n return summaries\n\n\[email protected]\nclass MultiagentScalar(tf_metric.TFStepMetric):\n \"\"\"Metric to compute average of simple scalars like number of obstacles.\"\"\"\n\n def __init__(self,\n n_agents,\n name,\n prefix='Metrics',\n dtype=tf.float32,\n buffer_size=10):\n super(MultiagentScalar, self).__init__(name=name, prefix=prefix)\n self._buffers = [TFDeque(buffer_size, dtype) for _ in range(n_agents)]\n self._n_agents = n_agents\n self._dtype = dtype\n\n @common.function(autograph=True)\n def call(self, new_scalar_vals, agent_id):\n self._buffers[agent_id].add(tf.reduce_mean(new_scalar_vals))\n return new_scalar_vals\n\n def result(self):\n return tf.reduce_mean([buffer.mean() for buffer in self._buffers])\n\n def result_for_agent(self, agent_id):\n return self._buffers[agent_id].mean()\n\n @common.function\n def reset(self):\n for buffer in self._buffers:\n buffer.clear()\n\n\ndef log_metrics(metrics, prefix=''):\n log = []\n for m in metrics:\n log.append('{0} = {1}'.format(m.name, m.result()))\n if 'Multiagent' in m.name:\n log += ['{0} = {1}'.format(\n m.name + '_agent' + str(a),\n m.result_for_agent(a)) for a in range(m.n_agents)]\n logging.info('%s \\n\\t\\t %s', prefix, '\\n\\t\\t '.join(log))\n\n\[email protected]\ndef eager_compute(metrics,\n environment,\n policy,\n num_episodes=1,\n train_step=None,\n summary_writer=None,\n summary_prefix='',\n use_function=True,\n use_attention_networks=False):\n \"\"\"Compute metrics using `policy` on the `environment`.\n\n *NOTE*: Because placeholders are not compatible with Eager mode we can not use\n python policies. Because we use tf_policies we need the environment time_steps\n to be tensors making it easier to use a tf_env for evaluations. Otherwise this\n method mirrors `compute` directly.\n\n Args:\n metrics: List of metrics to compute.\n environment: tf_environment instance.\n policy: tf_policy instance used to step the environment.\n num_episodes: Number of episodes to compute the metrics over.\n train_step: An optional step to write summaries against.\n summary_writer: An optional writer for generating metric summaries.\n summary_prefix: An optional prefix scope for metric summaries.\n use_function: Option to enable use of `tf.function` when collecting the\n metrics.\n use_attention_networks: Option to use attention network architecture in the\n agent. This architecture requires observations from the previous time step.\n Returns:\n A dictionary of results {metric_name: metric_value}\n \"\"\"\n for metric in metrics:\n metric.reset()\n\n multiagent_metrics = [m for m in metrics if 'Multiagent' in m.name]\n\n if use_attention_networks:\n driver = drivers.StateTFDriver(\n environment,\n policy,\n observers=metrics,\n max_episodes=num_episodes,\n disable_tf_function=not use_function,\n )\n else:\n driver = tf_driver.TFDriver(\n environment,\n policy,\n observers=metrics,\n max_episodes=num_episodes,\n disable_tf_function=not use_function)\n\n def run_driver():\n time_step = environment.reset()\n policy_state = policy.get_initial_state(environment.batch_size)\n if use_attention_networks:\n time_step.observation['policy_state'] = (\n policy_state['actor_network_state'][0],\n policy_state['actor_network_state'][1])\n driver.run(time_step, policy_state)\n\n if use_function:\n common.function(run_driver)()\n else:\n run_driver()\n\n results = [(metric.name, metric.result()) for metric in metrics]\n for m in multiagent_metrics:\n for a in range(m.n_agents):\n results.append((m.name + '_agent' + str(a), m.result_for_agent(a)))\n\n # TODO(b/120301678) remove the summaries and merge with compute\n if train_step and summary_writer:\n with summary_writer.as_default():\n for m in metrics:\n tag = common.join_scope(summary_prefix, m.name)\n tf.compat.v2.summary.scalar(name=tag, data=m.result(), step=train_step)\n if 'Multiagent' in m.name:\n for a in range(m.n_agents):\n tf.compat.v2.summary.scalar(name=tag + '_agent' + str(a),\n data=m.result_for_agent(a),\n step=train_step)\n # TODO(b/130249101): Add an option to log metrics.\n return collections.OrderedDict(results)\n\n\nclass MultiagentMetricsGroup(tf.Module):\n \"\"\"Group a list of Metrics into a container.\"\"\"\n\n def __init__(self, metrics, name=None):\n super(MultiagentMetricsGroup, self).__init__(name=name)\n self.metrics = metrics\n self.multiagent_metrics = [m for m in metrics if 'Multiagent' in m.name]\n\n def results(self):\n results = [(metric.name, metric.result()) for metric in self.metrics]\n\n for m in self.multiagent_metrics:\n for a in range(m.n_agents):\n results.append((m.name + '_agent' + str(a), m.result_for_agent(a)))\n return collections.OrderedDict(results)\n\n\[email protected]\nclass AverageReturnPyMetric(py_metrics.StreamingMetric):\n \"\"\"Computes the average undiscounted reward.\"\"\"\n\n def __init__(self,\n n_agents,\n name='MultiagentAverageReturn',\n buffer_size=10,\n batch_size=None):\n \"\"\"Creates an AverageReturnPyMetric.\"\"\"\n self.n_agents = n_agents\n self._np_state = numpy_storage.NumpyState()\n # Set a dummy value on self._np_state.episode_return so it gets included in\n # the first checkpoint (before metric is first called).\n self._np_state.episode_return = np.float64(0)\n self._agent_metrics = [\n py_metrics.AverageReturnMetric(\n 'AverageReturn%i' % i, buffer_size=buffer_size)\n for i in range(n_agents)\n ]\n super(AverageReturnPyMetric, self).__init__(name, buffer_size=buffer_size,\n batch_size=batch_size)\n\n def result_for_agent(self, agent_id):\n return self._agent_metrics[agent_id].result()\n\n # We want to reuse methods for the sub-metrics\n # pylint: disable=protected-access\n def _reset(self, batch_size):\n \"\"\"Resets stat gathering variables.\"\"\"\n self._np_state.episode_return = np.zeros(\n shape=(batch_size,), dtype=np.float64)\n for metric in self._agent_metrics:\n metric._reset(batch_size)\n\n def _batched_call(self, trajectory):\n \"\"\"Processes the trajectory to update the metric.\n\n Args:\n trajectory: a tf_agents.trajectory.Trajectory.\n \"\"\"\n episode_return = self._np_state.episode_return\n agent_episode_returns = [\n metric._np_state.episode_return for metric in self._agent_metrics\n ]\n\n is_first = np.where(trajectory.is_first())\n episode_return[is_first] = 0\n for r in agent_episode_returns:\n r[is_first] = 0\n\n for i in range(self.n_agents):\n agent_episode_returns[i] += trajectory.reward[:, i]\n episode_return += np.mean(trajectory.reward, axis=-1)\n\n is_last = np.where(trajectory.is_last())\n self.add_to_buffer(episode_return[is_last])\n for metric in self._agent_metrics:\n metric.add_to_buffer(agent_episode_returns[i][is_last])\n",
"# coding=utf-8\n# Copyright 2021 The Google Research Authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n# Lint as: python3\nr\"\"\"Wraps drq_sac_agent and expands the root_dir for nightly baselines.\n\n\"\"\"\nimport os\n\nfrom absl import app\nfrom absl import flags\nfrom absl import logging\nimport gin\nimport numpy as np\nimport tensorflow.compat.v2 as tf\n\nfrom pse.dm_control import train_eval_flags # pylint:disable=unused-import\nfrom pse.dm_control.agents import pse_drq_train_eval\n\nFLAGS = flags.FLAGS\nflags.DEFINE_bool('debugging', False,\n 'If True, we set additional logging and run in eager mode.')\n\n\ndef set_random_seed(seed):\n \"\"\"Set random seed for reproducibility.\"\"\"\n os.environ['PYTHONHASHSEED'] = str(seed)\n tf.random.set_seed(seed)\n np.random.seed(seed)\n\n\[email protected](module='evaluator')\ndef evaluate(max_train_step=int(1e+8)): # pylint: disable=unused-argument\n pass\n\n\ndef main(argv):\n del argv\n logging.set_verbosity(logging.INFO)\n if FLAGS.seed is not None:\n set_random_seed(FLAGS.seed)\n logging.info('Random seed %d', FLAGS.seed)\n trial_suffix = f'{FLAGS.trial_id}/seed_{FLAGS.seed}'\n else:\n trial_suffix = str(FLAGS.trial_id)\n\n expanded_root_dir = os.path.join(\n FLAGS.root_dir, FLAGS.env_name, trial_suffix)\n if FLAGS.load_pretrained and (FLAGS.pretrained_model_dir is not None):\n pretrained_model_dir = os.path.join(\n FLAGS.pretrained_model_dir, FLAGS.env_name, trial_suffix)\n else:\n pretrained_model_dir = None\n if FLAGS.debugging:\n tf.debugging.set_log_device_placement(True)\n tf.config.experimental_run_functions_eagerly(True)\n\n gin.parse_config_files_and_bindings(FLAGS.gin_files, FLAGS.gin_bindings)\n\n pse_drq_train_eval.train_eval(\n expanded_root_dir,\n FLAGS.env_name,\n num_train_steps=FLAGS.num_train_steps,\n policy_save_interval=FLAGS.policy_save_interval,\n checkpoint_interval=FLAGS.checkpoint_interval,\n load_pretrained=FLAGS.load_pretrained,\n pretrained_model_dir=pretrained_model_dir,\n contrastive_loss_weight=FLAGS.contrastive_loss_weight,\n contrastive_loss_temperature=FLAGS.contrastive_loss_temperature,\n image_encoder_representation=FLAGS.image_encoder_representation,\n reverb_port=FLAGS.reverb_port,\n eval_interval=FLAGS.eval_interval)\n\n\nif __name__ == '__main__':\n flags.mark_flag_as_required('root_dir')\n app.run(main)\n",
"# coding=utf-8\n# Copyright 2021 The Google Research Authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n# Lint as: python3\n\"\"\"Helpers for evaluating an agent on Jumpy World.\"\"\"\n\nimport io\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport seaborn as sns\nimport tensorflow.compat.v2 as tf\n\nsns.set_style('white')\n\n\ndef create_evaluation_grid(nn_model,\n imitation_data,\n mc_samples=1,\n color_name='WHITE'):\n \"\"\"Evaluates an agent on all environments in imitation_data.\"\"\"\n obstacle_positions = sorted(imitation_data.keys())\n floor_heights = sorted(imitation_data[obstacle_positions[0]].keys())\n evaluation_grid = np.zeros((len(obstacle_positions), len(floor_heights)))\n for i, pos in enumerate(obstacle_positions):\n for j, height in enumerate(floor_heights):\n input_observations, optimal_actions, _ = imitation_data[pos][height]\n predictions = tf.nn.softmax(\n nn_model(input_observations, training=False), axis=-1)\n # MC Averaging if using RandConv\n for _ in range(mc_samples - 1):\n predictions += tf.nn.softmax(\n nn_model(input_observations, training=False), axis=-1)\n predictions /= mc_samples\n greedy_actions = np.array(\n [1 if pi[1] > pi[0] else 0 for pi in predictions])\n action_diff = greedy_actions - np.array(optimal_actions)\n if color_name == 'GREEN':\n # The collision happens when the agent touches the block\n argmax_val = pos - 5\n elif color_name in ['WHITE', 'RED']:\n argmax_val = np.argmax(optimal_actions)\n else:\n raise ValueError(f'{color_name} is not a valid obstacle color.')\n binary_mask = np.arange(len(optimal_actions)) <= argmax_val\n is_optimal = sum(binary_mask * np.abs(action_diff)) == 0\n evaluation_grid[i][j] = is_optimal\n return evaluation_grid\n\n\ndef neigbhour_indices(x, y, max_x, max_y):\n valid_indices = []\n for index in [(x - 1, y), (x+1, y), (x, y-1), (x, y+1)]:\n is_x_valid = (0 <= index[0]) and (index[0] < max_x)\n is_y_valid = (0 <= index[1]) and (index[1] < max_y)\n if is_x_valid and is_y_valid:\n valid_indices.append(index)\n return valid_indices\n\n\ndef generate_validation_positions(training_positions, min_obs_position,\n min_floor_height, num_positions, num_heights):\n \"\"\"Generate validation positions.\"\"\"\n val_pos = []\n for (obstacle_pos, floor_height) in training_positions:\n pos_index = obstacle_pos - min_obs_position\n height_index = floor_height - min_floor_height\n validation_indices = neigbhour_indices(\n pos_index, height_index, num_positions, num_heights)\n for val_pos_index, val_height_index in validation_indices:\n val_pos.append((val_pos_index + min_obs_position,\n val_height_index + min_floor_height))\n return list(set(val_pos))\n\n\ndef num_solved_tasks(evaluation_grid, training_positions, validation_positions,\n min_obs_position, min_floor_height):\n \"\"\"Calculates number of tasks solved in training, validation and test sets.\"\"\"\n solved_envs = {'train': 0, 'test': 0}\n if validation_positions:\n solved_envs['validation'] = 0\n\n num_positions, num_heights = evaluation_grid.shape\n is_train_or_validation = np.zeros_like(evaluation_grid, dtype=np.int32)\n\n for (obstacle_pos, floor_height) in training_positions:\n pos_index = obstacle_pos - min_obs_position\n height_index = floor_height - min_floor_height\n is_train_or_validation[pos_index][height_index] = 1\n\n for (obstacle_pos, floor_height) in validation_positions:\n pos_index = obstacle_pos - min_obs_position\n height_index = floor_height - min_floor_height\n is_train_or_validation[pos_index][height_index] = 2\n\n for pos_index in range(num_positions):\n for height_index in range(num_heights):\n if is_train_or_validation[pos_index][height_index] == 1:\n solved_envs['train'] += evaluation_grid[pos_index][height_index]\n elif is_train_or_validation[pos_index][height_index] == 2:\n solved_envs['validation'] += evaluation_grid[pos_index][height_index]\n else:\n solved_envs['test'] += evaluation_grid[pos_index][height_index]\n return solved_envs\n\n\ndef plot_evaluation_grid(grid, training_positions, min_obs_position,\n min_floor_height):\n \"\"\"Plots the evaluation grid.\"\"\"\n fig, ax = plt.subplots(figsize=(7, 9))\n grid_x, grid_y = grid.shape\n extent = (0, grid_x, grid_y, 0)\n ax.imshow(grid.T, extent=extent, origin='lower')\n\n x_ticks = np.arange(grid_x)\n y_ticks = np.arange(grid_y)\n ax.set_xticks(x_ticks)\n ax.set_yticks(y_ticks)\n\n ax.tick_params(labelbottom=False, labelleft=False)\n\n # Loop over data dimensions and create text annotations.\n for (obstacle_pos, floor_height) in training_positions:\n pos_index = obstacle_pos - min_obs_position\n height_index = floor_height - min_floor_height\n ax.text(\n pos_index + 0.5,\n height_index + 0.5,\n 'T',\n ha='center',\n va='center',\n color='r')\n\n ax.grid(color='w', linewidth=1)\n fig.tight_layout()\n return fig\n\n\ndef plot_to_image(figure):\n \"\"\"Converts the plot specified by 'figure' to a PNG image and returns it.\"\"\"\n # Save the plot to a PNG in memory.\n buf = io.BytesIO()\n figure.savefig(buf, format='png')\n # Closing the figure prevents it from being displayed directly inside\n # the notebook.\n plt.close(figure)\n buf.seek(0)\n # Convert PNG buffer to TF image\n image = tf.image.decode_png(buf.getvalue(), channels=4)\n # Add the batch dimension\n image = tf.expand_dims(image, 0)\n return image\n\n\ndef np_array_figure(arr):\n fig, ax = plt.subplots(figsize=(6, 6))\n im = ax.imshow(arr.T, origin='lower', cmap='hot', interpolation='nearest')\n fig.colorbar(im, ax=ax)\n return plot_to_image(fig)\n\n\ndef sinkhorn_logspace(logits_rows, logits_cols, costs, n_steps,\n entropy_strength):\n \"\"\"Sinkhorn algorithm for (unbalanced) entropy-regularized optimal transport.\n\n The updates are computed in log-space and are thus more stable.\n\n Args:\n logits_rows: (..., n) tensor with the logits of the row-sum constraint\n logits_cols: (..., m) tensor with the logits of the column-sum constraint\n costs: (..., n, m) tensor holding the transportation costs\n n_steps: How many Sinkhorn iterations to perform.\n entropy_strength: The strength of the entropic regularizer\n\n Returns:\n (..., n, m) tensor with the computation optimal transportation matrices\n \"\"\"\n assert n_steps > 0\n assert entropy_strength > 0\n\n logits_rows = tf.expand_dims(logits_rows, axis=-1)\n logits_cols = tf.expand_dims(logits_cols, axis=-2)\n log_kernel = -costs / entropy_strength + logits_rows + logits_cols\n\n log_lbd_cols = tf.zeros_like(logits_cols)\n for _ in range(n_steps):\n log_lbd_rows = logits_rows - tf.reduce_logsumexp(\n log_kernel + log_lbd_cols, axis=-1, keepdims=True)\n log_lbd_cols = logits_cols - tf.reduce_logsumexp(\n log_kernel + log_lbd_rows, axis=-2, keepdims=True)\n return tf.exp(log_lbd_cols + log_kernel + log_lbd_rows)\n\n\[email protected]\ndef induced_coupling(similarity_matrix, n_steps=3, entropy_strength=0.0001):\n \"\"\"Calculates the coupling induced by the similarity matrix.\"\"\"\n dist_v = tf.ones(similarity_matrix.shape[0])\n dist_v /= tf.reduce_sum(dist_v)\n dist_v = tf.math.log(dist_v)\n coupling = tf.stop_gradient(sinkhorn_logspace(\n dist_v,\n dist_v,\n 1 - similarity_matrix,\n n_steps=n_steps,\n entropy_strength=entropy_strength))\n return coupling\n",
"# coding=utf-8\n# Copyright 2021 The Google Research 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\"\"\"CDP smooth sensitivity method for computing differentially private quantiles.\n\nThe smooth sensitivity method is described in\n\"Smooth Sensitivity and Sampling in Private Data Analysis\" by Nissim,\nRaskhodnikova, and Smith\n(https://cs-people.bu.edu/ads22/pubs/NRS07/NRS07-full-draft-v1.pdf). Details for\nthe CDP noise distribution appear in Section 3.1 of \"Average-Case Averages:\nPrivate Algorithms for Smooth Sensitivity and Mean Estimation\" by Bun and\nSteinke (NeurIPS 2019). Details for optimizing t, s, and sigma appear in\nSection 3.1.1 of the same paper.\n\"\"\"\n\nimport numpy as np\n\nfrom dp_multiq import base\nfrom dp_multiq import smooth_utils\n\n\ndef compute_triples(eps, ts):\n \"\"\"Returns triples of form (t, log(s), sigma) for hyperparameter optimization.\n\n Args:\n eps: Privacy parameter epsilon.\n ts: Array of possible smooth sensitivity parameters.\n \"\"\"\n triples = np.empty([len(ts), 3])\n for t_idx in range(len(ts)):\n t = ts[t_idx]\n triples[t_idx, 0] = t\n sigma = opt_sigma(eps, t)\n triples[t_idx, 2] = sigma\n triples[t_idx, 1] = -1.5 * (sigma**2) + np.log(eps - (t / sigma))\n return triples\n\n\ndef opt_sigma(eps, t):\n \"\"\"Returns optimal sigma as detailed in Section 3.1.1 of Bun and Steinke.\n\n Args:\n eps: Privacy parameter epsilon.\n t: Smooth sensitivity parameter.\n \"\"\"\n return np.real(np.roots([5 * eps / t, -5, 0, -1])[0])\n\n\ndef lln(sigma):\n \"\"\"Returns a sample from the Laplace Log-Normal distribution.\n\n Args:\n sigma: Sigma parameter for the Laplace Log-Normal distribution.\n \"\"\"\n return np.random.laplace() * np.exp(sigma * np.random.normal())\n\n\ndef csmooth(sorted_data, data_low, data_high, qs, divided_eps, ts):\n \"\"\"Returns eps^2/2-CDP quantile estimates for qs.\n\n Args:\n sorted_data: Array of data points sorted in increasing order.\n data_low: Lower limit for any differentially private quantile output value.\n data_high: Upper limit for any differentially private quantile output value.\n qs: Increasing array of quantiles in [0,1].\n divided_eps: Privacy parameter epsilon. Assumes eps has already been divided\n so that the overall desired privacy guarantee is achieved.\n ts: Array of smooth sensitivity parameters, one for each q in qs.\n \"\"\"\n sorted_data = np.clip(sorted_data, data_low, data_high)\n o = np.empty(len(qs))\n triples = compute_triples(divided_eps, ts)\n for i in range(len(qs)):\n t, log_s, sigma = triples[i]\n true_quantile_idx = base.quantile_index(len(sorted_data), qs[i])\n true_quantile_value = sorted_data[true_quantile_idx]\n laplace_log_normal_noise = lln(sigma)\n log_sensitivity = smooth_utils.compute_log_smooth_sensitivity(\n sorted_data, data_low, data_high, true_quantile_idx, t)\n noise = np.sign(laplace_log_normal_noise) * np.exp(\n log_sensitivity + np.log(np.abs(laplace_log_normal_noise)) - log_s)\n o[i] = true_quantile_value + noise\n o = np.clip(o, data_low, data_high)\n return np.sort(o)\n\n\ndef log_choose_triple_idx(triples, eps, log_sensitivities):\n \"\"\"Returns triple (t, log_s, sigma) that minimizes noisy statistic variance.\n\n Args:\n triples: Array with entries of form (t, log_s, sigma).\n eps: Privacy parameter epsilon.\n log_sensitivities: Log(t smooth sensitivity) for each t in triples.\n \"\"\"\n variances = np.empty(len(triples))\n for triple_idx in range(len(triples)):\n numerator = 2 * (np.exp(2 * log_sensitivities[triple_idx]))\n denominator = np.exp(-5 * (triples[triple_idx][2]**2)) * (\n (eps - (triples[triple_idx][0] / triples[triple_idx][2]))**2)\n variances[triple_idx] = numerator / denominator\n return np.argmin(variances)\n\n\ndef csmooth_tune_and_return_ts(sorted_data, data_low, data_high, qs,\n divided_eps, log_t_low, log_t_high, num_t):\n \"\"\"Returns ts minimizing variance for data and each q under ~eps^2/2-CDP.\n\n Args:\n sorted_data: Array of data points sorted in increasing order.\n data_low: Lower limit for any differentially private quantile output value.\n data_high: Upper limit for any differentially private quantile output value.\n qs: Increasing array of quantiles in [0,1].\n divided_eps: Privacy parameter epsilon. Assumes eps has already been divided\n so that the overall desired privacy guarantee is achieved.\n log_t_low: Tuning range for t has lower bound 10^(log_t_low).\n log_t_high: Tuning range for t has upper bound 10^(log_t_high).\n num_t: Number of logarithmically spaced t used to populate tuning range.\n \"\"\"\n sorted_data = np.clip(sorted_data, data_low, data_high)\n triples = compute_triples(divided_eps,\n np.logspace(log_t_low, log_t_high, num_t))\n num_qs = len(qs)\n ts = np.empty(num_qs)\n for i in range(num_qs):\n true_quantile_idx = base.quantile_index(len(sorted_data), qs[i])\n log_sensitivities = np.zeros(len(triples))\n for triple_idx in range(len(triples)):\n t = triples[triple_idx, 0]\n log_sensitivities[\n triple_idx] = smooth_utils.compute_log_smooth_sensitivity(\n sorted_data, data_low, data_high, true_quantile_idx, t)\n ts[i] = triples[log_choose_triple_idx(triples, divided_eps,\n log_sensitivities)][0]\n return ts\n\n\ndef csmooth_tune_t_experiment(eps, num_samples, num_trials, num_quantiles_range,\n data_low, data_high, log_t_low, log_t_high,\n num_t):\n \"\"\"Returns 2-D array of ts, tuned for each (num_quantiles, quantile) pair.\n\n Args:\n eps: Privacy parameter epsilon.\n num_samples: Number of standard Gaussian samples to draw for each trial.\n num_trials: Number of trials to average.\n num_quantiles_range: Array of number of quantiles to estimate.\n data_low: Lower bound for data, used by CSmooth.\n data_high: Upper bound for data, used by CSmooth.\n log_t_low: Tuning range for t has lower bound 10^(log_t_low).\n log_t_high: Tuning range for t has upper bound 10^(log_t_high).\n num_t: Number of logarithmically spaced t used to populate tuning range.\n \"\"\"\n ts = [np.zeros(num_quantiles) for num_quantiles in num_quantiles_range]\n num_quantiles_idx = 0\n for num_quantiles_idx in range(len(num_quantiles_range)):\n num_quantiles = num_quantiles_range[num_quantiles_idx]\n divided_eps = eps / np.sqrt(num_quantiles)\n for _ in range(num_trials):\n sorted_data = base.gen_gaussian(num_samples, 0, 1)\n qs = np.linspace(0, 1, num_quantiles + 2)[1:-1]\n ts[num_quantiles_idx] += csmooth_tune_and_return_ts(\n sorted_data, data_low, data_high, qs, divided_eps, log_t_low,\n log_t_high, num_t) / num_trials\n print(\"Finished num_quantiles: {}\".format(num_quantiles))\n return ts\n",
"# coding=utf-8\n# Copyright 2021 The Google Research 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# pylint: disable=logging-format-interpolation\n# pylint: disable=unused-import\n# pylint: disable=protected-access\n# pylint: disable=g-direct-tensorflow-import\n# pylint: disable=g-long-lambda\n\nr\"\"\"Docs.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\n\nfrom __future__ import print_function\n\nimport collections\nimport heapq\nimport os\nimport sys\nimport time\nimport traceback\n\nfrom absl import app\nfrom absl import flags\nfrom absl import logging\nimport numpy as np\nimport tensorflow.compat.v1 as tf\n\nfrom meta_pseudo_labels import common_utils\nfrom meta_pseudo_labels import data_utils\n\nfrom tensorflow.compiler.xla.experimental.xla_sharding import xla_sharding\nfrom tensorflow.python.tpu import tpu_feed\n\n\nMODEL_SCOPE = 'model'\n\n\ndef eval_step_fn(params, model):\n \"\"\"Build `step_fn` for eval.\"\"\"\n dtypes = [tf.bfloat16 if params.use_bfloat16 else tf.float32,\n tf.float32, tf.float32]\n batch_size = params.eval_batch_size // params.num_replicas\n image_size = (params.eval_image_size if 'eval_image_size' in params\n else params.image_size)\n shapes = [[batch_size, image_size, image_size, 3],\n [batch_size, params.num_classes],\n [batch_size]]\n\n if params.use_xla_sharding and params.num_cores_per_replica > 1:\n q = tpu_feed._PartitionedInfeedQueue(\n number_of_tuple_elements=3,\n host_id=0,\n input_partition_dims=[[1, 1, params.num_cores_per_replica, 1],\n [1, 1], [1]],\n device_assignment=params.device_assignment)\n q.set_tuple_types(dtypes)\n q.set_tuple_shapes(shapes)\n images, labels, mask = q.generate_dequeue_op()\n images = xla_sharding.split(images, 2, params.num_cores_per_replica)\n else:\n with tf.device(tf.tpu.core(0)):\n images, labels, mask = tf.raw_ops.InfeedDequeueTuple(dtypes=dtypes,\n shapes=shapes)\n\n if len(labels.shape) > 1: # `labels` is one_hot. turn it to `int.32`\n labels = tf.argmax(labels, axis=-1, output_type=tf.int32)\n labels = tf.expand_dims(labels, axis=-1)\n _ = tf.train.get_or_create_global_step()\n\n with tf.variable_scope(MODEL_SCOPE):\n logits = model(images, training=False)\n logits = tf.cast(logits, tf.float32)\n\n return logits, labels, mask\n\n\nclass Supervised(object):\n \"\"\"Supervised information.\"\"\"\n\n def __init__(self):\n step_info = collections.OrderedDict()\n self.step_info = step_info\n\n def outfeed_signature(self):\n \"\"\"Returns the sigature of `step_info` as returned by `step_fn`.\"\"\"\n return self.step_info\n\n def step_fn(self, params, model):\n \"\"\"A single step for supervised learning.\"\"\"\n\n batch_size = params.train_batch_size // params.num_replicas\n dtypes = [tf.bfloat16 if params.use_bfloat16 else tf.float32, tf.float32]\n shapes = [[batch_size, params.image_size, params.image_size, 3],\n [batch_size, params.num_classes]]\n\n if params.use_xla_sharding and params.num_cores_per_replica > 1:\n q = tpu_feed._PartitionedInfeedQueue(\n number_of_tuple_elements=2,\n host_id=0,\n input_partition_dims=[[1, 1, params.num_cores_per_replica, 1],\n [1, 1]],\n device_assignment=params.device_assignment)\n q.set_tuple_types(dtypes)\n q.set_tuple_shapes(shapes)\n images, labels = q.generate_dequeue_op()\n images = xla_sharding.split(images, 2, params.num_cores_per_replica)\n else:\n with tf.device(tf.tpu.core(0)):\n images, labels = tf.raw_ops.InfeedDequeueTuple(dtypes=dtypes,\n shapes=shapes)\n\n if labels.dtype == tf.int32:\n labels = tf.one_hot(labels, depth=params.num_classes, dtype=tf.float32)\n global_step = tf.train.get_or_create_global_step()\n\n train_batch_size = tf.cast(params.train_batch_size, tf.float32)\n num_replicas = tf.cast(params.num_replicas, tf.float32)\n\n with tf.variable_scope(MODEL_SCOPE):\n logits = model(images, training=True)\n\n if 'noisy_student' in params.dataset_name.lower():\n cross_entropy = labels * tf.nn.log_softmax(logits, axis=-1)\n cross_entropy = tf.reduce_sum(-cross_entropy) / train_batch_size\n else:\n cross_entropy = tf.losses.softmax_cross_entropy(\n onehot_labels=labels, logits=logits,\n label_smoothing=params.label_smoothing,\n reduction=tf.losses.Reduction.SUM) / train_batch_size\n\n l2_reg_rate = tf.cast(params.weight_decay / params.num_replicas, tf.float32)\n weight_dec = common_utils.get_l2_loss()\n total_loss = cross_entropy + weight_dec * l2_reg_rate\n\n variables = tf.trainable_variables()\n gradients = tf.gradients(total_loss, variables)\n gradients = [tf.tpu.cross_replica_sum(g) for g in gradients]\n gradients, grad_norm = tf.clip_by_global_norm(gradients, params.grad_bound)\n\n learning_rate, optimizer = common_utils.get_optimizer(params)\n update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)\n train_op = tf.cond(\n tf.math.is_finite(grad_norm),\n lambda: optimizer.apply_gradients(zip(gradients, variables),\n global_step=global_step),\n tf.no_op)\n with tf.control_dependencies(update_ops + [train_op]):\n ema_train_op = common_utils.setup_ema(params,\n f'{MODEL_SCOPE}/{model.name}')\n\n with tf.control_dependencies([ema_train_op]):\n logs = collections.OrderedDict()\n logs['global_step'] = tf.cast(global_step, tf.float32)\n logs['loss/total'] = total_loss\n logs['loss/weight_decay'] = weight_dec / num_replicas\n logs['loss/cross_entropy'] = cross_entropy\n logs['loss/lr'] = tf.identity(learning_rate) / num_replicas\n logs['loss/grad_norm'] = grad_norm / num_replicas\n\n tensors = [tf.expand_dims(t, axis=0) for t in logs.values()]\n self.step_info = {k: [tf.float32, [1]] for k in logs.keys()}\n outfeed_enqueue_op = tf.cond(\n common_utils.should_log(params),\n lambda: tf.raw_ops.OutfeedEnqueueTuple(inputs=tensors), tf.no_op)\n return outfeed_enqueue_op\n\n\nclass UDA(object):\n \"\"\"UDA (https://arxiv.org/abs/1904.12848).\"\"\"\n\n def __init__(self):\n self.step_info = collections.OrderedDict()\n\n def outfeed_signature(self):\n \"\"\"Returns the sigature of `step_info` as returned by `step_fn`.\"\"\"\n return self.step_info\n\n @staticmethod\n def build_uda_cross_entropy(params, model, all_images, l_labels):\n \"\"\"Compute the UDA loss.\"\"\"\n train_batch_size = params.train_batch_size\n num_replicas = params.num_replicas\n uda_data = params.uda_data\n batch_size = train_batch_size // num_replicas\n\n labels = {}\n if l_labels.dtype == tf.int32: # l_labels is sparse. turn into one_hot\n labels['l'] = tf.one_hot(l_labels, params.num_classes, dtype=tf.float32)\n else:\n labels['l'] = l_labels\n\n global_step = tf.train.get_or_create_global_step()\n\n masks = {}\n logits = {}\n cross_entropy = {}\n all_logits = model(all_images, training=True)\n\n logits['l'], logits['u_ori'], logits['u_aug'] = tf.split(\n all_logits, [batch_size, batch_size*uda_data, batch_size*uda_data], 0)\n\n # sup loss\n cross_entropy['l'] = tf.losses.softmax_cross_entropy(\n onehot_labels=labels['l'],\n logits=logits['l'],\n label_smoothing=params.label_smoothing,\n reduction=tf.losses.Reduction.NONE)\n probs = tf.nn.softmax(logits['l'], axis=-1)\n correct_probs = tf.reduce_sum(labels['l']*probs, axis=-1)\n r = tf.cast(global_step, tf.float32) / float(params.num_train_steps)\n l_threshold = r * (1. - 1./params.num_classes) + 1. / params.num_classes\n masks['l'] = tf.less_equal(correct_probs, l_threshold)\n masks['l'] = tf.cast(masks['l'], tf.float32)\n masks['l'] = tf.stop_gradient(masks['l'])\n cross_entropy['l'] = tf.reduce_sum(cross_entropy['l']) / float(\n train_batch_size)\n\n # unsup loss\n labels['u_ori'] = tf.nn.softmax(logits['u_ori'] / params.uda_temp, axis=-1)\n labels['u_ori'] = tf.stop_gradient(labels['u_ori'])\n\n cross_entropy['u'] = (labels['u_ori'] *\n tf.nn.log_softmax(logits['u_aug'], axis=-1))\n largest_probs = tf.reduce_max(labels['u_ori'], axis=-1, keepdims=True)\n masks['u'] = tf.greater_equal(largest_probs, params.uda_threshold)\n masks['u'] = tf.cast(masks['u'], tf.float32)\n masks['u'] = tf.stop_gradient(masks['u'])\n cross_entropy['u'] = tf.reduce_sum(-cross_entropy['u']*masks['u']) / float(\n train_batch_size*uda_data)\n return logits, labels, masks, cross_entropy\n\n def step_fn(self, params, model):\n \"\"\"Separate implementation.\"\"\"\n train_batch_size = params.train_batch_size\n num_replicas = params.num_replicas\n batch_size = train_batch_size // num_replicas\n\n dtypes = [\n tf.bfloat16 if params.use_bfloat16 else tf.float32,\n tf.float32,\n tf.bfloat16 if params.use_bfloat16 else tf.float32,\n tf.bfloat16 if params.use_bfloat16 else tf.float32]\n shapes = [\n [batch_size, params.image_size, params.image_size, 3],\n [batch_size, params.num_classes],\n [batch_size*params.uda_data, params.image_size, params.image_size, 3],\n [batch_size*params.uda_data, params.image_size, params.image_size, 3]]\n\n if params.use_xla_sharding and params.num_cores_per_replica > 1:\n q = tpu_feed._PartitionedInfeedQueue(\n number_of_tuple_elements=4,\n host_id=0,\n input_partition_dims=[[1, 1, params.num_cores_per_replica, 1],\n [1, 1],\n [1, 1, params.num_cores_per_replica, 1],\n [1, 1, params.num_cores_per_replica, 1],],\n device_assignment=params.device_assignment)\n q.set_tuple_types(dtypes)\n q.set_tuple_shapes(shapes)\n l_images, l_labels, u_images_ori, u_images_aug = q.generate_dequeue_op()\n l_images = xla_sharding.split(l_images, 2,\n params.num_cores_per_replica)\n u_images_ori = xla_sharding.split(u_images_ori, 2,\n params.num_cores_per_replica)\n u_images_aug = xla_sharding.split(u_images_aug, 2,\n params.num_cores_per_replica)\n else:\n with tf.device(tf.tpu.core(0)):\n (l_images, l_labels, u_images_ori,\n u_images_aug) = tf.raw_ops.InfeedDequeueTuple(dtypes=dtypes,\n shapes=shapes)\n\n all_images = tf.concat([l_images, u_images_ori, u_images_aug], axis=0)\n global_step = tf.train.get_or_create_global_step()\n num_replicas = tf.cast(params.num_replicas, tf.float32)\n\n with tf.variable_scope(MODEL_SCOPE, reuse=tf.AUTO_REUSE):\n _, _, masks, cross_entropy = UDA.build_uda_cross_entropy(\n params, model, all_images, l_labels)\n\n l2_reg_rate = tf.cast(params.weight_decay / params.num_replicas, tf.float32)\n weight_dec = common_utils.get_l2_loss()\n uda_weight = params.uda_weight * tf.minimum(\n 1., tf.cast(global_step, tf.float32) / float(params.uda_steps))\n total_loss = (cross_entropy['u'] * uda_weight +\n cross_entropy['l'] +\n weight_dec * l2_reg_rate)\n variables = tf.trainable_variables()\n gradients = tf.gradients(total_loss, variables)\n gradients = [tf.tpu.cross_replica_sum(g) for g in gradients]\n gradients, grad_norm = tf.clip_by_global_norm(gradients, params.grad_bound)\n update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)\n\n learning_rate, optimizer = common_utils.get_optimizer(params)\n with tf.control_dependencies(update_ops):\n train_op = optimizer.apply_gradients(zip(gradients, variables),\n global_step=global_step)\n\n with tf.control_dependencies([train_op]):\n ema_train_op = common_utils.setup_ema(\n params, f'{MODEL_SCOPE}/{model.name}')\n\n with tf.control_dependencies([ema_train_op]):\n logs = collections.OrderedDict()\n logs['global_step'] = tf.cast(global_step, tf.float32)\n logs['loss/total'] = total_loss\n logs['loss/cross_entropy'] = cross_entropy['l']\n logs['loss/lr'] = tf.identity(learning_rate) / num_replicas\n logs['loss/grad_norm'] = tf.identity(grad_norm) / num_replicas\n logs['loss/weight_dec'] = weight_dec / num_replicas\n\n logs['uda/cross_entropy'] = cross_entropy['u']\n logs['uda/u_ratio'] = tf.reduce_mean(masks['u']) / num_replicas\n logs['uda/l_ratio'] = tf.reduce_mean(masks['l']) / num_replicas\n logs['uda/weight'] = uda_weight / num_replicas\n\n tensors = [tf.expand_dims(t, axis=0) for t in logs.values()]\n self.step_info = {k: [tf.float32, [1]] for k in logs.keys()}\n outfeed_enqueue_op = tf.cond(\n common_utils.should_log(params),\n lambda: tf.raw_ops.OutfeedEnqueueTuple(inputs=tensors), tf.no_op)\n return outfeed_enqueue_op\n\n\nclass MPL(object):\n \"\"\"Meta Pseudo Labels.\"\"\"\n\n def __init__(self):\n self.step_info = collections.OrderedDict()\n\n def outfeed_signature(self):\n \"\"\"Returns the sigature of `step_info` as returned by `step_fn`.\"\"\"\n return self.step_info\n\n def step_fn(self, params, model):\n \"\"\"Separate implementation.\"\"\"\n train_batch_size = params.train_batch_size\n num_replicas = params.num_replicas\n uda_data = params.uda_data\n batch_size = train_batch_size // num_replicas\n\n dtypes = [\n tf.bfloat16 if params.use_bfloat16 else tf.float32,\n tf.float32,\n tf.bfloat16 if params.use_bfloat16 else tf.float32,\n tf.bfloat16 if params.use_bfloat16 else tf.float32]\n shapes = [\n [batch_size, params.image_size, params.image_size, 3],\n [batch_size, params.num_classes],\n [batch_size*params.uda_data, params.image_size, params.image_size, 3],\n [batch_size*params.uda_data, params.image_size, params.image_size, 3]]\n\n if params.use_xla_sharding and params.num_cores_per_replica > 1:\n q = tpu_feed._PartitionedInfeedQueue(\n number_of_tuple_elements=4,\n host_id=0,\n input_partition_dims=[[1, 1, params.num_cores_per_replica, 1],\n [1, 1],\n [1, 1, params.num_cores_per_replica, 1],\n [1, 1, params.num_cores_per_replica, 1],],\n device_assignment=params.device_assignment)\n q.set_tuple_types(dtypes)\n q.set_tuple_shapes(shapes)\n l_images, l_labels, u_images_ori, u_images_aug = q.generate_dequeue_op()\n l_images = xla_sharding.split(l_images, 2,\n params.num_cores_per_replica)\n u_images_ori = xla_sharding.split(u_images_ori, 2,\n params.num_cores_per_replica)\n u_images_aug = xla_sharding.split(u_images_aug, 2,\n params.num_cores_per_replica)\n else:\n with tf.device(tf.tpu.core(0)):\n (l_images, l_labels, u_images_ori,\n u_images_aug) = tf.raw_ops.InfeedDequeueTuple(dtypes=dtypes,\n shapes=shapes)\n global_step = tf.train.get_or_create_global_step()\n num_replicas = tf.cast(params.num_replicas, tf.float32)\n\n all_images = tf.concat([l_images, u_images_ori, u_images_aug], axis=0)\n\n # all calls to teacher\n with tf.variable_scope('teacher', reuse=tf.AUTO_REUSE):\n logits, labels, masks, cross_entropy = UDA.build_uda_cross_entropy(\n params, model, all_images, l_labels)\n\n # 1st call to student\n with tf.variable_scope(MODEL_SCOPE):\n u_aug_and_l_images = tf.concat([u_images_aug, l_images], axis=0)\n logits['s_on_u_aug_and_l'] = model(u_aug_and_l_images, training=True)\n logits['s_on_u'], logits['s_on_l_old'] = tf.split(\n logits['s_on_u_aug_and_l'],\n [u_images_aug.shape[0].value, l_images.shape[0].value], axis=0)\n\n # for backprop\n cross_entropy['s_on_u'] = tf.losses.softmax_cross_entropy(\n onehot_labels=tf.stop_gradient(tf.nn.softmax(logits['u_aug'], -1)),\n logits=logits['s_on_u'],\n label_smoothing=params.label_smoothing,\n reduction=tf.losses.Reduction.NONE)\n cross_entropy['s_on_u'] = tf.reduce_sum(cross_entropy['s_on_u']) / float(\n train_batch_size*uda_data)\n\n # for Taylor\n cross_entropy['s_on_l_old'] = tf.losses.softmax_cross_entropy(\n onehot_labels=labels['l'],\n logits=logits['s_on_l_old'],\n reduction=tf.losses.Reduction.SUM)\n cross_entropy['s_on_l_old'] = tf.tpu.cross_replica_sum(\n cross_entropy['s_on_l_old']) / float(train_batch_size)\n shadow = tf.get_variable(\n name='cross_entropy_old', shape=[], trainable=False, dtype=tf.float32)\n shadow_update = tf.assign(shadow, cross_entropy['s_on_l_old'])\n\n w_s = {}\n g_s = {}\n g_n = {}\n lr = {}\n optim = {}\n w_s['s'] = [w for w in tf.trainable_variables()\n if w.name.lower().startswith(MODEL_SCOPE)]\n g_s['s_on_u'] = tf.gradients(cross_entropy['s_on_u'], w_s['s'])\n # g_s['s_on_u'] = [tf.tpu.cross_replica_sum(g) for g in g_s['s_on_u']]\n\n lr['s'] = common_utils.get_learning_rate(\n params,\n initial_lr=params.mpl_student_lr,\n num_warmup_steps=params.mpl_student_lr_warmup_steps,\n num_wait_steps=params.mpl_student_lr_wait_steps)\n lr['s'], optim['s'] = common_utils.get_optimizer(\n params, learning_rate=lr['s'])\n optim['s']._create_slots(w_s['s']) # pylint: disable=protected-access\n update_ops = [op for op in tf.get_collection(tf.GraphKeys.UPDATE_OPS)\n if op.name.startswith(f'train/{MODEL_SCOPE}/')]\n\n with tf.control_dependencies(update_ops + [shadow_update]):\n g_s['s_on_u'] = common_utils.add_weight_decay(\n params, w_s['s'], g_s['s_on_u'])\n g_s['s_on_u'], g_n['s_on_u'] = tf.clip_by_global_norm(\n g_s['s_on_u'], params.grad_bound)\n train_op = optim['s'].apply_gradients(zip(g_s['s_on_u'], w_s['s']))\n\n with tf.control_dependencies([train_op]):\n ema_train_op = common_utils.setup_ema(\n params, name_scope=f'{MODEL_SCOPE}/{model.name}')\n\n # 2nd call to student\n with tf.control_dependencies([ema_train_op]):\n with tf.variable_scope(MODEL_SCOPE, reuse=tf.AUTO_REUSE):\n logits['s_on_l_new'] = model(l_images, training=True)\n\n cross_entropy['s_on_l_new'] = tf.losses.softmax_cross_entropy(\n onehot_labels=labels['l'],\n logits=logits['s_on_l_new'],\n reduction=tf.losses.Reduction.SUM)\n cross_entropy['s_on_l_new'] = tf.tpu.cross_replica_sum(\n cross_entropy['s_on_l_new']) / float(train_batch_size)\n\n dot_product = cross_entropy['s_on_l_new'] - shadow\n # dot_product = tf.clip_by_value(\n # dot_product,\n # clip_value_min=-params.mpl_dot_product_bound,\n # clip_value_max=params.mpl_dot_product_bound)\n moving_dot_product = tf.get_variable(\n 'moving_dot_product', shape=[], trainable=False, dtype=tf.float32)\n moving_dot_product_update = tf.assign_sub(\n moving_dot_product, 0.01 * (moving_dot_product - dot_product))\n with tf.control_dependencies([moving_dot_product_update]):\n dot_product = dot_product - moving_dot_product\n dot_product = tf.stop_gradient(dot_product)\n cross_entropy['mpl'] = tf.losses.softmax_cross_entropy(\n onehot_labels=tf.stop_gradient(tf.nn.softmax(logits['u_aug'], axis=-1)),\n logits=logits['u_aug'],\n reduction=tf.losses.Reduction.NONE)\n cross_entropy['mpl'] = tf.reduce_sum(cross_entropy['mpl']) / float(\n train_batch_size*uda_data)\n\n # teacher train op\n uda_weight = params.uda_weight * tf.minimum(\n 1., tf.cast(global_step, tf.float32) / float(params.uda_steps))\n teacher_loss = (cross_entropy['u'] * uda_weight +\n cross_entropy['l'] +\n cross_entropy['mpl'] * dot_product)\n w_s['t'] = [w for w in tf.trainable_variables() if 'teacher' in w.name]\n g_s['t'] = tf.gradients(teacher_loss, w_s['t'])\n g_s['t'] = common_utils.add_weight_decay(params, w_s['t'], g_s['t'])\n g_s['t'], g_n['t'] = tf.clip_by_global_norm(g_s['t'], params.grad_bound)\n lr['t'] = common_utils.get_learning_rate(\n params,\n initial_lr=params.mpl_teacher_lr,\n num_warmup_steps=params.mpl_teacher_lr_warmup_steps)\n lr['t'], optim['t'] = common_utils.get_optimizer(params,\n learning_rate=lr['t'])\n\n teacher_train_op = optim['t'].apply_gradients(zip(g_s['t'], w_s['t']),\n global_step=global_step)\n\n with tf.control_dependencies([teacher_train_op]):\n logs = collections.OrderedDict()\n logs['global_step'] = tf.cast(global_step, tf.float32)\n\n logs['cross_entropy/student_on_u'] = cross_entropy['s_on_u']\n logs['cross_entropy/student_on_l'] = (cross_entropy['s_on_l_new'] /\n num_replicas)\n logs['cross_entropy/teacher_on_u'] = cross_entropy['u']\n logs['cross_entropy/teacher_on_l'] = cross_entropy['l']\n logs['lr/student'] = tf.identity(lr['s']) / num_replicas\n logs['lr/teacher'] = tf.identity(lr['t']) / num_replicas\n logs['mpl/dot_product'] = dot_product / num_replicas\n logs['mpl/moving_dot_product'] = moving_dot_product / num_replicas\n logs['uda/u_ratio'] = tf.reduce_mean(masks['u']) / num_replicas\n logs['uda/l_ratio'] = tf.reduce_mean(masks['l']) / num_replicas\n logs['uda/weight'] = uda_weight / num_replicas\n\n tensors = [tf.expand_dims(t, axis=0) for t in logs.values()]\n self.step_info = {k: [tf.float32, [1]] for k in logs.keys()}\n def outfeed(tensors):\n with tf.device(tf.tpu.core(params.num_cores_per_replica-1)):\n return tf.raw_ops.OutfeedEnqueueTuple(inputs=tensors)\n\n outfeed_enqueue_op = tf.cond(\n common_utils.should_log(params), lambda: outfeed(tensors), tf.no_op)\n\n return outfeed_enqueue_op\n",
"# coding=utf-8\n# Copyright 2021 The Google Research 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\"\"\"Contains logging/saving utilities.\"\"\"\nimport csv\nimport tensorflow as tf\n\n\ndef log_row(csv_file, row):\n with tf.gfile.Open(csv_file, 'ab') as csvfile:\n cw = csv.writer(\n csvfile, delimiter='\\t', quotechar='|', quoting=csv.QUOTE_MINIMAL)\n cw.writerow(row)\n",
"# coding=utf-8\n# Copyright 2021 The Google Research Authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n# Lint as: python3\n# pylint:disable=line-too-long\nr\"\"\"Counts average audio length.\n\n\"\"\"\n# pylint:enable=line-too-long\n\nimport os\nfrom typing import Any, Dict, Iterable, List, Tuple\n\nfrom absl import app\nfrom absl import flags\nfrom absl import logging\n\nimport apache_beam as beam\nimport numpy as np\nimport tensorflow as tf\n\nfrom non_semantic_speech_benchmark.data_prep import audio_to_embeddings_beam_utils\n\nflags.DEFINE_string('output_file', None, 'Output file.')\nflags.DEFINE_boolean('debug', False, 'Whether to debug.')\nflags.DEFINE_list(\n 'audio_keys', ['audio', 'processed/audio_samples', 'audio_waveform'],\n 'Possible audio keys in tf.Examples.')\nflags.DEFINE_list(\n 'sr_keys', [], 'Possible sample rate keys in tf.Examples.')\n\nFLAGS = flags.FLAGS\n\n\ndef duration_from_tfex(k_v):\n \"\"\"Duration from a tf.Example.\"\"\"\n k, ex = k_v\n\n audio_vals = []\n for possible_audio_key in FLAGS.audio_keys:\n if possible_audio_key in ex.features.feature:\n logging.info('Found audio key: %s', possible_audio_key)\n audio_feats = ex.features.feature[possible_audio_key]\n cur_audio_vals = (audio_feats.int64_list.value or\n audio_feats.float_list.value)\n assert cur_audio_vals\n audio_vals.append(cur_audio_vals)\n assert len(audio_vals) == 1, ex\n audio_vals = audio_vals[0]\n logging.info('%s audio: %s', k, audio_vals)\n\n sr_vals = []\n for possible_sr_key in FLAGS.sr_keys:\n if possible_sr_key in ex.features.feature:\n logging.info('Found sample rate key: %s', possible_sr_key)\n cur_audio = ex.features.feature[possible_sr_key].int64_list.value[0]\n sr_vals.append(cur_audio)\n assert len(sr_vals) in [0, 1], ex\n if len(sr_vals) == 1:\n sr = sr_vals[0]\n else:\n logging.info('Used default sr.')\n sr = 16000\n\n return len(audio_vals) / float(sr)\n\n\ndef durations(root, ds_file, ds_name,\n reader_type, suffix):\n \"\"\"Beam pipeline for durations from a particular file or glob.\"\"\"\n logging.info('Reading from %s: (%s, %s)', reader_type, ds_name, ds_file)\n input_examples = audio_to_embeddings_beam_utils.reader_functions[reader_type](\n root, ds_file, f'Read-{suffix}')\n return input_examples | f'Lens-{suffix}' >> beam.Map(duration_from_tfex)\n\n\ndef duration_and_num_examples(\n root, ds_files, ds_name,\n reader_type):\n \"\"\"Beam pipeline for durations from a list of files or globs.\"\"\"\n durations_l = []\n for i, ds_file in enumerate(ds_files):\n cur_dur = durations(\n root, ds_file, ds_name, reader_type, suffix=f'{ds_name}_{i}')\n durations_l.append(cur_dur)\n def _mean_and_count(durs):\n return np.mean(durs), len(durs)\n return (durations_l\n | f'Flatten-{ds_name}' >> beam.Flatten()\n | f'ToList-{ds_name}' >> beam.combiners.ToList()\n | f'Stats-{ds_name}' >> beam.Map(_mean_and_count))\n\n\ndef get_dataset_info_dict(debug):\n \"\"\"Get dictionary of dataset info.\"\"\"\n def _tfds_fns(ds_name):\n fns = [\n x # pylint:disable=g-complex-comprehension\n for s in ('train', 'validation', 'test')\n for x in audio_to_embeddings_beam_utils._tfds_filenames(ds_name, s)] # pylint:disable=protected-access\n fns = [fns] # TFRecords require a list.\n return (fns, 'tfrecord')\n\n if debug:\n dss = {'savee': _tfds_fns('savee')}\n else:\n dss = {\n 'crema_d': _tfds_fns('crema_d'),\n 'savee': _tfds_fns('savee'),\n 'speech_commands': _tfds_fns('speech_commands'),\n 'voxceleb': _tfds_fns('voxceleb'),\n }\n\n return dss\n\n\ndef main(unused_argv):\n dss = get_dataset_info_dict(FLAGS.debug)\n\n out_file = FLAGS.output_file\n assert not tf.io.gfile.exists(out_file)\n if not tf.io.gfile.exists(os.path.dirname(out_file)):\n tf.io.gfile.makedirs(os.path.dirname(out_file))\n\n pipeline_option = None\n\n with beam.Pipeline(pipeline_option) as root:\n stats = [] # (ds name, avg duration, num examples)\n for ds_name, (ds_files, reader_type) in dss.items():\n cur_stat = duration_and_num_examples(root, ds_files, ds_name, reader_type)\n cur_stat = cur_stat | f'AddName-{ds_name}' >> beam.Map(\n lambda x, name: (name, x[0], x[1]), name=ds_name)\n stats.append(cur_stat)\n # Write output.\n _ = (\n stats\n | 'CombineDSes' >> beam.Flatten()\n | 'ToStr' >> beam.Map(lambda x: ','.join([str(r) for r in x]))\n | 'WriteOutput' >> beam.io.WriteToText(out_file, num_shards=1))\n\n\nif __name__ == '__main__':\n flags.mark_flag_as_required('output_file')\n app.run(main)\n",
"# coding=utf-8\n# Copyright 2021 The Google Research 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\"\"\"Common utilities for colab notebooks.\"\"\"\n\nimport collections\nimport datetime\nimport functools\nimport sys\nfrom typing import Any, List, Optional, Tuple\n\nimport numpy as np\nimport pandas as pd\nimport scipy.stats\n\n# pylint: disable=g-import-not-at-top\n# Only import version_utils if we are in a colab\nif 'google.colab' in sys.modules:\n from cloud_covid19_forecasting.etl.tools import version_utils\n# pylint: enable=g-import-not-at-top\n\nBQ_TABLES = {\n 'japan': 'covid_prod_features.jp_prefecture_ts',\n 'state': 'covid_prod_features.us_state_ts',\n 'county': 'covid_prod_features.us_county_ts',\n}\n\n# pylint: disable=line-too-long\nGT_FIELD_NAMES = {\n 'japan':\n 'kaz_deaths,open_gt_jp_deaths,kaz_confirmed_cases,open_gt_jp_confirmed_cases',\n 'state':\n 'jhu_state_confirmed_cases,jhu_state_deaths',\n 'county':\n 'jhu_county_confirmed_cases,jhu_county_deaths',\n}\n# pylint: enable=line-too-long\n\nLOC_NAME = {\n 'japan': 'pref',\n 'state': 'state_code',\n 'county': 'geo_id',\n}\n\n\ndef calculate_mape_apply_fn(row,\n average_type,\n expected_num_locations,\n min_count=None,\n min_mae=None,\n time_horizon=27,\n debug=False,\n value_type='cumulative'):\n \"\"\"Calculate MAPE, depending on various flags.\n\n From\n 'https://datascience.stackexchange.com/questions/15989/micro-average-vs-macro-average-performance-in-a-multiclass-classification-settin':\n \"A macro-average will compute the metric independently for each class and then\n take the average (hence treating all classes equally), whereas a micro-average\n will aggregate the contributions of all classes to compute the average\n metric.\"\n\n Args:\n row: A pd.Series. Should all have the same date.\n average_type: Python string. Either 'micro' or 'macro'.\n expected_num_locations: Expected number of locations.\n min_count: If not `None`, ignore values with max(gt) < min_count. Should be\n `None` if `average_type='micro'`. Only one of `min_count` and `min_mae`\n should be not `None.\n min_mae: If not `None`, ignore values with `mae < min_mae`. Should be `None`\n if `average_type='micro'`. Only one of `min_count` and `min_mae` should be\n not `None.\n time_horizon: The time horizon value to compare cumulative metrics on. The\n end of the forecast window is usually 28 days, but Reichlab uses 27 days,\n so we use that as the default. Note that `time_horizon` is 1-indexed,\n while Python arrays are 0-indexed.\n debug: Python bool. Whether to print verbose debug info.\n value_type: Python string. Describes the values to use for MAPE calculation.\n\n Returns:\n The appropriate MAPE score.\n \"\"\"\n assert average_type in ['micro', 'macro']\n assert expected_num_locations in [47, 51]\n assert value_type in ['cumulative', '4week', 'weekly']\n if average_type == 'micro':\n assert min_count is None, min_count\n assert min_mae is None, min_mae\n assert (min_count is None) or (min_mae is None), (min_count, min_mae)\n if 'forecast_date' in row:\n assert len(row.forecast_date.unique()) == 1, row\n cur_forecast_date = row.forecast_date.unique()[0]\n row_dat = row[['location_name', 0]]\n assert len(row_dat) == expected_num_locations, len(row_dat)\n\n # For macro average.\n mapes = []\n # For micro average.\n total_pred = None\n total_gt = None\n\n for _, loc_dat in row_dat.iterrows():\n cur_location_name = loc_dat.location_name\n cur_dat_dict = loc_dat[0]\n assert isinstance(cur_location_name, str), cur_location_name\n if not isinstance(cur_dat_dict, dict):\n assert np.isnan(cur_dat_dict), cur_dat_dict\n print(f'{cur_forecast_date} {cur_location_name} had no data, so '\n 'continuing with date...')\n continue\n # Time horizon is 1-indexed, but arrays are 0-index, so subtract 1.\n assert time_horizon <= len(cur_dat_dict['predictions'])\n if value_type == '4week':\n assert 'day_zero_gt' in cur_dat_dict, cur_dat_dict\n base_gt = cur_dat_dict['day_zero_gt']\n assert base_gt is not None, cur_dat_dict\n\n # The total increase over the last time window is\n # `dat[-1] - day_0_gt`, so we use this value in the \"4week\" case.\n # We use `day_0_gt` (rather than `gt[0]` in the forecast window) so that\n # incident cases on every day of the forecast window is possibly non-zero.\n pred_ys = (\n cur_dat_dict['predictions'][time_horizon - 1:time_horizon] - base_gt)\n gtru_ys = (\n cur_dat_dict['ground_truth'][time_horizon - 1:time_horizon] - base_gt)\n elif value_type == 'cumulative':\n # Since we are computing MAPE over cumulative values, we only care about\n # the values at the end of the forecast period.\n pred_ys = cur_dat_dict['predictions'][time_horizon - 1:time_horizon]\n gtru_ys = cur_dat_dict['ground_truth'][time_horizon - 1:time_horizon]\n else:\n assert value_type == 'weekly'\n # TODO(joelshor): We ignore `time_horizon`. Consider whether to use it.\n # Weekly is i=0,1,2,3, `dat[i*7 + 6] - dat[i*7]`, averaged over i.\n # However, since we only have 27 days into the future for GT, we modify\n # the last day.\n preds = cur_dat_dict['predictions']\n pred_ys = np.array([preds[7 * i + 6] - preds[7 * i] for i in range(3)] +\n [preds[7 * 3 + 5] - preds[7 * 3]])\n gtrs = cur_dat_dict['ground_truth']\n gtru_ys = np.array([gtrs[7 * i + 6] - gtrs[7 * i] for i in range(3)] +\n [gtrs[7 * 3 + 5] - gtrs[7 * 3]])\n if debug:\n print(f'{cur_forecast_date} {cur_location_name}: '\n f'gt {gtru_ys} pred {pred_ys}')\n\n if average_type == 'micro':\n if total_pred is None and total_gt is None:\n total_pred = np.zeros_like(pred_ys)\n total_gt = np.zeros_like(gtru_ys)\n assert isinstance(total_pred, np.ndarray)\n assert isinstance(total_gt, np.ndarray)\n total_pred += pred_ys\n total_gt += gtru_ys\n continue\n\n assert average_type == 'macro'\n assert isinstance(pred_ys, np.ndarray), type(pred_ys)\n assert isinstance(gtru_ys, np.ndarray), type(gtru_ys)\n assert pred_ys.size == (4 if value_type == 'weekly' else 1), pred_ys.size\n assert gtru_ys.size, gtru_ys.size\n\n cur_mape = calculate_mape(\n predictions=pred_ys.tolist(), ground_truths=gtru_ys.tolist())\n if debug:\n print(f'{cur_forecast_date} {cur_location_name}: MAPE: {cur_mape}')\n\n if min_count and max(gtru_ys) < min_count:\n mapes.append(np.nan)\n elif min_mae:\n cur_mae = calculate_mae(\n predictions=pred_ys.tolist(), ground_truth=gtru_ys.tolist())\n if cur_mae < min_mae:\n mapes.append(np.nan)\n else:\n mapes.append(cur_mape)\n else:\n mapes.append(cur_mape)\n\n if average_type == 'micro':\n if total_pred is None:\n return np.nan\n else:\n assert isinstance(total_pred, np.ndarray), total_pred\n assert isinstance(total_gt, np.ndarray), total_gt\n # We are only looking at the end of the forecast window, so it should be\n # size 1 if not weekly..\n assert total_pred.size == (4 if value_type == 'weekly' else\n 1), total_pred.size\n assert total_gt.size == total_pred.size, total_gt.size\n avg_pred = total_pred / expected_num_locations\n avg_gt = total_gt / expected_num_locations\n cur_mape = calculate_mape(\n predictions=avg_pred.tolist(), ground_truths=avg_gt.tolist())\n return cur_mape\n else:\n if len(mapes) == 0: # pylint:disable=g-explicit-length-test\n return np.nan\n else:\n assert average_type == 'macro', average_type\n # With low death counts, some prefectures are dropped, so this assert\n # isn't always helpful.\n # assert len(mapes) == expected_num_locations, len(mapes)\n return np.nanmean(mapes)\n\n\ndef get_gt(loc,\n start_date,\n end_date,\n feature_name,\n locale,\n bq_client,\n version = None,\n capitalize = True):\n \"\"\"Get ground truth in a colab.\"\"\"\n assert locale in ['japan', 'state', 'county'], locale\n\n assert feature_name in GT_FIELD_NAMES[locale], \\\n f'{feature_name} vs {GT_FIELD_NAMES[locale]}'\n\n bq_table = BQ_TABLES[locale]\n # Get the proper version.\n q = f'select DISTINCT(version) from `{bq_table}`'\n versions = bq_client.query(q).to_dataframe()\n if version:\n if version not in versions:\n raise ValueError(f'Version not found: {version} vs {versions}')\n else:\n # Get latest GT data ex \"2020-07-18 19:59:42 UTC\"\n version = versions.max()[0].strftime('%Y-%m-%d %H:%M:%S %Z')\n\n loc_field = LOC_NAME[locale]\n if capitalize:\n loc = loc.capitalize()\n q = (f'select dt,{loc_field},feature_name,feature_value '\n f'from `{bq_table}` '\n f'where dt >= \"{start_date}\" and dt <= \"{end_date}\" '\n f'and {loc_field} = \"{loc}\"'\n f'and feature_name = \"{feature_name}\" '\n f'and version = \"{version}\"')\n gt_pd = bq_client.query(q).to_dataframe()\n assert gt_pd.size > 0, q\n xs, ys = [], []\n for d, v in gt_pd.sort_values(by='dt')[['dt', 'feature_value']].values:\n xs.append(d)\n ys.append(v)\n return xs, ys\n\n\ndef get_all_gt(start_date,\n end_date,\n locale,\n bq_client,\n version = None,\n feature_keys = None):\n \"\"\"Return all ground truth during a certain date.\"\"\"\n assert locale in ['japan', 'state', 'county'], locale\n\n bq_table = BQ_TABLES[locale]\n # Get the proper version.If `version` is `None`, select latest.\n # If `version` is a string, use that version.\n # If `version` is a list, get all those versions.\n q = f'select DISTINCT(version) from `{bq_table}`'\n versions = bq_client.query(q).to_dataframe()\n if version is None:\n # Get latest GT data ex \"2020-07-18 19:59:42 UTC\"\n version = versions.max()[0].strftime('%Y-%m-%d %H:%M:%S %Z')\n elif isinstance(version, str):\n if not np.any(str(version) == versions):\n raise ValueError(f'Version not found: {version} vs {versions.to_numpy()}')\n else:\n assert isinstance(version, list)\n\n loc_field = LOC_NAME[locale]\n if isinstance(version, list):\n v_str = ','.join([f'\"{x}\"' for x in version])\n version_q = f'and version IN ({v_str})'\n else:\n version_q = f'and version = \"{version}\"'\n if feature_keys is not None:\n feat_str = ','.join([f'\"{x}\"' for x in feature_keys])\n feature_q = f' and feature_name IN ({feat_str})'\n else:\n feature_q = ''\n q = (f'select dt,{loc_field},feature_name,feature_value,version '\n f'from `{bq_table}` '\n f'where dt >= \"{start_date}\" and dt <= \"{end_date}\" '\n f' {version_q}{feature_q}')\n print(f'Querying GT with: \"{q}\"')\n gt_pd = bq_client.query(q).to_dataframe()\n assert gt_pd.size > 0, q\n\n if locale == 'japan':\n # Change data to standard spelling eg \"Hyōgo\" -> \"Hyogo\". The prefecture\n # names changed when we switched Japan data sources, so both names are\n # present in the GT tables.\n gt_pd = gt_pd.replace({loc_field: open_covid_locations_to_kaz_map()})\n\n return gt_pd\n\n\ndef get_gt_over_dates_and_versions(dates_and_gt_versions,\n locale,\n client,\n gt_feature_name,\n duration_days=28):\n \"\"\"Gets a single GT dataframe with the dates and versions requested.\"\"\"\n assert locale in ['japan', 'state'], locale\n\n # Minimize the number of reads by grouping reads of the same version.\n def _end_date_from_str(start_date):\n return (datetime.datetime.strptime(start_date, '%Y-%m-%d').date() +\n datetime.timedelta(days=duration_days)).isoformat()\n\n version_map = collections.defaultdict(list)\n for date, version in dates_and_gt_versions:\n version_map[version].append(date)\n version_map_list = [(v, min(dates), _end_date_from_str(max(dates)))\n for v, dates in version_map.items()]\n\n gt_dfs = []\n for version, start_date, end_date in version_map_list:\n # Read GT slice.\n print(f'Reading GT from {start_date} to {end_date}, version {version}...')\n gt_df = get_all_gt(\n start_date=start_date,\n end_date=end_date,\n locale=locale,\n bq_client=client,\n feature_keys=[gt_feature_name],\n version=version)\n gt_dfs.append(gt_df)\n gt_df = pd.concat(gt_dfs, axis=0).drop_duplicates()\n return gt_df\n\n\ndef get_gt_version_names(dates, version_locale, min_version, use_latest_gt,\n client):\n \"\"\"Returns either latest version or T+28 data version.\"\"\"\n assert isinstance(dates, list), type(dates)\n if use_latest_gt:\n gt_version = datetime.datetime.strptime(\n get_latest_version(client).name, '%Y-%m-%d %H:%M:%S %Z')\n gt_versions = [gt_version for _ in range(len(dates))]\n else:\n if isinstance(dates[0], str):\n dates = [datetime.datetime.strptime(d, '%Y-%m-%d').date() for d in dates]\n gt_versions = data_version_for_retrospective(\n dates,\n min_version=min_version,\n locale={\n 'japan': 'jp_prefecture',\n 'state': 'us_state'\n }[version_locale],\n client=client)\n return [\n gt_version.strftime('%Y-%m-%d %H:%M:%S+00:00')\n for gt_version in gt_versions\n ]\n\n\ndef get_public_forecast(\n forecast_pd,\n loc,\n cur_date,\n feature_key,\n loc_key,\n expeced_forecast_len = 28,\n prediction_date_key = 'prediction_date'):\n \"\"\"Extracts a single prediction from the historical forecasts table.\"\"\"\n assert loc_key in forecast_pd.columns, (loc_key, forecast_pd.columns)\n assert prediction_date_key in forecast_pd.columns, forecast_pd.columns\n assert feature_key in forecast_pd.columns, (feature_key, forecast_pd.columns)\n\n forecast = forecast_pd[(forecast_pd[loc_key] == loc)\n & (forecast_pd.forecast_date == cur_date) &\n (forecast_pd[prediction_date_key] > cur_date)]\n assert forecast.size > 0, (loc, cur_date, feature_key, loc_key)\n forecast_vals = forecast[[prediction_date_key,\n feature_key]].sort_values(by=prediction_date_key)\n xs = forecast_vals[prediction_date_key].to_numpy()\n ys = forecast_vals[feature_key].astype(np.float32).to_numpy()\n assert isinstance(xs[0], datetime.date), type(xs[0])\n assert xs.size == expeced_forecast_len, f'xs size: {xs.size}'\n assert ys.size == expeced_forecast_len, f'xs size: {ys.size}'\n return xs, ys\n\n\ndef calculate_mape(predictions, ground_truths):\n \"\"\"Calculate MAPE in a colab friendly way.\"\"\"\n if not predictions or len(predictions) != len(ground_truths):\n raise ValueError(\n 'Predictions and Ground Truth should be of equal length and non-empty')\n\n error = 0.\n num_nonzero_ground_truth = 0\n for prediction, ground_truth in zip(predictions, ground_truths):\n if ground_truth != 0:\n error += abs((prediction - ground_truth) / ground_truth)\n num_nonzero_ground_truth += 1\n\n if num_nonzero_ground_truth == 0:\n return float('nan')\n\n return 100 * error / num_nonzero_ground_truth\n\n\ndef calculate_mae(predictions, ground_truth):\n \"\"\"Calculate MAE in a colab friendly way.\"\"\"\n if not predictions or len(predictions) != len(ground_truth):\n raise ValueError(\n 'Predictions and Ground Truth should be of equal length and non-empty')\n\n error = 0.\n for i in range(len(predictions)):\n error += abs(predictions[i] - ground_truth[i])\n\n error /= len(predictions)\n\n return error\n\n\nLOCALES = ['country', 'us_county', 'us_state', 'jp_prefecture']\n\n\[email protected]_cache(maxsize=32)\ndef _read_data_versions(bq_client, locale):\n \"\"\"Wrapper around version table for easy caching.\"\"\"\n return version_utils.Client(bq_client).read_data_versions(\n dataset_name='covid_prod_features', table_name=f'{locale}_ts')\n\n\ndef get_closest_versions(ds,\n locale,\n bq_client = None,\n buffer_days = 0):\n \"\"\"Returns last first version stricly after given date + buffer days.\"\"\"\n if locale not in LOCALES:\n raise ValueError(f'Locale not recognized: {locale} not in {LOCALES}')\n vs = _read_data_versions(bq_client, locale)\n vs = [(version_utils.version_name_to_datetime(v).date(), v) for v in vs]\n\n vs = sorted(vs)\n rets = []\n for d in ds:\n if d < vs[0][0]:\n rets.append(vs[0][1])\n continue\n if d >= vs[-1][0]:\n rets.append(vs[-1][1])\n continue\n\n for i in range(len(vs)):\n # Don't break on equality, since we want strictly less than.\n if vs[i][0] > d + datetime.timedelta(days=buffer_days or 0):\n break\n rets.append(vs[i][1])\n\n return rets\n\n\ndef get_latest_version(bq_client):\n return version_utils.Client(bq_client).get_latest_version()\n\n\ndef version_or_min_version(version, min_version):\n \"\"\"Pick version or min version.\"\"\"\n if (version_utils.version_name_to_datetime(version) <=\n version_utils.version_name_to_datetime(min_version)):\n return min_version\n else:\n return version\n\n\ndef data_version_for_retrospective(dates,\n min_version,\n locale,\n client,\n days_ahead = 28):\n \"\"\"Get the GT data version associated with a particular time period.\n\n Args:\n dates: List of dates to fetch values for. This is parallelized for speed.\n min_version: Japan has a data minimum version, so use that if the requested\n version is too early.\n locale: String for locale.\n client: BQ Client for reading tables.\n days_ahead: Minimum number of days to include. If, for example, we want 28\n days ahead, we should look ahead (28-1) = 27 days. Some days in the\n prospective period actually require 28 day lookahead for some reason,\n however, so we rely on the automatic increment mechanism later in the\n code.\n\n Returns:\n List of version datetimes.\n \"\"\"\n version_dates = [d + datetime.timedelta(days=days_ahead) for d in dates]\n version_strs = get_closest_versions(version_dates, locale, client)\n if min_version:\n version_strs = [\n version_or_min_version(v_str, min_version=min_version)\n for v_str in version_strs\n ]\n return [\n version_utils.version_name_to_datetime(v_str) for v_str in version_strs\n ]\n\n\ndef trial_name_to_df(trial_name,\n predicted_metric,\n client,\n num_locs=47,\n forecast_len=28):\n \"\"\"Reads a trial name forecasts. Used for fetching retrospective results.\"\"\"\n assert predicted_metric in ['death', 'confirmed']\n\n # Read from the table and make sure the output is correct.\n all_pd = client.query(f'select * from `eval.{trial_name}`').to_dataframe()\n cur_pd = all_pd[all_pd.predicted_metric == predicted_metric][[\n 'location_name', 'time_horizon', 'point_prediction',\n 'target_prediction_date'\n ]]\n assert len(cur_pd) == num_locs * forecast_len, (\n len(cur_pd), all_pd.predicted_metric.unique())\n\n def _sort(x):\n x = x.sort_values(by='time_horizon')\n return {\n 'predictions': x.point_prediction.values,\n 'prediction_date': x.target_prediction_date.dt.date.values,\n }\n\n preds_pd = cur_pd.groupby('location_name').apply(_sort)\n assert len(preds_pd) == num_locs, len(preds_pd)\n\n target_prediction_dates = sorted(cur_pd['target_prediction_date'].unique())\n assert len(target_prediction_dates) == forecast_len\n\n return preds_pd, target_prediction_dates\n\n\ndef gather_data_from_prospective_row(row,\n gt_df,\n locale,\n available_versions,\n expected_forecast_len = 28,\n expected_gt_len = 27,\n debug = False):\n \"\"\"Pandas `apply` fn to gather GT and preds from data.\n\n We use this function to parallelize using the pandas groupby.\n With this optimization (compared to a for-loop), this function goes from\n 1.2 min -> 0.2 on Japan.\n 2.0 min -> XXX on US.\n\n Args:\n row:\n gt_df:\n locale:\n available_versions: A numpy array of available versions in `gt_df`. The\n difference between precomputing this and doing it on-the-fly for each row\n is about 10 minutes of compute over the prospective window, so we pass\n this in precomputed as a speedup.\n expected_forecast_len: Expected length of the forecast.\n expected_gt_len: Expected length of GT. Doesn't have to match\n `expected_forecast_len` due to how forecasts are measured.\n debug:\n\n Returns:\n {'dates', 'predictions', 'ground_truth'}\n \"\"\"\n assert 'predictions' in row.columns, row.columns\n assert 'prediction_date' in row.columns, row.colums\n assert 'gt_version' in row.columns, row.columns\n assert len(row.gt_version.unique()) == 1\n gt_version = row.gt_version.unique()[0]\n date, loc = row.name\n row = row.sort_values(by='prediction_date')\n pred_xs = row.prediction_date.values\n pred_ys = row.predictions.values\n\n return _row_gather_helper(loc, date, gt_version, available_versions, locale,\n pred_xs, pred_ys, expected_forecast_len,\n expected_gt_len, gt_df, debug)\n\n\ndef gather_data_from_retrospective_row(row,\n gt_df,\n locale,\n available_versions,\n expected_forecast_len = 28,\n expected_gt_len = 27,\n set_missing_values_to_zero = False,\n debug = False):\n \"\"\"Pandas `apply` fn to gather GT and preds from data.\n\n We use this function to parallelize using the pandas groupby.\n With this optimization (compared to a for-loop), this function goes from\n 1.2 min -> 0.2 on Japan.\n 2.0 min -> XXX on US.\n\n Args:\n row:\n gt_df:\n locale:\n available_versions: A numpy array of available versions in `gt_df`. The\n difference between precomputing this and doing it on-the-fly for each row\n is about 10 minutes of compute over the prospective window, so we pass\n this in precomputed as a speedup.\n expected_forecast_len: Expected length of the forecast.\n expected_gt_len: Expected length of GT. Doesn't have to match\n `expected_forecast_len` due to how forecasts are measured.\n set_missing_values_to_zero: If `True`, assuming missing GT values are 0.\n This should only be used for Japan deaths, during the retrospective\n period.\n debug:\n\n Returns:\n {'dates', 'predictions', 'ground_truth'}\n \"\"\"\n assert 'data' in row.index, row.index\n assert 'gt_version' in row.index, row.index\n date, loc = row.name\n date = datetime.datetime.strptime(date, '%Y-%m-%d').date()\n pred_xs = row.data['prediction_date']\n pred_ys = row.data['predictions']\n gt_version = row.gt_version\n\n return _row_gather_helper(loc, date, gt_version, available_versions, locale,\n pred_xs, pred_ys, expected_forecast_len,\n expected_gt_len, gt_df, debug,\n set_missing_values_to_zero)\n\n\ndef get_next_gt_version(cur_gt_version, all_gt_versions):\n \"\"\"Get the next gt version.\"\"\"\n assert cur_gt_version in all_gt_versions, (cur_gt_version, all_gt_versions)\n index = np.where(all_gt_versions == cur_gt_version)[0]\n assert len(index) == 1, index\n index = int(index[0])\n assert isinstance(index, int), (index, type(index))\n\n next_gt_version = all_gt_versions[index + 1]\n assert isinstance(next_gt_version, str), type(next_gt_version)\n\n return next_gt_version\n\n\ndef _day_before(day_date):\n assert isinstance(day_date, datetime.date)\n return day_date - datetime.timedelta(days=1)\n\n\ndef _row_gather_helper(loc,\n date,\n gt_version,\n available_versions,\n locale,\n pred_xs,\n pred_ys,\n expected_forecast_len,\n expected_gt_len,\n gt_df,\n debug,\n set_missing_values_to_zero=False,\n get_day_zero_gt=True):\n \"\"\"Common code for prospective / retrospective row gathers.\"\"\"\n assert len(pred_xs) == len(pred_ys)\n\n if len(pred_ys) != expected_forecast_len:\n print(f'No good predictions for {loc} {date}: '\n f'{len(pred_ys)} vs {expected_forecast_len}')\n return np.nan\n\n assert isinstance(pred_xs, np.ndarray), type(pred_xs)\n assert isinstance(pred_ys, np.ndarray), type(pred_ys)\n\n loc_key = LOC_NAME[locale]\n assert isinstance(date, datetime.date)\n\n # Change the location name, if necessary.\n gt_loc = loc.title()\n if locale == 'state':\n if gt_loc not in STATE_TO_CODE_MAP_:\n print(f'Skipping state {gt_loc}, since not found.')\n return np.nan\n gt_loc = STATE_TO_CODE_MAP_[gt_loc]\n\n # Get the right GT slice for this prediction window.\n # We start with `gt_version`, and increment until we have enough data to cover\n # `expected_gt_len` days into the future. This matches how the evaluator does\n # it.\n # We might have multiple features, so pick one that's the right length.\n feature_names = gt_df.feature_name.unique()\n cur_gt_version, cur_gt, day_zero_gt = None, pd.DataFrame(), None\n while cur_gt.size == 0 or len(cur_gt.dt.unique()) < expected_gt_len:\n if cur_gt_version is None:\n cur_gt_version = gt_version\n else:\n print(f'Date {date} {gt_loc} failed: Found {len(cur_gt.dt.unique())}, '\n f'expected {expected_gt_len} days with version {cur_gt_version}, '\n 'so incrementing...')\n cur_gt_version = get_next_gt_version(cur_gt_version, available_versions)\n for feature_name in feature_names:\n min_gt = _day_before(min(pred_xs)) if get_day_zero_gt else min(pred_xs)\n assert isinstance(min_gt, datetime.date)\n cur_gt = gt_df[(gt_df.version == cur_gt_version)\n & (gt_df.dt >= min_gt) & (gt_df.dt <= max(pred_xs)) &\n (gt_df[loc_key] == gt_loc) &\n (gt_df.feature_name == feature_name)][[\n 'dt', 'feature_value'\n ]]\n expected_len = expected_gt_len + 1 if get_day_zero_gt else expected_gt_len\n if len(cur_gt.dt.unique()) >= expected_len:\n if get_day_zero_gt:\n day_zero_gt = cur_gt[cur_gt.dt == min_gt]\n if len(day_zero_gt) == 0 and set_missing_values_to_zero: # pylint:disable=g-explicit-length-test\n day_zero_gt = 0\n else:\n day_zero_gt = day_zero_gt.feature_value.values[0]\n cur_gt = cur_gt[~(cur_gt.dt == min_gt)]\n break\n # Japan deaths are often empty, but we can safely assume that they're 0. So\n # skip the sanity check, and just assume that missing values are 0 later.\n if set_missing_values_to_zero:\n break\n assert len(cur_gt.dt.unique()) >= expected_gt_len\n assert expected_gt_len <= expected_forecast_len\n if set_missing_values_to_zero:\n cur_dates = cur_gt.dt.unique()\n expected_dates = pd.date_range(start=min(pred_xs), end=max(pred_xs))\n missing_dates = expected_dates.difference(cur_dates)\n if missing_dates.size > 0:\n print(f'Found missing dates for {date} {gt_loc}: {missing_dates}')\n cur_gt = cur_gt.append([{\n 'dt': dt.date(),\n 'feature_value': 0.0\n } for dt in missing_dates],\n ignore_index=True)\n assert expected_dates.difference(cur_gt.dt.unique()).size == 0\n assert np.all(\n sorted(cur_gt.dt.unique())[:expected_gt_len] == pred_xs[:expected_gt_len])\n\n cur_gt = cur_gt.sort_values(by='dt')\n gtru_xs = cur_gt.dt.to_numpy()\n gtru_ys = cur_gt.feature_value.to_numpy()\n if len(gtru_ys) < expected_gt_len:\n print(f'Length of gt wrong: {len(gtru_ys)} {loc} {date}')\n return np.nan\n\n if debug:\n print(f'Finish a row: {loc} {date}')\n\n ret = {\n 'dates': gtru_xs,\n 'predictions': pred_ys,\n 'ground_truth': gtru_ys,\n }\n if get_day_zero_gt:\n ret['day_zero_gt'] = day_zero_gt if day_zero_gt else 0.0\n\n return ret\n\n\ndef mean_confidence_interval(data, confidence=0.95, ignore_nan=False):\n a = 1.0 * np.array(data)\n n = len(a)\n if ignore_nan:\n m, se = np.nanmean(a), scipy.stats.sem(a, nan_policy='omit')\n else:\n m, se = np.mean(a), scipy.stats.sem(a)\n h = se * scipy.stats.t.ppf((1 + confidence) / 2., n - 1)\n return m, m - h, m + h\n\n\ndef kaz_locations_to_open_covid_map():\n return {\n 'Hyogo': 'Hyōgo',\n 'Kochi': 'Kōchi',\n 'Oita': 'Ōita',\n }\n\n\ndef open_covid_locations_to_kaz_map():\n return {v: k for (k, v) in kaz_locations_to_open_covid_map().items()}\n\n\ndef state_name_to_code_map():\n \"\"\"State name to code map.\"\"\"\n abbreviation = 'abbreviation'\n name = 'name'\n state_map = [\n {\n abbreviation: 'AL',\n name: 'Alabama'\n },\n {\n abbreviation: 'AK',\n name: 'Alaska'\n },\n {\n abbreviation: 'AZ',\n name: 'Arizona'\n },\n {\n abbreviation: 'AR',\n name: 'Arkansas'\n },\n {\n abbreviation: 'CA',\n name: 'California'\n },\n {\n abbreviation: 'CO',\n name: 'Colorado'\n },\n {\n abbreviation: 'CT',\n name: 'Connecticut'\n },\n {\n abbreviation: 'DE',\n name: 'Delaware'\n },\n {\n abbreviation: 'DC',\n name: 'District Of Columbia'\n },\n {\n abbreviation: 'FL',\n name: 'Florida'\n },\n {\n abbreviation: 'GA',\n name: 'Georgia'\n },\n {\n abbreviation: 'HI',\n name: 'Hawaii'\n },\n {\n abbreviation: 'ID',\n name: 'Idaho'\n },\n {\n abbreviation: 'IL',\n name: 'Illinois'\n },\n {\n abbreviation: 'IN',\n name: 'Indiana'\n },\n {\n abbreviation: 'IA',\n name: 'Iowa'\n },\n {\n abbreviation: 'KS',\n name: 'Kansas'\n },\n {\n abbreviation: 'KY',\n name: 'Kentucky'\n },\n {\n abbreviation: 'LA',\n name: 'Louisiana'\n },\n {\n abbreviation: 'ME',\n name: 'Maine'\n },\n {\n abbreviation: 'MD',\n name: 'Maryland'\n },\n {\n abbreviation: 'MA',\n name: 'Massachusetts'\n },\n {\n abbreviation: 'MI',\n name: 'Michigan'\n },\n {\n abbreviation: 'MN',\n name: 'Minnesota'\n },\n {\n abbreviation: 'MS',\n name: 'Mississippi'\n },\n {\n abbreviation: 'MO',\n name: 'Missouri'\n },\n {\n abbreviation: 'MT',\n name: 'Montana'\n },\n {\n abbreviation: 'NE',\n name: 'Nebraska'\n },\n {\n abbreviation: 'NV',\n name: 'Nevada'\n },\n {\n abbreviation: 'NH',\n name: 'New Hampshire'\n },\n {\n abbreviation: 'NJ',\n name: 'New Jersey'\n },\n {\n abbreviation: 'NM',\n name: 'New Mexico'\n },\n {\n abbreviation: 'NY',\n name: 'New York'\n },\n {\n abbreviation: 'NC',\n name: 'North Carolina'\n },\n {\n abbreviation: 'ND',\n name: 'North Dakota'\n },\n {\n abbreviation: 'OH',\n name: 'Ohio'\n },\n {\n abbreviation: 'OK',\n name: 'Oklahoma'\n },\n {\n abbreviation: 'OR',\n name: 'Oregon'\n },\n {\n abbreviation: 'PA',\n name: 'Pennsylvania'\n },\n {\n abbreviation: 'RI',\n name: 'Rhode Island'\n },\n {\n abbreviation: 'SC',\n name: 'South Carolina'\n },\n {\n abbreviation: 'SD',\n name: 'South Dakota'\n },\n {\n abbreviation: 'TN',\n name: 'Tennessee'\n },\n {\n abbreviation: 'TX',\n name: 'Texas'\n },\n {\n abbreviation: 'UT',\n name: 'Utah'\n },\n {\n abbreviation: 'VT',\n name: 'Vermont'\n },\n {\n abbreviation: 'VA',\n name: 'Virginia'\n },\n {\n abbreviation: 'WA',\n name: 'Washington'\n },\n {\n abbreviation: 'WV',\n name: 'West Virginia'\n },\n {\n abbreviation: 'WI',\n name: 'Wisconsin'\n },\n {\n abbreviation: 'WY',\n name: 'Wyoming'\n },\n ]\n return {d[name]: d[abbreviation] for d in state_map}\n\n\nSTATE_TO_CODE_MAP_ = state_name_to_code_map()\n\n\ndef code_to_state_name_map():\n return {v: k for (k, v) in state_name_to_code_map().items()}\n",
"# coding=utf-8\n# Copyright 2021 The Google Research 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\"\"\"Transformer layers for ReadTwice.\"\"\"\n\nfrom typing import List, Optional, Text, Union\n\nimport tensorflow as tf\n\nfrom readtwice.layers import attention\nfrom readtwice.layers import tensor_utils\nfrom readtwice.layers import wrappers\n\n\nclass TransformerWithSideInputLayers(tf.keras.layers.Layer):\n \"\"\"A sequence of Transformer layers (currently only the encoder side).\n\n The model follows the original Transformer model\n (https://arxiv.org/abs/1706.03762) while allowing additional side inputs.\n These inputs are only used during self-attention computations\n as extra keys and values.\n \"\"\"\n\n def __init__(self,\n hidden_size,\n num_hidden_layers,\n num_attention_heads,\n intermediate_size = None,\n hidden_act=tensor_utils.get_activation('gelu'),\n hidden_dropout_prob = 0.1,\n attention_probs_dropout_prob = 0.1,\n initializer_range = 0.02,\n share_kv_projections = False,\n num_cross_attention_heads = None,\n enable_default_side_input = False,\n name = 'transformer_layers',\n **kwargs):\n \"\"\"Init.\n\n Args:\n hidden_size: Size of the output hidden dimension. Must match the input\n hidden dimension size.\n num_hidden_layers: Number of Transformer layers. Each layer includes both\n an attention sublayer and a feed-forward sublayer.\n num_attention_heads: Number of attention heads. Must evenly divide\n `hidden_size`.\n intermediate_size: The size of the \"intermediate\" (i.e. feed-forward)\n layers. Defaults to 4 * hidden_size.\n hidden_act: The non-linear activation function in the intermediate layers.\n hidden_dropout_prob: The dropout probability for the attention and\n feed-forward residual blocks. Must be between 0.0 and 1.0.\n attention_probs_dropout_prob: Dropout probability for attention\n probabilities. Must be between 0.0 and 1.0.\n initializer_range: The standard deviation of the truncated normal\n initializer for initializing weight matrices not created by\n `linear_make_fn`. If zero, the scale of the truncated normal initializer\n will be tuned automatically according to the distribution of the inputs.\n share_kv_projections: If True, key and value projections will be shared\n between main-to-main and main-to-side components. This results in 1\n key projection per layer instead of 2 (and similarly for value\n projections). Only relevant for fused side attention,\n NOT cross attention over the side input (when num_cross_attention_heads\n is not None).\n num_cross_attention_heads: If it is not None, will add a cross-attention\n layer over side inputs. In this case, side inputs will NOT be used\n in the `FusedSideAttention`. Must be greater or equal than 0, where 0\n means that cross attention layer will have a single attention head\n WITHOUT projection matrices.\n enable_default_side_input: Add a default side input, which acts like a\n no-op attention, effective allowing attention weights to sum up\n to something less than 1.\n Currently, only available for the cross attention over side inputs.\n name: Name of the layer.\n **kwargs: Forwarded to super.\n \"\"\"\n super(TransformerWithSideInputLayers, self).__init__(name=name, **kwargs)\n\n if intermediate_size is None:\n intermediate_size = 4 * hidden_size\n\n if num_cross_attention_heads is not None:\n # This will prevent from allocating extra parameters for\n # fused side attention since side input will not be used there anyway.\n share_kv_projections = True\n\n self.hidden_size = hidden_size\n self.num_hidden_layers = num_hidden_layers\n self.num_attention_heads = num_attention_heads\n self.intermediate_size = intermediate_size\n self.hidden_act = hidden_act\n self.hidden_dropout_prob = hidden_dropout_prob\n self.attention_probs_dropout_prob = attention_probs_dropout_prob\n self.share_kv_projections = share_kv_projections\n self.num_cross_attention_heads = num_cross_attention_heads\n self.enable_default_side_input = enable_default_side_input\n\n if (self.enable_default_side_input and\n self.num_cross_attention_heads is None):\n raise ValueError('`enable_default_side_input` is only used when '\n 'num_cross_attention_heads is enabled.')\n if (self.num_cross_attention_heads is not None and\n self.num_cross_attention_heads < 0):\n raise ValueError('If `num_cross_attention_heads` is specified '\n 'it must be non-negative.')\n\n self.initializer = tf.keras.initializers.TruncatedNormal(\n stddev=initializer_range)\n\n self.attention_layers = []\n self.cross_attention_layers = []\n self.feed_forward_layers = []\n for i in range(num_hidden_layers):\n self.attention_layers.append(\n wrappers.ResidualBlock(\n inner_layer=attention.FusedSideAttention(\n hidden_size=self.hidden_size,\n num_heads=self.num_attention_heads,\n att_dropout_prob=self.attention_probs_dropout_prob,\n share_kv_projections=self.share_kv_projections,\n initializer=self.initializer),\n dropout_probability=self.hidden_dropout_prob,\n use_pre_activation_order=False,\n name='attention_layer_%d' % i))\n\n if self.num_cross_attention_heads is not None:\n self.cross_attention_layers.append(\n wrappers.ResidualBlock(\n inner_layer=attention.SideAttention(\n hidden_size=self.hidden_size,\n num_heads=self.num_cross_attention_heads,\n att_dropout_prob=self.attention_probs_dropout_prob,\n initializer=self.initializer,\n enable_default_side_input=self.enable_default_side_input),\n dropout_probability=self.hidden_dropout_prob,\n use_pre_activation_order=False,\n name='cross_attention_layer_%d' % i))\n\n self.feed_forward_layers.append(\n wrappers.ResidualBlock(\n dropout_probability=self.hidden_dropout_prob,\n use_pre_activation_order=False,\n inner_intermediate_size=self.intermediate_size,\n inner_activation=self.hidden_act,\n inner_kernel_initializer=self.initializer,\n name='feed_forward_layer_%d' % i))\n\n # TODO(urikz): Add some way for the user to access activations from\n # each hidden layer.\n def call(self,\n main_input,\n side_input = None,\n att_mask = None,\n training=None):\n \"\"\"Calls the layer.\n\n Args:\n main_input: <float32>[batch_size, main_seq_len, hidden_size].\n side_input: <float32>[batch_size, side_seq_len, hidden_size] or a list\n of tensors with this shape. The length of the list must be equal to\n `num_hidden_layers`.\n att_mask: <int32>[batch_size, main_seq_len, main_seq_len +\n side_seq_len]. Should have only 0 and 1 values, with 0 for entries\n that should be masked and 1 otherwise. Leave as None to allow all\n elements to attend to all other elements within each example.\n training: For Keras, optional boolean scalar tensor or Python boolean\n indicating whether the call is meant for training or inference.\n\n Returns:\n <float32>[batch_size, main_seq_len, hidden_size].\n\n Raises:\n ValueError if `side_input` is list and the length of `side_input`\n is not equal to `num_hidden_layers`.\n \"\"\"\n output_tensor = main_input\n\n if side_input is not None and not isinstance(side_input, list):\n side_input = [side_input] * self.num_hidden_layers\n else:\n side_input = [None] * self.num_hidden_layers\n\n if len(side_input) != self.num_hidden_layers:\n raise ValueError('Length of side input ({}) is not equal to '\n 'the number of hidden layers ({})'.format(\n len(side_input), self.num_hidden_layers))\n\n if att_mask is not None and self.num_cross_attention_heads is not None:\n main_seq_len = tf.shape(main_input)[1]\n att_mask_attention_layer = att_mask[:, :, :main_seq_len]\n att_mask_cross_attention_layer = att_mask[:, :, main_seq_len:]\n else:\n att_mask_attention_layer = None\n att_mask_cross_attention_layer = None\n\n for i in range(self.num_hidden_layers):\n if self.num_cross_attention_heads is not None:\n output_tensor = self.attention_layers[i](\n output_tensor,\n training=training,\n side_input=None,\n att_mask=att_mask_attention_layer)\n\n output_tensor = self.cross_attention_layers[i](\n output_tensor,\n side_input=side_input[i],\n att_mask=att_mask_cross_attention_layer,\n training=training)\n else:\n output_tensor = self.attention_layers[i](\n output_tensor,\n training=training,\n side_input=side_input[i],\n att_mask=att_mask)\n\n output_tensor = self.feed_forward_layers[i](\n output_tensor, training=training)\n\n return output_tensor\n",
"# coding=utf-8\n# Copyright 2021 The Google Research 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\"\"\"Tensorflow Example input layer.\"\"\"\n\nimport tensorflow as tf\n\nfrom poem.core import common\n\n\ndef add_decoder_image_sizes(instance_shape, common_module=common):\n \"\"\"Adds decoders for image sizes.\n\n Args:\n instance_shape: A list of integers for the shape (layout) of instances for\n each record.\n common_module: A Python module that defines common constants.\n\n Returns:\n A dictionary for decoders.\n \"\"\"\n return {\n common_module.TFE_KEY_IMAGE_HEIGHT:\n tf.io.FixedLenFeature(instance_shape, dtype=tf.int64),\n common_module.TFE_KEY_IMAGE_WIDTH:\n tf.io.FixedLenFeature(instance_shape, dtype=tf.int64),\n }\n\n\ndef add_decoder_keypoints_2d(keypoint_names_2d,\n include_keypoint_scores_2d,\n instance_shape,\n common_module=common):\n \"\"\"Adds decoders for 2D keypoints.\n\n Args:\n keypoint_names_2d: A list of strings for 2D keypoint names.\n include_keypoint_scores_2d: A boolean for whether to include 2D keypoint\n scores.\n instance_shape: A list of integers for the shape (layout) of instances for\n each record.\n common_module: A Python module that defines common constants.\n\n Returns:\n decoders: A dictionary for decoders.\n \"\"\"\n decoders = {}\n\n for name in keypoint_names_2d:\n for key_suffix in common_module.TFE_KEY_SUFFIX_KEYPOINT_2D:\n key = common_module.TFE_KEY_PREFIX_KEYPOINT_2D + name + key_suffix\n decoders[key] = tf.io.FixedLenFeature(instance_shape, dtype=tf.float32)\n if include_keypoint_scores_2d:\n key = (\n common_module.TFE_KEY_PREFIX_KEYPOINT_2D + name +\n common_module.TFE_KEY_SUFFIX_KEYPOINT_SCORE)\n decoders[key] = tf.io.FixedLenFeature(instance_shape, dtype=tf.float32)\n\n return decoders\n\n\ndef add_decoder_keypoints_3d(keypoint_names_3d,\n include_keypoint_scores_3d,\n instance_shape,\n common_module=common):\n \"\"\"Adds decoders for 3D keypoints.\n\n Args:\n keypoint_names_3d: A list of strings for 3D keypoint names.\n include_keypoint_scores_3d: A boolean for whether to include 3D keypoint\n scores.\n instance_shape: A list of integers for the shape (layout) of instances for\n each record.\n common_module: A Python module that defines common constants.\n\n Returns:\n decoders: A dictionary for decoders.\n \"\"\"\n decoders = {}\n\n for name in keypoint_names_3d:\n for key_suffix in common_module.TFE_KEY_SUFFIX_KEYPOINT_3D:\n key = common_module.TFE_KEY_PREFIX_KEYPOINT_3D + name + key_suffix\n decoders[key] = tf.io.FixedLenFeature(instance_shape, dtype=tf.float32)\n if include_keypoint_scores_3d:\n key = (\n common_module.TFE_KEY_PREFIX_KEYPOINT_3D + name +\n common_module.TFE_KEY_SUFFIX_KEYPOINT_SCORE)\n decoders[key] = tf.io.FixedLenFeature(instance_shape, dtype=tf.float32)\n\n return decoders\n\n\ndef add_decoder_features(feature_dim, instance_shape, common_module=common):\n \"\"\"Adds decoder for pre-computed features.\n\n Args:\n feature_dim: An integer for size of feature vectors.\n instance_shape: A list of integers for the shape (layout) of instances for\n each record.\n common_module: A Python module that defines common constants.\n\n Returns:\n A dictionary for decoder.\n \"\"\"\n feature_shape = list(instance_shape) + [feature_dim]\n return {\n common_module.TFE_KEY_FEATURE:\n tf.io.FixedLenFeature(feature_shape, dtype=tf.float32)\n }\n\n\ndef add_decoder_class_labels(common_module=common):\n \"\"\"Adds decoders for class label ids and confidences.\n\n IMPORTANT: Note that we assume there is one copy of label ids and confidences\n in each record and they apply to all the objects in the record.\n\n Args:\n common_module: A Python module that defines common constants.\n\n Returns:\n A dictionary for decoders.\n \"\"\"\n return {\n common_module.TFE_KEY_CLASS_LABEL_ID:\n tf.io.VarLenFeature(dtype=tf.int64),\n common_module.TFE_KEY_CLASS_LABEL_CONFIDENCE:\n tf.io.VarLenFeature(dtype=tf.float32)\n }\n\n\ndef process_decoded_image_sizes(decoded_tensors, common_module=common):\n \"\"\"Processes decoded image sizes.\n\n Args:\n decoded_tensors: A dictionary for decoded tensors.\n common_module: A Python module that defines common constants.\n\n Returns:\n A dictionary for processed 2D keypoint tensors.\n \"\"\"\n image_heights = decoded_tensors[common_module.TFE_KEY_IMAGE_HEIGHT]\n image_widths = decoded_tensors[common_module.TFE_KEY_IMAGE_WIDTH]\n return {\n common_module.KEY_IMAGE_SIZES:\n tf.stack([image_heights, image_widths], axis=-1)\n }\n\n\ndef process_decoded_keypoints_2d(decoded_tensors,\n keypoint_names_2d,\n include_keypoint_scores_2d,\n common_module=common):\n \"\"\"Processes decoded 2D keypoint tensors.\n\n Args:\n decoded_tensors: A dictionary for decoded tensors.\n keypoint_names_2d: A list of strings for 2D keypoint names.\n include_keypoint_scores_2d: A boolean for whether to include 2D keypoint\n scores.\n common_module: A Python module that defines common constants.\n\n Returns:\n outputs: A dictionary for processed 2D keypoint tensors.\n \"\"\"\n outputs = {}\n\n keypoints_2d = []\n for name in keypoint_names_2d:\n sub_keypoints_2d = []\n for key_suffix in common_module.TFE_KEY_SUFFIX_KEYPOINT_2D:\n key = common_module.TFE_KEY_PREFIX_KEYPOINT_2D + name + key_suffix\n sub_keypoints_2d.append(decoded_tensors[key])\n keypoints_2d.append(tf.stack(sub_keypoints_2d, axis=-1))\n outputs[common_module.KEY_KEYPOINTS_2D] = tf.stack(keypoints_2d, axis=-2)\n\n if include_keypoint_scores_2d:\n keypoint_scores_2d = []\n for name in keypoint_names_2d:\n key = (\n common_module.TFE_KEY_PREFIX_KEYPOINT_2D + name +\n common_module.TFE_KEY_SUFFIX_KEYPOINT_SCORE)\n keypoint_scores_2d.append(decoded_tensors[key])\n outputs[common_module.KEY_KEYPOINT_SCORES_2D] = tf.stack(\n keypoint_scores_2d, axis=-1)\n\n return outputs\n\n\ndef process_decoded_keypoints_3d(decoded_tensors,\n keypoint_names_3d,\n include_keypoint_scores_3d,\n common_module=common):\n \"\"\"Processes decoded 3D keypoint tensors.\n\n Args:\n decoded_tensors: A dictionary for decoded tensors.\n keypoint_names_3d: A list of strings for 3D keypoint names.\n include_keypoint_scores_3d: A boolean for whether to include 2D keypoint\n scores.\n common_module: A Python module that defines common constants.\n\n Returns:\n outputs: A dictionary for processed 2D keypoint tensors.\n \"\"\"\n outputs = {}\n\n keypoints_3d = []\n for name in keypoint_names_3d:\n sub_keypoints_3d = []\n for key_suffix in common_module.TFE_KEY_SUFFIX_KEYPOINT_3D:\n key = common_module.TFE_KEY_PREFIX_KEYPOINT_3D + name + key_suffix\n sub_keypoints_3d.append(decoded_tensors[key])\n keypoints_3d.append(tf.stack(sub_keypoints_3d, axis=-1))\n outputs[common_module.KEY_KEYPOINTS_3D] = tf.stack(keypoints_3d, axis=-2)\n\n if include_keypoint_scores_3d:\n keypoint_scores_3d = []\n for name in keypoint_names_3d:\n key = (\n common_module.TFE_KEY_PREFIX_KEYPOINT_3D + name +\n common_module.TFE_KEY_SUFFIX_KEYPOINT_SCORE)\n keypoint_scores_3d.append(decoded_tensors[key])\n outputs[common_module.KEY_KEYPOINT_SCORES_3D] = tf.stack(\n keypoint_scores_3d, axis=-1)\n\n return outputs\n\n\ndef process_decoded_features(decoded_tensors, common_module=common):\n \"\"\"Processes decoded features.\n\n Args:\n decoded_tensors: A dictionary for decoded tensors.\n common_module: A Python module that defines common constants.\n\n Returns:\n A dictionary for processed 2D keypoint tensors.\n \"\"\"\n return {\n common_module.KEY_FEATURES: decoded_tensors[common_module.TFE_KEY_FEATURE]\n }\n\n\ndef generate_class_targets(label_ids,\n label_confidences,\n num_classes,\n positive_label_confidence_threshold=0.5):\n \"\"\"Generates class targets and weights from label ids and confidences.\n\n Note that we use `class_targets` to represent if a label is positive or\n negative, and use `class_weights` to represent if a label exists in the input\n or not.\n\n Example usage:\n num_classes = 5\n label_ids = [0, 1, 3]\n label_confidences = [0.9, 0.3, 0.7]\n positive_label_confidence_threshold = 0.5\n -->\n class_targets = [1, 0, 0, 1, 0]\n class_weights = [1.0, 1.0, 0.0, 1.0, 0.0]\n\n Args:\n label_ids: A tensor for label ids. Shape = [num_classes].\n label_confidences: A tensor for label confidences. Shape = [num_classes].\n num_classes: An integer for total number of classes.\n positive_label_confidence_threshold: A float for the threshold to determine\n class target for label ids. If the confidence of a label id is greater\n than this value, it has positive class target (1), otherwise negative\n target (0).\n\n Returns:\n class_targets: A int64 tensor for class targets. Shape = [num_classes].\n class_weights: A float32 tensor for class weights. Shape = [num_classes].\n\n Raises:\n ValueError: If `label_ids` or `label_confidences` is not 1D tensor.\n \"\"\"\n if len(label_ids.shape.as_list()) != 1:\n raise ValueError('Label id tensor must be 1D: %d.' %\n len(label_ids.shape.as_list()))\n if len(label_confidences.shape.as_list()) != 1:\n raise ValueError('Label confidence tensor must be 1D: %d.' %\n len(label_confidences.shape.as_list()))\n\n if isinstance(label_ids, tf.SparseTensor):\n label_ids = tf.sparse.to_dense(label_ids)\n if isinstance(label_confidences, tf.SparseTensor):\n label_confidences = tf.sparse.to_dense(label_confidences)\n positive_label_id_masks = tf.math.greater(\n label_confidences, positive_label_confidence_threshold)\n positive_label_ids = tf.boolean_mask(label_ids, mask=positive_label_id_masks)\n class_targets = tf.math.reduce_sum(\n tf.one_hot(positive_label_ids, num_classes, dtype=tf.int64), axis=0)\n class_weights = tf.math.reduce_sum(\n tf.one_hot(label_ids, num_classes, dtype=tf.float32), axis=0)\n return class_targets, class_weights\n\n\ndef process_class_labels(decoded_tensors,\n num_classes,\n num_objects,\n common_module=common):\n \"\"\"Processes decoded class labels and confidences into targets and weights.\n\n IMPORTANT: Note that we assume there is one copy of label ids and confidences\n in each record and they apply to all the objects in the record.\n\n Args:\n decoded_tensors: A dictionary for decoded tensors.\n num_classes: An integer for total number of classification label classes to\n read labels for.\n num_objects: An integer for the number of objects each example has.\n common_module: A Python module that defines common constants.\n\n Returns:\n outputs: A dictionary for processed 2D keypoint tensors.\n \"\"\"\n class_targets, class_weights = (\n generate_class_targets(\n decoded_tensors[common_module.TFE_KEY_CLASS_LABEL_ID],\n decoded_tensors[common_module.TFE_KEY_CLASS_LABEL_CONFIDENCE],\n num_classes=num_classes))\n\n # Stack the same class targets and weights for multiple objects.\n class_targets = tf.stack([class_targets for i in range(num_objects)], axis=0)\n class_weights = tf.stack([class_weights for i in range(num_objects)], axis=0)\n\n outputs = {\n common_module.KEY_CLASS_TARGETS: class_targets,\n common_module.KEY_CLASS_WEIGHTS: class_weights,\n }\n return outputs\n\n\ndef get_tfe_parser_fn(decoders, post_process_fn):\n \"\"\"Creates a tf.Example parser function.\n\n Args:\n decoders: A dictionary for keyed tf.Example field decoders.\n post_process_fn: A function handle for postprocessing decoded tensors.\n\n Returns:\n parser_fn: A function handle for the parser function.\n \"\"\"\n\n def parser_fn(*inputs):\n \"\"\"Decoder function.\"\"\"\n # Here `inputs` can be either just a serialized example or a (key,\n # serialized example) tuple (in which we ignore the key), and we would like\n # to handle both cases.\n serialized_example = inputs[-1]\n decoded_tensors = tf.io.parse_single_example(serialized_example, decoders)\n return post_process_fn(decoded_tensors)\n\n return parser_fn\n\n\ndef create_tfe_parser(keypoint_names_2d=None,\n keypoint_names_3d=None,\n include_keypoint_scores_2d=True,\n include_keypoint_scores_3d=False,\n feature_dim=None,\n num_classes=None,\n num_objects=1,\n sequence_length=None,\n common_module=common):\n \"\"\"Creates tf.Example parser function.\n\n IMPORTANT: Currently only supports all objects having the same class label\n information, and the class label related fields in tf.Examples are expected to\n only have values for one object.\n\n Args:\n keypoint_names_2d: A list of strings for 2D keypoint names. Use None to skip\n reading 2D keypoints.\n keypoint_names_3d: A list of strings for 3D keypoint names. Use None to skip\n reading 3D keypoints.\n include_keypoint_scores_2d: A boolean for whether to read 2D keypoint\n scores. Only used if `keypoint_names_2d` is specified.\n include_keypoint_scores_3d: A boolean for whether to read 3D keypoint\n scores. Only used if `keypoint_names_3d` is specified.\n feature_dim: An integer for size of pre-computed feature vectors. Only reads\n features if specified.\n num_classes: An integer for the number of classification label classes to\n read labels for. Only reads labels if specified.\n num_objects: An integer for the number of objects each example has.\n sequence_length: An integer for the length of sequence per object each\n example has. Skips adding the sequence dimension if None.\n common_module: A Python module that defines common constants.\n\n Returns:\n parser_fn: A function handle for the parser.\n \"\"\"\n instance_shape = ([num_objects] if sequence_length is None else\n [num_objects, sequence_length])\n\n decoders = add_decoder_image_sizes(\n instance_shape=instance_shape, common_module=common_module)\n\n if keypoint_names_2d:\n decoders.update(\n add_decoder_keypoints_2d(\n keypoint_names_2d,\n include_keypoint_scores_2d=include_keypoint_scores_2d,\n instance_shape=instance_shape,\n common_module=common_module))\n\n if keypoint_names_3d:\n decoders.update(\n add_decoder_keypoints_3d(\n keypoint_names_3d,\n include_keypoint_scores_3d=include_keypoint_scores_3d,\n instance_shape=instance_shape,\n common_module=common_module))\n\n if feature_dim:\n decoders.update(\n add_decoder_features(\n feature_dim=feature_dim,\n instance_shape=instance_shape,\n common_module=common_module))\n\n if num_classes:\n decoders.update(add_decoder_class_labels(common_module=common_module))\n\n def post_process_decoded_tensors(decoded_tensors):\n \"\"\"Postprocesses decoded tensors.\"\"\"\n outputs = process_decoded_image_sizes(decoded_tensors, common_module)\n\n if keypoint_names_2d:\n outputs.update(\n process_decoded_keypoints_2d(\n decoded_tensors,\n keypoint_names_2d=keypoint_names_2d,\n include_keypoint_scores_2d=include_keypoint_scores_2d,\n common_module=common_module))\n\n if keypoint_names_3d:\n outputs.update(\n process_decoded_keypoints_3d(\n decoded_tensors,\n keypoint_names_3d=keypoint_names_3d,\n include_keypoint_scores_3d=include_keypoint_scores_3d,\n common_module=common_module))\n\n if feature_dim:\n outputs.update(\n process_decoded_features(\n decoded_tensors, common_module=common_module))\n\n if num_classes:\n outputs.update(\n process_class_labels(\n decoded_tensors,\n num_classes=num_classes,\n num_objects=num_objects,\n common_module=common_module))\n\n return outputs\n\n return get_tfe_parser_fn(decoders, post_process_decoded_tensors)\n\n\ndef read_from_table(table_pattern,\n shuffle=True,\n num_epochs=None,\n shuffle_buffer_size=4096,\n num_shards=1,\n shard_index=None,\n dataset_class=tf.data.TFRecordDataset,\n parser_fn=None,\n seed=None):\n \"\"\"Reads tf.Examples from input table.\n\n Args:\n table_pattern: Path or pattern to input tables.\n shuffle: A boolean for whether to shuffle the common queue when reading.\n num_epochs: An integer for the number of epochs to read. Use None to read\n indefinitely.\n shuffle_buffer_size: An integer for the buffer size used for shuffling. A\n large buffer size benefits shuffling quality.\n num_shards: An integer for the number of shards to divide the dataset. This\n is useful to distributed training. See `tf.data.Dataset.shard` for\n details.\n shard_index: An integer for the shard index to use. This is useful to\n distributed training, and should usually be set to the id of a\n synchronized worker. See `tf.data.Dataset.shard` for details. Note this\n must be specified if `num_shards` is greater than 1.\n dataset_class: A dataset class to use. Must match input table type.\n parser_fn: A function handle for parser function.\n seed: An integer for random seed.\n\n Returns:\n A dictionary of parsed input tensors.\n\n Raises:\n ValueError: If `num_shards` is greater than 1 but `shard_index` is not\n specified.\n \"\"\"\n dataset = tf.data.Dataset.list_files(\n table_pattern, shuffle=shuffle, seed=seed)\n dataset = dataset.interleave(\n dataset_class, cycle_length=tf.data.experimental.AUTOTUNE)\n dataset = dataset.repeat(num_epochs)\n\n if num_shards > 1:\n if shard_index is None:\n raise ValueError('Shard index is not specified: `%s.`' % str(shard_index))\n dataset = dataset.shard(num_shards, index=shard_index)\n\n if shuffle:\n dataset = dataset.shuffle(shuffle_buffer_size, seed=seed)\n\n dataset = dataset.map(\n parser_fn, num_parallel_calls=tf.data.experimental.AUTOTUNE)\n dataset = dataset.prefetch(tf.data.experimental.AUTOTUNE)\n\n return dataset\n\n\ndef read_batch_from_tables(table_patterns,\n batch_sizes,\n drop_remainder,\n seed=None,\n **reader_kwargs):\n \"\"\"Reads and batches inputs from tf.Example tables.\n\n Args:\n table_patterns: A list of strings for the paths or pattern to input tables.\n batch_sizes: A list of integers for the batch sizes to read from each table.\n drop_remainder: A boolean for whether to drop remaining elements that cannot\n make up a full batch at the end of an epoch. Usually set to True for\n evaluation.\n seed: An integer for random seed.\n **reader_kwargs: A dictionary of additional arguments passed to\n `read_from_table`.\n\n Returns:\n A dictionary of parsed input tensors.\n\n Raises:\n ValueError: If the size of `table_patterns` is different than that of\n `nums_samples`.\n ValueError: If the size of `table_patterns` is different than that of\n `batch_sizes`.\n \"\"\"\n if not table_patterns:\n raise ValueError('No table pattern is provided.')\n\n if len(table_patterns) != len(batch_sizes):\n raise ValueError(\n 'Number of table patterns is different than that of batch sizes: %d vs.'\n ' %d.' % (len(table_patterns), len(batch_sizes)))\n\n if len(table_patterns) == 1:\n dataset = read_from_table(table_patterns[0], seed=seed, **reader_kwargs)\n else:\n datasets = [\n read_from_table(table_pattern, seed=seed, **reader_kwargs)\n for table_pattern in table_patterns\n ]\n dataset = tf.data.experimental.sample_from_datasets(\n datasets, weights=[float(x) for x in batch_sizes], seed=seed)\n return dataset.batch(sum(batch_sizes), drop_remainder=drop_remainder)\n",
"# coding=utf-8\n# Copyright 2021 The Google Research 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\"\"\"Tests for smu_utils_lib.\"\"\"\n\nimport copy\nimport os\nimport tempfile\n\nfrom absl.testing import absltest\nfrom absl.testing import parameterized\nimport numpy as np\nimport pandas as pd\nfrom rdkit import Chem\n\nfrom google.protobuf import text_format\nfrom smu import dataset_pb2\nfrom smu.parser import smu_parser_lib\nfrom smu.parser import smu_utils_lib\n\nMAIN_DAT_FILE = 'x07_sample.dat'\nSTAGE1_DAT_FILE = 'x07_stage1.dat'\nTESTDATA_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)),\n 'testdata')\n\n\ndef str_to_bond_topology(s):\n bt = dataset_pb2.BondTopology()\n text_format.Parse(s, bt)\n return bt\n\n\ndef get_stage1_conformer():\n parser = smu_parser_lib.SmuParser(\n os.path.join(TESTDATA_PATH, STAGE1_DAT_FILE))\n conformer, _ = next(parser.process_stage1())\n return conformer\n\n\ndef get_stage2_conformer():\n parser = smu_parser_lib.SmuParser(os.path.join(TESTDATA_PATH, MAIN_DAT_FILE))\n conformer, _ = next(parser.process_stage2())\n return conformer\n\n\nclass SpecialIDTest(absltest.TestCase):\n\n def test_from_dat_id(self):\n self.assertIsNone(\n smu_utils_lib.special_case_bt_id_from_dat_id(123456, 'CC'))\n self.assertEqual(smu_utils_lib.special_case_bt_id_from_dat_id(999998, 'O'),\n 899650)\n self.assertEqual(smu_utils_lib.special_case_bt_id_from_dat_id(0, 'O'),\n 899650)\n with self.assertRaises(ValueError):\n smu_utils_lib.special_case_bt_id_from_dat_id(0, 'NotASpecialCaseSmiles')\n\n def test_from_bt_id(self):\n self.assertIsNone(smu_utils_lib.special_case_dat_id_from_bt_id(123456))\n self.assertEqual(\n smu_utils_lib.special_case_dat_id_from_bt_id(899651), 999997)\n\n\nclass GetCompositionTest(absltest.TestCase):\n\n def test_simple(self):\n bt = dataset_pb2.BondTopology()\n bt.atoms.extend([dataset_pb2.BondTopology.ATOM_C,\n dataset_pb2.BondTopology.ATOM_C,\n dataset_pb2.BondTopology.ATOM_N,\n dataset_pb2.BondTopology.ATOM_H,\n dataset_pb2.BondTopology.ATOM_H,\n dataset_pb2.BondTopology.ATOM_H])\n self.assertEqual('x03_c2nh3', smu_utils_lib.get_composition(bt))\n\n\nclass GetCanonicalStoichiometryWithHydrogensTest(absltest.TestCase):\n\n def test_cyclobutane(self):\n bt = smu_utils_lib.create_bond_topology('CCCC', '110011', '2222')\n self.assertEqual(\n smu_utils_lib.get_canonical_stoichiometry_with_hydrogens(bt), '(ch2)4')\n\n def test_ethylene(self):\n bt = smu_utils_lib.create_bond_topology('CC', '2', '22')\n self.assertEqual(\n smu_utils_lib.get_canonical_stoichiometry_with_hydrogens(bt), '(ch2)2')\n\n def test_acrylic_acid(self):\n bt = smu_utils_lib.create_bond_topology('CCCOO', '2000100210', '21001')\n self.assertEqual(\n smu_utils_lib.get_canonical_stoichiometry_with_hydrogens(bt),\n '(c)(ch)(ch2)(o)(oh)')\n\n def test_fluorine(self):\n bt = smu_utils_lib.create_bond_topology('OFF', '110', '000')\n self.assertEqual(\n smu_utils_lib.get_canonical_stoichiometry_with_hydrogens(bt), '(o)(f)2')\n\n def test_fully_saturated(self):\n self.assertEqual(\n smu_utils_lib.get_canonical_stoichiometry_with_hydrogens(\n smu_utils_lib.create_bond_topology('C', '', '4')), '(ch4)')\n self.assertEqual(\n smu_utils_lib.get_canonical_stoichiometry_with_hydrogens(\n smu_utils_lib.create_bond_topology('N', '', '3')), '(nh3)')\n self.assertEqual(\n smu_utils_lib.get_canonical_stoichiometry_with_hydrogens(\n smu_utils_lib.create_bond_topology('O', '', '2')), '(oh2)')\n self.assertEqual(\n smu_utils_lib.get_canonical_stoichiometry_with_hydrogens(\n smu_utils_lib.create_bond_topology('F', '', '1')), '(fh)')\n\n def test_nplus_oneg(self):\n bt = smu_utils_lib.create_bond_topology('NO', '1', '30')\n self.assertEqual(\n smu_utils_lib.get_canonical_stoichiometry_with_hydrogens(bt),\n '(nh3)(o)')\n\n\nclass ParseBondTopologyTest(absltest.TestCase):\n\n def test_4_heavy(self):\n num_atoms, atoms_str, matrix, hydrogens = smu_utils_lib.parse_bond_topology_line(\n ' 4 N+O O O- 010110 3000')\n self.assertEqual(num_atoms, 4)\n self.assertEqual(atoms_str, 'N+O O O-')\n self.assertEqual(matrix, '010110')\n self.assertEqual(hydrogens, '3000')\n\n def test_7_heavy(self):\n num_atoms, atoms_str, matrix, hydrogens = smu_utils_lib.parse_bond_topology_line(\n ' 7 N+O O O O-F F 001011101001000000000 1000000')\n self.assertEqual(num_atoms, 7)\n self.assertEqual(atoms_str, 'N+O O O O-F F ') # Note the trailing space\n self.assertEqual(matrix, '001011101001000000000')\n self.assertEqual(hydrogens, '1000000')\n\n\nclass CreateBondTopologyTest(absltest.TestCase):\n\n def test_no_charged(self):\n got = smu_utils_lib.create_bond_topology('CNFF', '111000', '1200')\n expected_str = '''\natoms: ATOM_C\natoms: ATOM_N\natoms: ATOM_F\natoms: ATOM_F\natoms: ATOM_H\natoms: ATOM_H\natoms: ATOM_H\nbonds {\n atom_b: 1\n bond_type: BOND_SINGLE\n}\nbonds {\n atom_b: 2\n bond_type: BOND_SINGLE\n}\nbonds {\n atom_b: 3\n bond_type: BOND_SINGLE\n}\nbonds {\n atom_b: 4\n bond_type: BOND_SINGLE\n}\nbonds {\n atom_a: 1\n atom_b: 5\n bond_type: BOND_SINGLE\n}\nbonds {\n atom_a: 1\n atom_b: 6\n bond_type: BOND_SINGLE\n}\n'''\n expected = str_to_bond_topology(expected_str)\n self.assertEqual(str(expected), str(got))\n\n def test_charged(self):\n # This is actually C N N+O-\n got = smu_utils_lib.create_bond_topology('CNNO', '200101', '2020')\n expected_str = '''\natoms: ATOM_C\natoms: ATOM_N\natoms: ATOM_NPOS\natoms: ATOM_ONEG\natoms: ATOM_H\natoms: ATOM_H\natoms: ATOM_H\natoms: ATOM_H\nbonds {\n atom_b: 1\n bond_type: BOND_DOUBLE\n}\nbonds {\n atom_a: 1\n atom_b: 2\n bond_type: BOND_SINGLE\n}\nbonds {\n atom_a: 2\n atom_b: 3\n bond_type: BOND_SINGLE\n}\nbonds {\n atom_b: 4\n bond_type: BOND_SINGLE\n}\nbonds {\n atom_b: 5\n bond_type: BOND_SINGLE\n}\nbonds {\n atom_a: 2\n atom_b: 6\n bond_type: BOND_SINGLE\n}\nbonds {\n atom_a: 2\n atom_b: 7\n bond_type: BOND_SINGLE\n}\n'''\n expected = str_to_bond_topology(expected_str)\n self.assertEqual(str(expected), str(got))\n\n def test_one_heavy(self):\n got = smu_utils_lib.create_bond_topology('C', '', '4')\n expected_str = '''\natoms: ATOM_C\natoms: ATOM_H\natoms: ATOM_H\natoms: ATOM_H\natoms: ATOM_H\nbonds {\n atom_b: 1\n bond_type: BOND_SINGLE\n}\nbonds {\n atom_b: 2\n bond_type: BOND_SINGLE\n}\nbonds {\n atom_b: 3\n bond_type: BOND_SINGLE\n}\nbonds {\n atom_b: 4\n bond_type: BOND_SINGLE\n}\n'''\n expected = str_to_bond_topology(expected_str)\n self.assertEqual(str(expected), str(got))\n\n\nclass FromCSVTest(absltest.TestCase):\n\n def test_basic(self):\n infile = tempfile.NamedTemporaryFile(mode='w', delete=False)\n infile.write(\n 'id,num_atoms,atoms_str,connectivity_matrix,hydrogens,smiles\\n')\n infile.write('68,3,C N+O-,310,010,[NH+]#C[O-]\\n')\n infile.write('134,4,N+O-F F ,111000,1000,[O-][NH+](F)F\\n')\n infile.close()\n\n out = smu_utils_lib.generate_bond_topologies_from_csv(infile.name)\n\n bt = next(out)\n self.assertEqual(68, bt.bond_topology_id)\n self.assertLen(bt.atoms, 4)\n self.assertEqual(bt.smiles, '[NH+]#C[O-]')\n\n bt = next(out)\n self.assertEqual(134, bt.bond_topology_id)\n self.assertLen(bt.atoms, 5)\n self.assertEqual(bt.smiles, '[O-][NH+](F)F')\n\n\nclass ParseDuplicatesFileTest(absltest.TestCase):\n\n def test_basic(self):\n df = smu_utils_lib.parse_duplicates_file(\n os.path.join(TESTDATA_PATH, 'small.equivalent_isomers.dat'))\n pd.testing.assert_frame_equal(\n pd.DataFrame(\n columns=['name1', 'stoich1', 'btid1', 'shortconfid1', 'confid1',\n 'name2', 'stoich2', 'btid2', 'shortconfid2', 'confid2'],\n data=[\n ['x07_c2n2o2fh3.224227.004',\n 'c2n2o2fh3', 224227, 4, 224227004,\n 'x07_c2n2o2fh3.224176.005',\n 'c2n2o2fh3', 224176, 5, 224176005],\n ['x07_c2n2o2fh3.260543.005',\n 'c2n2o2fh3', 260543, 5, 260543005,\n 'x07_c2n2o2fh3.224050.001',\n 'c2n2o2fh3', 224050, 1, 224050001],\n ]),\n df,\n check_like=True)\n\n\nclass BondTopologyToMoleculeTest(absltest.TestCase):\n\n def test_o2(self):\n bond_topology = str_to_bond_topology('''\natoms: ATOM_O\natoms: ATOM_O\nbonds {\n atom_b: 1\n bond_type: BOND_DOUBLE\n}\n''')\n got = smu_utils_lib.bond_topology_to_molecule(bond_topology)\n self.assertEqual('O=O', Chem.MolToSmiles(got))\n\n def test_methane(self):\n bond_topology = str_to_bond_topology('''\natoms: ATOM_C\natoms: ATOM_H\natoms: ATOM_H\natoms: ATOM_H\natoms: ATOM_H\nbonds {\n atom_b: 1\n bond_type: BOND_SINGLE\n}\nbonds {\n atom_b: 2\n bond_type: BOND_SINGLE\n}\nbonds {\n atom_b: 3\n bond_type: BOND_SINGLE\n}\nbonds {\n atom_b: 4\n bond_type: BOND_SINGLE\n}\n''')\n got = smu_utils_lib.bond_topology_to_molecule(bond_topology)\n self.assertEqual('[H]C([H])([H])[H]', Chem.MolToSmiles(got))\n\n # This molecule is an N+ central atom, bonded to C (triply), O-, and F\n def test_charged_molecule(self):\n bond_topology = str_to_bond_topology('''\natoms: ATOM_C\natoms: ATOM_NPOS\natoms: ATOM_ONEG\natoms: ATOM_F\nbonds {\n atom_b: 1\n bond_type: BOND_TRIPLE\n}\nbonds {\n atom_a: 1\n atom_b: 2\n bond_type: BOND_SINGLE\n}\nbonds {\n atom_a: 1\n atom_b: 3\n bond_type: BOND_SINGLE\n}\n''')\n got = smu_utils_lib.bond_topology_to_molecule(bond_topology)\n self.assertEqual('C#[N+]([O-])F', Chem.MolToSmiles(got))\n\n\nclass ConformerToMoleculeTest(absltest.TestCase):\n\n def setUp(self):\n super().setUp()\n self.conformer = get_stage2_conformer()\n\n # We'll make a new initial_geometry which is just the current one with all\n # coordinates multiplied by 1000\n self.conformer.initial_geometries.append(\n self.conformer.initial_geometries[0])\n new_geom = self.conformer.initial_geometries[1]\n for atom_pos in new_geom.atom_positions:\n atom_pos.x = atom_pos.x * 1000\n atom_pos.y = atom_pos.y * 1000\n atom_pos.z = atom_pos.z * 1000\n\n # For the extra bond_topology, we'll just copy the existing one and change\n # the id. Through the dumb luck of the molecule we picked there's not a\n # simple way to make this a new bond topology and still have it look valid\n # to RDKit\n self.conformer.bond_topologies.append(self.conformer.bond_topologies[0])\n self.conformer.bond_topologies[1].bond_topology_id = 99999\n\n def test_all_outputs(self):\n mols = list(smu_utils_lib.conformer_to_molecules(self.conformer))\n self.assertLen(mols, 6) # 2 bond topologies * (1 opt geom + 2 init_geom)\n self.assertEqual([m.GetProp('_Name') for m in mols], [\n 'SMU 618451001 bt=618451(0/2) geom=init(0/2)',\n 'SMU 618451001 bt=618451(0/2) geom=init(1/2)',\n 'SMU 618451001 bt=618451(0/2) geom=opt',\n 'SMU 618451001 bt=99999(1/2) geom=init(0/2)',\n 'SMU 618451001 bt=99999(1/2) geom=init(1/2)',\n 'SMU 618451001 bt=99999(1/2) geom=opt'\n ])\n self.assertEqual(\n '[H]C(F)=C(OC([H])([H])[H])OC([H])([H])[H]',\n Chem.MolToSmiles(mols[0], kekuleSmiles=True, isomericSmiles=False))\n self.assertEqual(\n '[H]C(F)=C(OC([H])([H])[H])OC([H])([H])[H]',\n Chem.MolToSmiles(mols[4], kekuleSmiles=True, isomericSmiles=False))\n\n def test_initial_only(self):\n mols = list(\n smu_utils_lib.conformer_to_molecules(\n self.conformer,\n include_initial_geometries=True,\n include_optimized_geometry=False,\n include_all_bond_topologies=False))\n self.assertLen(mols, 2)\n self.assertEqual([m.GetProp('_Name') for m in mols], [\n 'SMU 618451001 bt=618451(0/2) geom=init(0/2)',\n 'SMU 618451001 bt=618451(0/2) geom=init(1/2)',\n ])\n # This is just one random atom I picked from the .dat file and converted to\n # angstroms instead of bohr.\n self.assertEqual('C', mols[0].GetAtomWithIdx(1).GetSymbol())\n np.testing.assert_allclose([0.6643, -3.470301, 3.4766],\n list(mols[0].GetConformer().GetAtomPosition(1)),\n atol=1e-6)\n\n self.assertEqual('C', mols[1].GetAtomWithIdx(1).GetSymbol())\n np.testing.assert_allclose([664.299998, -3470.300473, 3476.600215],\n list(mols[1].GetConformer().GetAtomPosition(1)),\n atol=1e-6)\n\n def test_optimized_only(self):\n mols = list(\n smu_utils_lib.conformer_to_molecules(\n self.conformer,\n include_initial_geometries=False,\n include_optimized_geometry=True,\n include_all_bond_topologies=False))\n self.assertLen(mols, 1)\n self.assertEqual(\n mols[0].GetProp('_Name'),\n 'SMU 618451001 bt=618451(0/2) geom=opt',\n )\n self.assertEqual(\n '[H]C(F)=C(OC([H])([H])[H])OC([H])([H])[H]',\n Chem.MolToSmiles(mols[0], kekuleSmiles=True, isomericSmiles=False))\n # This is just two random atoms I picked from the .dat file and converted to\n # angstroms instead of bohr.\n self.assertEqual('C', mols[0].GetAtomWithIdx(1).GetSymbol())\n np.testing.assert_allclose([0.540254, -3.465543, 3.456982],\n list(mols[0].GetConformer().GetAtomPosition(1)),\n atol=1e-6)\n self.assertEqual('H', mols[0].GetAtomWithIdx(13).GetSymbol())\n np.testing.assert_allclose([2.135153, -1.817366, 0.226376],\n list(mols[0].GetConformer().GetAtomPosition(13)),\n atol=1e-6)\n\n\nclass SmilesCompareTest(absltest.TestCase):\n\n def test_string_format(self):\n # for some simplicity later on, we use shorter names\n self.assertEqual('MISSING', str(smu_utils_lib.SmilesCompareResult.MISSING))\n self.assertEqual('MISMATCH',\n str(smu_utils_lib.SmilesCompareResult.MISMATCH))\n self.assertEqual('MATCH', str(smu_utils_lib.SmilesCompareResult.MATCH))\n\n def test_missing(self):\n bond_topology = str_to_bond_topology('''\natoms: ATOM_O\natoms: ATOM_O\nbonds {\n atom_b: 1\n bond_type: BOND_DOUBLE\n}\n''')\n result, with_h, without_h = smu_utils_lib.bond_topology_smiles_comparison(\n bond_topology)\n self.assertEqual(smu_utils_lib.SmilesCompareResult.MISSING, result)\n self.assertEqual('O=O', with_h)\n self.assertEqual('O=O', without_h)\n\n # Also directly test compute_smiles_for_bond_topology\n self.assertEqual(\n 'O=O',\n smu_utils_lib.compute_smiles_for_bond_topology(\n bond_topology, include_hs=True))\n\n def test_mismatch(self):\n bond_topology = str_to_bond_topology('''\natoms: ATOM_O\natoms: ATOM_O\nbonds {\n atom_b: 1\n bond_type: BOND_DOUBLE\n}\nsmiles: \"BlahBlahBlah\"\n''')\n result, with_h, without_h = smu_utils_lib.bond_topology_smiles_comparison(\n bond_topology)\n self.assertEqual(smu_utils_lib.SmilesCompareResult.MISMATCH, result)\n self.assertEqual('O=O', with_h)\n self.assertEqual('O=O', without_h)\n\n def test_matched_and_h_stripping(self):\n bond_topology = str_to_bond_topology('''\natoms: ATOM_O\natoms: ATOM_H\natoms: ATOM_H\nbonds {\n atom_b: 1\n bond_type: BOND_SINGLE\n}\nbonds {\n atom_b: 2\n bond_type: BOND_SINGLE\n}\nsmiles: \"O\"\n''')\n result, with_h, without_h = smu_utils_lib.bond_topology_smiles_comparison(\n bond_topology)\n self.assertEqual(smu_utils_lib.SmilesCompareResult.MATCH, result)\n self.assertEqual('[H]O[H]', with_h)\n self.assertEqual('O', without_h)\n\n # Also directly test compute_smiles_for_bond_topology\n self.assertEqual(\n '[H]O[H]',\n smu_utils_lib.compute_smiles_for_bond_topology(\n bond_topology, include_hs=True))\n self.assertEqual(\n 'O',\n smu_utils_lib.compute_smiles_for_bond_topology(\n bond_topology, include_hs=False))\n\n def test_compute_smiles_from_molecule_no_hs(self):\n mol = Chem.MolFromSmiles('FOC', sanitize=False)\n self.assertEqual(\n smu_utils_lib.compute_smiles_for_molecule(mol, include_hs=False), 'COF')\n # This is expected. Even with include_hs=True, if there were no Hs in the\n # molecule, they will not be in the smiles.\n self.assertEqual(\n smu_utils_lib.compute_smiles_for_molecule(mol, include_hs=True), 'COF')\n\n def test_compute_smiles_from_molecule_with_hs(self):\n mol = Chem.MolFromSmiles('FOC', sanitize=False)\n Chem.SanitizeMol(mol, Chem.rdmolops.SanitizeFlags.SANITIZE_ADJUSTHS)\n mol = Chem.AddHs(mol)\n self.assertEqual(\n smu_utils_lib.compute_smiles_for_molecule(mol, include_hs=False), 'COF')\n self.assertEqual(\n smu_utils_lib.compute_smiles_for_molecule(mol, include_hs=True),\n '[H]C([H])([H])OF')\n\n def test_compute_smiles_from_molecule_special_case(self):\n mol = Chem.MolFromSmiles('C12=C3C4=C1C4=C23', sanitize=False)\n # Double check that this really is the special case -- we get back the\n # SMILES we put in even though it's not the one we want.\n self.assertEqual('C12=C3C4=C1C4=C23',\n Chem.MolToSmiles(mol, kekuleSmiles=True))\n self.assertEqual(\n smu_utils_lib.compute_smiles_for_molecule(mol, include_hs=False),\n 'C12=C3C1=C1C2=C31')\n\n def test_compute_smiles_from_molecule_labeled_with_h(self):\n mol = Chem.MolFromSmiles(\n '[O-][N+]([H])([H])N([H])OC([H])([H])F', sanitize=False)\n self.assertIsNotNone(mol)\n self.assertEqual(\n '[O-][N+:1]([H:2])([H:3])[N:4]([H:5])[O:6][C:7]([H:8])([H:9])[F:10]',\n smu_utils_lib.compute_smiles_for_molecule(\n mol, include_hs=True, labeled_atoms=True))\n\n def test_compute_smiles_from_molecule_labeled_no_h(self):\n mol = Chem.MolFromSmiles(\n '[O-][N+]([H])([H])N([H])OC([H])([H])F', sanitize=False)\n self.assertIsNotNone(mol)\n self.assertEqual(\n '[O-][NH2+:1][NH:2][O:3][CH2:4][F:5]',\n smu_utils_lib.compute_smiles_for_molecule(\n mol, include_hs=False, labeled_atoms=True))\n\n\nclass MergeConformersTest(absltest.TestCase):\n\n def setUp(self):\n super().setUp()\n # We are relying on the fact that the first conformer in both x07_sample.dat\n # and x07_stage1.dat are the same.\n self.stage1_conformer = get_stage1_conformer()\n self.stage2_conformer = get_stage2_conformer()\n\n self.duplicate_conformer = dataset_pb2.Conformer()\n self.duplicate_conformer.conformer_id = self.stage1_conformer.conformer_id\n # A real duplicate conformer wouldn't have both of these fields filled in,\n # but it's fine for the test to make sure everything is copied.\n self.duplicate_conformer.duplicated_by = 123\n self.duplicate_conformer.duplicate_of.extend([111, 222])\n\n def test_two_stage2(self):\n with self.assertRaises(ValueError):\n smu_utils_lib.merge_conformer(self.stage2_conformer,\n self.stage2_conformer)\n\n def test_two_stage1(self):\n with self.assertRaises(ValueError):\n smu_utils_lib.merge_conformer(self.stage1_conformer,\n self.stage1_conformer)\n\n def test_two_duplicates(self):\n duplicate_conformer2 = copy.deepcopy(self.duplicate_conformer)\n duplicate_conformer2.duplicate_of[:] = [333, 444]\n\n got_conf, got_conflict = smu_utils_lib.merge_conformer(\n self.duplicate_conformer, duplicate_conformer2)\n self.assertIsNone(got_conflict)\n self.assertEqual(123, got_conf.duplicated_by)\n self.assertCountEqual([111, 222, 333, 444], got_conf.duplicate_of)\n\n def test_stage2_stage1(self):\n # Add a duplicate to stage1 to make sure it is copied\n self.stage1_conformer.duplicate_of.append(999)\n got_conf, got_conflict = smu_utils_lib.merge_conformer(\n self.stage2_conformer, self.stage1_conformer)\n self.assertIsNone(got_conflict)\n self.assertEqual(got_conf.duplicate_of, [999])\n # Just check a random field that is in stage2 but not stage1\n self.assertNotEmpty(got_conf.properties.normal_modes)\n\n def test_stage2_stage1_conflict_energy(self):\n self.stage2_conformer.properties.initial_geometry_energy.value = -1.23\n got_conf, got_conflict = smu_utils_lib.merge_conformer(\n self.stage2_conformer, self.stage1_conformer)\n self.assertEqual(got_conflict, [\n 618451001,\n 1, 1, 1, 1, -406.51179, 0.052254, -406.522079, 2.5e-05, True, True,\n 1, 1, 1, 1, -1.23, 0.052254, -406.522079, 2.5e-05, True, True\n ])\n # Just check a random field that is in stage2 but not stage1\n self.assertNotEmpty(got_conf.properties.normal_modes)\n # This stage2 values should be returned\n self.assertEqual(got_conf.properties.initial_geometry_energy.value, -1.23)\n\n def test_stage2_stage1_conflict_error_codes(self):\n self.stage2_conformer.properties.errors.error_nstat1 = 999\n got_conf, got_conflict = smu_utils_lib.merge_conformer(\n self.stage2_conformer, self.stage1_conformer)\n self.assertEqual(got_conflict, [\n 618451001,\n 1, 1, 1, 1, -406.51179, 0.052254, -406.522079, 2.5e-05, True, True,\n 999, 1, 1, 1, -406.51179, 0.052254, -406.522079, 2.5e-05, True, True\n ])\n # Just check a random field that is in stage2 but not stage1\n self.assertNotEmpty(got_conf.properties.normal_modes)\n\n def test_stage2_stage1_conflict_missing_geometry(self):\n self.stage2_conformer.ClearField('optimized_geometry')\n got_conf, got_conflict = smu_utils_lib.merge_conformer(\n self.stage2_conformer, self.stage1_conformer)\n self.assertEqual(got_conflict, [\n 618451001,\n 1, 1, 1, 1, -406.51179, 0.052254, -406.522079, 2.5e-05, True, True,\n 1, 1, 1, 1, -406.51179, 0.052254, -406.522079, 2.5e-05, True, False\n ])\n # Just check a random field that is in stage2 but not stage1\n self.assertNotEmpty(got_conf.properties.normal_modes)\n\n def test_stage2_stage1_no_conflict_minus1(self):\n # If stage2 contains a -1, we keep that (stricter error checking later on)\n self.stage2_conformer.properties.initial_geometry_energy.value = -1.0\n got_conf, got_conflict = smu_utils_lib.merge_conformer(\n self.stage2_conformer, self.stage1_conformer)\n self.assertIsNone(got_conflict)\n self.assertEqual(got_conf.properties.initial_geometry_energy.value, -1.0)\n\n def test_stage2_stage1_no_conflict_approx_equal(self):\n self.stage2_conformer.properties.initial_geometry_energy.value += 1e-7\n got_conf, got_conflict = smu_utils_lib.merge_conformer(\n self.stage2_conformer, self.stage1_conformer)\n self.assertIsNone(got_conflict)\n # Just check a random field from stage2\n self.assertNotEmpty(got_conf.properties.normal_modes)\n\n def test_stage2_duplicate(self):\n got_conf, got_conflict = smu_utils_lib.merge_conformer(\n self.stage2_conformer, self.duplicate_conformer)\n self.assertIsNone(got_conflict)\n self.assertEqual(got_conf.duplicate_of, [111, 222])\n self.assertEqual(got_conf.duplicated_by, 123)\n # Just check a random field from stage2\n self.assertNotEmpty(got_conf.properties.normal_modes)\n\n def test_stage1_duplicate(self):\n got_conf, got_conflict = smu_utils_lib.merge_conformer(\n self.stage1_conformer, self.duplicate_conformer)\n self.assertIsNone(got_conflict)\n self.assertEqual(got_conf.duplicate_of, [111, 222])\n self.assertEqual(got_conf.duplicated_by, 123)\n # Just check a random field from stage1\n self.assertTrue(got_conf.properties.HasField('initial_geometry_energy'))\n\n def test_multiple_initial_geometries(self):\n bad_conformer = copy.deepcopy(self.stage1_conformer)\n bad_conformer.initial_geometries.append(bad_conformer.initial_geometries[0])\n with self.assertRaises(ValueError):\n smu_utils_lib.merge_conformer(bad_conformer, self.stage2_conformer)\n with self.assertRaises(ValueError):\n smu_utils_lib.merge_conformer(self.stage2_conformer, bad_conformer)\n\n def test_multiple_bond_topologies(self):\n bad_conformer = copy.deepcopy(self.stage1_conformer)\n bad_conformer.bond_topologies.append(bad_conformer.bond_topologies[0])\n with self.assertRaises(ValueError):\n smu_utils_lib.merge_conformer(bad_conformer, self.stage2_conformer)\n with self.assertRaises(ValueError):\n smu_utils_lib.merge_conformer(self.stage2_conformer, bad_conformer)\n\n def test_different_bond_topologies(self):\n self.stage1_conformer.bond_topologies[0].atoms[0] = (\n dataset_pb2.BondTopology.ATOM_H)\n with self.assertRaises(ValueError):\n smu_utils_lib.merge_conformer(self.stage1_conformer,\n self.stage2_conformer)\n with self.assertRaises(ValueError):\n smu_utils_lib.merge_conformer(self.stage2_conformer,\n self.stage1_conformer)\n\n\nclass ConformerErrorTest(absltest.TestCase):\n\n def test_stage1_no_error(self):\n conformer = get_stage1_conformer()\n self.assertFalse(smu_utils_lib.conformer_has_calculation_errors(conformer))\n\n def test_stage1_error(self):\n conformer = get_stage2_conformer()\n conformer.properties.errors.error_frequencies = 123\n self.assertTrue(smu_utils_lib.conformer_has_calculation_errors(conformer))\n\n def test_stage2_no_error(self):\n conformer = get_stage2_conformer()\n self.assertFalse(smu_utils_lib.conformer_has_calculation_errors(conformer))\n\n def test_stage2_error_in_1_expected_field(self):\n conformer = get_stage2_conformer()\n conformer.properties.errors.error_rotational_modes = 123\n self.assertTrue(smu_utils_lib.conformer_has_calculation_errors(conformer))\n\n def test_stage2_error_in_0_expected_field(self):\n conformer = get_stage2_conformer()\n # This field is 0 to indicate no error. Why the discrepancy? Who knows!\n conformer.properties.errors.error_nsvg09 = 1\n self.assertTrue(smu_utils_lib.conformer_has_calculation_errors(conformer))\n\n def test_stage2_nstat1_is_3(self):\n # This is the other bizaare case. nstat1 of 3 is still considered success.\n conformer = get_stage2_conformer()\n conformer.properties.errors.error_nstat1 = 3\n self.assertFalse(smu_utils_lib.conformer_has_calculation_errors(conformer))\n\n\nclass FilterConformerByAvailabilityTest(absltest.TestCase):\n\n def setUp(self):\n super().setUp()\n self.conformer = dataset_pb2.Conformer()\n properties = self.conformer.properties\n # A STANDARD field\n properties.single_point_energy_pbe0d3_6_311gd.value = 1.23\n # A COMPLETE field\n properties.homo_pbe0_aug_pc_1.value = 1.23\n # An INTERNAL_ONLY field\n properties.nuclear_repulsion_energy.value = 1.23\n\n def test_standard(self):\n smu_utils_lib.filter_conformer_by_availability(self.conformer,\n [dataset_pb2.STANDARD])\n self.assertTrue(\n self.conformer.properties.HasField(\n 'single_point_energy_pbe0d3_6_311gd'))\n self.assertFalse(self.conformer.properties.HasField('homo_pbe0_aug_pc_1'))\n self.assertFalse(\n self.conformer.properties.HasField('nuclear_repulsion_energy'))\n\n def test_complete_and_internal_only(self):\n smu_utils_lib.filter_conformer_by_availability(\n self.conformer, [dataset_pb2.COMPLETE, dataset_pb2.INTERNAL_ONLY])\n self.assertFalse(\n self.conformer.properties.HasField(\n 'single_point_energy_pbe0d3_6_311gd'))\n self.assertTrue(self.conformer.properties.HasField('homo_pbe0_aug_pc_1'))\n self.assertTrue(\n self.conformer.properties.HasField('nuclear_repulsion_energy'))\n\n\nclass ConformerToStandardTest(absltest.TestCase):\n\n def setUp(self):\n super().setUp()\n\n self.conformer = get_stage2_conformer()\n\n def test_field_filtering(self):\n # Check that the field which should be filtered starts out set\n self.assertTrue(self.conformer.properties.HasField(\n 'single_point_energy_hf_6_31gd'))\n\n got = smu_utils_lib.conformer_to_standard(self.conformer)\n # Check for a field that was originally in self.conformer and should be\n # filtered and a field which should still be present.\n self.assertTrue(got.properties.HasField(\n 'single_point_energy_pbe0d3_6_311gd'))\n self.assertFalse(\n got.properties.HasField('single_point_energy_hf_6_31gd'))\n\n def test_remove_error_conformer(self):\n self.conformer.properties.errors.error_frequencies = 123\n\n self.assertIsNone(smu_utils_lib.conformer_to_standard(self.conformer))\n\n def test_remove_duplicate(self):\n self.conformer.duplicated_by = 123\n\n self.assertIsNone(smu_utils_lib.conformer_to_standard(self.conformer))\n\n\nclass DetermineFateTest(parameterized.TestCase):\n\n def test_duplicate_same_topology(self):\n conformer = get_stage1_conformer()\n # bond topology is conformer_id // 1000\n conformer.duplicated_by = conformer.conformer_id + 1\n self.assertEqual(dataset_pb2.Conformer.FATE_DUPLICATE_SAME_TOPOLOGY,\n smu_utils_lib.determine_fate(conformer))\n\n def test_duplicate_different_topology(self):\n conformer = get_stage1_conformer()\n # bond topology is conformer_id // 1000\n conformer.duplicated_by = conformer.conformer_id + 1000\n self.assertEqual(dataset_pb2.Conformer.FATE_DUPLICATE_DIFFERENT_TOPOLOGY,\n smu_utils_lib.determine_fate(conformer))\n\n @parameterized.parameters(\n (2, dataset_pb2.Conformer.FATE_GEOMETRY_OPTIMIZATION_PROBLEM),\n (5, dataset_pb2.Conformer.FATE_DISASSOCIATED),\n (4, dataset_pb2.Conformer.FATE_FORCE_CONSTANT_FAILURE),\n (6, dataset_pb2.Conformer.FATE_DISCARDED_OTHER))\n def test_geometry_failures(self, nstat1, expected_fate):\n conformer = get_stage1_conformer()\n conformer.properties.errors.error_nstat1 = nstat1\n self.assertEqual(expected_fate, smu_utils_lib.determine_fate(conformer))\n\n def test_no_result(self):\n conformer = get_stage1_conformer()\n self.assertEqual(dataset_pb2.Conformer.FATE_NO_CALCULATION_RESULTS,\n smu_utils_lib.determine_fate(conformer))\n\n def test_calculation_errors(self):\n conformer = get_stage2_conformer()\n # This is a random choice of an error to set. I just need some error.\n conformer.properties.errors.error_atomic_analysis = 999\n self.assertEqual(dataset_pb2.Conformer.FATE_CALCULATION_WITH_ERROR,\n smu_utils_lib.determine_fate(conformer))\n\n def test_success(self):\n conformer = get_stage2_conformer()\n self.assertEqual(dataset_pb2.Conformer.FATE_SUCCESS,\n smu_utils_lib.determine_fate(conformer))\n\n\nclass ToBondTopologySummaryTest(absltest.TestCase):\n\n def setUp(self):\n super().setUp()\n self.conformer = get_stage2_conformer()\n\n def test_dup_same(self):\n self.conformer.fate = dataset_pb2.Conformer.FATE_DUPLICATE_SAME_TOPOLOGY\n got = list(\n smu_utils_lib.conformer_to_bond_topology_summaries(self.conformer))\n self.assertLen(got, 1)\n self.assertEqual(got[0].bond_topology.bond_topology_id,\n self.conformer.bond_topologies[0].bond_topology_id)\n self.assertEqual(got[0].count_attempted_conformers, 1)\n self.assertEqual(got[0].count_duplicates_same_topology, 1)\n\n def test_dup_diff(self):\n self.conformer.fate = (\n dataset_pb2.Conformer.FATE_DUPLICATE_DIFFERENT_TOPOLOGY)\n got = list(\n smu_utils_lib.conformer_to_bond_topology_summaries(self.conformer))\n self.assertLen(got, 1)\n self.assertEqual(got[0].count_attempted_conformers, 1)\n self.assertEqual(got[0].count_duplicates_different_topology, 1)\n\n def test_geometry_failed(self):\n self.conformer.fate = (dataset_pb2.Conformer.FATE_DISCARDED_OTHER)\n got = list(\n smu_utils_lib.conformer_to_bond_topology_summaries(self.conformer))\n self.assertLen(got, 1)\n self.assertEqual(got[0].count_attempted_conformers, 1)\n self.assertEqual(got[0].count_failed_geometry_optimization, 1)\n\n def test_missing_calculation(self):\n self.conformer.fate = dataset_pb2.Conformer.FATE_NO_CALCULATION_RESULTS\n got = list(\n smu_utils_lib.conformer_to_bond_topology_summaries(self.conformer))\n self.assertLen(got, 1)\n self.assertEqual(got[0].count_attempted_conformers, 1)\n self.assertEqual(got[0].count_kept_geometry, 1)\n self.assertEqual(got[0].count_missing_calculation, 1)\n\n def test_calculation_with_error(self):\n self.conformer.fate = dataset_pb2.Conformer.FATE_CALCULATION_WITH_ERROR\n self.conformer.bond_topologies.append(self.conformer.bond_topologies[0])\n self.conformer.bond_topologies[-1].bond_topology_id = 123\n got = list(\n smu_utils_lib.conformer_to_bond_topology_summaries(self.conformer))\n self.assertLen(got, 2)\n # We don't actually care about the order, but this is what comes out right\n # now.\n self.assertEqual(got[0].bond_topology.bond_topology_id, 123)\n self.assertEqual(got[0].count_attempted_conformers, 0)\n self.assertEqual(got[0].count_kept_geometry, 0)\n self.assertEqual(got[0].count_calculation_with_error, 0)\n self.assertEqual(got[0].count_detected_match_with_error, 1)\n\n self.assertEqual(got[1].bond_topology.bond_topology_id,\n self.conformer.bond_topologies[0].bond_topology_id)\n self.assertEqual(got[1].count_attempted_conformers, 1)\n self.assertEqual(got[1].count_kept_geometry, 1)\n self.assertEqual(got[1].count_calculation_with_error, 1)\n self.assertEqual(got[1].count_detected_match_with_error, 0)\n\n def test_calculation_success(self):\n self.conformer.fate = dataset_pb2.Conformer.FATE_SUCCESS\n self.conformer.bond_topologies.append(self.conformer.bond_topologies[0])\n self.conformer.bond_topologies[-1].bond_topology_id = 123\n got = list(\n smu_utils_lib.conformer_to_bond_topology_summaries(self.conformer))\n self.assertLen(got, 2)\n # We don't actually care about the order, but this is what comes out right\n # now.\n self.assertEqual(got[0].bond_topology.bond_topology_id, 123)\n self.assertEqual(got[0].count_attempted_conformers, 0)\n self.assertEqual(got[0].count_kept_geometry, 0)\n self.assertEqual(got[0].count_calculation_success, 0)\n self.assertEqual(got[0].count_detected_match_success, 1)\n\n self.assertEqual(got[1].bond_topology.bond_topology_id,\n self.conformer.bond_topologies[0].bond_topology_id)\n self.assertEqual(got[1].count_attempted_conformers, 1)\n self.assertEqual(got[1].count_kept_geometry, 1)\n self.assertEqual(got[1].count_calculation_success, 1)\n self.assertEqual(got[1].count_detected_match_success, 0)\n\n\nclass LabeledSmilesTester(absltest.TestCase):\n\n def test_atom_labels(self):\n mol = Chem.MolFromSmiles('FCON[NH2+][O-]', sanitize=False)\n self.assertIsNotNone(mol)\n smiles_before = Chem.MolToSmiles(mol)\n self.assertEqual(\n smu_utils_lib.labeled_smiles(mol), 'F[CH2:1][O:2][NH:3][NH2+:4][O-:5]')\n # Testing both the atom numbers and the smiles is redundant,\n # but guards against possible future changes.\n for atom in mol.GetAtoms():\n self.assertEqual(atom.GetAtomMapNum(), 0)\n self.assertEqual(Chem.MolToSmiles(mol), smiles_before)\n\n\nif __name__ == '__main__':\n absltest.main()\n"
] | [
[
"tensorflow.compat.v1.random.uniform",
"numpy.random.RandomState"
],
[
"tensorflow.compat.v1.VariableScope",
"tensorflow.Variable",
"tensorflow.function"
],
[
"tensorflow.compat.v2.summary.scalar",
"numpy.zeros",
"numpy.mean",
"numpy.float64",
"tensorflow.zeros_like",
"tensorflow.reduce_mean"
],
[
"numpy.random.seed",
"tensorflow.compat.v2.config.experimental_run_functions_eagerly",
"tensorflow.compat.v2.random.set_seed",
"tensorflow.compat.v2.debugging.set_log_device_placement"
],
[
"numpy.zeros_like",
"numpy.array",
"tensorflow.compat.v2.reduce_logsumexp",
"tensorflow.compat.v2.exp",
"tensorflow.compat.v2.expand_dims",
"matplotlib.pyplot.close",
"matplotlib.pyplot.subplots",
"tensorflow.compat.v2.zeros_like",
"tensorflow.compat.v2.ones",
"numpy.arange",
"numpy.argmax",
"numpy.abs",
"tensorflow.compat.v2.reduce_sum",
"tensorflow.compat.v2.math.log"
],
[
"numpy.random.normal",
"numpy.empty",
"numpy.argmin",
"numpy.zeros",
"numpy.log",
"numpy.roots",
"numpy.exp",
"numpy.sign",
"numpy.sort",
"numpy.sqrt",
"numpy.clip",
"numpy.abs",
"numpy.linspace",
"numpy.logspace",
"numpy.random.laplace"
],
[
"tensorflow.compat.v1.assign",
"tensorflow.compat.v1.clip_by_global_norm",
"tensorflow.compat.v1.identity",
"tensorflow.python.tpu.tpu_feed._PartitionedInfeedQueue",
"tensorflow.compat.v1.trainable_variables",
"tensorflow.compat.v1.argmax",
"tensorflow.compat.v1.reduce_sum",
"tensorflow.compat.v1.less_equal",
"tensorflow.compat.v1.gradients",
"tensorflow.compat.v1.assign_sub",
"tensorflow.compat.v1.greater_equal",
"tensorflow.compat.v1.split",
"tensorflow.compat.v1.train.get_or_create_global_step",
"tensorflow.compat.v1.reduce_mean",
"tensorflow.compat.v1.cast",
"tensorflow.compat.v1.math.is_finite",
"tensorflow.compat.v1.stop_gradient",
"tensorflow.compat.v1.variable_scope",
"tensorflow.compat.v1.control_dependencies",
"tensorflow.compat.v1.reduce_max",
"tensorflow.compat.v1.expand_dims",
"tensorflow.compat.v1.raw_ops.InfeedDequeueTuple",
"tensorflow.compiler.xla.experimental.xla_sharding.xla_sharding.split",
"tensorflow.compat.v1.nn.log_softmax",
"tensorflow.compat.v1.get_collection",
"tensorflow.compat.v1.tpu.cross_replica_sum",
"tensorflow.compat.v1.get_variable",
"tensorflow.compat.v1.one_hot",
"tensorflow.compat.v1.losses.softmax_cross_entropy",
"tensorflow.compat.v1.concat",
"tensorflow.compat.v1.nn.softmax",
"tensorflow.compat.v1.tpu.core",
"tensorflow.compat.v1.raw_ops.OutfeedEnqueueTuple"
],
[
"tensorflow.gfile.Open"
],
[
"tensorflow.io.gfile.exists",
"numpy.mean"
],
[
"numpy.array",
"numpy.isnan",
"numpy.zeros_like",
"pandas.DataFrame",
"numpy.mean",
"numpy.where",
"numpy.nanmean",
"pandas.concat"
],
[
"tensorflow.shape",
"tensorflow.keras.initializers.TruncatedNormal"
],
[
"tensorflow.data.Dataset.list_files",
"tensorflow.io.FixedLenFeature",
"tensorflow.sparse.to_dense",
"tensorflow.io.parse_single_example",
"tensorflow.stack",
"tensorflow.math.greater",
"tensorflow.one_hot",
"tensorflow.io.VarLenFeature",
"tensorflow.boolean_mask"
],
[
"pandas.DataFrame"
]
] |
ishine/malaya-speech | [
"fd34afc7107af1656dff4b3201fa51dda54fde18",
"fd34afc7107af1656dff4b3201fa51dda54fde18",
"fd34afc7107af1656dff4b3201fa51dda54fde18",
"fd34afc7107af1656dff4b3201fa51dda54fde18",
"fd34afc7107af1656dff4b3201fa51dda54fde18",
"fd34afc7107af1656dff4b3201fa51dda54fde18",
"fd34afc7107af1656dff4b3201fa51dda54fde18"
] | [
"pretrained-model/stt/hubert/conformer-tiny-ctc.py",
"session/speaker-change/finetune-vggvox-v2.py",
"pretrained-model/stt/jasper/medium-jasper-ctc.py",
"malaya_speech/train/model/fastsplit/model.py",
"malaya_speech/train/model/fastsplit/loss.py",
"malaya_speech/train/model/pix2pix/discriminator.py",
"pretrained-model/vocoder/universal-melgan/universal-melgan-1024.py"
] | [
"import os\n\nos.environ['CUDA_VISIBLE_DEVICES'] = '3'\n\nimport pyroomacoustics as pra\nimport numpy as np\nfrom pydub import AudioSegment\nfrom sklearn.utils import shuffle\nfrom glob import glob\nimport random\nimport json\nfrom malaya_speech.train.model.conformer.model import Model as ConformerModel\nfrom malaya_speech.train.model import hubert, ctc\nimport malaya_speech.train as train\nimport malaya_speech.config\nimport malaya_speech.augmentation.waveform as augmentation\nimport malaya_speech\nimport tensorflow as tf\nimport os\nimport string\n\n\nsr = 16000\nmaxlen = 18\nminlen_text = 1\nprob_aug = 0.95\n\nunique_vocab = [''] + list(string.ascii_lowercase + string.digits) + [' ']\n\n\ndef augment_room(y, scale=1.0):\n corners = np.array(\n [[0, 0], [0, 5 * scale], [3 * scale, 5 * scale], [3 * scale, 0]]\n ).T\n room = pra.Room.from_corners(\n corners,\n fs=sr,\n materials=pra.Material(0.2, 0.15),\n ray_tracing=True,\n air_absorption=True,\n )\n room.extrude(3.5, materials=pra.Material(0.2, 0.15))\n room.set_ray_tracing(\n receiver_radius=0.5, n_rays=1000, energy_thres=1e-5\n )\n room.add_source([1.5 * scale, 4 * scale, 0.5], signal=y)\n R = np.array([[1.5 * scale], [0.5 * scale], [0.5]])\n room.add_microphone(R)\n room.simulate()\n return room.mic_array.signals[0]\n\n\ndef random_amplitude_threshold(sample, low=1, high=2, threshold=0.4):\n y_aug = sample.copy()\n dyn_change = np.random.uniform(low=low, high=high)\n y_aug[np.abs(y_aug) >= threshold] = (\n y_aug[np.abs(y_aug) >= threshold] * dyn_change\n )\n return np.clip(y_aug, -1, 1)\n\n\ndef add_uniform_noise(\n sample, power=0.01, return_noise=False, scale=False\n):\n y_noise = sample.copy()\n noise_amp = power * np.random.uniform() * np.amax(y_noise)\n noise = noise_amp * np.random.normal(size=y_noise.shape[0])\n y_noise = y_noise + noise\n if scale:\n y_noise = y_noise / (np.max(np.abs(y_noise)) + 1e-9)\n if return_noise:\n if scale:\n noise = noise / (np.max(np.abs(y_noise)) + 1e-9)\n return y_noise, noise\n else:\n return y_noise\n\n\ndef calc(signal, add_uniform=True):\n choice = random.randint(0, 10)\n print('choice', choice)\n if choice == 0:\n x = augmentation.sox_augment_high(\n signal,\n min_bass_gain=random.randint(25, 50),\n reverberance=random.randint(0, 80),\n hf_damping=10,\n room_scale=random.randint(0, 50),\n negate=1,\n )\n if choice == 1:\n x = augmentation.sox_augment_high(\n signal,\n min_bass_gain=random.randint(25, 70),\n reverberance=random.randint(0, 80),\n hf_damping=10,\n room_scale=random.randint(0, 50),\n negate=0,\n )\n if choice == 2:\n x = augmentation.sox_augment_low(\n signal,\n min_bass_gain=random.randint(5, 30),\n reverberance=random.randint(0, 80),\n hf_damping=10,\n room_scale=random.randint(0, 50),\n negate=random.randint(0, 1),\n )\n if choice == 3:\n x = augmentation.sox_augment_combine(\n signal,\n min_bass_gain_high=random.randint(25, 70),\n min_bass_gain_low=random.randint(5, 30),\n reverberance=random.randint(0, 80),\n hf_damping=10,\n room_scale=random.randint(0, 90),\n )\n if choice == 4:\n x = augmentation.sox_reverb(\n signal,\n reverberance=random.randint(10, 80),\n hf_damping=10,\n room_scale=random.randint(10, 90),\n )\n if choice == 5:\n x = random_amplitude_threshold(\n signal, threshold=random.uniform(0.35, 0.8)\n )\n if choice == 6:\n x = augmentation.lowpass_filter(\n signal, sr=sr, cutoff=random.randint(200, 551)\n )\n if choice == 7:\n x = augmentation.highpass_filter(\n signal, sr=sr, cutoff=random.randint(551, 1653)\n )\n if choice == 8:\n x = augmentation.bandpass_filter(\n signal,\n sr=sr,\n cutoff_low=random.randint(200, 551),\n cutoff_high=random.randint(551, 1653),\n )\n if choice == 9:\n x = augment_room(signal)\n if choice == 10:\n x = signal\n\n if choice not in [5] and random.gauss(0.5, 0.14) > 0.6:\n x = random_amplitude_threshold(\n x, low=1.0, high=2.0, threshold=random.uniform(0.6, 0.9)\n )\n\n if random.gauss(0.5, 0.14) > 0.6 and add_uniform:\n x = add_uniform_noise(x, power=random.uniform(0.005, 0.015))\n\n return x\n\n\ndef mp3_to_wav(file, sr=sr):\n audio = AudioSegment.from_file(file)\n audio = audio.set_frame_rate(sr).set_channels(1)\n sample = np.array(audio.get_array_of_samples())\n return malaya_speech.astype.int_to_float(sample), sr\n\n\ndef generate(file):\n with open(file) as fopen:\n dataset = json.load(fopen)\n audios, cleaned_texts = dataset['X'], dataset['Y']\n while True:\n audios, cleaned_texts = shuffle(audios, cleaned_texts)\n for i in range(len(audios)):\n try:\n if audios[i].endswith('.mp3'):\n # print('found mp3', audios[i])\n wav_data, _ = mp3_to_wav(audios[i])\n else:\n wav_data, _ = malaya_speech.load(audios[i], sr=sr)\n\n if len(cleaned_texts[i]) < minlen_text:\n # print(f'skipped text too short {audios[i]}')\n continue\n\n if (len(wav_data) / sr) > maxlen:\n continue\n\n t = [unique_vocab.index(c) for c in cleaned_texts[i]]\n\n yield {\n 'waveforms': wav_data,\n 'waveforms_length': [len(wav_data)],\n 'targets': t,\n 'targets_length': [len(t)],\n }\n except Exception as e:\n print(e)\n\n\ndef get_dataset(\n file,\n batch_size=12,\n shuffle_size=20,\n thread_count=24,\n maxlen_feature=1800,\n):\n def get():\n dataset = tf.data.Dataset.from_generator(\n generate,\n {\n 'waveforms': tf.float32,\n 'waveforms_length': tf.int32,\n 'targets': tf.int32,\n 'targets_length': tf.int32,\n },\n output_shapes={\n 'waveforms': tf.TensorShape([None]),\n 'waveforms_length': tf.TensorShape([None]),\n 'targets': tf.TensorShape([None]),\n 'targets_length': tf.TensorShape([None]),\n },\n args=(file,),\n )\n dataset = dataset.prefetch(tf.contrib.data.AUTOTUNE)\n dataset = dataset.padded_batch(\n batch_size,\n padded_shapes={\n 'waveforms': tf.TensorShape([None]),\n 'waveforms_length': tf.TensorShape([None]),\n 'targets': tf.TensorShape([None]),\n 'targets_length': tf.TensorShape([None]),\n },\n padding_values={\n 'waveforms': tf.constant(0, dtype=tf.float32),\n 'waveforms_length': tf.constant(0, dtype=tf.int32),\n 'targets': tf.constant(0, dtype=tf.int32),\n 'targets_length': tf.constant(0, dtype=tf.int32),\n },\n )\n return dataset\n\n return get\n\n\nclass Encoder:\n def __init__(self, config):\n self.config = config\n self.encoder = ConformerModel(**self.config)\n\n def __call__(self, x, input_mask, training=True):\n return self.encoder(x, training=training)\n\n\ntotal_steps = 2000000\n\n\ndef model_fn(features, labels, mode, params):\n config_conformer = malaya_speech.config.conformer_tiny_encoder_config\n config_conformer['subsampling']['type'] = 'none'\n config_conformer['dropout'] = 0.0\n encoder = Encoder(config_conformer)\n cfg = hubert.HuBERTConfig(\n extractor_mode='layer_norm',\n dropout=0.0,\n attention_dropout=0.0,\n encoder_layerdrop=0.0,\n dropout_input=0.0,\n dropout_features=0.0,\n final_dim=128,\n )\n model = hubert.Model(cfg, encoder, ['pad', 'eos', 'unk'] + [str(i) for i in range(100)])\n X = features['waveforms']\n X_len = features['waveforms_length'][:, 0]\n targets = features['targets']\n targets_int32 = tf.cast(targets, tf.int32)\n targets_length = features['targets_length'][:, 0]\n r = model(X, padding_mask=X_len, features_only=True, mask=False)\n logits = tf.layers.dense(r['x'], len(unique_vocab) + 1)\n seq_lens = tf.reduce_sum(\n tf.cast(tf.logical_not(r['padding_mask']), tf.int32), axis=1\n )\n mean_error, sum_error, sum_weight = ctc.loss.ctc_loss(\n logits, seq_lens, targets_int32, targets_length\n )\n loss = mean_error\n accuracy = ctc.metrics.ctc_sequence_accuracy(\n logits, seq_lens, targets_int32, targets_length,\n )\n\n tf.identity(loss, 'train_loss')\n tf.identity(accuracy, name='train_accuracy')\n\n tf.summary.scalar('train_accuracy', accuracy)\n\n variables = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES)\n init_checkpoint = 'hubert-conformer-tiny/model.ckpt-1000000'\n\n assignment_map, initialized_variable_names = train.get_assignment_map_from_checkpoint(\n variables, init_checkpoint\n )\n\n tf.train.init_from_checkpoint(init_checkpoint, assignment_map)\n\n if mode == tf.estimator.ModeKeys.TRAIN:\n train_op = train.optimizer.adamw.create_optimizer(\n loss,\n init_lr=5e-5,\n num_train_steps=total_steps,\n num_warmup_steps=100000,\n end_learning_rate=0.0,\n weight_decay_rate=0.01,\n beta_1=0.9,\n beta_2=0.999,\n epsilon=1e-6,\n clip_norm=1.0,\n )\n estimator_spec = tf.estimator.EstimatorSpec(\n mode=mode, loss=loss, train_op=train_op\n )\n\n elif mode == tf.estimator.ModeKeys.EVAL:\n\n estimator_spec = tf.estimator.EstimatorSpec(\n mode=tf.estimator.ModeKeys.EVAL,\n loss=loss,\n eval_metric_ops={\n 'accuracy': ctc.metrics.ctc_sequence_accuracy_estimator(\n logits, seq_lens, targets_int32, targets_length\n )\n },\n )\n\n return estimator_spec\n\n\ntrain_hooks = [\n tf.train.LoggingTensorHook(\n ['train_accuracy', 'train_loss'], every_n_iter=1\n )\n]\ntrain_dataset = get_dataset('bahasa-asr-train-combined.json')\ndev_dataset = get_dataset('bahasa-asr-test.json')\n\ntrain.run_training(\n train_fn=train_dataset,\n model_fn=model_fn,\n model_dir='hubert-conformer-tiny-ctc-char',\n num_gpus=1,\n log_step=1,\n save_checkpoint_step=20000,\n max_steps=total_steps,\n eval_fn=dev_dataset,\n train_hooks=train_hooks,\n)\n",
"import os\n\nos.environ['GOOGLE_APPLICATION_CREDENTIALS'] = '../gcs/mesolitica-storage.json'\nos.environ['CUDA_VISIBLE_DEVICES'] = '1'\n\nimport tensorflow as tf\nimport malaya_speech.train as train\nimport malaya_speech.train.model.vggvox_v2 as vggvox_v2\nimport malaya_speech\nfrom glob import glob\nimport librosa\nimport numpy as np\n\n\ndef lin_spectogram_from_wav(wav, hop_length, win_length, n_fft=1024):\n linear = librosa.stft(\n wav, n_fft=n_fft, win_length=win_length, hop_length=hop_length\n ) # linear spectrogram\n return linear.T\n\n\ndef load_data(\n wav,\n win_length=400,\n sr=16000,\n hop_length=50,\n n_fft=512,\n spec_len=250,\n mode='train',\n):\n linear_spect = lin_spectogram_from_wav(wav, hop_length, win_length, n_fft)\n mag, _ = librosa.magphase(linear_spect) # magnitude\n mag_T = mag.T\n freq, time = mag_T.shape\n if mode == 'train':\n if time > spec_len:\n randtime = np.random.randint(0, time - spec_len)\n spec_mag = mag_T[:, randtime: randtime + spec_len]\n else:\n spec_mag = np.pad(mag_T, ((0, 0), (0, spec_len - time)), 'constant')\n else:\n spec_mag = mag_T\n # preprocessing, subtract mean, divided by time-wise var\n mu = np.mean(spec_mag, 0, keepdims=True)\n std = np.std(spec_mag, 0, keepdims=True)\n return (spec_mag - mu) / (std + 1e-5)\n\n\nDIMENSION = 257\n\n\ndef calc(v):\n\n r = load_data(v, mode='eval')\n return r\n\n\ndef preprocess_inputs(example):\n s = tf.compat.v1.numpy_function(calc, [example['inputs']], tf.float32)\n\n s = tf.reshape(s, (DIMENSION, -1, 1))\n example['inputs'] = s\n\n return example\n\n\ndef parse(serialized_example):\n\n data_fields = {\n 'inputs': tf.VarLenFeature(tf.float32),\n 'targets': tf.VarLenFeature(tf.int64),\n }\n features = tf.parse_single_example(\n serialized_example, features=data_fields\n )\n for k in features.keys():\n features[k] = features[k].values\n\n features = preprocess_inputs(features)\n\n keys = list(features.keys())\n for k in keys:\n if k not in ['inputs', 'targets']:\n features.pop(k, None)\n\n return features\n\n\ndef get_dataset(files, batch_size=32, shuffle_size=1024, thread_count=24):\n def get():\n dataset = tf.data.TFRecordDataset(files)\n dataset = dataset.map(parse, num_parallel_calls=thread_count)\n dataset = dataset.shuffle(shuffle_size)\n dataset = dataset.padded_batch(\n batch_size,\n padded_shapes={\n 'inputs': tf.TensorShape([DIMENSION, None, 1]),\n 'targets': tf.TensorShape([None]),\n },\n padding_values={\n 'inputs': tf.constant(0, dtype=tf.float32),\n 'targets': tf.constant(0, dtype=tf.int64),\n },\n )\n dataset = dataset.repeat()\n return dataset\n\n return get\n\n\nlearning_rate = 1e-5\ninit_checkpoint = '../vggvox-speaker-identification/v2/vggvox.ckpt'\n\n\ndef model_fn(features, labels, mode, params):\n Y = tf.cast(features['targets'][:, 0], tf.int32)\n model = vggvox_v2.Model(features['inputs'], num_class=2, mode='train')\n\n logits = model.logits\n loss = tf.reduce_mean(\n tf.nn.sparse_softmax_cross_entropy_with_logits(\n logits=logits, labels=Y\n )\n )\n\n tf.identity(loss, 'train_loss')\n\n accuracy = tf.metrics.accuracy(\n labels=Y, predictions=tf.argmax(logits, axis=1)\n )\n\n tf.identity(accuracy[1], name='train_accuracy')\n tf.summary.scalar('train_accuracy', accuracy[1])\n\n variables = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES)\n variables = [v for v in variables if 'prediction' not in v.name]\n\n assignment_map, initialized_variable_names = train.get_assignment_map_from_checkpoint(\n variables, init_checkpoint\n )\n\n tf.train.init_from_checkpoint(init_checkpoint, assignment_map)\n\n if mode == tf.estimator.ModeKeys.TRAIN:\n global_step = tf.train.get_or_create_global_step()\n optimizer = tf.train.AdamOptimizer(learning_rate)\n train_op = optimizer.minimize(loss, global_step=global_step)\n estimator_spec = tf.estimator.EstimatorSpec(\n mode=mode, loss=loss, train_op=train_op\n )\n\n elif mode == tf.estimator.ModeKeys.EVAL:\n\n estimator_spec = tf.estimator.EstimatorSpec(\n mode=tf.estimator.ModeKeys.EVAL,\n loss=loss,\n eval_metric_ops={'accuracy': accuracy},\n )\n\n return estimator_spec\n\n\ntrain_hooks = [\n tf.train.LoggingTensorHook(\n ['train_accuracy', 'train_loss'], every_n_iter=1\n )\n]\n\nfiles = tf.io.gfile.glob(\n 'gs://mesolitica-general/speaker-change/data/*.tfrecords'\n)\ntrain_dataset = get_dataset(files)\n\nsave_directory = 'output-vggvox-v2-speaker-change'\n\ntrain.run_training(\n train_fn=train_dataset,\n model_fn=model_fn,\n model_dir=save_directory,\n num_gpus=1,\n log_step=1,\n save_checkpoint_step=25000,\n max_steps=300000,\n train_hooks=train_hooks,\n)\n",
"import os\n\nos.environ['CUDA_VISIBLE_DEVICES'] = '2,3'\n\nimport tensorflow as tf\nimport malaya_speech\nimport malaya_speech.augmentation.waveform as augmentation\nimport malaya_speech.augmentation.spectrogram as mask_augmentation\nimport malaya_speech.train.model.medium_jasper as jasper\nimport malaya_speech.train.model.ctc as ctc\nimport malaya_speech.train as train\nfrom malaya_speech.train.model.quartznet import layer, abstract\nimport numpy as np\nimport random\nfrom glob import glob\nimport json\n\nwith open('malaya-speech-sst-vocab.json') as fopen:\n unique_vocab = json.load(fopen) + ['{', '}', '[']\n\nparameters = {\n 'optimizer_params': {},\n 'lr_policy_params': {\n 'learning_rate': 1e-4,\n 'min_lr': 1e-6,\n 'warmup_steps': 0,\n 'decay_steps': 500_000,\n },\n}\n\n\ndef learning_rate_scheduler(global_step):\n return train.schedule.cosine_decay(\n global_step, **parameters['lr_policy_params']\n )\n\n\nfeaturizer = malaya_speech.tf_featurization.STTFeaturizer(\n normalize_per_feature=True\n)\nn_mels = featurizer.num_feature_bins\n\n\ndef mel_augmentation(features):\n\n features = mask_augmentation.mask_frequency(features, width_freq_mask=15)\n features = mask_augmentation.mask_time(\n features, width_time_mask=int(features.shape[0] * 0.05)\n )\n return features\n\n\ndef preprocess_inputs(example):\n s = featurizer.vectorize(example['waveforms'])\n s = tf.reshape(s, (-1, n_mels))\n s = tf.compat.v1.numpy_function(mel_augmentation, [s], tf.float32)\n mel_fbanks = tf.reshape(s, (-1, n_mels))\n length = tf.cast(tf.shape(mel_fbanks)[0], tf.int32)\n length = tf.expand_dims(length, 0)\n example['inputs'] = mel_fbanks\n example['inputs_length'] = length\n\n return example\n\n\ndef parse(serialized_example):\n\n data_fields = {\n 'waveforms': tf.VarLenFeature(tf.float32),\n 'targets': tf.VarLenFeature(tf.int64),\n }\n features = tf.parse_single_example(\n serialized_example, features=data_fields\n )\n for k in features.keys():\n features[k] = features[k].values\n\n features = preprocess_inputs(features)\n\n keys = list(features.keys())\n for k in keys:\n if k not in ['waveforms', 'inputs', 'inputs_length', 'targets']:\n features.pop(k, None)\n\n return features\n\n\ndef get_dataset(\n path,\n batch_size=32,\n shuffle_size=32,\n thread_count=24,\n maxlen_feature=1800,\n):\n def get():\n files = glob(path)\n dataset = tf.data.TFRecordDataset(files)\n dataset = dataset.shuffle(shuffle_size)\n dataset = dataset.repeat()\n dataset = dataset.prefetch(tf.contrib.data.AUTOTUNE)\n dataset = dataset.map(parse, num_parallel_calls=thread_count)\n dataset = dataset.padded_batch(\n batch_size,\n padded_shapes={\n 'waveforms': tf.TensorShape([None]),\n 'inputs': tf.TensorShape([None, n_mels]),\n 'inputs_length': tf.TensorShape([None]),\n 'targets': tf.TensorShape([None]),\n },\n padding_values={\n 'waveforms': tf.constant(0, dtype=tf.float32),\n 'inputs': tf.constant(0, dtype=tf.float32),\n 'inputs_length': tf.constant(0, dtype=tf.int32),\n 'targets': tf.constant(0, dtype=tf.int64),\n },\n )\n return dataset\n\n return get\n\n\ndef model_fn(features, labels, mode, params):\n\n model = jasper.Model(\n features['inputs'], features['inputs_length'][:, 0], training=True\n )\n logits = tf.layers.dense(model.logits['outputs'], len(unique_vocab) + 1)\n seq_lens = model.logits['src_length']\n\n targets_int32 = tf.cast(features['targets'], tf.int32)\n\n mean_error, sum_error, sum_weight = ctc.loss.ctc_loss(\n logits, targets_int32, seq_lens\n )\n\n loss = mean_error\n accuracy = ctc.metrics.ctc_sequence_accuracy(\n logits, targets_int32, seq_lens\n )\n\n tf.identity(loss, 'train_loss')\n tf.identity(accuracy, name='train_accuracy')\n\n tf.summary.scalar('train_accuracy', accuracy)\n\n if mode == tf.estimator.ModeKeys.TRAIN:\n train_op = train.optimizer.optimize_loss(\n loss,\n tf.train.AdamOptimizer,\n parameters['optimizer_params'],\n learning_rate_scheduler,\n summaries=['learning_rate', 'loss_scale'],\n larc_params=parameters.get('larc_params', None),\n loss_scaling=parameters.get('loss_scaling', 1.0),\n loss_scaling_params=parameters.get('loss_scaling_params', None),\n )\n estimator_spec = tf.estimator.EstimatorSpec(\n mode=mode, loss=loss, train_op=train_op\n )\n\n elif mode == tf.estimator.ModeKeys.EVAL:\n\n estimator_spec = tf.estimator.EstimatorSpec(\n mode=tf.estimator.ModeKeys.EVAL,\n loss=loss,\n eval_metric_ops={\n 'accuracy': ctc.metrics.ctc_sequence_accuracy_estimator(\n logits, targets_int32, seq_lens\n )\n },\n )\n\n return estimator_spec\n\n\ntrain_hooks = [\n tf.train.LoggingTensorHook(\n ['train_accuracy', 'train_loss'], every_n_iter=1\n )\n]\ntrain_dataset = get_dataset(\n '../speech-bahasa/bahasa-asr/data/bahasa-asr-train-*'\n)\ndev_dataset = get_dataset(\n '../speech-bahasa/bahasa-asr-test/data/bahasa-asr-dev-*'\n)\n\ntrain.run_training(\n train_fn=train_dataset,\n model_fn=model_fn,\n model_dir='asr-medium-jasper-ctc',\n num_gpus=2,\n log_step=1,\n save_checkpoint_step=5000,\n max_steps=parameters['lr_policy_params']['decay_steps'],\n eval_fn=dev_dataset,\n train_hooks=train_hooks,\n)\n",
"import tensorflow as tf\nfrom ..fastspeech.model import TFFastSpeechEncoder\nimport numpy as np\n\n\nclass Encoder(tf.keras.layers.Layer):\n def __init__(self, config, **kwargs):\n super(Encoder, self).__init__(name='Encoder', **kwargs)\n self.config = config\n self.encoder = TFFastSpeechEncoder(config, name='encoder')\n self.position_embeddings = tf.convert_to_tensor(\n self._sincos_embedding()\n )\n\n def call(self, x, attention_mask, training=True):\n input_shape = tf.shape(x)\n seq_length = input_shape[1]\n\n position_ids = tf.range(1, seq_length + 1, dtype=tf.int32)[\n tf.newaxis, :\n ]\n inputs = tf.cast(position_ids, tf.int32)\n position_embeddings = tf.gather(self.position_embeddings, inputs)\n x = x + tf.cast(position_embeddings, x.dtype)\n f = self.encoder([x, attention_mask], training=training)[0]\n return f\n\n def _sincos_embedding(self):\n position_enc = np.array(\n [\n [\n pos\n / np.power(10000, 2.0 * (i // 2) / self.config.hidden_size)\n for i in range(self.config.hidden_size)\n ]\n for pos in range(self.config.max_position_embeddings + 1)\n ]\n )\n\n position_enc[:, 0::2] = np.sin(position_enc[:, 0::2])\n position_enc[:, 1::2] = np.cos(position_enc[:, 1::2])\n\n # pad embedding.\n position_enc[0] = 0.0\n\n return position_enc\n\n\nclass Model(tf.keras.Model):\n def __init__(\n self, config, O, C, kernel_size=5, masking=False, **kwargs\n ):\n super(Model, self).__init__(name='fastvc', **kwargs)\n self.encoder = Encoder(config.encoder_self_attention_params)\n self.decoder = Encoder(config.decoder_self_attention_params)\n self.encoder_dense = tf.keras.layers.Conv1D(\n config.encoder_self_attention_params.hidden_size,\n kernel_size=kernel_size,\n strides=1,\n use_bias=False,\n padding='SAME',\n )\n self.mel_dense = tf.keras.layers.Dense(\n units=config.num_mels, dtype=tf.float32, name='mel_before'\n )\n self.dim = O\n self.C = C\n self.masking = masking\n\n def call(self, x, mel_lengths, training=True, **kwargs):\n original = x\n T_mix = tf.shape(x)[1]\n batch_size = tf.shape(x)[0]\n max_length = tf.cast(tf.reduce_max(mel_lengths), tf.int32)\n attention_mask = tf.sequence_mask(\n lengths=mel_lengths, maxlen=max_length, dtype=tf.float32\n )\n attention_mask.set_shape((None, None))\n x = tf.concat([x] * self.C, axis=2)\n x = self.encoder_dense(x)\n encoded = self.encoder(x, attention_mask, training=training)\n decoder_output = self.decoder(\n encoded, attention_mask, training=training\n )\n decoder_output = tf.reshape(\n decoder_output, (batch_size, T_mix, self.C, self.dim)\n )\n mel_before = self.mel_dense(decoder_output)\n if self.masking:\n mel_before = tf.nn.tanh(mel_before)\n tiled = tf.tile(tf.expand_dims(original, 2), [1, 1, self.C, 1])\n return tiled * mel_before\n else:\n return mel_before\n",
"import tensorflow as tf\nimport numpy as np\nfrom itertools import permutations\nfrom tensorflow.python.ops import weights_broadcast_ops\n\nEPS = 1e-8\n\n\ndef cal_abs_with_pit(\n source, estimate_source, source_lengths, C, method=tf.abs\n):\n # estimate_source = B, T, S, D\n # source = B, S, T, D\n\n # estimate_source = B, S, T, D\n estimate_source = tf.transpose(estimate_source, perm=[0, 2, 1, 3])\n\n mask = tf.cast(\n tf.sequence_mask(source_lengths, tf.reduce_max(source_lengths)),\n source.dtype,\n )\n mask = tf.expand_dims(mask, 1)\n mask = tf.expand_dims(mask, -1)\n # estimate_source *= mask\n\n targets = tf.expand_dims(source, 1)\n est_targets = tf.expand_dims(estimate_source, 2)\n pw_loss = method(targets - est_targets)\n # pair_wise_abs = tf.reduce_mean(pw_loss, axis = [3, 4])\n\n losses = pw_loss\n m = tf.expand_dims(mask, 1)\n weights = tf.cast(m, dtype=tf.float32)\n weighted_losses = tf.multiply(losses, weights)\n total_loss = tf.reduce_sum(weighted_losses, axis=[3, 4])\n present = tf.where(\n tf.equal(weights, 0.0), tf.zeros_like(weights), tf.ones_like(weights)\n )\n present = weights_broadcast_ops.broadcast_weights(present, losses)\n present = tf.reduce_sum(present, axis=[3, 4])\n pair_wise_abs = tf.div_no_nan(total_loss, present)\n\n v_perms = tf.constant(list(permutations(range(C))))\n perms_one_hot = tf.one_hot(v_perms, C)\n\n abs_set = tf.einsum('bij,pij->bp', pair_wise_abs, perms_one_hot)\n min_abs = tf.reduce_min(abs_set, axis=1, keepdims=True)\n\n return min_abs, abs_set\n\n\ndef calculate_loss(\n source,\n estimate_source,\n source_lengths,\n C,\n method=tf.abs,\n return_set=False,\n):\n min_abs, abs_set = cal_abs_with_pit(\n source, estimate_source, source_lengths, C, method=method\n )\n if return_set:\n return tf.reduce_mean(min_abs), abs_set\n else:\n return tf.reduce_mean(min_abs)\n",
"import tensorflow as tf\nfrom .layer import *\n\n\nclass Discriminator:\n def __init__(self, inputs, targets, ndf=64):\n n_layers = 3\n layers = []\n input = tf.concat([inputs, targets], axis=3)\n with tf.variable_scope('layer_1'):\n convolved = discrim_conv(input, ndf, stride=2)\n rectified = lrelu(convolved, 0.2)\n layers.append(rectified)\n\n for i in range(n_layers):\n with tf.variable_scope('layer_%d' % (len(layers) + 1)):\n out_channels = ndf * min(2 ** (i + 1), 8)\n stride = 1 if i == n_layers - 1 else 2\n convolved = discrim_conv(\n layers[-1], out_channels, stride=stride\n )\n normalized = batchnorm(convolved)\n rectified = lrelu(normalized, 0.2)\n layers.append(rectified)\n with tf.variable_scope('layer_%d' % (len(layers) + 1)):\n convolved = discrim_conv(rectified, out_channels=1, stride=1)\n output = tf.sigmoid(convolved)\n layers.append(output)\n\n self.logits = layers[-1]\n",
"import os\n\nos.environ['CUDA_VISIBLE_DEVICES'] = '1'\n\nimport tensorflow as tf\nimport numpy as np\nfrom glob import glob\nfrom itertools import cycle\nimport malaya_speech\nimport malaya_speech.train\nfrom malaya_speech.train.model import universal_melgan as melgan\nfrom malaya_speech.train.model import melgan as melgan_loss\nimport malaya_speech.config\nfrom malaya_speech.train.loss import calculate_2d_loss, calculate_3d_loss\nimport random\n\nmels = glob('output-universal/mels/*.npy')\nmels.extend(glob('speech-augmentation/mels/*.npy'))\nrandom.shuffle(mels)\nfile_cycle = cycle(mels)\n\n\ndef generate(batch_max_steps=8192, hop_size=256):\n while True:\n f = next(file_cycle)\n mel = np.load(f)\n audio = np.load(f.replace('mels', 'audios'))\n\n batch_max_frames = batch_max_steps // hop_size\n if len(audio) < len(mel) * hop_size:\n audio = np.pad(audio, [[0, len(mel) * hop_size - len(audio)]])\n\n if len(mel) > batch_max_frames:\n interval_start = 0\n interval_end = len(mel) - batch_max_frames\n start_frame = random.randint(interval_start, interval_end)\n start_step = start_frame * hop_size\n audio = audio[start_step: start_step + batch_max_steps]\n mel = mel[start_frame: start_frame + batch_max_frames, :]\n else:\n audio = np.pad(audio, [[0, batch_max_steps - len(audio)]])\n mel = np.pad(mel, [[0, batch_max_frames - len(mel)], [0, 0]])\n\n yield {'mel': mel, 'audio': audio}\n\n\ndataset = tf.data.Dataset.from_generator(\n generate,\n {'mel': tf.float32, 'audio': tf.float32},\n output_shapes={\n 'mel': tf.TensorShape([None, 80]),\n 'audio': tf.TensorShape([None]),\n },\n)\ndataset = dataset.shuffle(32)\ndataset = dataset.padded_batch(\n 32,\n padded_shapes={\n 'audio': tf.TensorShape([None]),\n 'mel': tf.TensorShape([None, 80]),\n },\n padding_values={\n 'audio': tf.constant(0, dtype=tf.float32),\n 'mel': tf.constant(0, dtype=tf.float32),\n },\n)\n\nfeatures = dataset.make_one_shot_iterator().get_next()\n\nmelgan_config = malaya_speech.config.universal_melgan_config\nmelgan_config['melgan_generator_params']['filters'] = 1024\ngenerator = melgan.Generator(\n melgan.GeneratorConfig(**melgan_config['melgan_generator_params']),\n name='universalmelgan-generator',\n)\ndiscriminator = melgan.MultiScaleDiscriminator(\n melgan.WaveFormDiscriminatorConfig(\n **melgan_config['melgan_waveform_discriminator_params']\n ),\n melgan.STFTDiscriminatorConfig(\n **melgan_config['melgan_stft_discriminator_params']\n ),\n name='universalmelgan-discriminator',\n)\n\nmels_loss = melgan_loss.loss.TFMelSpectrogram()\n\nmse_loss = tf.keras.losses.MeanSquaredError()\nmae_loss = tf.keras.losses.MeanAbsoluteError()\n\n\ndef compute_per_example_generator_losses(audios, outputs):\n y_hat = outputs\n p_hat = discriminator(y_hat)\n p = discriminator(tf.expand_dims(audios, 2))\n\n adv_loss = 0.0\n for i in range(len(p_hat)):\n adv_loss += mse_loss(tf.ones_like(p_hat[i][-1]), p_hat[i][-1])\n adv_loss /= i + 1\n\n fm_loss = 0.0\n for i in range(len(p_hat)):\n for j in range(len(p_hat[i]) - 1):\n fm_loss += mae_loss(p[i][j], p_hat[i][j])\n fm_loss /= (i + 1) * (j + 1)\n adv_loss += 10 * fm_loss\n\n per_example_losses = adv_loss\n\n a = calculate_2d_loss(audios, tf.squeeze(y_hat, -1), loss_fn=mels_loss)\n\n dict_metrics_losses = {\n 'adversarial_loss': adv_loss,\n 'fm_loss': fm_loss,\n 'gen_loss': adv_loss,\n 'mels_spectrogram_loss': tf.reduce_mean(a),\n }\n\n return per_example_losses, dict_metrics_losses\n\n\ndef compute_per_example_discriminator_losses(audios, gen_outputs):\n y_hat = gen_outputs\n y = tf.expand_dims(audios, 2)\n p = discriminator(y)\n p_hat = discriminator(y_hat)\n\n real_loss = 0.0\n fake_loss = 0.0\n for i in range(len(p)):\n real_loss += mse_loss(tf.ones_like(p[i][-1]), p[i][-1])\n fake_loss += mse_loss(tf.zeros_like(p_hat[i][-1]), p_hat[i][-1])\n\n real_loss /= i + 1\n fake_loss /= i + 1\n dis_loss = real_loss + fake_loss\n\n per_example_losses = dis_loss\n\n dict_metrics_losses = {\n 'real_loss': real_loss,\n 'fake_loss': fake_loss,\n 'dis_loss': dis_loss,\n }\n\n return per_example_losses, dict_metrics_losses\n\n\ny_hat = generator(features['mel'], training=True)\naudios = features['audio']\nper_example_losses, generator_losses = compute_per_example_generator_losses(\n audios, y_hat\n)\ngenerator_loss = tf.reduce_mean(per_example_losses)\n\ny_hat = generator(features['mel'], training=True)\naudios = features['audio']\nper_example_losses, discriminator_losses = compute_per_example_discriminator_losses(\n audios, y_hat\n)\ndiscriminator_loss = tf.reduce_mean(per_example_losses)\n\nfor k, v in generator_losses.items():\n tf.summary.scalar(k, v)\n\nfor k, v in discriminator_losses.items():\n tf.summary.scalar(k, v)\n\nsummaries = tf.summary.merge_all()\n\nt_vars = tf.trainable_variables()\nd_vars = [\n var\n for var in t_vars\n if var.name.startswith('universalmelgan-discriminator')\n]\ng_vars = [\n var for var in t_vars if var.name.startswith('universalmelgan-generator')\n]\n\nd_optimizer = tf.train.AdamOptimizer(0.0001, beta1=0.5, beta2=0.9).minimize(\n discriminator_loss, var_list=d_vars\n)\ng_optimizer = tf.train.AdamOptimizer(0.0001, beta1=0.5, beta2=0.9).minimize(\n generator_loss, var_list=g_vars\n)\n\nsess = tf.InteractiveSession()\nsess.run(tf.global_variables_initializer())\nsaver = tf.train.Saver()\n\ncheckpoint = 5000\nwrite_tensorboard = 100\nepoch = 1_000_000\npath = 'universal-melgan-1024'\n\nwriter = tf.summary.FileWriter(f'./{path}')\n\nckpt_path = tf.train.latest_checkpoint(path)\nif ckpt_path:\n saver.restore(sess, ckpt_path)\n\nfor i in range(epoch):\n g_loss, _ = sess.run([generator_loss, g_optimizer])\n d_loss, _ = sess.run([discriminator_loss, d_optimizer])\n s = sess.run(summaries)\n writer.add_summary(s, i)\n\n if i % checkpoint == 0:\n saver.save(sess, f'{path}/model.ckpt', global_step=i)\n\n if i % write_tensorboard == 0:\n writer.add_summary(s, i)\n\n print(i, g_loss, d_loss)\n"
] | [
[
"numpy.random.normal",
"numpy.array",
"tensorflow.estimator.EstimatorSpec",
"tensorflow.train.LoggingTensorHook",
"tensorflow.summary.scalar",
"tensorflow.TensorShape",
"tensorflow.logical_not",
"tensorflow.get_collection",
"tensorflow.constant",
"numpy.random.uniform",
"numpy.amax",
"numpy.abs",
"numpy.clip",
"tensorflow.train.init_from_checkpoint",
"tensorflow.identity",
"tensorflow.cast",
"sklearn.utils.shuffle"
],
[
"tensorflow.data.TFRecordDataset",
"numpy.mean",
"tensorflow.reshape",
"tensorflow.identity",
"tensorflow.parse_single_example",
"tensorflow.cast",
"tensorflow.argmax",
"tensorflow.TensorShape",
"tensorflow.constant",
"numpy.random.randint",
"tensorflow.compat.v1.numpy_function",
"tensorflow.get_collection",
"numpy.pad",
"tensorflow.estimator.EstimatorSpec",
"tensorflow.train.AdamOptimizer",
"tensorflow.train.LoggingTensorHook",
"tensorflow.summary.scalar",
"numpy.std",
"tensorflow.train.init_from_checkpoint",
"tensorflow.nn.sparse_softmax_cross_entropy_with_logits",
"tensorflow.io.gfile.glob",
"tensorflow.VarLenFeature",
"tensorflow.train.get_or_create_global_step"
],
[
"tensorflow.estimator.EstimatorSpec",
"tensorflow.data.TFRecordDataset",
"tensorflow.shape",
"tensorflow.train.LoggingTensorHook",
"tensorflow.expand_dims",
"tensorflow.summary.scalar",
"tensorflow.TensorShape",
"tensorflow.reshape",
"tensorflow.VarLenFeature",
"tensorflow.constant",
"tensorflow.compat.v1.numpy_function",
"tensorflow.identity",
"tensorflow.parse_single_example",
"tensorflow.cast"
],
[
"tensorflow.keras.layers.Conv1D",
"numpy.sin",
"tensorflow.shape",
"tensorflow.sequence_mask",
"tensorflow.concat",
"tensorflow.range",
"tensorflow.expand_dims",
"tensorflow.reshape",
"tensorflow.keras.layers.Dense",
"tensorflow.reduce_max",
"numpy.power",
"numpy.cos",
"tensorflow.gather",
"tensorflow.nn.tanh",
"tensorflow.cast"
],
[
"tensorflow.multiply",
"tensorflow.einsum",
"tensorflow.reduce_min",
"tensorflow.expand_dims",
"tensorflow.div_no_nan",
"tensorflow.equal",
"tensorflow.ones_like",
"tensorflow.transpose",
"tensorflow.zeros_like",
"tensorflow.python.ops.weights_broadcast_ops.broadcast_weights",
"tensorflow.reduce_max",
"tensorflow.reduce_sum",
"tensorflow.one_hot",
"tensorflow.reduce_mean",
"tensorflow.cast"
],
[
"tensorflow.variable_scope",
"tensorflow.concat",
"tensorflow.sigmoid"
],
[
"tensorflow.ones_like",
"numpy.load",
"tensorflow.zeros_like",
"tensorflow.global_variables_initializer",
"tensorflow.InteractiveSession",
"tensorflow.trainable_variables",
"tensorflow.train.latest_checkpoint",
"tensorflow.TensorShape",
"tensorflow.keras.losses.MeanAbsoluteError",
"tensorflow.train.Saver",
"tensorflow.constant",
"tensorflow.squeeze",
"tensorflow.train.AdamOptimizer",
"tensorflow.expand_dims",
"tensorflow.summary.scalar",
"tensorflow.keras.losses.MeanSquaredError",
"tensorflow.summary.merge_all",
"tensorflow.summary.FileWriter",
"tensorflow.reduce_mean"
]
] |
fab464654/SSD_on_ActiveVisionDataset | [
"1bc6f0745241d0b45c3f257c6fb09ea0435c993e"
] | [
"train.py"
] | [
"import time\nimport torch.backends.cudnn as cudnn\nimport torch.optim\nimport torch.utils.data\nfrom model import SSD300, MultiBoxLoss\nfrom datasets import PascalVOCDataset\nfrom utils import *\n\n# Data parameters\ndata_folder = 'google_drive/MyDrive/ColabNotebooks/Project/GT' # folder with data files\nkeep_difficult = True # use objects considered difficult to detect?\n\n# Model parameters\n# Not too many here since the SSD300 has a very specific structure\nn_classes = len(label_map) # number of different types of objects\ndevice = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n\n# Learning parameters\ncheckpoint = \"google_drive/MyDrive/checkpointsIeri/checkpoint_ssd300.pth.tar\" # path to model checkpoint, None if none\nbatch_size = 9 # batch size\niterations = 120000 # number of iterations to train\nworkers = 4 # number of workers for loading data in the DataLoader\nprint_freq = 5 # print training status every __ batches\nlr = 5e-4 # learning rate\ndecay_lr_at = [80000, 100000] # decay learning rate after these many iterations\ndecay_lr_to = 0.1 # decay learning rate to this fraction of the existing learning rate\nmomentum = 0.9 # momentum\nweight_decay = 5e-4 # weight decay\ngrad_clip = None # clip if gradients are exploding, which may happen at larger batch sizes (sometimes at 32) - you will recognize it by a sorting error in the MuliBox loss calculation\n\ncudnn.benchmark = True\n\n\ndef main():\n \"\"\"\n Training.\n \"\"\"\n global start_epoch, label_map, epoch, checkpoint, decay_lr_at\n\n # Initialize model or load checkpoint\n if checkpoint is None:\n start_epoch = 0\n model = SSD300(n_classes=n_classes)\n # Initialize the optimizer, with twice the default learning rate for biases, as in the original Caffe repo\n biases = list()\n not_biases = list()\n for param_name, param in model.named_parameters():\n if param.requires_grad:\n if param_name.endswith('.bias'):\n biases.append(param)\n else:\n not_biases.append(param)\n optimizer = torch.optim.SGD(params=[{'params': biases, 'lr': 2 * lr}, {'params': not_biases}],\n lr=lr, momentum=momentum, weight_decay=weight_decay)\n\n else:\n checkpoint = torch.load(checkpoint)\n start_epoch = checkpoint['epoch'] + 1\n print('\\nLoaded checkpoint from epoch %d.\\n' % start_epoch)\n model = checkpoint['model']\n optimizer = checkpoint['optimizer']\n\n # Move to default device\n model = model.to(device)\n criterion = MultiBoxLoss(priors_cxcy=model.priors_cxcy).to(device)\n\n #import active_vision_dataset_processing.data_loading\n import transforms, active_vision_dataset\n\n #Include all instances\n pick_trans = transforms.PickInstances(range(34))\n\n TRAIN_PATH = \"./google_drive/MyDrive/ColabNotebooks/Project/trainDataset\"\n\n \n train_dataset = active_vision_dataset.AVD(root=TRAIN_PATH, train=True,\n target_transform=pick_trans,\n scene_list=['Home_001_1', \n 'Home_002_1',\n 'Home_003_1', \n 'Home_004_1',\n 'Home_005_1',\n 'Home_006_1',\n 'Home_007_1',\n 'Home_008_1',\n 'Home_014_1',\n 'Home_011_1',\n 'Home_010_1',\n 'Office_001_1'],\n fraction_of_no_box=-1)\n \n\n train_loader = torch.utils.data.DataLoader(train_dataset,\n batch_size=batch_size,\n shuffle=True,\n collate_fn=active_vision_dataset.collate\n )\n \"\"\"\n #I TRY TO USE THE DEFAULT DATASET LOADER::::::::::::::\n\n # Custom dataloaders\n train_dataset = PascalVOCDataset(data_folder,\n split='train',\n keep_difficult=keep_difficult)\n train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True,\n collate_fn=train_dataset.collate_fn, num_workers=workers,\n pin_memory=True) # note that we're passing the collate function here\n \"\"\"\n\n # Calculate total number of epochs to train and the epochs to decay learning rate at (i.e. convert iterations to epochs)\n # To convert iterations to epochs, divide iterations by the number of iterations per epoch\n # The paper trains for 120,000 iterations with a batch size of 32, decays after 80,000 and 100,000 iterations\n epochs = iterations // (len(train_dataset) // 32)\n decay_lr_at = [it // (len(train_dataset) // 32) for it in decay_lr_at]\n\n # Epochs\n for epoch in range(start_epoch, epochs):\n \n # Decay learning rate at particular epochs\n if epoch in decay_lr_at:\n adjust_learning_rate(optimizer, decay_lr_to)\n\n # One epoch's training\n train(train_loader=train_loader,\n model=model,\n criterion=criterion,\n optimizer=optimizer,\n epoch=epoch)\n\n # Save checkpoint\n save_checkpoint(epoch, model, optimizer)\n \n\n\ndef train(train_loader, model, criterion, optimizer, epoch):\n \n \n \"\"\"\n One epoch's training.\n\n :param train_loader: DataLoader for training data\n :param model: model\n :param criterion: MultiBox loss\n :param optimizer: optimizer\n :param epoch: epoch number\n \"\"\"\n model.train() # training mode enables dropout\n\n batch_time = AverageMeter() # forward prop. + back prop. time\n data_time = AverageMeter() # data loading time\n losses = AverageMeter() # loss\n\n start = time.time()\n\n import numpy as np\n # Batches\n for i, (images, labels) in enumerate(train_loader):\n\n #CHECK / REMOVE THIS CODE!\n data_time.update(time.time() - start)\n #print(len(images))\n #print(labels)\n # Move to default device\n data = images\n a = np.asarray(data)\n #print(a.shape)\n #a = np.squeeze(a, axis=1) # shape should now be (L, 224, 224, 3)\n \n\n #image = torch.from_numpy(a) \n #image = image.permute(0,3,1,2)\n #print(image.shape)\n\n #Pre-processing: \n from torchvision import transforms as transf\n preprocess = transf.Compose([\n transf.ToPILImage(),\n transf.Resize(300),\n transf.CenterCrop(300),\n transf.ToTensor(), \n transf.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),\n ])\n \n for j in range(batch_size): \n \n if j == 0: \n input_tensor = preprocess(images[j])\n input_tensor = input_tensor.unsqueeze(0)\n input_batch = input_tensor\n else:\n input_tensor = preprocess(images[j])\n #print(input_tensor)\n input_tensor = input_tensor.unsqueeze(0) # create a mini-batch as expected by the model\n #print(input_tensor.shape)\n input_batch = torch.cat((input_batch, input_tensor), 0)\n #print(\"shape images: \",input_batch.shape) \n\n \n \n # In the Active Vision Dataset we have this formatting:\n # [xmin ymin xmax ymax instance_id difficulty]\n \n \"\"\" From the Tutorial: \nSince the number of objects in any given image can vary, we can't use a fixed \nsize tensor for storing the bounding boxes for the entire batch of N images.\n\nTherefore, ground truth bounding boxes fed to the model must be a list of \nlength N, where each element of the list is a Float tensor of dimensions\nN_o, 4, where N_o is the number of objects present in that particular image.\n\nTherefore, ground truth labels fed to the model must be a list of length N, \nwhere each element of the list is a Long tensor of dimensions N_o, where N_o \nis the number of objects present in that particular image.\n \"\"\"\n #Prints to test\n #print(j)\n box_id_diff = [b for b in labels[j][0]] \n box = [l[0:4] for l in box_id_diff]\n\n #print('before:',box) #To check\n\n #Boundary coordinates as requested\n for k in range(len(box)): \n box[k][0] = box[k][0]/1920.0\n box[k][2] = box[k][2]/1920.0 \n box[k][1] = box[k][1]/1080.0\n box[k][3] = box[k][3]/1080.0 \n\n #print('after:',box) #To check\n \n box_tensor = torch.FloatTensor(box).to(device)\n\n #Done with the parameter in AVD method\n \"\"\" \n #Check if there are objects in the images\n if j == 0: \n start = True\n \n if len(box_tensor) > 0:\n if start == True:\n box_list = box_tensor\n start = False\n elif start == False:\n box_list = [box_list, box_tensor] \n #box_list = torch.cat((box_list,box_tensor),0) \n else:\n start = True\n \"\"\"\n \n #print(box_tensor) #To check\n\n if j == 0: \n box_list = [box_tensor]\n else:\n box_list.append(box_tensor) \n\n label = [l[4] for l in box_id_diff]\n label_tensor = torch.LongTensor(label).to(device)\n if j == 0: \n label_list = [label_tensor]\n else:\n label_list.append(label_tensor) \n\n \n #print(box_id_diff[0][0:4])\n \n \"\"\"\n if len(box_id_diff.size())-1 != 0:\n if j == 0: \n box = box_id_diff[0][0:4]\n print(\"asad:\",box)\n #box = box.unsqueeze(0)\n boxes = box\n else:\n box = [l[0:4] for l in box_id_diff]\n\n #box = box.unsqueeze(0) # create a mini-batch as expected by the model\n #print(input_tensor.shape)\n boxes = torch.cat((boxes, box), 0)\n print(\"boxes:\", boxes)\n \"\"\"\n #box = torch.split(box_id_diff, 2)\n #print(box)\n \"\"\"\n if not labels[j][0]:\n labels = [] \n print(\"coasc\") \n else: \n labels = [l.to(device) for l in torch.tensor(labels[j][0][4])]\n \"\"\"\n \n #print(\"list of boxes:\",box_list)\n #print(\"list of labels:\", label_list)\n\n images = input_batch.to(device) # (batch_size (N), 3, 300, 300)\n #print(images.shape)\n boxes = box_list\n labels = label_list\n\n # Forward prop. \n predicted_locs, predicted_scores = model(images) # (N, 8732, 4), (N, 8732, n_classes)\n\n #Prints to check the dimensions\n #print(predicted_locs.shape) #correct \n #print(predicted_scores.shape) #correct \n\n # Loss\n loss = criterion(predicted_locs, predicted_scores, boxes, labels) # scalar\n\n # Backward prop.\n optimizer.zero_grad()\n loss.backward()\n\n # Clip gradients, if necessary\n if grad_clip is not None:\n clip_gradient(optimizer, grad_clip)\n\n # Update model\n optimizer.step()\n\n losses.update(loss.item(), images.size(0))\n batch_time.update(time.time() - start)\n\n start = time.time()\n\n \n # Print status\n if i % print_freq == 0: \n print('Epoch: [{0}][{1}/{2}]\\t' \n 'Loss {loss.val:.4f} ({loss.avg:.4f})\\t'.format(epoch, i, len(train_loader), loss=losses))\n \"\"\"\n print('Epoch: [{0}][{1}/{2}]\\t'\n 'Batch Time {batch_time.val:.3f} ({batch_time.avg:.3f})\\t'\n 'Data Time {data_time.val:.3f} ({data_time.avg:.3f})\\t'\n 'Loss {loss.val:.4f} ({loss.avg:.4f})\\t'.format(epoch, i, len(train_loader),\n batch_time=batch_time,\n data_time=data_time, loss=losses))\n \"\"\" \n del predicted_locs, predicted_scores, images, boxes, labels # free some memory since their histories may be stored\n\n\nif __name__ == '__main__':\n main()\n"
] | [
[
"numpy.asarray"
]
] |
1nadequacy/dm_control | [
"a55474768cf0a6d570fe4a376802630027ad5f01"
] | [
"dm_control/rl/specs_test.py"
] | [
"# Copyright 2017 The dm_control 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\"\"\"Tests for specs.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\n# Internal dependencies.\n\nfrom absl.testing import absltest\nfrom dm_control.rl import specs as array_spec\nimport numpy as np\nimport six\n\n\nclass ArraySpecTest(absltest.TestCase):\n\n def testShapeTypeError(self):\n with self.assertRaises(TypeError):\n array_spec.ArraySpec(32, np.int32)\n\n def testDtypeTypeError(self):\n with self.assertRaises(TypeError):\n array_spec.ArraySpec((1, 2, 3), \"32\")\n\n def testStringDtype(self):\n array_spec.ArraySpec((1, 2, 3), \"int32\")\n\n def testNumpyDtype(self):\n array_spec.ArraySpec((1, 2, 3), np.int32)\n\n def testDtype(self):\n spec = array_spec.ArraySpec((1, 2, 3), np.int32)\n self.assertEqual(np.int32, spec.dtype)\n\n def testShape(self):\n spec = array_spec.ArraySpec([1, 2, 3], np.int32)\n self.assertEqual((1, 2, 3), spec.shape)\n\n def testEqual(self):\n spec_1 = array_spec.ArraySpec((1, 2, 3), np.int32)\n spec_2 = array_spec.ArraySpec((1, 2, 3), np.int32)\n self.assertEqual(spec_1, spec_2)\n\n def testNotEqualDifferentShape(self):\n spec_1 = array_spec.ArraySpec((1, 2, 3), np.int32)\n spec_2 = array_spec.ArraySpec((1, 3, 3), np.int32)\n self.assertNotEqual(spec_1, spec_2)\n\n def testNotEqualDifferentDtype(self):\n spec_1 = array_spec.ArraySpec((1, 2, 3), np.int64)\n spec_2 = array_spec.ArraySpec((1, 2, 3), np.int32)\n self.assertNotEqual(spec_1, spec_2)\n\n def testNotEqualOtherClass(self):\n spec_1 = array_spec.ArraySpec((1, 2, 3), np.int32)\n spec_2 = None\n self.assertNotEqual(spec_1, spec_2)\n self.assertNotEqual(spec_2, spec_1)\n\n spec_2 = ()\n self.assertNotEqual(spec_1, spec_2)\n self.assertNotEqual(spec_2, spec_1)\n\n def testIsUnhashable(self):\n spec = array_spec.ArraySpec(shape=(1, 2, 3), dtype=np.int32)\n with self.assertRaisesRegexp(TypeError, \"unhashable type\"):\n hash(spec)\n\n def testValidateDtype(self):\n spec = array_spec.ArraySpec((1, 2), np.int32)\n spec.validate(np.zeros((1, 2), dtype=np.int32))\n with self.assertRaises(ValueError):\n spec.validate(np.zeros((1, 2), dtype=np.float32))\n\n def testValidateShape(self):\n spec = array_spec.ArraySpec((1, 2), np.int32)\n spec.validate(np.zeros((1, 2), dtype=np.int32))\n with self.assertRaises(ValueError):\n spec.validate(np.zeros((1, 2, 3), dtype=np.int32))\n\n def testGenerateValue(self):\n spec = array_spec.ArraySpec((1, 2), np.int32)\n test_value = spec.generate_value()\n spec.validate(test_value)\n\n\nclass BoundedArraySpecTest(absltest.TestCase):\n\n def testInvalidMinimum(self):\n with six.assertRaisesRegex(self, ValueError, \"not compatible\"):\n array_spec.BoundedArraySpec((3, 5), np.uint8, (0, 0, 0), (1, 1))\n\n def testInvalidMaximum(self):\n with six.assertRaisesRegex(self, ValueError, \"not compatible\"):\n array_spec.BoundedArraySpec((3, 5), np.uint8, 0, (1, 1, 1))\n\n def testMinMaxAttributes(self):\n spec = array_spec.BoundedArraySpec((1, 2, 3), np.float32, 0, (5, 5, 5))\n self.assertEqual(type(spec.minimum), np.ndarray)\n self.assertEqual(type(spec.maximum), np.ndarray)\n\n def testNotWriteable(self):\n spec = array_spec.BoundedArraySpec((1, 2, 3), np.float32, 0, (5, 5, 5))\n with six.assertRaisesRegex(self, ValueError, \"read-only\"):\n spec.minimum[0] = -1\n with six.assertRaisesRegex(self, ValueError, \"read-only\"):\n spec.maximum[0] = 100\n\n def testEqualBroadcastingBounds(self):\n spec_1 = array_spec.BoundedArraySpec(\n (1, 2), np.int32, minimum=0.0, maximum=1.0)\n spec_2 = array_spec.BoundedArraySpec(\n (1, 2), np.int32, minimum=[0.0, 0.0], maximum=[1.0, 1.0])\n self.assertEqual(spec_1, spec_2)\n\n def testNotEqualDifferentMinimum(self):\n spec_1 = array_spec.BoundedArraySpec(\n (1, 2), np.int32, minimum=[0.0, -0.6], maximum=[1.0, 1.0])\n spec_2 = array_spec.BoundedArraySpec(\n (1, 2), np.int32, minimum=[0.0, 0.0], maximum=[1.0, 1.0])\n self.assertNotEqual(spec_1, spec_2)\n\n def testNotEqualOtherClass(self):\n spec_1 = array_spec.BoundedArraySpec(\n (1, 2), np.int32, minimum=[0.0, -0.6], maximum=[1.0, 1.0])\n spec_2 = array_spec.ArraySpec((1, 2), np.int32)\n self.assertNotEqual(spec_1, spec_2)\n self.assertNotEqual(spec_2, spec_1)\n\n spec_2 = None\n self.assertNotEqual(spec_1, spec_2)\n self.assertNotEqual(spec_2, spec_1)\n\n spec_2 = ()\n self.assertNotEqual(spec_1, spec_2)\n self.assertNotEqual(spec_2, spec_1)\n\n def testNotEqualDifferentMaximum(self):\n spec_1 = array_spec.BoundedArraySpec(\n (1, 2), np.int32, minimum=0.0, maximum=2.0)\n spec_2 = array_spec.BoundedArraySpec(\n (1, 2), np.int32, minimum=[0.0, 0.0], maximum=[1.0, 1.0])\n self.assertNotEqual(spec_1, spec_2)\n\n def testIsUnhashable(self):\n spec = array_spec.BoundedArraySpec(\n shape=(1, 2), dtype=np.int32, minimum=0.0, maximum=2.0)\n with self.assertRaisesRegexp(TypeError, \"unhashable type\"):\n hash(spec)\n\n def testRepr(self):\n as_string = repr(array_spec.BoundedArraySpec(\n (1, 2), np.int32, minimum=101.0, maximum=73.0))\n self.assertIn(\"101\", as_string)\n self.assertIn(\"73\", as_string)\n\n def testValidateBounds(self):\n spec = array_spec.BoundedArraySpec((2, 2), np.int32, minimum=5, maximum=10)\n spec.validate(np.array([[5, 6], [8, 10]], dtype=np.int32))\n with self.assertRaises(ValueError):\n spec.validate(np.array([[5, 6], [8, 11]], dtype=np.int32))\n with self.assertRaises(ValueError):\n spec.validate(np.array([[4, 6], [8, 10]], dtype=np.int32))\n\n def testGenerateValue(self):\n spec = array_spec.BoundedArraySpec((2, 2), np.int32, minimum=5, maximum=10)\n test_value = spec.generate_value()\n spec.validate(test_value)\n\n def testScalarBounds(self):\n spec = array_spec.BoundedArraySpec((), np.float, minimum=0.0, maximum=1.0)\n\n self.assertIsInstance(spec.minimum, np.ndarray)\n self.assertIsInstance(spec.maximum, np.ndarray)\n\n # Sanity check that numpy compares correctly to a scalar for an empty shape.\n self.assertEqual(0.0, spec.minimum)\n self.assertEqual(1.0, spec.maximum)\n\n # Check that the spec doesn't fail its own input validation.\n _ = array_spec.BoundedArraySpec(\n spec.shape, spec.dtype, spec.minimum, spec.maximum)\n\n\nif __name__ == \"__main__\":\n absltest.main()\n"
] | [
[
"numpy.array",
"numpy.zeros"
]
] |
JoeTao-097/Multi-REZ-Evalution-for-Breast-Ultrasound-Images | [
"344d64ad2fe9d790c49e8005b3abee219d362278",
"344d64ad2fe9d790c49e8005b3abee219d362278"
] | [
"Model_test.py",
"Model Perfomance Comparasion.py"
] | [
"# -*- coding: utf-8 -*-\r\n\"\"\"\r\nCreated on Mon Aug 2 17:32:52 2021\r\n\r\n@author: jiangyt\r\n\"\"\"\r\n\r\nfrom Tools import *\r\nfrom tensorflow import keras\r\nfrom tensorflow.keras.layers import Dense, Activation, Flatten, Dropout, Input, BatchNormalization\r\nfrom tensorflow.keras.layers import Conv2D, MaxPooling2D, add, AveragePooling2D, ZeroPadding2D, GlobalAveragePooling2D\r\nfrom tensorflow.keras.models import Model, Sequential\r\n\r\n\"\"\"\r\nWeight Dict\r\n\"\"\"\r\nWeight = {'Resnet50_448':\"./model_checkpoints/ResNet50_448_checkpoints/20218131038.h5\",\r\n 'MobileNet_224':\"./model_checkpoints/MobileNet_224_checkpoints/202189956.h5\",\r\n 'Xception_448':\"./model_checkpoints/Xception_448_checkpoints/2021810951.h5\",\r\n 'EfficientNet_B0_320':\"./model_checkpoints/EfficientNetB0_320_checkpoints/2021871045.h5\",\r\n 'DenseNet121_448':\"./model_checkpoints/DenseNet121_448_checkpoints/2021891655.h5\"}\r\n\r\n\"\"\"\r\nLoad model\r\n\"\"\"\r\ndf = pd.read_excel('./AI-Physician Comparasion Dataset.xlsx')\r\n# df = pd.read_csv('/home/joe/Project/Breast_new/20210805_b_m_Xception_train/df_test_small.csv')\r\n\r\n\"\"\"\r\nEval each model\r\n\"\"\"\r\nfor key in Weight.keys():\r\n if key == 'Resnet50_448':\r\n from tensorflow.keras.applications.resnet50 import preprocess_input\r\n backbone_model= keras.applications.resnet50.ResNet50(include_top=False, weights=None, input_tensor=None,\r\n input_shape=(448, 448, 3), pooling=None, classes=2)\r\n elif key == 'MobileNet_224':\r\n from tensorflow.keras.applications.mobilenet import preprocess_input\r\n backbone_model= keras.applications.mobilenet.MobileNet(include_top=False, weights=None, input_tensor=None,\r\n input_shape=(224, 224, 3), pooling=None, classes=2)\r\n elif key == 'Xception_448':\r\n from tensorflow.keras.applications.xception import preprocess_input\r\n backbone_model= keras.applications.xception.Xception(include_top=False, weights=None, input_tensor=None,\r\n input_shape=(448, 448, 3), pooling=None, classes=2)\r\n elif key == 'EfficientNet_B0_320':\r\n from tensorflow.keras.applications.efficientnet import preprocess_input\r\n backbone_model= keras.applications.efficientnet.EfficientNetB0(include_top=False, weights=None, input_tensor=None,\r\n input_shape=(320, 320, 3), pooling=None, classes=2)\r\n elif key == 'DenseNet121_448':\r\n from tensorflow.keras.applications.densenet import preprocess_input\r\n\r\n backbone_model = keras.applications.densenet.DenseNet121(include_top=False, weights=\"imagenet\",\r\n input_tensor=None,\r\n input_shape=(448, 448, 3), pooling=None, classes=2)\r\n else:\r\n print('Error: No model weight find')\r\n test_model = Sequential()\r\n test_model.add(backbone_model)\r\n test_model.add(GlobalAveragePooling2D())\r\n test_model.add(Dense(2, activation='softmax', name='fc1'))\r\n test_model.load_weights(Weight[key])\r\n\r\n test_model.summary()\r\n\r\n y_true = []\r\n y_pred = []\r\n\r\n for i in range(len(df)):\r\n y_true.append(df['malignancy'][i])\r\n x = Image.open(df['path'][i])\r\n x = np.array(x)\r\n x = zero_pad(x,int(key.split('_')[-1]))\r\n x = preprocess_input(x)\r\n x = x.reshape(1,x.shape[0],x.shape[1],x.shape[2])\r\n y_pred.append(test_model.predict(x))\r\n \r\n\r\n y_pred = np.array(y_pred)\r\n y_pred = y_pred.reshape(y_pred.shape[0],2)\r\n y_pred_1 = y_pred[:,1]\r\n\r\n thresh_0=get_auc(0, np.array(y_true), np.array(y_pred_1), 'Malignancy', plot=False)\r\n y_pred_comp_lvl=[1 if y>thresh_0 else 0 for y in y_pred_1]\r\n cm_comp=confusion_matrix(y_true, y_pred_comp_lvl)\r\n\r\n fig, axes = plt.subplots(nrows=2, ncols=2)\r\n fig.tight_layout(pad=2, w_pad=2.)\r\n fig.set_figheight(8)\r\n fig.set_figwidth(7)\r\n thresh_0=get_auc(axes[0, 0], np.array(y_true), np.array(y_pred_1), 'Performance of {}'.format(key))\r\n thresh_AP=get_precision_recall(axes[0, 1], np.array(y_true), np.array(y_pred_1), 'Malignancy=0 vs 1')\r\n plot_confusion_matrix(axes[1, 0], cm_comp, [\"0\", \"1\"], title='Malignancy', normalize=False)\r\n plot_confusion_matrix(axes[1, 1], cm_comp, [\"0\", \"1\"], title='Malignancy (normalized)')\r\n print('f1 score is: {:.3f}'.format(f1_score(y_true, y_pred_comp_lvl)))\r\n",
"#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Thu Dec 16 10:55:17 2021\n\n@author: joe\n\"\"\"\n\nimport numpy as np\nfrom matplotlib import pyplot as plt\nimport scipy.stats as st\nfrom sklearn import metrics\n\nclass DelongTest():\n def __init__(self,preds1,preds2,label,threshold=0.05):\n '''\n preds1:the output of model1\n preds2:the output of model2\n label :the actual label\n '''\n self._preds1=preds1\n self._preds2=preds2\n self._label=label\n self.threshold=threshold\n self._show_result()\n\n\n def _auc(self,X, Y)->float:\n return 1/(len(X)*len(Y)) * sum([self._kernel(x, y) for x in X for y in Y])\n\n def _kernel(self,X, Y)->float:\n '''\n Mann-Whitney statistic\n '''\n return .5 if Y==X else int(Y < X)\n\n def _structural_components(self,X, Y)->list:\n V10 = [1/len(Y) * sum([self._kernel(x, y) for y in Y]) for x in X]\n V01 = [1/len(X) * sum([self._kernel(x, y) for x in X]) for y in Y]\n return V10, V01\n\n def _get_S_entry(self,V_A, V_B, auc_A, auc_B)->float:\n return 1/(len(V_A)-1) * sum([(a-auc_A)*(b-auc_B) for a,b in zip(V_A, V_B)])\n \n def _z_score(self,var_A, var_B, covar_AB, auc_A, auc_B):\n return (auc_A - auc_B)/((var_A + var_B - 2*covar_AB )**(.5)+ 1e-8)\n\n def _group_preds_by_label(self,preds, actual)->list:\n X = [p for (p, a) in zip(preds, actual) if a]\n Y = [p for (p, a) in zip(preds, actual) if not a]\n return X, Y\n\n def _compute_z_p(self):\n X_A, Y_A = self._group_preds_by_label(self._preds1, self._label)\n X_B, Y_B = self._group_preds_by_label(self._preds2, self._label)\n\n V_A10, V_A01 = self._structural_components(X_A, Y_A)\n V_B10, V_B01 = self._structural_components(X_B, Y_B)\n\n auc_A = self._auc(X_A, Y_A)\n auc_B = self._auc(X_B, Y_B)\n\n # Compute entries of covariance matrix S (covar_AB = covar_BA)\n var_A = (self._get_S_entry(V_A10, V_A10, auc_A, auc_A) * 1/len(V_A10)+ self._get_S_entry(V_A01, V_A01, auc_A, auc_A) * 1/len(V_A01))\n var_B = (self._get_S_entry(V_B10, V_B10, auc_B, auc_B) * 1/len(V_B10)+ self._get_S_entry(V_B01, V_B01, auc_B, auc_B) * 1/len(V_B01))\n covar_AB = (self._get_S_entry(V_A10, V_B10, auc_A, auc_B) * 1/len(V_A10)+ self._get_S_entry(V_A01, V_B01, auc_A, auc_B) * 1/len(V_A01))\n\n # Two tailed test\n z = self._z_score(var_A, var_B, covar_AB, auc_A, auc_B)\n p = st.norm.sf(abs(z))*2\n\n return z,p\n\n def _show_result(self):\n z,p=self._compute_z_p()\n print(f\"z score = {z:.5f};\\np value = {p:.5f};\")\n if p < self.threshold :print(\"There is a significant difference\")\n else: print(\"There is NO significant difference\")\n\nimport pandas as pd\nimport seaborn as sns\n\n\n\ndf = pd.read_csv('./model and physicians performance on AI-Physician Comparasion set/AI-Physician Comparasion result.csv')\n\nphys_name = ['senior-1','senior-2','junior-1','junior-2','entry-1','entry-2']\nphys = df.columns.tolist()[6:12]\ncols = df.columns.tolist()[1:]\nAIs = df.columns.tolist()[1:6]\n\nd_frame = []\n\nfor AI in AIs:\n d = []\n\n for AI2 in AIs:\n Delong = DelongTest(np.array(df[AI]), np.array(df[AI2]), np.array(df['y_true']))\n z,p = Delong._compute_z_p()\n d.append(p)\n \n d_frame.append(d)\n \nd_frame = pd.DataFrame(d_frame).T\nd_frame.columns = AIs\nd_frame.index = AIs\n\nplt.figure()\nsns.heatmap(data=d_frame,annot=True,cmap='RdBu_r')\nplt.xticks(rotation=30)\nplt.yticks(rotation=0)\nplt.title('p value of DeLong test(error of AIs)')\n\n\n\n"
] | [
[
"tensorflow.keras.applications.densenet.DenseNet121",
"tensorflow.keras.applications.xception.Xception",
"tensorflow.keras.applications.efficientnet.EfficientNetB0",
"tensorflow.keras.layers.Dense",
"tensorflow.keras.applications.mobilenet.MobileNet",
"tensorflow.keras.applications.resnet50.ResNet50",
"tensorflow.keras.layers.GlobalAveragePooling2D",
"tensorflow.keras.models.Sequential",
"tensorflow.keras.applications.densenet.preprocess_input"
],
[
"numpy.array",
"pandas.DataFrame",
"matplotlib.pyplot.title",
"matplotlib.pyplot.yticks",
"matplotlib.pyplot.figure",
"pandas.read_csv",
"matplotlib.pyplot.xticks"
]
] |
arnoyu-hub/COMP0016miemie | [
"59af664dcf190eab4f93cefb8471908717415fea",
"59af664dcf190eab4f93cefb8471908717415fea",
"59af664dcf190eab4f93cefb8471908717415fea",
"59af664dcf190eab4f93cefb8471908717415fea",
"59af664dcf190eab4f93cefb8471908717415fea",
"59af664dcf190eab4f93cefb8471908717415fea",
"59af664dcf190eab4f93cefb8471908717415fea",
"59af664dcf190eab4f93cefb8471908717415fea",
"59af664dcf190eab4f93cefb8471908717415fea",
"59af664dcf190eab4f93cefb8471908717415fea",
"59af664dcf190eab4f93cefb8471908717415fea",
"59af664dcf190eab4f93cefb8471908717415fea",
"59af664dcf190eab4f93cefb8471908717415fea",
"59af664dcf190eab4f93cefb8471908717415fea",
"59af664dcf190eab4f93cefb8471908717415fea",
"59af664dcf190eab4f93cefb8471908717415fea",
"59af664dcf190eab4f93cefb8471908717415fea",
"59af664dcf190eab4f93cefb8471908717415fea",
"59af664dcf190eab4f93cefb8471908717415fea"
] | [
"venv/Lib/site-packages/pandas/tests/series/indexing/test_get.py",
"venv/Lib/site-packages/pandas/tests/frame/methods/test_at_time.py",
"venv/Lib/site-packages/pandas/tests/arrays/categorical/test_operators.py",
"venv/Lib/site-packages/pandas/tests/frame/methods/test_filter.py",
"venv/Lib/site-packages/sklearn/base.py",
"venv/Lib/site-packages/pandas/tests/series/methods/test_append.py",
"venv/Lib/site-packages/pandas/tests/dtypes/cast/test_construct_ndarray.py",
"venv/Lib/site-packages/pandas/core/groupby/ops.py",
"venv/Lib/site-packages/pandas/tests/util/test_assert_series_equal.py",
"venv/Lib/site-packages/sklearn/linear_model/_coordinate_descent.py",
"venv/Lib/site-packages/pandas/core/indexes/range.py",
"venv/Lib/site-packages/sklearn/feature_selection/_mutual_info.py",
"venv/Lib/site-packages/sklearn/inspection/_plot/tests/test_plot_partial_dependence.py",
"venv/Lib/site-packages/pandas/tests/extension/test_extension.py",
"venv/Lib/site-packages/pandas/tests/indexing/test_chaining_and_caching.py",
"venv/Lib/site-packages/mpl_toolkits/axes_grid1/inset_locator.py",
"venv/Lib/site-packages/pandas/core/arrays/boolean.py",
"venv/Lib/site-packages/matplotlib/tri/tricontour.py",
"venv/Lib/site-packages/pandas/tests/indexes/datetimes/methods/test_astype.py"
] | [
"import numpy as np\r\nimport pytest\r\n\r\nimport pandas as pd\r\nfrom pandas import Series\r\nimport pandas._testing as tm\r\n\r\n\r\ndef test_get():\r\n # GH 6383\r\n s = Series(\r\n np.array(\r\n [\r\n 43,\r\n 48,\r\n 60,\r\n 48,\r\n 50,\r\n 51,\r\n 50,\r\n 45,\r\n 57,\r\n 48,\r\n 56,\r\n 45,\r\n 51,\r\n 39,\r\n 55,\r\n 43,\r\n 54,\r\n 52,\r\n 51,\r\n 54,\r\n ]\r\n )\r\n )\r\n\r\n result = s.get(25, 0)\r\n expected = 0\r\n assert result == expected\r\n\r\n s = Series(\r\n np.array(\r\n [\r\n 43,\r\n 48,\r\n 60,\r\n 48,\r\n 50,\r\n 51,\r\n 50,\r\n 45,\r\n 57,\r\n 48,\r\n 56,\r\n 45,\r\n 51,\r\n 39,\r\n 55,\r\n 43,\r\n 54,\r\n 52,\r\n 51,\r\n 54,\r\n ]\r\n ),\r\n index=pd.Float64Index(\r\n [\r\n 25.0,\r\n 36.0,\r\n 49.0,\r\n 64.0,\r\n 81.0,\r\n 100.0,\r\n 121.0,\r\n 144.0,\r\n 169.0,\r\n 196.0,\r\n 1225.0,\r\n 1296.0,\r\n 1369.0,\r\n 1444.0,\r\n 1521.0,\r\n 1600.0,\r\n 1681.0,\r\n 1764.0,\r\n 1849.0,\r\n 1936.0,\r\n ]\r\n ),\r\n )\r\n\r\n result = s.get(25, 0)\r\n expected = 43\r\n assert result == expected\r\n\r\n # GH 7407\r\n # with a boolean accessor\r\n df = pd.DataFrame({\"i\": [0] * 3, \"b\": [False] * 3})\r\n vc = df.i.value_counts()\r\n result = vc.get(99, default=\"Missing\")\r\n assert result == \"Missing\"\r\n\r\n vc = df.b.value_counts()\r\n result = vc.get(False, default=\"Missing\")\r\n assert result == 3\r\n\r\n result = vc.get(True, default=\"Missing\")\r\n assert result == \"Missing\"\r\n\r\n\r\ndef test_get_nan():\r\n # GH 8569\r\n s = pd.Float64Index(range(10)).to_series()\r\n assert s.get(np.nan) is None\r\n assert s.get(np.nan, default=\"Missing\") == \"Missing\"\r\n\r\n\r\ndef test_get_nan_multiple():\r\n # GH 8569\r\n # ensure that fixing \"test_get_nan\" above hasn't broken get\r\n # with multiple elements\r\n s = pd.Float64Index(range(10)).to_series()\r\n\r\n idx = [2, 30]\r\n assert s.get(idx) is None\r\n\r\n idx = [2, np.nan]\r\n assert s.get(idx) is None\r\n\r\n # GH 17295 - all missing keys\r\n idx = [20, 30]\r\n assert s.get(idx) is None\r\n\r\n idx = [np.nan, np.nan]\r\n assert s.get(idx) is None\r\n\r\n\r\ndef test_get_with_default():\r\n # GH#7725\r\n d0 = [\"a\", \"b\", \"c\", \"d\"]\r\n d1 = np.arange(4, dtype=\"int64\")\r\n others = [\"e\", 10]\r\n\r\n for data, index in ((d0, d1), (d1, d0)):\r\n s = Series(data, index=index)\r\n for i, d in zip(index, data):\r\n assert s.get(i) == d\r\n assert s.get(i, d) == d\r\n assert s.get(i, \"z\") == d\r\n for other in others:\r\n assert s.get(other, \"z\") == \"z\"\r\n assert s.get(other, other) == other\r\n\r\n\r\[email protected](\r\n \"arr\",\r\n [np.random.randn(10), tm.makeDateIndex(10, name=\"a\").tz_localize(tz=\"US/Eastern\")],\r\n)\r\ndef test_get2(arr):\r\n # TODO: better name, possibly split\r\n # GH#21260\r\n ser = Series(arr, index=[2 * i for i in range(len(arr))])\r\n assert ser.get(4) == ser.iloc[2]\r\n\r\n result = ser.get([4, 6])\r\n expected = ser.iloc[[2, 3]]\r\n tm.assert_series_equal(result, expected)\r\n\r\n result = ser.get(slice(2))\r\n expected = ser.iloc[[0, 1]]\r\n tm.assert_series_equal(result, expected)\r\n\r\n assert ser.get(-1) is None\r\n assert ser.get(ser.index.max() + 1) is None\r\n\r\n ser = Series(arr[:6], index=list(\"abcdef\"))\r\n assert ser.get(\"c\") == ser.iloc[2]\r\n\r\n result = ser.get(slice(\"b\", \"d\"))\r\n expected = ser.iloc[[1, 2, 3]]\r\n tm.assert_series_equal(result, expected)\r\n\r\n result = ser.get(\"Z\")\r\n assert result is None\r\n\r\n assert ser.get(4) == ser.iloc[4]\r\n assert ser.get(-1) == ser.iloc[-1]\r\n assert ser.get(len(ser)) is None\r\n\r\n # GH#21257\r\n ser = Series(arr)\r\n ser2 = ser[::2]\r\n assert ser2.get(1) is None\r\n\r\n\r\ndef test_getitem_get(string_series, object_series):\r\n for obj in [string_series, object_series]:\r\n idx = obj.index[5]\r\n\r\n assert obj[idx] == obj.get(idx)\r\n assert obj[idx] == obj[5]\r\n\r\n assert string_series.get(-1) == string_series.get(string_series.index[-1])\r\n assert string_series[5] == string_series.get(string_series.index[5])\r\n\r\n\r\ndef test_get_none():\r\n # GH#5652\r\n s1 = Series(dtype=object)\r\n s2 = Series(dtype=object, index=list(\"abc\"))\r\n for s in [s1, s2]:\r\n result = s.get(None)\r\n assert result is None\r\n",
"from datetime import time\r\n\r\nimport numpy as np\r\nimport pytest\r\nimport pytz\r\n\r\nfrom pandas._libs.tslibs import timezones\r\n\r\nfrom pandas import (\r\n DataFrame,\r\n date_range,\r\n)\r\nimport pandas._testing as tm\r\n\r\n\r\nclass TestAtTime:\r\n @pytest.mark.parametrize(\"tzstr\", [\"US/Eastern\", \"dateutil/US/Eastern\"])\r\n def test_localized_at_time(self, tzstr, frame_or_series):\r\n tz = timezones.maybe_get_tz(tzstr)\r\n\r\n rng = date_range(\"4/16/2012\", \"5/1/2012\", freq=\"H\")\r\n ts = frame_or_series(np.random.randn(len(rng)), index=rng)\r\n\r\n ts_local = ts.tz_localize(tzstr)\r\n\r\n result = ts_local.at_time(time(10, 0))\r\n expected = ts.at_time(time(10, 0)).tz_localize(tzstr)\r\n tm.assert_equal(result, expected)\r\n assert timezones.tz_compare(result.index.tz, tz)\r\n\r\n def test_at_time(self, frame_or_series):\r\n rng = date_range(\"1/1/2000\", \"1/5/2000\", freq=\"5min\")\r\n ts = DataFrame(np.random.randn(len(rng), 2), index=rng)\r\n if frame_or_series is not DataFrame:\r\n ts = ts[0]\r\n rs = ts.at_time(rng[1])\r\n assert (rs.index.hour == rng[1].hour).all()\r\n assert (rs.index.minute == rng[1].minute).all()\r\n assert (rs.index.second == rng[1].second).all()\r\n\r\n result = ts.at_time(\"9:30\")\r\n expected = ts.at_time(time(9, 30))\r\n tm.assert_equal(result, expected)\r\n\r\n def test_at_time_midnight(self, frame_or_series):\r\n # midnight, everything\r\n rng = date_range(\"1/1/2000\", \"1/31/2000\")\r\n ts = DataFrame(np.random.randn(len(rng), 3), index=rng)\r\n if frame_or_series is not DataFrame:\r\n ts = ts[0]\r\n\r\n result = ts.at_time(time(0, 0))\r\n tm.assert_equal(result, ts)\r\n\r\n def test_at_time_nonexistent(self, frame_or_series):\r\n # time doesn't exist\r\n rng = date_range(\"1/1/2012\", freq=\"23Min\", periods=384)\r\n ts = DataFrame(np.random.randn(len(rng)), rng)\r\n if frame_or_series is not DataFrame:\r\n ts = ts[0]\r\n rs = ts.at_time(\"16:00\")\r\n assert len(rs) == 0\r\n\r\n @pytest.mark.parametrize(\r\n \"hour\", [\"1:00\", \"1:00AM\", time(1), time(1, tzinfo=pytz.UTC)]\r\n )\r\n def test_at_time_errors(self, hour):\r\n # GH#24043\r\n dti = date_range(\"2018\", periods=3, freq=\"H\")\r\n df = DataFrame(list(range(len(dti))), index=dti)\r\n if getattr(hour, \"tzinfo\", None) is None:\r\n result = df.at_time(hour)\r\n expected = df.iloc[1:2]\r\n tm.assert_frame_equal(result, expected)\r\n else:\r\n with pytest.raises(ValueError, match=\"Index must be timezone\"):\r\n df.at_time(hour)\r\n\r\n def test_at_time_tz(self):\r\n # GH#24043\r\n dti = date_range(\"2018\", periods=3, freq=\"H\", tz=\"US/Pacific\")\r\n df = DataFrame(list(range(len(dti))), index=dti)\r\n result = df.at_time(time(4, tzinfo=pytz.timezone(\"US/Eastern\")))\r\n expected = df.iloc[1:2]\r\n tm.assert_frame_equal(result, expected)\r\n\r\n def test_at_time_raises(self, frame_or_series):\r\n # GH#20725\r\n obj = DataFrame([[1, 2, 3], [4, 5, 6]])\r\n if frame_or_series is not DataFrame:\r\n obj = obj[0]\r\n msg = \"Index must be DatetimeIndex\"\r\n with pytest.raises(TypeError, match=msg): # index is not a DatetimeIndex\r\n obj.at_time(\"00:00\")\r\n\r\n @pytest.mark.parametrize(\"axis\", [\"index\", \"columns\", 0, 1])\r\n def test_at_time_axis(self, axis):\r\n # issue 8839\r\n rng = date_range(\"1/1/2000\", \"1/5/2000\", freq=\"5min\")\r\n ts = DataFrame(np.random.randn(len(rng), len(rng)))\r\n ts.index, ts.columns = rng, rng\r\n\r\n indices = rng[(rng.hour == 9) & (rng.minute == 30) & (rng.second == 0)]\r\n\r\n if axis in [\"index\", 0]:\r\n expected = ts.loc[indices, :]\r\n elif axis in [\"columns\", 1]:\r\n expected = ts.loc[:, indices]\r\n\r\n result = ts.at_time(\"9:30\", axis=axis)\r\n\r\n # Without clearing freq, result has freq 1440T and expected 5T\r\n result.index = result.index._with_freq(None)\r\n expected.index = expected.index._with_freq(None)\r\n tm.assert_frame_equal(result, expected)\r\n\r\n def test_at_time_datetimeindex(self):\r\n index = date_range(\"2012-01-01\", \"2012-01-05\", freq=\"30min\")\r\n df = DataFrame(np.random.randn(len(index), 5), index=index)\r\n akey = time(12, 0, 0)\r\n ainds = [24, 72, 120, 168]\r\n\r\n result = df.at_time(akey)\r\n expected = df.loc[akey]\r\n expected2 = df.iloc[ainds]\r\n tm.assert_frame_equal(result, expected)\r\n tm.assert_frame_equal(result, expected2)\r\n assert len(result) == 4\r\n",
"import operator\r\nimport warnings\r\n\r\nimport numpy as np\r\nimport pytest\r\n\r\nimport pandas as pd\r\nfrom pandas import (\r\n Categorical,\r\n DataFrame,\r\n Series,\r\n date_range,\r\n)\r\nimport pandas._testing as tm\r\nfrom pandas.tests.arrays.categorical.common import TestCategorical\r\n\r\n\r\nclass TestCategoricalOpsWithFactor(TestCategorical):\r\n def test_categories_none_comparisons(self):\r\n factor = Categorical([\"a\", \"b\", \"b\", \"a\", \"a\", \"c\", \"c\", \"c\"], ordered=True)\r\n tm.assert_categorical_equal(factor, self.factor)\r\n\r\n def test_comparisons(self):\r\n result = self.factor[self.factor == \"a\"]\r\n expected = self.factor[np.asarray(self.factor) == \"a\"]\r\n tm.assert_categorical_equal(result, expected)\r\n\r\n result = self.factor[self.factor != \"a\"]\r\n expected = self.factor[np.asarray(self.factor) != \"a\"]\r\n tm.assert_categorical_equal(result, expected)\r\n\r\n result = self.factor[self.factor < \"c\"]\r\n expected = self.factor[np.asarray(self.factor) < \"c\"]\r\n tm.assert_categorical_equal(result, expected)\r\n\r\n result = self.factor[self.factor > \"a\"]\r\n expected = self.factor[np.asarray(self.factor) > \"a\"]\r\n tm.assert_categorical_equal(result, expected)\r\n\r\n result = self.factor[self.factor >= \"b\"]\r\n expected = self.factor[np.asarray(self.factor) >= \"b\"]\r\n tm.assert_categorical_equal(result, expected)\r\n\r\n result = self.factor[self.factor <= \"b\"]\r\n expected = self.factor[np.asarray(self.factor) <= \"b\"]\r\n tm.assert_categorical_equal(result, expected)\r\n\r\n n = len(self.factor)\r\n\r\n other = self.factor[np.random.permutation(n)]\r\n result = self.factor == other\r\n expected = np.asarray(self.factor) == np.asarray(other)\r\n tm.assert_numpy_array_equal(result, expected)\r\n\r\n result = self.factor == \"d\"\r\n expected = np.zeros(len(self.factor), dtype=bool)\r\n tm.assert_numpy_array_equal(result, expected)\r\n\r\n # comparisons with categoricals\r\n cat_rev = Categorical([\"a\", \"b\", \"c\"], categories=[\"c\", \"b\", \"a\"], ordered=True)\r\n cat_rev_base = Categorical(\r\n [\"b\", \"b\", \"b\"], categories=[\"c\", \"b\", \"a\"], ordered=True\r\n )\r\n cat = Categorical([\"a\", \"b\", \"c\"], ordered=True)\r\n cat_base = Categorical([\"b\", \"b\", \"b\"], categories=cat.categories, ordered=True)\r\n\r\n # comparisons need to take categories ordering into account\r\n res_rev = cat_rev > cat_rev_base\r\n exp_rev = np.array([True, False, False])\r\n tm.assert_numpy_array_equal(res_rev, exp_rev)\r\n\r\n res_rev = cat_rev < cat_rev_base\r\n exp_rev = np.array([False, False, True])\r\n tm.assert_numpy_array_equal(res_rev, exp_rev)\r\n\r\n res = cat > cat_base\r\n exp = np.array([False, False, True])\r\n tm.assert_numpy_array_equal(res, exp)\r\n\r\n # Only categories with same categories can be compared\r\n msg = \"Categoricals can only be compared if 'categories' are the same\"\r\n with pytest.raises(TypeError, match=msg):\r\n cat > cat_rev\r\n\r\n cat_rev_base2 = Categorical([\"b\", \"b\", \"b\"], categories=[\"c\", \"b\", \"a\", \"d\"])\r\n\r\n with pytest.raises(TypeError, match=msg):\r\n cat_rev > cat_rev_base2\r\n\r\n # Only categories with same ordering information can be compared\r\n cat_unorderd = cat.set_ordered(False)\r\n assert not (cat > cat).any()\r\n\r\n with pytest.raises(TypeError, match=msg):\r\n cat > cat_unorderd\r\n\r\n # comparison (in both directions) with Series will raise\r\n s = Series([\"b\", \"b\", \"b\"])\r\n msg = (\r\n \"Cannot compare a Categorical for op __gt__ with type \"\r\n r\"<class 'numpy\\.ndarray'>\"\r\n )\r\n with pytest.raises(TypeError, match=msg):\r\n cat > s\r\n with pytest.raises(TypeError, match=msg):\r\n cat_rev > s\r\n with pytest.raises(TypeError, match=msg):\r\n s < cat\r\n with pytest.raises(TypeError, match=msg):\r\n s < cat_rev\r\n\r\n # comparison with numpy.array will raise in both direction, but only on\r\n # newer numpy versions\r\n a = np.array([\"b\", \"b\", \"b\"])\r\n with pytest.raises(TypeError, match=msg):\r\n cat > a\r\n with pytest.raises(TypeError, match=msg):\r\n cat_rev > a\r\n\r\n # Make sure that unequal comparison take the categories order in\r\n # account\r\n cat_rev = Categorical(list(\"abc\"), categories=list(\"cba\"), ordered=True)\r\n exp = np.array([True, False, False])\r\n res = cat_rev > \"b\"\r\n tm.assert_numpy_array_equal(res, exp)\r\n\r\n # check that zero-dim array gets unboxed\r\n res = cat_rev > np.array(\"b\")\r\n tm.assert_numpy_array_equal(res, exp)\r\n\r\n\r\nclass TestCategoricalOps:\r\n def test_compare_frame(self):\r\n # GH#24282 check that Categorical.__cmp__(DataFrame) defers to frame\r\n data = [\"a\", \"b\", 2, \"a\"]\r\n cat = Categorical(data)\r\n\r\n df = DataFrame(cat)\r\n\r\n result = cat == df.T\r\n expected = DataFrame([[True, True, True, True]])\r\n tm.assert_frame_equal(result, expected)\r\n\r\n result = cat[::-1] != df.T\r\n expected = DataFrame([[False, True, True, False]])\r\n tm.assert_frame_equal(result, expected)\r\n\r\n def test_compare_frame_raises(self, all_compare_operators):\r\n # alignment raises unless we transpose\r\n op = getattr(operator, all_compare_operators)\r\n cat = Categorical([\"a\", \"b\", 2, \"a\"])\r\n df = DataFrame(cat)\r\n msg = \"Unable to coerce to Series, length must be 1: given 4\"\r\n with pytest.raises(ValueError, match=msg):\r\n op(cat, df)\r\n\r\n def test_datetime_categorical_comparison(self):\r\n dt_cat = Categorical(date_range(\"2014-01-01\", periods=3), ordered=True)\r\n tm.assert_numpy_array_equal(dt_cat > dt_cat[0], np.array([False, True, True]))\r\n tm.assert_numpy_array_equal(dt_cat[0] < dt_cat, np.array([False, True, True]))\r\n\r\n def test_reflected_comparison_with_scalars(self):\r\n # GH8658\r\n cat = Categorical([1, 2, 3], ordered=True)\r\n tm.assert_numpy_array_equal(cat > cat[0], np.array([False, True, True]))\r\n tm.assert_numpy_array_equal(cat[0] < cat, np.array([False, True, True]))\r\n\r\n def test_comparison_with_unknown_scalars(self):\r\n # https://github.com/pandas-dev/pandas/issues/9836#issuecomment-92123057\r\n # and following comparisons with scalars not in categories should raise\r\n # for unequal comps, but not for equal/not equal\r\n cat = Categorical([1, 2, 3], ordered=True)\r\n\r\n msg = \"Invalid comparison between dtype=category and int\"\r\n with pytest.raises(TypeError, match=msg):\r\n cat < 4\r\n with pytest.raises(TypeError, match=msg):\r\n cat > 4\r\n with pytest.raises(TypeError, match=msg):\r\n 4 < cat\r\n with pytest.raises(TypeError, match=msg):\r\n 4 > cat\r\n\r\n tm.assert_numpy_array_equal(cat == 4, np.array([False, False, False]))\r\n tm.assert_numpy_array_equal(cat != 4, np.array([True, True, True]))\r\n\r\n def test_comparison_with_tuple(self):\r\n cat = Categorical(np.array([\"foo\", (0, 1), 3, (0, 1)], dtype=object))\r\n\r\n result = cat == \"foo\"\r\n expected = np.array([True, False, False, False], dtype=bool)\r\n tm.assert_numpy_array_equal(result, expected)\r\n\r\n result = cat == (0, 1)\r\n expected = np.array([False, True, False, True], dtype=bool)\r\n tm.assert_numpy_array_equal(result, expected)\r\n\r\n result = cat != (0, 1)\r\n tm.assert_numpy_array_equal(result, ~expected)\r\n\r\n def test_comparison_of_ordered_categorical_with_nan_to_scalar(\r\n self, compare_operators_no_eq_ne\r\n ):\r\n # https://github.com/pandas-dev/pandas/issues/26504\r\n # BUG: fix ordered categorical comparison with missing values (#26504 )\r\n # and following comparisons with scalars in categories with missing\r\n # values should be evaluated as False\r\n\r\n cat = Categorical([1, 2, 3, None], categories=[1, 2, 3], ordered=True)\r\n scalar = 2\r\n with warnings.catch_warnings():\r\n warnings.simplefilter(\"ignore\", RuntimeWarning)\r\n expected = getattr(np.array(cat), compare_operators_no_eq_ne)(scalar)\r\n actual = getattr(cat, compare_operators_no_eq_ne)(scalar)\r\n tm.assert_numpy_array_equal(actual, expected)\r\n\r\n def test_comparison_of_ordered_categorical_with_nan_to_listlike(\r\n self, compare_operators_no_eq_ne\r\n ):\r\n # https://github.com/pandas-dev/pandas/issues/26504\r\n # and following comparisons of missing values in ordered Categorical\r\n # with listlike should be evaluated as False\r\n\r\n cat = Categorical([1, 2, 3, None], categories=[1, 2, 3], ordered=True)\r\n other = Categorical([2, 2, 2, 2], categories=[1, 2, 3], ordered=True)\r\n with warnings.catch_warnings():\r\n warnings.simplefilter(\"ignore\", RuntimeWarning)\r\n expected = getattr(np.array(cat), compare_operators_no_eq_ne)(2)\r\n actual = getattr(cat, compare_operators_no_eq_ne)(other)\r\n tm.assert_numpy_array_equal(actual, expected)\r\n\r\n @pytest.mark.parametrize(\r\n \"data,reverse,base\",\r\n [(list(\"abc\"), list(\"cba\"), list(\"bbb\")), ([1, 2, 3], [3, 2, 1], [2, 2, 2])],\r\n )\r\n def test_comparisons(self, data, reverse, base):\r\n cat_rev = Series(Categorical(data, categories=reverse, ordered=True))\r\n cat_rev_base = Series(Categorical(base, categories=reverse, ordered=True))\r\n cat = Series(Categorical(data, ordered=True))\r\n cat_base = Series(\r\n Categorical(base, categories=cat.cat.categories, ordered=True)\r\n )\r\n s = Series(base)\r\n a = np.array(base)\r\n\r\n # comparisons need to take categories ordering into account\r\n res_rev = cat_rev > cat_rev_base\r\n exp_rev = Series([True, False, False])\r\n tm.assert_series_equal(res_rev, exp_rev)\r\n\r\n res_rev = cat_rev < cat_rev_base\r\n exp_rev = Series([False, False, True])\r\n tm.assert_series_equal(res_rev, exp_rev)\r\n\r\n res = cat > cat_base\r\n exp = Series([False, False, True])\r\n tm.assert_series_equal(res, exp)\r\n\r\n scalar = base[1]\r\n res = cat > scalar\r\n exp = Series([False, False, True])\r\n exp2 = cat.values > scalar\r\n tm.assert_series_equal(res, exp)\r\n tm.assert_numpy_array_equal(res.values, exp2)\r\n res_rev = cat_rev > scalar\r\n exp_rev = Series([True, False, False])\r\n exp_rev2 = cat_rev.values > scalar\r\n tm.assert_series_equal(res_rev, exp_rev)\r\n tm.assert_numpy_array_equal(res_rev.values, exp_rev2)\r\n\r\n # Only categories with same categories can be compared\r\n msg = \"Categoricals can only be compared if 'categories' are the same\"\r\n with pytest.raises(TypeError, match=msg):\r\n cat > cat_rev\r\n\r\n # categorical cannot be compared to Series or numpy array, and also\r\n # not the other way around\r\n msg = (\r\n \"Cannot compare a Categorical for op __gt__ with type \"\r\n r\"<class 'numpy\\.ndarray'>\"\r\n )\r\n with pytest.raises(TypeError, match=msg):\r\n cat > s\r\n with pytest.raises(TypeError, match=msg):\r\n cat_rev > s\r\n with pytest.raises(TypeError, match=msg):\r\n cat > a\r\n with pytest.raises(TypeError, match=msg):\r\n cat_rev > a\r\n\r\n with pytest.raises(TypeError, match=msg):\r\n s < cat\r\n with pytest.raises(TypeError, match=msg):\r\n s < cat_rev\r\n\r\n with pytest.raises(TypeError, match=msg):\r\n a < cat\r\n with pytest.raises(TypeError, match=msg):\r\n a < cat_rev\r\n\r\n @pytest.mark.parametrize(\r\n \"ctor\",\r\n [\r\n lambda *args, **kwargs: Categorical(*args, **kwargs),\r\n lambda *args, **kwargs: Series(Categorical(*args, **kwargs)),\r\n ],\r\n )\r\n def test_unordered_different_order_equal(self, ctor):\r\n # https://github.com/pandas-dev/pandas/issues/16014\r\n c1 = ctor([\"a\", \"b\"], categories=[\"a\", \"b\"], ordered=False)\r\n c2 = ctor([\"a\", \"b\"], categories=[\"b\", \"a\"], ordered=False)\r\n assert (c1 == c2).all()\r\n\r\n c1 = ctor([\"a\", \"b\"], categories=[\"a\", \"b\"], ordered=False)\r\n c2 = ctor([\"b\", \"a\"], categories=[\"b\", \"a\"], ordered=False)\r\n assert (c1 != c2).all()\r\n\r\n c1 = ctor([\"a\", \"a\"], categories=[\"a\", \"b\"], ordered=False)\r\n c2 = ctor([\"b\", \"b\"], categories=[\"b\", \"a\"], ordered=False)\r\n assert (c1 != c2).all()\r\n\r\n c1 = ctor([\"a\", \"a\"], categories=[\"a\", \"b\"], ordered=False)\r\n c2 = ctor([\"a\", \"b\"], categories=[\"b\", \"a\"], ordered=False)\r\n result = c1 == c2\r\n tm.assert_numpy_array_equal(np.array(result), np.array([True, False]))\r\n\r\n def test_unordered_different_categories_raises(self):\r\n c1 = Categorical([\"a\", \"b\"], categories=[\"a\", \"b\"], ordered=False)\r\n c2 = Categorical([\"a\", \"c\"], categories=[\"c\", \"a\"], ordered=False)\r\n\r\n with pytest.raises(TypeError, match=(\"Categoricals can only be compared\")):\r\n c1 == c2\r\n\r\n def test_compare_different_lengths(self):\r\n c1 = Categorical([], categories=[\"a\", \"b\"])\r\n c2 = Categorical([], categories=[\"a\"])\r\n\r\n msg = \"Categoricals can only be compared if 'categories' are the same.\"\r\n with pytest.raises(TypeError, match=msg):\r\n c1 == c2\r\n\r\n def test_compare_unordered_different_order(self):\r\n # https://github.com/pandas-dev/pandas/issues/16603#issuecomment-\r\n # 349290078\r\n a = Categorical([\"a\"], categories=[\"a\", \"b\"])\r\n b = Categorical([\"b\"], categories=[\"b\", \"a\"])\r\n assert not a.equals(b)\r\n\r\n def test_numeric_like_ops(self):\r\n\r\n df = DataFrame({\"value\": np.random.randint(0, 10000, 100)})\r\n labels = [f\"{i} - {i + 499}\" for i in range(0, 10000, 500)]\r\n cat_labels = Categorical(labels, labels)\r\n\r\n df = df.sort_values(by=[\"value\"], ascending=True)\r\n df[\"value_group\"] = pd.cut(\r\n df.value, range(0, 10500, 500), right=False, labels=cat_labels\r\n )\r\n\r\n # numeric ops should not succeed\r\n for op, str_rep in [\r\n (\"__add__\", r\"\\+\"),\r\n (\"__sub__\", \"-\"),\r\n (\"__mul__\", r\"\\*\"),\r\n (\"__truediv__\", \"/\"),\r\n ]:\r\n msg = f\"Series cannot perform the operation {str_rep}|unsupported operand\"\r\n with pytest.raises(TypeError, match=msg):\r\n getattr(df, op)(df)\r\n\r\n # reduction ops should not succeed (unless specifically defined, e.g.\r\n # min/max)\r\n s = df[\"value_group\"]\r\n for op in [\"kurt\", \"skew\", \"var\", \"std\", \"mean\", \"sum\", \"median\"]:\r\n msg = f\"'Categorical' does not implement reduction '{op}'\"\r\n with pytest.raises(TypeError, match=msg):\r\n getattr(s, op)(numeric_only=False)\r\n\r\n # mad technically works because it takes always the numeric data\r\n\r\n # numpy ops\r\n s = Series(Categorical([1, 2, 3, 4]))\r\n with pytest.raises(\r\n TypeError, match=\"'Categorical' does not implement reduction 'sum'\"\r\n ):\r\n np.sum(s)\r\n\r\n # numeric ops on a Series\r\n for op, str_rep in [\r\n (\"__add__\", r\"\\+\"),\r\n (\"__sub__\", \"-\"),\r\n (\"__mul__\", r\"\\*\"),\r\n (\"__truediv__\", \"/\"),\r\n ]:\r\n msg = f\"Series cannot perform the operation {str_rep}|unsupported operand\"\r\n with pytest.raises(TypeError, match=msg):\r\n getattr(s, op)(2)\r\n\r\n # invalid ufunc\r\n msg = \"Object with dtype category cannot perform the numpy op log\"\r\n with pytest.raises(TypeError, match=msg):\r\n np.log(s)\r\n",
"import numpy as np\r\nimport pytest\r\n\r\nimport pandas as pd\r\nfrom pandas import DataFrame\r\nimport pandas._testing as tm\r\n\r\n\r\nclass TestDataFrameFilter:\r\n def test_filter(self, float_frame, float_string_frame):\r\n # Items\r\n filtered = float_frame.filter([\"A\", \"B\", \"E\"])\r\n assert len(filtered.columns) == 2\r\n assert \"E\" not in filtered\r\n\r\n filtered = float_frame.filter([\"A\", \"B\", \"E\"], axis=\"columns\")\r\n assert len(filtered.columns) == 2\r\n assert \"E\" not in filtered\r\n\r\n # Other axis\r\n idx = float_frame.index[0:4]\r\n filtered = float_frame.filter(idx, axis=\"index\")\r\n expected = float_frame.reindex(index=idx)\r\n tm.assert_frame_equal(filtered, expected)\r\n\r\n # like\r\n fcopy = float_frame.copy()\r\n fcopy[\"AA\"] = 1\r\n\r\n filtered = fcopy.filter(like=\"A\")\r\n assert len(filtered.columns) == 2\r\n assert \"AA\" in filtered\r\n\r\n # like with ints in column names\r\n df = DataFrame(0.0, index=[0, 1, 2], columns=[0, 1, \"_A\", \"_B\"])\r\n filtered = df.filter(like=\"_\")\r\n assert len(filtered.columns) == 2\r\n\r\n # regex with ints in column names\r\n # from PR #10384\r\n df = DataFrame(0.0, index=[0, 1, 2], columns=[\"A1\", 1, \"B\", 2, \"C\"])\r\n expected = DataFrame(\r\n 0.0, index=[0, 1, 2], columns=pd.Index([1, 2], dtype=object)\r\n )\r\n filtered = df.filter(regex=\"^[0-9]+$\")\r\n tm.assert_frame_equal(filtered, expected)\r\n\r\n expected = DataFrame(0.0, index=[0, 1, 2], columns=[0, \"0\", 1, \"1\"])\r\n # shouldn't remove anything\r\n filtered = expected.filter(regex=\"^[0-9]+$\")\r\n tm.assert_frame_equal(filtered, expected)\r\n\r\n # pass in None\r\n with pytest.raises(TypeError, match=\"Must pass\"):\r\n float_frame.filter()\r\n with pytest.raises(TypeError, match=\"Must pass\"):\r\n float_frame.filter(items=None)\r\n with pytest.raises(TypeError, match=\"Must pass\"):\r\n float_frame.filter(axis=1)\r\n\r\n # test mutually exclusive arguments\r\n with pytest.raises(TypeError, match=\"mutually exclusive\"):\r\n float_frame.filter(items=[\"one\", \"three\"], regex=\"e$\", like=\"bbi\")\r\n with pytest.raises(TypeError, match=\"mutually exclusive\"):\r\n float_frame.filter(items=[\"one\", \"three\"], regex=\"e$\", axis=1)\r\n with pytest.raises(TypeError, match=\"mutually exclusive\"):\r\n float_frame.filter(items=[\"one\", \"three\"], regex=\"e$\")\r\n with pytest.raises(TypeError, match=\"mutually exclusive\"):\r\n float_frame.filter(items=[\"one\", \"three\"], like=\"bbi\", axis=0)\r\n with pytest.raises(TypeError, match=\"mutually exclusive\"):\r\n float_frame.filter(items=[\"one\", \"three\"], like=\"bbi\")\r\n\r\n # objects\r\n filtered = float_string_frame.filter(like=\"foo\")\r\n assert \"foo\" in filtered\r\n\r\n # unicode columns, won't ascii-encode\r\n df = float_frame.rename(columns={\"B\": \"\\u2202\"})\r\n filtered = df.filter(like=\"C\")\r\n assert \"C\" in filtered\r\n\r\n def test_filter_regex_search(self, float_frame):\r\n fcopy = float_frame.copy()\r\n fcopy[\"AA\"] = 1\r\n\r\n # regex\r\n filtered = fcopy.filter(regex=\"[A]+\")\r\n assert len(filtered.columns) == 2\r\n assert \"AA\" in filtered\r\n\r\n # doesn't have to be at beginning\r\n df = DataFrame(\r\n {\"aBBa\": [1, 2], \"BBaBB\": [1, 2], \"aCCa\": [1, 2], \"aCCaBB\": [1, 2]}\r\n )\r\n\r\n result = df.filter(regex=\"BB\")\r\n exp = df[[x for x in df.columns if \"BB\" in x]]\r\n tm.assert_frame_equal(result, exp)\r\n\r\n @pytest.mark.parametrize(\r\n \"name,expected\",\r\n [\r\n (\"a\", DataFrame({\"a\": [1, 2]})),\r\n (\"a\", DataFrame({\"a\": [1, 2]})),\r\n (\"あ\", DataFrame({\"あ\": [3, 4]})),\r\n ],\r\n )\r\n def test_filter_unicode(self, name, expected):\r\n # GH13101\r\n df = DataFrame({\"a\": [1, 2], \"あ\": [3, 4]})\r\n\r\n tm.assert_frame_equal(df.filter(like=name), expected)\r\n tm.assert_frame_equal(df.filter(regex=name), expected)\r\n\r\n @pytest.mark.parametrize(\"name\", [\"a\", \"a\"])\r\n def test_filter_bytestring(self, name):\r\n # GH13101\r\n df = DataFrame({b\"a\": [1, 2], b\"b\": [3, 4]})\r\n expected = DataFrame({b\"a\": [1, 2]})\r\n\r\n tm.assert_frame_equal(df.filter(like=name), expected)\r\n tm.assert_frame_equal(df.filter(regex=name), expected)\r\n\r\n def test_filter_corner(self):\r\n empty = DataFrame()\r\n\r\n result = empty.filter([])\r\n tm.assert_frame_equal(result, empty)\r\n\r\n result = empty.filter(like=\"foo\")\r\n tm.assert_frame_equal(result, empty)\r\n\r\n def test_filter_regex_non_string(self):\r\n # GH#5798 trying to filter on non-string columns should drop,\r\n # not raise\r\n df = DataFrame(np.random.random((3, 2)), columns=[\"STRING\", 123])\r\n result = df.filter(regex=\"STRING\")\r\n expected = df[[\"STRING\"]]\r\n tm.assert_frame_equal(result, expected)\r\n",
"\"\"\"Base classes for all estimators.\"\"\"\r\n\r\n# Author: Gael Varoquaux <[email protected]>\r\n# License: BSD 3 clause\r\n\r\nimport copy\r\nimport warnings\r\nfrom collections import defaultdict\r\nimport platform\r\nimport inspect\r\nimport re\r\n\r\nimport numpy as np\r\n\r\nfrom . import __version__\r\nfrom ._config import get_config\r\nfrom .utils import _IS_32BIT\r\nfrom .utils._tags import (\r\n _DEFAULT_TAGS,\r\n _safe_tags,\r\n)\r\nfrom .utils.validation import check_X_y\r\nfrom .utils.validation import check_array\r\nfrom .utils.validation import _check_y\r\nfrom .utils.validation import _num_features\r\nfrom .utils.validation import _check_feature_names_in\r\nfrom .utils._estimator_html_repr import estimator_html_repr\r\nfrom .utils.validation import _get_feature_names\r\n\r\n\r\ndef clone(estimator, *, safe=True):\r\n \"\"\"Constructs a new unfitted estimator with the same parameters.\r\n\r\n Clone does a deep copy of the model in an estimator\r\n without actually copying attached data. It yields a new estimator\r\n with the same parameters that has not been fitted on any data.\r\n\r\n If the estimator's `random_state` parameter is an integer (or if the\r\n estimator doesn't have a `random_state` parameter), an *exact clone* is\r\n returned: the clone and the original estimator will give the exact same\r\n results. Otherwise, *statistical clone* is returned: the clone might\r\n yield different results from the original estimator. More details can be\r\n found in :ref:`randomness`.\r\n\r\n Parameters\r\n ----------\r\n estimator : {list, tuple, set} of estimator instance or a single \\\r\n estimator instance\r\n The estimator or group of estimators to be cloned.\r\n\r\n safe : bool, default=True\r\n If safe is False, clone will fall back to a deep copy on objects\r\n that are not estimators.\r\n\r\n \"\"\"\r\n estimator_type = type(estimator)\r\n # XXX: not handling dictionaries\r\n if estimator_type in (list, tuple, set, frozenset):\r\n return estimator_type([clone(e, safe=safe) for e in estimator])\r\n elif not hasattr(estimator, \"get_params\") or isinstance(estimator, type):\r\n if not safe:\r\n return copy.deepcopy(estimator)\r\n else:\r\n if isinstance(estimator, type):\r\n raise TypeError(\r\n \"Cannot clone object. \"\r\n + \"You should provide an instance of \"\r\n + \"scikit-learn estimator instead of a class.\"\r\n )\r\n else:\r\n raise TypeError(\r\n \"Cannot clone object '%s' (type %s): \"\r\n \"it does not seem to be a scikit-learn \"\r\n \"estimator as it does not implement a \"\r\n \"'get_params' method.\" % (repr(estimator), type(estimator))\r\n )\r\n\r\n klass = estimator.__class__\r\n new_object_params = estimator.get_params(deep=False)\r\n for name, param in new_object_params.items():\r\n new_object_params[name] = clone(param, safe=False)\r\n new_object = klass(**new_object_params)\r\n params_set = new_object.get_params(deep=False)\r\n\r\n # quick sanity check of the parameters of the clone\r\n for name in new_object_params:\r\n param1 = new_object_params[name]\r\n param2 = params_set[name]\r\n if param1 is not param2:\r\n raise RuntimeError(\r\n \"Cannot clone object %s, as the constructor \"\r\n \"either does not set or modifies parameter %s\" % (estimator, name)\r\n )\r\n return new_object\r\n\r\n\r\ndef _pprint(params, offset=0, printer=repr):\r\n \"\"\"Pretty print the dictionary 'params'\r\n\r\n Parameters\r\n ----------\r\n params : dict\r\n The dictionary to pretty print\r\n\r\n offset : int, default=0\r\n The offset in characters to add at the begin of each line.\r\n\r\n printer : callable, default=repr\r\n The function to convert entries to strings, typically\r\n the builtin str or repr\r\n\r\n \"\"\"\r\n # Do a multi-line justified repr:\r\n options = np.get_printoptions()\r\n np.set_printoptions(precision=5, threshold=64, edgeitems=2)\r\n params_list = list()\r\n this_line_length = offset\r\n line_sep = \",\\n\" + (1 + offset // 2) * \" \"\r\n for i, (k, v) in enumerate(sorted(params.items())):\r\n if type(v) is float:\r\n # use str for representing floating point numbers\r\n # this way we get consistent representation across\r\n # architectures and versions.\r\n this_repr = \"%s=%s\" % (k, str(v))\r\n else:\r\n # use repr of the rest\r\n this_repr = \"%s=%s\" % (k, printer(v))\r\n if len(this_repr) > 500:\r\n this_repr = this_repr[:300] + \"...\" + this_repr[-100:]\r\n if i > 0:\r\n if this_line_length + len(this_repr) >= 75 or \"\\n\" in this_repr:\r\n params_list.append(line_sep)\r\n this_line_length = len(line_sep)\r\n else:\r\n params_list.append(\", \")\r\n this_line_length += 2\r\n params_list.append(this_repr)\r\n this_line_length += len(this_repr)\r\n\r\n np.set_printoptions(**options)\r\n lines = \"\".join(params_list)\r\n # Strip trailing space to avoid nightmare in doctests\r\n lines = \"\\n\".join(l.rstrip(\" \") for l in lines.split(\"\\n\"))\r\n return lines\r\n\r\n\r\nclass BaseEstimator:\r\n \"\"\"Base class for all estimators in scikit-learn.\r\n\r\n Notes\r\n -----\r\n All estimators should specify all the parameters that can be set\r\n at the class level in their ``__init__`` as explicit keyword\r\n arguments (no ``*args`` or ``**kwargs``).\r\n \"\"\"\r\n\r\n @classmethod\r\n def _get_param_names(cls):\r\n \"\"\"Get parameter names for the estimator\"\"\"\r\n # fetch the constructor or the original constructor before\r\n # deprecation wrapping if any\r\n init = getattr(cls.__init__, \"deprecated_original\", cls.__init__)\r\n if init is object.__init__:\r\n # No explicit constructor to introspect\r\n return []\r\n\r\n # introspect the constructor arguments to find the model parameters\r\n # to represent\r\n init_signature = inspect.signature(init)\r\n # Consider the constructor parameters excluding 'self'\r\n parameters = [\r\n p\r\n for p in init_signature.parameters.values()\r\n if p.name != \"self\" and p.kind != p.VAR_KEYWORD\r\n ]\r\n for p in parameters:\r\n if p.kind == p.VAR_POSITIONAL:\r\n raise RuntimeError(\r\n \"scikit-learn estimators should always \"\r\n \"specify their parameters in the signature\"\r\n \" of their __init__ (no varargs).\"\r\n \" %s with constructor %s doesn't \"\r\n \" follow this convention.\" % (cls, init_signature)\r\n )\r\n # Extract and sort argument names excluding 'self'\r\n return sorted([p.name for p in parameters])\r\n\r\n def get_params(self, deep=True):\r\n \"\"\"\r\n Get parameters for this estimator.\r\n\r\n Parameters\r\n ----------\r\n deep : bool, default=True\r\n If True, will return the parameters for this estimator and\r\n contained subobjects that are estimators.\r\n\r\n Returns\r\n -------\r\n params : dict\r\n Parameter names mapped to their values.\r\n \"\"\"\r\n out = dict()\r\n for key in self._get_param_names():\r\n value = getattr(self, key)\r\n if deep and hasattr(value, \"get_params\"):\r\n deep_items = value.get_params().items()\r\n out.update((key + \"__\" + k, val) for k, val in deep_items)\r\n out[key] = value\r\n return out\r\n\r\n def set_params(self, **params):\r\n \"\"\"\r\n Set the parameters of this estimator.\r\n\r\n The method works on simple estimators as well as on nested objects\r\n (such as :class:`~sklearn.pipeline.Pipeline`). The latter have\r\n parameters of the form ``<component>__<parameter>`` so that it's\r\n possible to update each component of a nested object.\r\n\r\n Parameters\r\n ----------\r\n **params : dict\r\n Estimator parameters.\r\n\r\n Returns\r\n -------\r\n self : estimator instance\r\n Estimator instance.\r\n \"\"\"\r\n if not params:\r\n # Simple optimization to gain speed (inspect is slow)\r\n return self\r\n valid_params = self.get_params(deep=True)\r\n\r\n nested_params = defaultdict(dict) # grouped by prefix\r\n for key, value in params.items():\r\n key, delim, sub_key = key.partition(\"__\")\r\n if key not in valid_params:\r\n raise ValueError(\r\n \"Invalid parameter %s for estimator %s. \"\r\n \"Check the list of available parameters \"\r\n \"with `estimator.get_params().keys()`.\" % (key, self)\r\n )\r\n\r\n if delim:\r\n nested_params[key][sub_key] = value\r\n else:\r\n setattr(self, key, value)\r\n valid_params[key] = value\r\n\r\n for key, sub_params in nested_params.items():\r\n valid_params[key].set_params(**sub_params)\r\n\r\n return self\r\n\r\n def __repr__(self, N_CHAR_MAX=700):\r\n # N_CHAR_MAX is the (approximate) maximum number of non-blank\r\n # characters to render. We pass it as an optional parameter to ease\r\n # the tests.\r\n\r\n from .utils._pprint import _EstimatorPrettyPrinter\r\n\r\n N_MAX_ELEMENTS_TO_SHOW = 30 # number of elements to show in sequences\r\n\r\n # use ellipsis for sequences with a lot of elements\r\n pp = _EstimatorPrettyPrinter(\r\n compact=True,\r\n indent=1,\r\n indent_at_name=True,\r\n n_max_elements_to_show=N_MAX_ELEMENTS_TO_SHOW,\r\n )\r\n\r\n repr_ = pp.pformat(self)\r\n\r\n # Use bruteforce ellipsis when there are a lot of non-blank characters\r\n n_nonblank = len(\"\".join(repr_.split()))\r\n if n_nonblank > N_CHAR_MAX:\r\n lim = N_CHAR_MAX // 2 # apprx number of chars to keep on both ends\r\n regex = r\"^(\\s*\\S){%d}\" % lim\r\n # The regex '^(\\s*\\S){%d}' % n\r\n # matches from the start of the string until the nth non-blank\r\n # character:\r\n # - ^ matches the start of string\r\n # - (pattern){n} matches n repetitions of pattern\r\n # - \\s*\\S matches a non-blank char following zero or more blanks\r\n left_lim = re.match(regex, repr_).end()\r\n right_lim = re.match(regex, repr_[::-1]).end()\r\n\r\n if \"\\n\" in repr_[left_lim:-right_lim]:\r\n # The left side and right side aren't on the same line.\r\n # To avoid weird cuts, e.g.:\r\n # categoric...ore',\r\n # we need to start the right side with an appropriate newline\r\n # character so that it renders properly as:\r\n # categoric...\r\n # handle_unknown='ignore',\r\n # so we add [^\\n]*\\n which matches until the next \\n\r\n regex += r\"[^\\n]*\\n\"\r\n right_lim = re.match(regex, repr_[::-1]).end()\r\n\r\n ellipsis = \"...\"\r\n if left_lim + len(ellipsis) < len(repr_) - right_lim:\r\n # Only add ellipsis if it results in a shorter repr\r\n repr_ = repr_[:left_lim] + \"...\" + repr_[-right_lim:]\r\n\r\n return repr_\r\n\r\n def __getstate__(self):\r\n try:\r\n state = super().__getstate__()\r\n except AttributeError:\r\n state = self.__dict__.copy()\r\n\r\n if type(self).__module__.startswith(\"sklearn.\"):\r\n return dict(state.items(), _sklearn_version=__version__)\r\n else:\r\n return state\r\n\r\n def __setstate__(self, state):\r\n if type(self).__module__.startswith(\"sklearn.\"):\r\n pickle_version = state.pop(\"_sklearn_version\", \"pre-0.18\")\r\n if pickle_version != __version__:\r\n warnings.warn(\r\n \"Trying to unpickle estimator {0} from version {1} when \"\r\n \"using version {2}. This might lead to breaking code or \"\r\n \"invalid results. Use at your own risk. \"\r\n \"For more info please refer to:\\n\"\r\n \"https://scikit-learn.org/stable/modules/model_persistence\"\r\n \".html#security-maintainability-limitations\".format(\r\n self.__class__.__name__, pickle_version, __version__\r\n ),\r\n UserWarning,\r\n )\r\n try:\r\n super().__setstate__(state)\r\n except AttributeError:\r\n self.__dict__.update(state)\r\n\r\n def _more_tags(self):\r\n return _DEFAULT_TAGS\r\n\r\n def _get_tags(self):\r\n collected_tags = {}\r\n for base_class in reversed(inspect.getmro(self.__class__)):\r\n if hasattr(base_class, \"_more_tags\"):\r\n # need the if because mixins might not have _more_tags\r\n # but might do redundant work in estimators\r\n # (i.e. calling more tags on BaseEstimator multiple times)\r\n more_tags = base_class._more_tags(self)\r\n collected_tags.update(more_tags)\r\n return collected_tags\r\n\r\n def _check_n_features(self, X, reset):\r\n \"\"\"Set the `n_features_in_` attribute, or check against it.\r\n\r\n Parameters\r\n ----------\r\n X : {ndarray, sparse matrix} of shape (n_samples, n_features)\r\n The input samples.\r\n reset : bool\r\n If True, the `n_features_in_` attribute is set to `X.shape[1]`.\r\n If False and the attribute exists, then check that it is equal to\r\n `X.shape[1]`. If False and the attribute does *not* exist, then\r\n the check is skipped.\r\n .. note::\r\n It is recommended to call reset=True in `fit` and in the first\r\n call to `partial_fit`. All other methods that validate `X`\r\n should set `reset=False`.\r\n \"\"\"\r\n try:\r\n n_features = _num_features(X)\r\n except TypeError as e:\r\n if not reset and hasattr(self, \"n_features_in_\"):\r\n raise ValueError(\r\n \"X does not contain any features, but \"\r\n f\"{self.__class__.__name__} is expecting \"\r\n f\"{self.n_features_in_} features\"\r\n ) from e\r\n # If the number of features is not defined and reset=True,\r\n # then we skip this check\r\n return\r\n\r\n if reset:\r\n self.n_features_in_ = n_features\r\n return\r\n\r\n if not hasattr(self, \"n_features_in_\"):\r\n # Skip this check if the expected number of expected input features\r\n # was not recorded by calling fit first. This is typically the case\r\n # for stateless transformers.\r\n return\r\n\r\n if n_features != self.n_features_in_:\r\n raise ValueError(\r\n f\"X has {n_features} features, but {self.__class__.__name__} \"\r\n f\"is expecting {self.n_features_in_} features as input.\"\r\n )\r\n\r\n def _check_feature_names(self, X, *, reset):\r\n \"\"\"Set or check the `feature_names_in_` attribute.\r\n\r\n .. versionadded:: 1.0\r\n\r\n Parameters\r\n ----------\r\n X : {ndarray, dataframe} of shape (n_samples, n_features)\r\n The input samples.\r\n\r\n reset : bool\r\n Whether to reset the `feature_names_in_` attribute.\r\n If False, the input will be checked for consistency with\r\n feature names of data provided when reset was last True.\r\n .. note::\r\n It is recommended to call `reset=True` in `fit` and in the first\r\n call to `partial_fit`. All other methods that validate `X`\r\n should set `reset=False`.\r\n \"\"\"\r\n\r\n if reset:\r\n feature_names_in = _get_feature_names(X)\r\n if feature_names_in is not None:\r\n self.feature_names_in_ = feature_names_in\r\n elif hasattr(self, \"feature_names_in_\"):\r\n # Delete the attribute when the estimator is fitted on a new dataset\r\n # that has no feature names.\r\n delattr(self, \"feature_names_in_\")\r\n return\r\n\r\n fitted_feature_names = getattr(self, \"feature_names_in_\", None)\r\n X_feature_names = _get_feature_names(X)\r\n\r\n if fitted_feature_names is None and X_feature_names is None:\r\n # no feature names seen in fit and in X\r\n return\r\n\r\n if X_feature_names is not None and fitted_feature_names is None:\r\n warnings.warn(\r\n f\"X has feature names, but {self.__class__.__name__} was fitted without\"\r\n \" feature names\"\r\n )\r\n return\r\n\r\n if X_feature_names is None and fitted_feature_names is not None:\r\n warnings.warn(\r\n \"X does not have valid feature names, but\"\r\n f\" {self.__class__.__name__} was fitted with feature names\"\r\n )\r\n return\r\n\r\n # validate the feature names against the `feature_names_in_` attribute\r\n if len(fitted_feature_names) != len(X_feature_names) or np.any(\r\n fitted_feature_names != X_feature_names\r\n ):\r\n message = (\r\n \"The feature names should match those that were \"\r\n \"passed during fit. Starting version 1.2, an error will be raised.\\n\"\r\n )\r\n fitted_feature_names_set = set(fitted_feature_names)\r\n X_feature_names_set = set(X_feature_names)\r\n\r\n unexpected_names = sorted(X_feature_names_set - fitted_feature_names_set)\r\n missing_names = sorted(fitted_feature_names_set - X_feature_names_set)\r\n\r\n def add_names(names):\r\n output = \"\"\r\n max_n_names = 5\r\n for i, name in enumerate(names):\r\n if i >= max_n_names:\r\n output += \"- ...\\n\"\r\n break\r\n output += f\"- {name}\\n\"\r\n return output\r\n\r\n if unexpected_names:\r\n message += \"Feature names unseen at fit time:\\n\"\r\n message += add_names(unexpected_names)\r\n\r\n if missing_names:\r\n message += \"Feature names seen at fit time, yet now missing:\\n\"\r\n message += add_names(missing_names)\r\n\r\n if not missing_names and not missing_names:\r\n message += (\r\n \"Feature names must be in the same order as they were in fit.\\n\"\r\n )\r\n\r\n warnings.warn(message, FutureWarning)\r\n\r\n def _validate_data(\r\n self,\r\n X=\"no_validation\",\r\n y=\"no_validation\",\r\n reset=True,\r\n validate_separately=False,\r\n **check_params,\r\n ):\r\n \"\"\"Validate input data and set or check the `n_features_in_` attribute.\r\n\r\n Parameters\r\n ----------\r\n X : {array-like, sparse matrix, dataframe} of shape \\\r\n (n_samples, n_features), default='no validation'\r\n The input samples.\r\n If `'no_validation'`, no validation is performed on `X`. This is\r\n useful for meta-estimator which can delegate input validation to\r\n their underlying estimator(s). In that case `y` must be passed and\r\n the only accepted `check_params` are `multi_output` and\r\n `y_numeric`.\r\n\r\n y : array-like of shape (n_samples,), default='no_validation'\r\n The targets.\r\n\r\n - If `None`, `check_array` is called on `X`. If the estimator's\r\n requires_y tag is True, then an error will be raised.\r\n - If `'no_validation'`, `check_array` is called on `X` and the\r\n estimator's requires_y tag is ignored. This is a default\r\n placeholder and is never meant to be explicitly set. In that case\r\n `X` must be passed.\r\n - Otherwise, only `y` with `_check_y` or both `X` and `y` are\r\n checked with either `check_array` or `check_X_y` depending on\r\n `validate_separately`.\r\n\r\n reset : bool, default=True\r\n Whether to reset the `n_features_in_` attribute.\r\n If False, the input will be checked for consistency with data\r\n provided when reset was last True.\r\n .. note::\r\n It is recommended to call reset=True in `fit` and in the first\r\n call to `partial_fit`. All other methods that validate `X`\r\n should set `reset=False`.\r\n validate_separately : False or tuple of dicts, default=False\r\n Only used if y is not None.\r\n If False, call validate_X_y(). Else, it must be a tuple of kwargs\r\n to be used for calling check_array() on X and y respectively.\r\n **check_params : kwargs\r\n Parameters passed to :func:`sklearn.utils.check_array` or\r\n :func:`sklearn.utils.check_X_y`. Ignored if validate_separately\r\n is not False.\r\n\r\n Returns\r\n -------\r\n out : {ndarray, sparse matrix} or tuple of these\r\n The validated input. A tuple is returned if both `X` and `y` are\r\n validated.\r\n \"\"\"\r\n self._check_feature_names(X, reset=reset)\r\n\r\n if y is None and self._get_tags()[\"requires_y\"]:\r\n raise ValueError(\r\n f\"This {self.__class__.__name__} estimator \"\r\n \"requires y to be passed, but the target y is None.\"\r\n )\r\n\r\n no_val_X = isinstance(X, str) and X == \"no_validation\"\r\n no_val_y = y is None or isinstance(y, str) and y == \"no_validation\"\r\n\r\n if no_val_X and no_val_y:\r\n raise ValueError(\"Validation should be done on X, y or both.\")\r\n elif not no_val_X and no_val_y:\r\n X = check_array(X, **check_params)\r\n out = X\r\n elif no_val_X and not no_val_y:\r\n y = _check_y(y, **check_params)\r\n out = y\r\n else:\r\n if validate_separately:\r\n # We need this because some estimators validate X and y\r\n # separately, and in general, separately calling check_array()\r\n # on X and y isn't equivalent to just calling check_X_y()\r\n # :(\r\n check_X_params, check_y_params = validate_separately\r\n X = check_array(X, **check_X_params)\r\n y = check_array(y, **check_y_params)\r\n else:\r\n X, y = check_X_y(X, y, **check_params)\r\n out = X, y\r\n\r\n if not no_val_X and check_params.get(\"ensure_2d\", True):\r\n self._check_n_features(X, reset=reset)\r\n\r\n return out\r\n\r\n @property\r\n def _repr_html_(self):\r\n \"\"\"HTML representation of estimator.\r\n\r\n This is redundant with the logic of `_repr_mimebundle_`. The latter\r\n should be favorted in the long term, `_repr_html_` is only\r\n implemented for consumers who do not interpret `_repr_mimbundle_`.\r\n \"\"\"\r\n if get_config()[\"display\"] != \"diagram\":\r\n raise AttributeError(\r\n \"_repr_html_ is only defined when the \"\r\n \"'display' configuration option is set to \"\r\n \"'diagram'\"\r\n )\r\n return self._repr_html_inner\r\n\r\n def _repr_html_inner(self):\r\n \"\"\"This function is returned by the @property `_repr_html_` to make\r\n `hasattr(estimator, \"_repr_html_\") return `True` or `False` depending\r\n on `get_config()[\"display\"]`.\r\n \"\"\"\r\n return estimator_html_repr(self)\r\n\r\n def _repr_mimebundle_(self, **kwargs):\r\n \"\"\"Mime bundle used by jupyter kernels to display estimator\"\"\"\r\n output = {\"text/plain\": repr(self)}\r\n if get_config()[\"display\"] == \"diagram\":\r\n output[\"text/html\"] = estimator_html_repr(self)\r\n return output\r\n\r\n\r\nclass ClassifierMixin:\r\n \"\"\"Mixin class for all classifiers in scikit-learn.\"\"\"\r\n\r\n _estimator_type = \"classifier\"\r\n\r\n def score(self, X, y, sample_weight=None):\r\n \"\"\"\r\n Return the mean accuracy on the given test data and labels.\r\n\r\n In multi-label classification, this is the subset accuracy\r\n which is a harsh metric since you require for each sample that\r\n each label set be correctly predicted.\r\n\r\n Parameters\r\n ----------\r\n X : array-like of shape (n_samples, n_features)\r\n Test samples.\r\n\r\n y : array-like of shape (n_samples,) or (n_samples, n_outputs)\r\n True labels for `X`.\r\n\r\n sample_weight : array-like of shape (n_samples,), default=None\r\n Sample weights.\r\n\r\n Returns\r\n -------\r\n score : float\r\n Mean accuracy of ``self.predict(X)`` wrt. `y`.\r\n \"\"\"\r\n from .metrics import accuracy_score\r\n\r\n return accuracy_score(y, self.predict(X), sample_weight=sample_weight)\r\n\r\n def _more_tags(self):\r\n return {\"requires_y\": True}\r\n\r\n\r\nclass RegressorMixin:\r\n \"\"\"Mixin class for all regression estimators in scikit-learn.\"\"\"\r\n\r\n _estimator_type = \"regressor\"\r\n\r\n def score(self, X, y, sample_weight=None):\r\n \"\"\"Return the coefficient of determination of the prediction.\r\n\r\n The coefficient of determination :math:`R^2` is defined as\r\n :math:`(1 - \\\\frac{u}{v})`, where :math:`u` is the residual\r\n sum of squares ``((y_true - y_pred)** 2).sum()`` and :math:`v`\r\n is the total sum of squares ``((y_true - y_true.mean()) ** 2).sum()``.\r\n The best possible score is 1.0 and it can be negative (because the\r\n model can be arbitrarily worse). A constant model that always predicts\r\n the expected value of `y`, disregarding the input features, would get\r\n a :math:`R^2` score of 0.0.\r\n\r\n Parameters\r\n ----------\r\n X : array-like of shape (n_samples, n_features)\r\n Test samples. For some estimators this may be a precomputed\r\n kernel matrix or a list of generic objects instead with shape\r\n ``(n_samples, n_samples_fitted)``, where ``n_samples_fitted``\r\n is the number of samples used in the fitting for the estimator.\r\n\r\n y : array-like of shape (n_samples,) or (n_samples, n_outputs)\r\n True values for `X`.\r\n\r\n sample_weight : array-like of shape (n_samples,), default=None\r\n Sample weights.\r\n\r\n Returns\r\n -------\r\n score : float\r\n :math:`R^2` of ``self.predict(X)`` wrt. `y`.\r\n\r\n Notes\r\n -----\r\n The :math:`R^2` score used when calling ``score`` on a regressor uses\r\n ``multioutput='uniform_average'`` from version 0.23 to keep consistent\r\n with default value of :func:`~sklearn.metrics.r2_score`.\r\n This influences the ``score`` method of all the multioutput\r\n regressors (except for\r\n :class:`~sklearn.multioutput.MultiOutputRegressor`).\r\n \"\"\"\r\n\r\n from .metrics import r2_score\r\n\r\n y_pred = self.predict(X)\r\n return r2_score(y, y_pred, sample_weight=sample_weight)\r\n\r\n def _more_tags(self):\r\n return {\"requires_y\": True}\r\n\r\n\r\nclass ClusterMixin:\r\n \"\"\"Mixin class for all cluster estimators in scikit-learn.\"\"\"\r\n\r\n _estimator_type = \"clusterer\"\r\n\r\n def fit_predict(self, X, y=None):\r\n \"\"\"\r\n Perform clustering on `X` and returns cluster labels.\r\n\r\n Parameters\r\n ----------\r\n X : array-like of shape (n_samples, n_features)\r\n Input data.\r\n\r\n y : Ignored\r\n Not used, present for API consistency by convention.\r\n\r\n Returns\r\n -------\r\n labels : ndarray of shape (n_samples,), dtype=np.int64\r\n Cluster labels.\r\n \"\"\"\r\n # non-optimized default implementation; override when a better\r\n # method is possible for a given clustering algorithm\r\n self.fit(X)\r\n return self.labels_\r\n\r\n def _more_tags(self):\r\n return {\"preserves_dtype\": []}\r\n\r\n\r\nclass BiclusterMixin:\r\n \"\"\"Mixin class for all bicluster estimators in scikit-learn.\"\"\"\r\n\r\n @property\r\n def biclusters_(self):\r\n \"\"\"Convenient way to get row and column indicators together.\r\n\r\n Returns the ``rows_`` and ``columns_`` members.\r\n \"\"\"\r\n return self.rows_, self.columns_\r\n\r\n def get_indices(self, i):\r\n \"\"\"Row and column indices of the `i`'th bicluster.\r\n\r\n Only works if ``rows_`` and ``columns_`` attributes exist.\r\n\r\n Parameters\r\n ----------\r\n i : int\r\n The index of the cluster.\r\n\r\n Returns\r\n -------\r\n row_ind : ndarray, dtype=np.intp\r\n Indices of rows in the dataset that belong to the bicluster.\r\n col_ind : ndarray, dtype=np.intp\r\n Indices of columns in the dataset that belong to the bicluster.\r\n \"\"\"\r\n rows = self.rows_[i]\r\n columns = self.columns_[i]\r\n return np.nonzero(rows)[0], np.nonzero(columns)[0]\r\n\r\n def get_shape(self, i):\r\n \"\"\"Shape of the `i`'th bicluster.\r\n\r\n Parameters\r\n ----------\r\n i : int\r\n The index of the cluster.\r\n\r\n Returns\r\n -------\r\n n_rows : int\r\n Number of rows in the bicluster.\r\n\r\n n_cols : int\r\n Number of columns in the bicluster.\r\n \"\"\"\r\n indices = self.get_indices(i)\r\n return tuple(len(i) for i in indices)\r\n\r\n def get_submatrix(self, i, data):\r\n \"\"\"Return the submatrix corresponding to bicluster `i`.\r\n\r\n Parameters\r\n ----------\r\n i : int\r\n The index of the cluster.\r\n data : array-like of shape (n_samples, n_features)\r\n The data.\r\n\r\n Returns\r\n -------\r\n submatrix : ndarray of shape (n_rows, n_cols)\r\n The submatrix corresponding to bicluster `i`.\r\n\r\n Notes\r\n -----\r\n Works with sparse matrices. Only works if ``rows_`` and\r\n ``columns_`` attributes exist.\r\n \"\"\"\r\n from .utils.validation import check_array\r\n\r\n data = check_array(data, accept_sparse=\"csr\")\r\n row_ind, col_ind = self.get_indices(i)\r\n return data[row_ind[:, np.newaxis], col_ind]\r\n\r\n\r\nclass TransformerMixin:\r\n \"\"\"Mixin class for all transformers in scikit-learn.\"\"\"\r\n\r\n def fit_transform(self, X, y=None, **fit_params):\r\n \"\"\"\r\n Fit to data, then transform it.\r\n\r\n Fits transformer to `X` and `y` with optional parameters `fit_params`\r\n and returns a transformed version of `X`.\r\n\r\n Parameters\r\n ----------\r\n X : array-like of shape (n_samples, n_features)\r\n Input samples.\r\n\r\n y : array-like of shape (n_samples,) or (n_samples, n_outputs), \\\r\n default=None\r\n Target values (None for unsupervised transformations).\r\n\r\n **fit_params : dict\r\n Additional fit parameters.\r\n\r\n Returns\r\n -------\r\n X_new : ndarray array of shape (n_samples, n_features_new)\r\n Transformed array.\r\n \"\"\"\r\n # non-optimized default implementation; override when a better\r\n # method is possible for a given clustering algorithm\r\n if y is None:\r\n # fit method of arity 1 (unsupervised transformation)\r\n return self.fit(X, **fit_params).transform(X)\r\n else:\r\n # fit method of arity 2 (supervised transformation)\r\n return self.fit(X, y, **fit_params).transform(X)\r\n\r\n\r\nclass _OneToOneFeatureMixin:\r\n \"\"\"Provides `get_feature_names_out` for simple transformers.\r\n\r\n Assumes there's a 1-to-1 correspondence between input features\r\n and output features.\r\n \"\"\"\r\n\r\n def get_feature_names_out(self, input_features=None):\r\n \"\"\"Get output feature names for transformation.\r\n\r\n Parameters\r\n ----------\r\n input_features : array-like of str or None, default=None\r\n Input features.\r\n\r\n - If `input_features` is `None`, then `feature_names_in_` is\r\n used as feature names in. If `feature_names_in_` is not defined,\r\n then names are generated: `[x0, x1, ..., x(n_features_in_)]`.\r\n - If `input_features` is an array-like, then `input_features` must\r\n match `feature_names_in_` if `feature_names_in_` is defined.\r\n\r\n Returns\r\n -------\r\n feature_names_out : ndarray of str objects\r\n Same as input features.\r\n \"\"\"\r\n return _check_feature_names_in(self, input_features)\r\n\r\n\r\nclass DensityMixin:\r\n \"\"\"Mixin class for all density estimators in scikit-learn.\"\"\"\r\n\r\n _estimator_type = \"DensityEstimator\"\r\n\r\n def score(self, X, y=None):\r\n \"\"\"Return the score of the model on the data `X`.\r\n\r\n Parameters\r\n ----------\r\n X : array-like of shape (n_samples, n_features)\r\n Test samples.\r\n\r\n y : Ignored\r\n Not used, present for API consistency by convention.\r\n\r\n Returns\r\n -------\r\n score : float\r\n \"\"\"\r\n pass\r\n\r\n\r\nclass OutlierMixin:\r\n \"\"\"Mixin class for all outlier detection estimators in scikit-learn.\"\"\"\r\n\r\n _estimator_type = \"outlier_detector\"\r\n\r\n def fit_predict(self, X, y=None):\r\n \"\"\"Perform fit on X and returns labels for X.\r\n\r\n Returns -1 for outliers and 1 for inliers.\r\n\r\n Parameters\r\n ----------\r\n X : {array-like, sparse matrix} of shape (n_samples, n_features)\r\n The input samples.\r\n\r\n y : Ignored\r\n Not used, present for API consistency by convention.\r\n\r\n Returns\r\n -------\r\n y : ndarray of shape (n_samples,)\r\n 1 for inliers, -1 for outliers.\r\n \"\"\"\r\n # override for transductive outlier detectors like LocalOulierFactor\r\n return self.fit(X).predict(X)\r\n\r\n\r\nclass MetaEstimatorMixin:\r\n _required_parameters = [\"estimator\"]\r\n \"\"\"Mixin class for all meta estimators in scikit-learn.\"\"\"\r\n\r\n\r\nclass MultiOutputMixin:\r\n \"\"\"Mixin to mark estimators that support multioutput.\"\"\"\r\n\r\n def _more_tags(self):\r\n return {\"multioutput\": True}\r\n\r\n\r\nclass _UnstableArchMixin:\r\n \"\"\"Mark estimators that are non-determinstic on 32bit or PowerPC\"\"\"\r\n\r\n def _more_tags(self):\r\n return {\r\n \"non_deterministic\": (\r\n _IS_32BIT or platform.machine().startswith((\"ppc\", \"powerpc\"))\r\n )\r\n }\r\n\r\n\r\ndef is_classifier(estimator):\r\n \"\"\"Return True if the given estimator is (probably) a classifier.\r\n\r\n Parameters\r\n ----------\r\n estimator : object\r\n Estimator object to test.\r\n\r\n Returns\r\n -------\r\n out : bool\r\n True if estimator is a classifier and False otherwise.\r\n \"\"\"\r\n return getattr(estimator, \"_estimator_type\", None) == \"classifier\"\r\n\r\n\r\ndef is_regressor(estimator):\r\n \"\"\"Return True if the given estimator is (probably) a regressor.\r\n\r\n Parameters\r\n ----------\r\n estimator : estimator instance\r\n Estimator object to test.\r\n\r\n Returns\r\n -------\r\n out : bool\r\n True if estimator is a regressor and False otherwise.\r\n \"\"\"\r\n return getattr(estimator, \"_estimator_type\", None) == \"regressor\"\r\n\r\n\r\ndef is_outlier_detector(estimator):\r\n \"\"\"Return True if the given estimator is (probably) an outlier detector.\r\n\r\n Parameters\r\n ----------\r\n estimator : estimator instance\r\n Estimator object to test.\r\n\r\n Returns\r\n -------\r\n out : bool\r\n True if estimator is an outlier detector and False otherwise.\r\n \"\"\"\r\n return getattr(estimator, \"_estimator_type\", None) == \"outlier_detector\"\r\n\r\n\r\ndef _is_pairwise(estimator):\r\n \"\"\"Returns True if estimator is pairwise.\r\n\r\n - If the `_pairwise` attribute and the tag are present and consistent,\r\n then use the value and not issue a warning.\r\n - If the `_pairwise` attribute and the tag are present and not\r\n consistent, use the `_pairwise` value and issue a deprecation\r\n warning.\r\n - If only the `_pairwise` attribute is present and it is not False,\r\n issue a deprecation warning and use the `_pairwise` value.\r\n\r\n Parameters\r\n ----------\r\n estimator : object\r\n Estimator object to test.\r\n\r\n Returns\r\n -------\r\n out : bool\r\n True if the estimator is pairwise and False otherwise.\r\n \"\"\"\r\n with warnings.catch_warnings():\r\n warnings.filterwarnings(\"ignore\", category=FutureWarning)\r\n has_pairwise_attribute = hasattr(estimator, \"_pairwise\")\r\n pairwise_attribute = getattr(estimator, \"_pairwise\", False)\r\n pairwise_tag = _safe_tags(estimator, key=\"pairwise\")\r\n\r\n if has_pairwise_attribute:\r\n if pairwise_attribute != pairwise_tag:\r\n warnings.warn(\r\n \"_pairwise was deprecated in 0.24 and will be removed in 1.1 \"\r\n \"(renaming of 0.26). Set the estimator tags of your estimator \"\r\n \"instead\",\r\n FutureWarning,\r\n )\r\n return pairwise_attribute\r\n\r\n # use pairwise tag when the attribute is not present\r\n return pairwise_tag\r\n",
"import numpy as np\r\nimport pytest\r\n\r\nimport pandas as pd\r\nfrom pandas import (\r\n DataFrame,\r\n DatetimeIndex,\r\n Index,\r\n Series,\r\n Timestamp,\r\n date_range,\r\n)\r\nimport pandas._testing as tm\r\n\r\n\r\nclass TestSeriesAppend:\r\n def test_append_preserve_name(self, datetime_series):\r\n result = datetime_series[:5].append(datetime_series[5:])\r\n assert result.name == datetime_series.name\r\n\r\n def test_append(self, datetime_series, string_series, object_series):\r\n appended_series = string_series.append(object_series)\r\n for idx, value in appended_series.items():\r\n if idx in string_series.index:\r\n assert value == string_series[idx]\r\n elif idx in object_series.index:\r\n assert value == object_series[idx]\r\n else:\r\n raise AssertionError(\"orphaned index!\")\r\n\r\n msg = \"Indexes have overlapping values:\"\r\n with pytest.raises(ValueError, match=msg):\r\n datetime_series.append(datetime_series, verify_integrity=True)\r\n\r\n def test_append_many(self, datetime_series):\r\n pieces = [datetime_series[:5], datetime_series[5:10], datetime_series[10:]]\r\n\r\n result = pieces[0].append(pieces[1:])\r\n tm.assert_series_equal(result, datetime_series)\r\n\r\n def test_append_duplicates(self):\r\n # GH 13677\r\n s1 = Series([1, 2, 3])\r\n s2 = Series([4, 5, 6])\r\n exp = Series([1, 2, 3, 4, 5, 6], index=[0, 1, 2, 0, 1, 2])\r\n tm.assert_series_equal(s1.append(s2), exp)\r\n tm.assert_series_equal(pd.concat([s1, s2]), exp)\r\n\r\n # the result must have RangeIndex\r\n exp = Series([1, 2, 3, 4, 5, 6])\r\n tm.assert_series_equal(\r\n s1.append(s2, ignore_index=True), exp, check_index_type=True\r\n )\r\n tm.assert_series_equal(\r\n pd.concat([s1, s2], ignore_index=True), exp, check_index_type=True\r\n )\r\n\r\n msg = \"Indexes have overlapping values:\"\r\n with pytest.raises(ValueError, match=msg):\r\n s1.append(s2, verify_integrity=True)\r\n with pytest.raises(ValueError, match=msg):\r\n pd.concat([s1, s2], verify_integrity=True)\r\n\r\n def test_append_tuples(self):\r\n # GH 28410\r\n s = Series([1, 2, 3])\r\n list_input = [s, s]\r\n tuple_input = (s, s)\r\n\r\n expected = s.append(list_input)\r\n result = s.append(tuple_input)\r\n\r\n tm.assert_series_equal(expected, result)\r\n\r\n def test_append_dataframe_raises(self):\r\n # GH 31413\r\n df = DataFrame({\"A\": [1, 2], \"B\": [3, 4]})\r\n\r\n msg = \"to_append should be a Series or list/tuple of Series, got DataFrame\"\r\n with pytest.raises(TypeError, match=msg):\r\n df.A.append(df)\r\n with pytest.raises(TypeError, match=msg):\r\n df.A.append([df])\r\n\r\n\r\nclass TestSeriesAppendWithDatetimeIndex:\r\n def test_append(self):\r\n rng = date_range(\"5/8/2012 1:45\", periods=10, freq=\"5T\")\r\n ts = Series(np.random.randn(len(rng)), rng)\r\n df = DataFrame(np.random.randn(len(rng), 4), index=rng)\r\n\r\n result = ts.append(ts)\r\n result_df = df.append(df)\r\n ex_index = DatetimeIndex(np.tile(rng.values, 2))\r\n tm.assert_index_equal(result.index, ex_index)\r\n tm.assert_index_equal(result_df.index, ex_index)\r\n\r\n appended = rng.append(rng)\r\n tm.assert_index_equal(appended, ex_index)\r\n\r\n appended = rng.append([rng, rng])\r\n ex_index = DatetimeIndex(np.tile(rng.values, 3))\r\n tm.assert_index_equal(appended, ex_index)\r\n\r\n # different index names\r\n rng1 = rng.copy()\r\n rng2 = rng.copy()\r\n rng1.name = \"foo\"\r\n rng2.name = \"bar\"\r\n assert rng1.append(rng1).name == \"foo\"\r\n assert rng1.append(rng2).name is None\r\n\r\n def test_append_tz(self):\r\n # see gh-2938\r\n rng = date_range(\"5/8/2012 1:45\", periods=10, freq=\"5T\", tz=\"US/Eastern\")\r\n rng2 = date_range(\"5/8/2012 2:35\", periods=10, freq=\"5T\", tz=\"US/Eastern\")\r\n rng3 = date_range(\"5/8/2012 1:45\", periods=20, freq=\"5T\", tz=\"US/Eastern\")\r\n ts = Series(np.random.randn(len(rng)), rng)\r\n df = DataFrame(np.random.randn(len(rng), 4), index=rng)\r\n ts2 = Series(np.random.randn(len(rng2)), rng2)\r\n df2 = DataFrame(np.random.randn(len(rng2), 4), index=rng2)\r\n\r\n result = ts.append(ts2)\r\n result_df = df.append(df2)\r\n tm.assert_index_equal(result.index, rng3)\r\n tm.assert_index_equal(result_df.index, rng3)\r\n\r\n appended = rng.append(rng2)\r\n tm.assert_index_equal(appended, rng3)\r\n\r\n def test_append_tz_explicit_pytz(self):\r\n # see gh-2938\r\n from pytz import timezone as timezone\r\n\r\n rng = date_range(\r\n \"5/8/2012 1:45\", periods=10, freq=\"5T\", tz=timezone(\"US/Eastern\")\r\n )\r\n rng2 = date_range(\r\n \"5/8/2012 2:35\", periods=10, freq=\"5T\", tz=timezone(\"US/Eastern\")\r\n )\r\n rng3 = date_range(\r\n \"5/8/2012 1:45\", periods=20, freq=\"5T\", tz=timezone(\"US/Eastern\")\r\n )\r\n ts = Series(np.random.randn(len(rng)), rng)\r\n df = DataFrame(np.random.randn(len(rng), 4), index=rng)\r\n ts2 = Series(np.random.randn(len(rng2)), rng2)\r\n df2 = DataFrame(np.random.randn(len(rng2), 4), index=rng2)\r\n\r\n result = ts.append(ts2)\r\n result_df = df.append(df2)\r\n tm.assert_index_equal(result.index, rng3)\r\n tm.assert_index_equal(result_df.index, rng3)\r\n\r\n appended = rng.append(rng2)\r\n tm.assert_index_equal(appended, rng3)\r\n\r\n def test_append_tz_dateutil(self):\r\n # see gh-2938\r\n rng = date_range(\r\n \"5/8/2012 1:45\", periods=10, freq=\"5T\", tz=\"dateutil/US/Eastern\"\r\n )\r\n rng2 = date_range(\r\n \"5/8/2012 2:35\", periods=10, freq=\"5T\", tz=\"dateutil/US/Eastern\"\r\n )\r\n rng3 = date_range(\r\n \"5/8/2012 1:45\", periods=20, freq=\"5T\", tz=\"dateutil/US/Eastern\"\r\n )\r\n ts = Series(np.random.randn(len(rng)), rng)\r\n df = DataFrame(np.random.randn(len(rng), 4), index=rng)\r\n ts2 = Series(np.random.randn(len(rng2)), rng2)\r\n df2 = DataFrame(np.random.randn(len(rng2), 4), index=rng2)\r\n\r\n result = ts.append(ts2)\r\n result_df = df.append(df2)\r\n tm.assert_index_equal(result.index, rng3)\r\n tm.assert_index_equal(result_df.index, rng3)\r\n\r\n appended = rng.append(rng2)\r\n tm.assert_index_equal(appended, rng3)\r\n\r\n def test_series_append_aware(self):\r\n rng1 = date_range(\"1/1/2011 01:00\", periods=1, freq=\"H\", tz=\"US/Eastern\")\r\n rng2 = date_range(\"1/1/2011 02:00\", periods=1, freq=\"H\", tz=\"US/Eastern\")\r\n ser1 = Series([1], index=rng1)\r\n ser2 = Series([2], index=rng2)\r\n ts_result = ser1.append(ser2)\r\n\r\n exp_index = DatetimeIndex(\r\n [\"2011-01-01 01:00\", \"2011-01-01 02:00\"], tz=\"US/Eastern\", freq=\"H\"\r\n )\r\n exp = Series([1, 2], index=exp_index)\r\n tm.assert_series_equal(ts_result, exp)\r\n assert ts_result.index.tz == rng1.tz\r\n\r\n rng1 = date_range(\"1/1/2011 01:00\", periods=1, freq=\"H\", tz=\"UTC\")\r\n rng2 = date_range(\"1/1/2011 02:00\", periods=1, freq=\"H\", tz=\"UTC\")\r\n ser1 = Series([1], index=rng1)\r\n ser2 = Series([2], index=rng2)\r\n ts_result = ser1.append(ser2)\r\n\r\n exp_index = DatetimeIndex(\r\n [\"2011-01-01 01:00\", \"2011-01-01 02:00\"], tz=\"UTC\", freq=\"H\"\r\n )\r\n exp = Series([1, 2], index=exp_index)\r\n tm.assert_series_equal(ts_result, exp)\r\n utc = rng1.tz\r\n assert utc == ts_result.index.tz\r\n\r\n # GH#7795\r\n # different tz coerces to object dtype, not UTC\r\n rng1 = date_range(\"1/1/2011 01:00\", periods=1, freq=\"H\", tz=\"US/Eastern\")\r\n rng2 = date_range(\"1/1/2011 02:00\", periods=1, freq=\"H\", tz=\"US/Central\")\r\n ser1 = Series([1], index=rng1)\r\n ser2 = Series([2], index=rng2)\r\n ts_result = ser1.append(ser2)\r\n exp_index = Index(\r\n [\r\n Timestamp(\"1/1/2011 01:00\", tz=\"US/Eastern\"),\r\n Timestamp(\"1/1/2011 02:00\", tz=\"US/Central\"),\r\n ]\r\n )\r\n exp = Series([1, 2], index=exp_index)\r\n tm.assert_series_equal(ts_result, exp)\r\n\r\n def test_series_append_aware_naive(self):\r\n rng1 = date_range(\"1/1/2011 01:00\", periods=1, freq=\"H\")\r\n rng2 = date_range(\"1/1/2011 02:00\", periods=1, freq=\"H\", tz=\"US/Eastern\")\r\n ser1 = Series(np.random.randn(len(rng1)), index=rng1)\r\n ser2 = Series(np.random.randn(len(rng2)), index=rng2)\r\n ts_result = ser1.append(ser2)\r\n\r\n expected = ser1.index.astype(object).append(ser2.index.astype(object))\r\n assert ts_result.index.equals(expected)\r\n\r\n # mixed\r\n rng1 = date_range(\"1/1/2011 01:00\", periods=1, freq=\"H\")\r\n rng2 = range(100)\r\n ser1 = Series(np.random.randn(len(rng1)), index=rng1)\r\n ser2 = Series(np.random.randn(len(rng2)), index=rng2)\r\n ts_result = ser1.append(ser2)\r\n\r\n expected = ser1.index.astype(object).append(ser2.index)\r\n assert ts_result.index.equals(expected)\r\n\r\n def test_series_append_dst(self):\r\n rng1 = date_range(\"1/1/2016 01:00\", periods=3, freq=\"H\", tz=\"US/Eastern\")\r\n rng2 = date_range(\"8/1/2016 01:00\", periods=3, freq=\"H\", tz=\"US/Eastern\")\r\n ser1 = Series([1, 2, 3], index=rng1)\r\n ser2 = Series([10, 11, 12], index=rng2)\r\n ts_result = ser1.append(ser2)\r\n\r\n exp_index = DatetimeIndex(\r\n [\r\n \"2016-01-01 01:00\",\r\n \"2016-01-01 02:00\",\r\n \"2016-01-01 03:00\",\r\n \"2016-08-01 01:00\",\r\n \"2016-08-01 02:00\",\r\n \"2016-08-01 03:00\",\r\n ],\r\n tz=\"US/Eastern\",\r\n )\r\n exp = Series([1, 2, 3, 10, 11, 12], index=exp_index)\r\n tm.assert_series_equal(ts_result, exp)\r\n assert ts_result.index.tz == rng1.tz\r\n",
"import numpy as np\r\nimport pytest\r\n\r\nimport pandas._testing as tm\r\nfrom pandas.core.construction import sanitize_array\r\n\r\n\r\[email protected](\r\n \"values, dtype, expected\",\r\n [\r\n ([1, 2, 3], None, np.array([1, 2, 3], dtype=np.int64)),\r\n (np.array([1, 2, 3]), None, np.array([1, 2, 3])),\r\n ([\"1\", \"2\", None], None, np.array([\"1\", \"2\", None])),\r\n ([\"1\", \"2\", None], np.dtype(\"str\"), np.array([\"1\", \"2\", None])),\r\n ([1, 2, None], np.dtype(\"str\"), np.array([\"1\", \"2\", None])),\r\n ],\r\n)\r\ndef test_construct_1d_ndarray_preserving_na(values, dtype, expected):\r\n result = sanitize_array(values, index=None, dtype=dtype)\r\n tm.assert_numpy_array_equal(result, expected)\r\n\r\n\r\[email protected](\"dtype\", [\"m8[ns]\", \"M8[ns]\"])\r\ndef test_construct_1d_ndarray_preserving_na_datetimelike(dtype):\r\n arr = np.arange(5, dtype=np.int64).view(dtype)\r\n expected = np.array(list(arr), dtype=object)\r\n assert all(isinstance(x, type(arr[0])) for x in expected)\r\n\r\n result = sanitize_array(arr, index=None, dtype=np.dtype(object))\r\n tm.assert_numpy_array_equal(result, expected)\r\n",
"\"\"\"\r\nProvide classes to perform the groupby aggregate operations.\r\n\r\nThese are not exposed to the user and provide implementations of the grouping\r\noperations, primarily in cython. These classes (BaseGrouper and BinGrouper)\r\nare contained *in* the SeriesGroupBy and DataFrameGroupBy objects.\r\n\"\"\"\r\nfrom __future__ import annotations\r\n\r\nimport collections\r\nimport functools\r\nfrom typing import (\r\n Generic,\r\n Hashable,\r\n Iterator,\r\n Sequence,\r\n overload,\r\n)\r\n\r\nimport numpy as np\r\n\r\nfrom pandas._libs import (\r\n NaT,\r\n lib,\r\n)\r\nimport pandas._libs.groupby as libgroupby\r\nimport pandas._libs.reduction as libreduction\r\nfrom pandas._typing import (\r\n ArrayLike,\r\n DtypeObj,\r\n F,\r\n FrameOrSeries,\r\n Shape,\r\n final,\r\n)\r\nfrom pandas.errors import AbstractMethodError\r\nfrom pandas.util._decorators import cache_readonly\r\n\r\nfrom pandas.core.dtypes.cast import (\r\n maybe_cast_pointwise_result,\r\n maybe_downcast_to_dtype,\r\n)\r\nfrom pandas.core.dtypes.common import (\r\n ensure_float64,\r\n ensure_int64,\r\n ensure_platform_int,\r\n is_1d_only_ea_obj,\r\n is_bool_dtype,\r\n is_categorical_dtype,\r\n is_complex_dtype,\r\n is_datetime64_any_dtype,\r\n is_float_dtype,\r\n is_integer_dtype,\r\n is_numeric_dtype,\r\n is_sparse,\r\n is_timedelta64_dtype,\r\n needs_i8_conversion,\r\n)\r\nfrom pandas.core.dtypes.dtypes import ExtensionDtype\r\nfrom pandas.core.dtypes.missing import (\r\n isna,\r\n maybe_fill,\r\n)\r\n\r\nfrom pandas.core.arrays import (\r\n DatetimeArray,\r\n ExtensionArray,\r\n PeriodArray,\r\n TimedeltaArray,\r\n)\r\nfrom pandas.core.arrays.boolean import BooleanDtype\r\nfrom pandas.core.arrays.floating import (\r\n Float64Dtype,\r\n FloatingDtype,\r\n)\r\nfrom pandas.core.arrays.integer import (\r\n Int64Dtype,\r\n _IntegerDtype,\r\n)\r\nfrom pandas.core.arrays.masked import (\r\n BaseMaskedArray,\r\n BaseMaskedDtype,\r\n)\r\nfrom pandas.core.arrays.string_ import StringDtype\r\nimport pandas.core.common as com\r\nfrom pandas.core.frame import DataFrame\r\nfrom pandas.core.generic import NDFrame\r\nfrom pandas.core.groupby import (\r\n base,\r\n grouper,\r\n)\r\nfrom pandas.core.indexes.api import (\r\n CategoricalIndex,\r\n Index,\r\n MultiIndex,\r\n ensure_index,\r\n)\r\nfrom pandas.core.internals import ArrayManager\r\nfrom pandas.core.series import Series\r\nfrom pandas.core.sorting import (\r\n compress_group_index,\r\n decons_obs_group_ids,\r\n get_flattened_list,\r\n get_group_index,\r\n get_group_index_sorter,\r\n get_indexer_dict,\r\n)\r\n\r\n\r\nclass WrappedCythonOp:\r\n \"\"\"\r\n Dispatch logic for functions defined in _libs.groupby\r\n \"\"\"\r\n\r\n # Functions for which we do _not_ attempt to cast the cython result\r\n # back to the original dtype.\r\n cast_blocklist = frozenset([\"rank\", \"count\", \"size\", \"idxmin\", \"idxmax\"])\r\n\r\n def __init__(self, kind: str, how: str):\r\n self.kind = kind\r\n self.how = how\r\n\r\n _CYTHON_FUNCTIONS = {\r\n \"aggregate\": {\r\n \"add\": \"group_add\",\r\n \"prod\": \"group_prod\",\r\n \"min\": \"group_min\",\r\n \"max\": \"group_max\",\r\n \"mean\": \"group_mean\",\r\n \"median\": \"group_median\",\r\n \"var\": \"group_var\",\r\n \"first\": \"group_nth\",\r\n \"last\": \"group_last\",\r\n \"ohlc\": \"group_ohlc\",\r\n },\r\n \"transform\": {\r\n \"cumprod\": \"group_cumprod\",\r\n \"cumsum\": \"group_cumsum\",\r\n \"cummin\": \"group_cummin\",\r\n \"cummax\": \"group_cummax\",\r\n \"rank\": \"group_rank\",\r\n },\r\n }\r\n\r\n _MASKED_CYTHON_FUNCTIONS = {\"cummin\", \"cummax\"}\r\n\r\n _cython_arity = {\"ohlc\": 4} # OHLC\r\n\r\n # Note: we make this a classmethod and pass kind+how so that caching\r\n # works at the class level and not the instance level\r\n @classmethod\r\n @functools.lru_cache(maxsize=None)\r\n def _get_cython_function(\r\n cls, kind: str, how: str, dtype: np.dtype, is_numeric: bool\r\n ):\r\n\r\n dtype_str = dtype.name\r\n ftype = cls._CYTHON_FUNCTIONS[kind][how]\r\n\r\n # see if there is a fused-type version of function\r\n # only valid for numeric\r\n f = getattr(libgroupby, ftype)\r\n if is_numeric:\r\n return f\r\n # error: Non-overlapping equality check (left operand type: \"dtype[Any]\", right\r\n # operand type: \"Literal['object']\")\r\n elif dtype == object: # type: ignore[comparison-overlap]\r\n if \"object\" not in f.__signatures__:\r\n # raise NotImplementedError here rather than TypeError later\r\n raise NotImplementedError(\r\n f\"function is not implemented for this dtype: \"\r\n f\"[how->{how},dtype->{dtype_str}]\"\r\n )\r\n return f\r\n\r\n def get_cython_func_and_vals(self, values: np.ndarray, is_numeric: bool):\r\n \"\"\"\r\n Find the appropriate cython function, casting if necessary.\r\n\r\n Parameters\r\n ----------\r\n values : np.ndarray\r\n is_numeric : bool\r\n\r\n Returns\r\n -------\r\n func : callable\r\n values : np.ndarray\r\n \"\"\"\r\n how = self.how\r\n kind = self.kind\r\n\r\n if how in [\"median\", \"cumprod\"]:\r\n # these two only have float64 implementations\r\n if is_numeric:\r\n values = ensure_float64(values)\r\n else:\r\n raise NotImplementedError(\r\n f\"function is not implemented for this dtype: \"\r\n f\"[how->{how},dtype->{values.dtype.name}]\"\r\n )\r\n func = getattr(libgroupby, f\"group_{how}_float64\")\r\n return func, values\r\n\r\n func = self._get_cython_function(kind, how, values.dtype, is_numeric)\r\n\r\n if values.dtype.kind in [\"i\", \"u\"]:\r\n if how in [\"add\", \"var\", \"prod\", \"mean\", \"ohlc\"]:\r\n # result may still include NaN, so we have to cast\r\n values = ensure_float64(values)\r\n\r\n return func, values\r\n\r\n def _disallow_invalid_ops(self, dtype: DtypeObj, is_numeric: bool = False):\r\n \"\"\"\r\n Check if we can do this operation with our cython functions.\r\n\r\n Raises\r\n ------\r\n NotImplementedError\r\n This is either not a valid function for this dtype, or\r\n valid but not implemented in cython.\r\n \"\"\"\r\n how = self.how\r\n\r\n if is_numeric:\r\n # never an invalid op for those dtypes, so return early as fastpath\r\n return\r\n\r\n if is_categorical_dtype(dtype):\r\n # NotImplementedError for methods that can fall back to a\r\n # non-cython implementation.\r\n if how in [\"add\", \"prod\", \"cumsum\", \"cumprod\"]:\r\n raise TypeError(f\"{dtype} type does not support {how} operations\")\r\n raise NotImplementedError(f\"{dtype} dtype not supported\")\r\n\r\n elif is_sparse(dtype):\r\n # categoricals are only 1d, so we\r\n # are not setup for dim transforming\r\n raise NotImplementedError(f\"{dtype} dtype not supported\")\r\n elif is_datetime64_any_dtype(dtype):\r\n # we raise NotImplemented if this is an invalid operation\r\n # entirely, e.g. adding datetimes\r\n if how in [\"add\", \"prod\", \"cumsum\", \"cumprod\"]:\r\n raise TypeError(f\"datetime64 type does not support {how} operations\")\r\n elif is_timedelta64_dtype(dtype):\r\n if how in [\"prod\", \"cumprod\"]:\r\n raise TypeError(f\"timedelta64 type does not support {how} operations\")\r\n\r\n def _get_output_shape(self, ngroups: int, values: np.ndarray) -> Shape:\r\n how = self.how\r\n kind = self.kind\r\n\r\n arity = self._cython_arity.get(how, 1)\r\n\r\n out_shape: Shape\r\n if how == \"ohlc\":\r\n out_shape = (ngroups, 4)\r\n elif arity > 1:\r\n raise NotImplementedError(\r\n \"arity of more than 1 is not supported for the 'how' argument\"\r\n )\r\n elif kind == \"transform\":\r\n out_shape = values.shape\r\n else:\r\n out_shape = (ngroups,) + values.shape[1:]\r\n return out_shape\r\n\r\n def get_out_dtype(self, dtype: np.dtype) -> np.dtype:\r\n how = self.how\r\n\r\n if how == \"rank\":\r\n out_dtype = \"float64\"\r\n else:\r\n if is_numeric_dtype(dtype):\r\n out_dtype = f\"{dtype.kind}{dtype.itemsize}\"\r\n else:\r\n out_dtype = \"object\"\r\n return np.dtype(out_dtype)\r\n\r\n @overload\r\n def _get_result_dtype(self, dtype: np.dtype) -> np.dtype:\r\n ... # pragma: no cover\r\n\r\n @overload\r\n def _get_result_dtype(self, dtype: ExtensionDtype) -> ExtensionDtype:\r\n ... # pragma: no cover\r\n\r\n def _get_result_dtype(self, dtype: DtypeObj) -> DtypeObj:\r\n \"\"\"\r\n Get the desired dtype of a result based on the\r\n input dtype and how it was computed.\r\n\r\n Parameters\r\n ----------\r\n dtype : np.dtype or ExtensionDtype\r\n Input dtype.\r\n\r\n Returns\r\n -------\r\n np.dtype or ExtensionDtype\r\n The desired dtype of the result.\r\n \"\"\"\r\n how = self.how\r\n\r\n if how in [\"add\", \"cumsum\", \"sum\", \"prod\"]:\r\n if dtype == np.dtype(bool):\r\n return np.dtype(np.int64)\r\n elif isinstance(dtype, (BooleanDtype, _IntegerDtype)):\r\n return Int64Dtype()\r\n elif how in [\"mean\", \"median\", \"var\"]:\r\n if isinstance(dtype, (BooleanDtype, _IntegerDtype)):\r\n return Float64Dtype()\r\n elif is_float_dtype(dtype):\r\n return dtype\r\n elif is_numeric_dtype(dtype):\r\n return np.dtype(np.float64)\r\n return dtype\r\n\r\n def uses_mask(self) -> bool:\r\n return self.how in self._MASKED_CYTHON_FUNCTIONS\r\n\r\n @final\r\n def _ea_wrap_cython_operation(\r\n self,\r\n values: ExtensionArray,\r\n min_count: int,\r\n ngroups: int,\r\n comp_ids: np.ndarray,\r\n **kwargs,\r\n ) -> ArrayLike:\r\n \"\"\"\r\n If we have an ExtensionArray, unwrap, call _cython_operation, and\r\n re-wrap if appropriate.\r\n \"\"\"\r\n # TODO: general case implementation overridable by EAs.\r\n if isinstance(values, BaseMaskedArray) and self.uses_mask():\r\n return self._masked_ea_wrap_cython_operation(\r\n values,\r\n min_count=min_count,\r\n ngroups=ngroups,\r\n comp_ids=comp_ids,\r\n **kwargs,\r\n )\r\n orig_values = values\r\n\r\n if isinstance(orig_values, (DatetimeArray, PeriodArray)):\r\n # All of the functions implemented here are ordinal, so we can\r\n # operate on the tz-naive equivalents\r\n npvalues = orig_values._ndarray.view(\"M8[ns]\")\r\n res_values = self._cython_op_ndim_compat(\r\n npvalues,\r\n min_count=min_count,\r\n ngroups=ngroups,\r\n comp_ids=comp_ids,\r\n mask=None,\r\n **kwargs,\r\n )\r\n if self.how in [\"rank\"]:\r\n # i.e. how in WrappedCythonOp.cast_blocklist, since\r\n # other cast_blocklist methods dont go through cython_operation\r\n # preserve float64 dtype\r\n return res_values\r\n\r\n res_values = res_values.view(\"i8\")\r\n result = type(orig_values)(res_values, dtype=orig_values.dtype)\r\n return result\r\n\r\n elif isinstance(orig_values, TimedeltaArray):\r\n # We have an ExtensionArray but not ExtensionDtype\r\n res_values = self._cython_op_ndim_compat(\r\n orig_values._ndarray,\r\n min_count=min_count,\r\n ngroups=ngroups,\r\n comp_ids=comp_ids,\r\n mask=None,\r\n **kwargs,\r\n )\r\n if self.how in [\"rank\"]:\r\n # i.e. how in WrappedCythonOp.cast_blocklist, since\r\n # other cast_blocklist methods dont go through cython_operation\r\n # preserve float64 dtype\r\n return res_values\r\n\r\n # otherwise res_values has the same dtype as original values\r\n return type(orig_values)(res_values)\r\n\r\n elif isinstance(values.dtype, (BooleanDtype, _IntegerDtype)):\r\n # IntegerArray or BooleanArray\r\n npvalues = values.to_numpy(\"float64\", na_value=np.nan)\r\n res_values = self._cython_op_ndim_compat(\r\n npvalues,\r\n min_count=min_count,\r\n ngroups=ngroups,\r\n comp_ids=comp_ids,\r\n mask=None,\r\n **kwargs,\r\n )\r\n if self.how in [\"rank\"]:\r\n # i.e. how in WrappedCythonOp.cast_blocklist, since\r\n # other cast_blocklist methods dont go through cython_operation\r\n return res_values\r\n\r\n dtype = self._get_result_dtype(orig_values.dtype)\r\n cls = dtype.construct_array_type()\r\n return cls._from_sequence(res_values, dtype=dtype)\r\n\r\n elif isinstance(values.dtype, FloatingDtype):\r\n # FloatingArray\r\n npvalues = values.to_numpy(\r\n values.dtype.numpy_dtype,\r\n na_value=np.nan,\r\n )\r\n res_values = self._cython_op_ndim_compat(\r\n npvalues,\r\n min_count=min_count,\r\n ngroups=ngroups,\r\n comp_ids=comp_ids,\r\n mask=None,\r\n **kwargs,\r\n )\r\n if self.how in [\"rank\"]:\r\n # i.e. how in WrappedCythonOp.cast_blocklist, since\r\n # other cast_blocklist methods dont go through cython_operation\r\n return res_values\r\n\r\n dtype = self._get_result_dtype(orig_values.dtype)\r\n cls = dtype.construct_array_type()\r\n return cls._from_sequence(res_values, dtype=dtype)\r\n\r\n elif isinstance(values.dtype, StringDtype):\r\n # StringArray\r\n npvalues = values.to_numpy(object, na_value=np.nan)\r\n res_values = self._cython_op_ndim_compat(\r\n npvalues,\r\n min_count=min_count,\r\n ngroups=ngroups,\r\n comp_ids=comp_ids,\r\n mask=None,\r\n **kwargs,\r\n )\r\n if self.how in [\"rank\"]:\r\n # i.e. how in WrappedCythonOp.cast_blocklist, since\r\n # other cast_blocklist methods dont go through cython_operation\r\n return res_values\r\n\r\n dtype = self._get_result_dtype(orig_values.dtype)\r\n cls = dtype.construct_array_type()\r\n return cls._from_sequence(res_values, dtype=dtype)\r\n\r\n raise NotImplementedError(\r\n f\"function is not implemented for this dtype: {values.dtype}\"\r\n )\r\n\r\n @final\r\n def _masked_ea_wrap_cython_operation(\r\n self,\r\n values: BaseMaskedArray,\r\n min_count: int,\r\n ngroups: int,\r\n comp_ids: np.ndarray,\r\n **kwargs,\r\n ) -> BaseMaskedArray:\r\n \"\"\"\r\n Equivalent of `_ea_wrap_cython_operation`, but optimized for masked EA's\r\n and cython algorithms which accept a mask.\r\n \"\"\"\r\n orig_values = values\r\n\r\n # Copy to ensure input and result masks don't end up shared\r\n mask = values._mask.copy()\r\n arr = values._data\r\n\r\n res_values = self._cython_op_ndim_compat(\r\n arr,\r\n min_count=min_count,\r\n ngroups=ngroups,\r\n comp_ids=comp_ids,\r\n mask=mask,\r\n **kwargs,\r\n )\r\n dtype = self._get_result_dtype(orig_values.dtype)\r\n assert isinstance(dtype, BaseMaskedDtype)\r\n cls = dtype.construct_array_type()\r\n\r\n return cls(res_values.astype(dtype.type, copy=False), mask)\r\n\r\n @final\r\n def _cython_op_ndim_compat(\r\n self,\r\n values: np.ndarray,\r\n *,\r\n min_count: int,\r\n ngroups: int,\r\n comp_ids: np.ndarray,\r\n mask: np.ndarray | None,\r\n **kwargs,\r\n ) -> np.ndarray:\r\n if values.ndim == 1:\r\n # expand to 2d, dispatch, then squeeze if appropriate\r\n values2d = values[None, :]\r\n res = self._call_cython_op(\r\n values2d,\r\n min_count=min_count,\r\n ngroups=ngroups,\r\n comp_ids=comp_ids,\r\n mask=mask,\r\n **kwargs,\r\n )\r\n if res.shape[0] == 1:\r\n return res[0]\r\n\r\n # otherwise we have OHLC\r\n return res.T\r\n\r\n return self._call_cython_op(\r\n values,\r\n min_count=min_count,\r\n ngroups=ngroups,\r\n comp_ids=comp_ids,\r\n mask=mask,\r\n **kwargs,\r\n )\r\n\r\n @final\r\n def _call_cython_op(\r\n self,\r\n values: np.ndarray, # np.ndarray[ndim=2]\r\n *,\r\n min_count: int,\r\n ngroups: int,\r\n comp_ids: np.ndarray,\r\n mask: np.ndarray | None,\r\n **kwargs,\r\n ) -> np.ndarray: # np.ndarray[ndim=2]\r\n orig_values = values\r\n\r\n dtype = values.dtype\r\n is_numeric = is_numeric_dtype(dtype)\r\n\r\n is_datetimelike = needs_i8_conversion(dtype)\r\n\r\n if is_datetimelike:\r\n values = values.view(\"int64\")\r\n is_numeric = True\r\n elif is_bool_dtype(dtype):\r\n values = values.astype(\"int64\")\r\n elif is_integer_dtype(dtype):\r\n # e.g. uint8 -> uint64, int16 -> int64\r\n dtype_str = dtype.kind + \"8\"\r\n values = values.astype(dtype_str, copy=False)\r\n elif is_numeric:\r\n if not is_complex_dtype(dtype):\r\n values = ensure_float64(values)\r\n\r\n values = values.T\r\n\r\n if mask is not None:\r\n mask = mask.reshape(values.shape, order=\"C\")\r\n\r\n out_shape = self._get_output_shape(ngroups, values)\r\n func, values = self.get_cython_func_and_vals(values, is_numeric)\r\n out_dtype = self.get_out_dtype(values.dtype)\r\n\r\n result = maybe_fill(np.empty(out_shape, dtype=out_dtype))\r\n if self.kind == \"aggregate\":\r\n counts = np.zeros(ngroups, dtype=np.int64)\r\n if self.how in [\"min\", \"max\", \"mean\"]:\r\n func(\r\n result,\r\n counts,\r\n values,\r\n comp_ids,\r\n min_count,\r\n is_datetimelike=is_datetimelike,\r\n )\r\n else:\r\n func(result, counts, values, comp_ids, min_count)\r\n else:\r\n # TODO: min_count\r\n if self.uses_mask():\r\n func(\r\n result,\r\n values,\r\n comp_ids,\r\n ngroups,\r\n is_datetimelike,\r\n mask=mask,\r\n **kwargs,\r\n )\r\n else:\r\n func(result, values, comp_ids, ngroups, is_datetimelike, **kwargs)\r\n\r\n if self.kind == \"aggregate\":\r\n # i.e. counts is defined. Locations where count<min_count\r\n # need to have the result set to np.nan, which may require casting,\r\n # see GH#40767\r\n if is_integer_dtype(result.dtype) and not is_datetimelike:\r\n cutoff = max(1, min_count)\r\n empty_groups = counts < cutoff\r\n if empty_groups.any():\r\n # Note: this conversion could be lossy, see GH#40767\r\n result = result.astype(\"float64\")\r\n result[empty_groups] = np.nan\r\n\r\n result = result.T\r\n\r\n if self.how not in self.cast_blocklist:\r\n # e.g. if we are int64 and need to restore to datetime64/timedelta64\r\n # \"rank\" is the only member of cast_blocklist we get here\r\n res_dtype = self._get_result_dtype(orig_values.dtype)\r\n op_result = maybe_downcast_to_dtype(result, res_dtype)\r\n else:\r\n op_result = result\r\n\r\n # error: Incompatible return value type (got \"Union[ExtensionArray, ndarray]\",\r\n # expected \"ndarray\")\r\n return op_result # type: ignore[return-value]\r\n\r\n @final\r\n def cython_operation(\r\n self,\r\n *,\r\n values: ArrayLike,\r\n axis: int,\r\n min_count: int = -1,\r\n comp_ids: np.ndarray,\r\n ngroups: int,\r\n **kwargs,\r\n ) -> ArrayLike:\r\n \"\"\"\r\n Call our cython function, with appropriate pre- and post- processing.\r\n \"\"\"\r\n if values.ndim > 2:\r\n raise NotImplementedError(\"number of dimensions is currently limited to 2\")\r\n elif values.ndim == 2:\r\n assert axis == 1, axis\r\n elif not is_1d_only_ea_obj(values):\r\n # Note: it is *not* the case that axis is always 0 for 1-dim values,\r\n # as we can have 1D ExtensionArrays that we need to treat as 2D\r\n assert axis == 0\r\n\r\n dtype = values.dtype\r\n is_numeric = is_numeric_dtype(dtype)\r\n\r\n # can we do this operation with our cython functions\r\n # if not raise NotImplementedError\r\n self._disallow_invalid_ops(dtype, is_numeric)\r\n\r\n if not isinstance(values, np.ndarray):\r\n # i.e. ExtensionArray\r\n return self._ea_wrap_cython_operation(\r\n values,\r\n min_count=min_count,\r\n ngroups=ngroups,\r\n comp_ids=comp_ids,\r\n **kwargs,\r\n )\r\n\r\n return self._cython_op_ndim_compat(\r\n values,\r\n min_count=min_count,\r\n ngroups=ngroups,\r\n comp_ids=comp_ids,\r\n mask=None,\r\n **kwargs,\r\n )\r\n\r\n\r\nclass BaseGrouper:\r\n \"\"\"\r\n This is an internal Grouper class, which actually holds\r\n the generated groups\r\n\r\n Parameters\r\n ----------\r\n axis : Index\r\n groupings : Sequence[Grouping]\r\n all the grouping instances to handle in this grouper\r\n for example for grouper list to groupby, need to pass the list\r\n sort : bool, default True\r\n whether this grouper will give sorted result or not\r\n group_keys : bool, default True\r\n mutated : bool, default False\r\n indexer : np.ndarray[np.intp], optional\r\n the indexer created by Grouper\r\n some groupers (TimeGrouper) will sort its axis and its\r\n group_info is also sorted, so need the indexer to reorder\r\n\r\n \"\"\"\r\n\r\n axis: Index\r\n\r\n def __init__(\r\n self,\r\n axis: Index,\r\n groupings: Sequence[grouper.Grouping],\r\n sort: bool = True,\r\n group_keys: bool = True,\r\n mutated: bool = False,\r\n indexer: np.ndarray | None = None,\r\n dropna: bool = True,\r\n ):\r\n assert isinstance(axis, Index), axis\r\n\r\n self.axis = axis\r\n self._groupings: list[grouper.Grouping] = list(groupings)\r\n self._sort = sort\r\n self.group_keys = group_keys\r\n self.mutated = mutated\r\n self.indexer = indexer\r\n self.dropna = dropna\r\n\r\n @property\r\n def groupings(self) -> list[grouper.Grouping]:\r\n return self._groupings\r\n\r\n @property\r\n def shape(self) -> Shape:\r\n return tuple(ping.ngroups for ping in self.groupings)\r\n\r\n def __iter__(self):\r\n return iter(self.indices)\r\n\r\n @property\r\n def nkeys(self) -> int:\r\n return len(self.groupings)\r\n\r\n def get_iterator(\r\n self, data: FrameOrSeries, axis: int = 0\r\n ) -> Iterator[tuple[Hashable, FrameOrSeries]]:\r\n \"\"\"\r\n Groupby iterator\r\n\r\n Returns\r\n -------\r\n Generator yielding sequence of (name, subsetted object)\r\n for each group\r\n \"\"\"\r\n splitter = self._get_splitter(data, axis=axis)\r\n keys = self._get_group_keys()\r\n for key, group in zip(keys, splitter):\r\n yield key, group.__finalize__(data, method=\"groupby\")\r\n\r\n @final\r\n def _get_splitter(self, data: FrameOrSeries, axis: int = 0) -> DataSplitter:\r\n \"\"\"\r\n Returns\r\n -------\r\n Generator yielding subsetted objects\r\n\r\n __finalize__ has not been called for the subsetted objects returned.\r\n \"\"\"\r\n ids, _, ngroups = self.group_info\r\n return get_splitter(data, ids, ngroups, axis=axis)\r\n\r\n def _get_grouper(self):\r\n \"\"\"\r\n We are a grouper as part of another's groupings.\r\n\r\n We have a specific method of grouping, so cannot\r\n convert to a Index for our grouper.\r\n \"\"\"\r\n return self.groupings[0].grouping_vector\r\n\r\n @final\r\n def _get_group_keys(self):\r\n if len(self.groupings) == 1:\r\n return self.levels[0]\r\n else:\r\n ids, _, ngroups = self.group_info\r\n\r\n # provide \"flattened\" iterator for multi-group setting\r\n return get_flattened_list(ids, ngroups, self.levels, self.codes)\r\n\r\n @final\r\n def apply(self, f: F, data: FrameOrSeries, axis: int = 0):\r\n mutated = self.mutated\r\n splitter = self._get_splitter(data, axis=axis)\r\n group_keys = self._get_group_keys()\r\n result_values = None\r\n\r\n if data.ndim == 2 and any(\r\n isinstance(x, ExtensionArray) for x in data._iter_column_arrays()\r\n ):\r\n # calling splitter.fast_apply will raise TypeError via apply_frame_axis0\r\n # if we pass EA instead of ndarray\r\n # TODO: can we have a workaround for EAs backed by ndarray?\r\n pass\r\n\r\n elif isinstance(data._mgr, ArrayManager):\r\n # TODO(ArrayManager) don't use fast_apply / libreduction.apply_frame_axis0\r\n # for now -> relies on BlockManager internals\r\n pass\r\n elif (\r\n com.get_callable_name(f) not in base.plotting_methods\r\n and isinstance(splitter, FrameSplitter)\r\n and axis == 0\r\n # fast_apply/libreduction doesn't allow non-numpy backed indexes\r\n and not data.index._has_complex_internals\r\n ):\r\n try:\r\n sdata = splitter.sorted_data\r\n result_values, mutated = splitter.fast_apply(f, sdata, group_keys)\r\n\r\n except IndexError:\r\n # This is a rare case in which re-running in python-space may\r\n # make a difference, see test_apply_mutate.test_mutate_groups\r\n pass\r\n\r\n else:\r\n # If the fast apply path could be used we can return here.\r\n # Otherwise we need to fall back to the slow implementation.\r\n if len(result_values) == len(group_keys):\r\n return group_keys, result_values, mutated\r\n\r\n if result_values is None:\r\n # result_values is None if fast apply path wasn't taken\r\n # or fast apply aborted with an unexpected exception.\r\n # In either case, initialize the result list and perform\r\n # the slow iteration.\r\n result_values = []\r\n skip_first = False\r\n else:\r\n # If result_values is not None we're in the case that the\r\n # fast apply loop was broken prematurely but we have\r\n # already the result for the first group which we can reuse.\r\n skip_first = True\r\n\r\n # This calls DataSplitter.__iter__\r\n zipped = zip(group_keys, splitter)\r\n if skip_first:\r\n # pop the first item from the front of the iterator\r\n next(zipped)\r\n\r\n for key, group in zipped:\r\n object.__setattr__(group, \"name\", key)\r\n\r\n # group might be modified\r\n group_axes = group.axes\r\n res = f(group)\r\n if not _is_indexed_like(res, group_axes, axis):\r\n mutated = True\r\n result_values.append(res)\r\n\r\n return group_keys, result_values, mutated\r\n\r\n @cache_readonly\r\n def indices(self):\r\n \"\"\"dict {group name -> group indices}\"\"\"\r\n if len(self.groupings) == 1 and isinstance(self.result_index, CategoricalIndex):\r\n # This shows unused categories in indices GH#38642\r\n return self.groupings[0].indices\r\n codes_list = [ping.codes for ping in self.groupings]\r\n keys = [ping.group_index for ping in self.groupings]\r\n return get_indexer_dict(codes_list, keys)\r\n\r\n @property\r\n def codes(self) -> list[np.ndarray]:\r\n return [ping.codes for ping in self.groupings]\r\n\r\n @property\r\n def levels(self) -> list[Index]:\r\n return [ping.group_index for ping in self.groupings]\r\n\r\n @property\r\n def names(self) -> list[Hashable]:\r\n return [ping.name for ping in self.groupings]\r\n\r\n @final\r\n def size(self) -> Series:\r\n \"\"\"\r\n Compute group sizes.\r\n \"\"\"\r\n ids, _, ngroups = self.group_info\r\n if ngroups:\r\n out = np.bincount(ids[ids != -1], minlength=ngroups)\r\n else:\r\n out = []\r\n return Series(out, index=self.result_index, dtype=\"int64\")\r\n\r\n @cache_readonly\r\n def groups(self) -> dict[Hashable, np.ndarray]:\r\n \"\"\"dict {group name -> group labels}\"\"\"\r\n if len(self.groupings) == 1:\r\n return self.groupings[0].groups\r\n else:\r\n to_groupby = zip(*(ping.grouping_vector for ping in self.groupings))\r\n index = Index(to_groupby)\r\n return self.axis.groupby(index)\r\n\r\n @final\r\n @cache_readonly\r\n def is_monotonic(self) -> bool:\r\n # return if my group orderings are monotonic\r\n return Index(self.group_info[0]).is_monotonic\r\n\r\n @cache_readonly\r\n def group_info(self):\r\n comp_ids, obs_group_ids = self._get_compressed_codes()\r\n\r\n ngroups = len(obs_group_ids)\r\n comp_ids = ensure_platform_int(comp_ids)\r\n\r\n return comp_ids, obs_group_ids, ngroups\r\n\r\n @final\r\n @cache_readonly\r\n def codes_info(self) -> np.ndarray:\r\n # return the codes of items in original grouped axis\r\n ids, _, _ = self.group_info\r\n if self.indexer is not None:\r\n sorter = np.lexsort((ids, self.indexer))\r\n ids = ids[sorter]\r\n return ids\r\n\r\n @final\r\n def _get_compressed_codes(self) -> tuple[np.ndarray, np.ndarray]:\r\n if len(self.groupings) > 1:\r\n group_index = get_group_index(self.codes, self.shape, sort=True, xnull=True)\r\n return compress_group_index(group_index, sort=self._sort)\r\n\r\n ping = self.groupings[0]\r\n return ping.codes, np.arange(len(ping.group_index))\r\n\r\n @final\r\n @cache_readonly\r\n def ngroups(self) -> int:\r\n return len(self.result_index)\r\n\r\n @property\r\n def reconstructed_codes(self) -> list[np.ndarray]:\r\n codes = self.codes\r\n ids, obs_ids, _ = self.group_info\r\n return decons_obs_group_ids(ids, obs_ids, self.shape, codes, xnull=True)\r\n\r\n @cache_readonly\r\n def result_arraylike(self) -> ArrayLike:\r\n \"\"\"\r\n Analogous to result_index, but returning an ndarray/ExtensionArray\r\n allowing us to retain ExtensionDtypes not supported by Index.\r\n \"\"\"\r\n # TODO: once Index supports arbitrary EAs, this can be removed in favor\r\n # of result_index\r\n if len(self.groupings) == 1:\r\n return self.groupings[0].group_arraylike\r\n\r\n return self.result_index._values\r\n\r\n @cache_readonly\r\n def result_index(self) -> Index:\r\n if len(self.groupings) == 1:\r\n return self.groupings[0].result_index.rename(self.names[0])\r\n\r\n codes = self.reconstructed_codes\r\n levels = [ping.result_index for ping in self.groupings]\r\n return MultiIndex(\r\n levels=levels, codes=codes, verify_integrity=False, names=self.names\r\n )\r\n\r\n @final\r\n def get_group_levels(self) -> list[ArrayLike]:\r\n # Note: only called from _insert_inaxis_grouper_inplace, which\r\n # is only called for BaseGrouper, never for BinGrouper\r\n if len(self.groupings) == 1:\r\n return [self.groupings[0].result_index]\r\n\r\n name_list = []\r\n for ping, codes in zip(self.groupings, self.reconstructed_codes):\r\n codes = ensure_platform_int(codes)\r\n levels = ping.result_index.take(codes)\r\n\r\n name_list.append(levels)\r\n\r\n return name_list\r\n\r\n # ------------------------------------------------------------\r\n # Aggregation functions\r\n\r\n @final\r\n def _cython_operation(\r\n self,\r\n kind: str,\r\n values,\r\n how: str,\r\n axis: int,\r\n min_count: int = -1,\r\n **kwargs,\r\n ) -> ArrayLike:\r\n \"\"\"\r\n Returns the values of a cython operation.\r\n \"\"\"\r\n assert kind in [\"transform\", \"aggregate\"]\r\n\r\n cy_op = WrappedCythonOp(kind=kind, how=how)\r\n\r\n ids, _, _ = self.group_info\r\n ngroups = self.ngroups\r\n return cy_op.cython_operation(\r\n values=values,\r\n axis=axis,\r\n min_count=min_count,\r\n comp_ids=ids,\r\n ngroups=ngroups,\r\n **kwargs,\r\n )\r\n\r\n @final\r\n def agg_series(\r\n self, obj: Series, func: F, preserve_dtype: bool = False\r\n ) -> ArrayLike:\r\n \"\"\"\r\n Parameters\r\n ----------\r\n obj : Series\r\n func : function taking a Series and returning a scalar-like\r\n preserve_dtype : bool\r\n Whether the aggregation is known to be dtype-preserving.\r\n\r\n Returns\r\n -------\r\n np.ndarray or ExtensionArray\r\n \"\"\"\r\n # test_groupby_empty_with_category gets here with self.ngroups == 0\r\n # and len(obj) > 0\r\n\r\n if len(obj) == 0:\r\n # SeriesGrouper would raise if we were to call _aggregate_series_fast\r\n result = self._aggregate_series_pure_python(obj, func)\r\n\r\n elif not isinstance(obj._values, np.ndarray):\r\n # _aggregate_series_fast would raise TypeError when\r\n # calling libreduction.Slider\r\n # In the datetime64tz case it would incorrectly cast to tz-naive\r\n # TODO: can we get a performant workaround for EAs backed by ndarray?\r\n result = self._aggregate_series_pure_python(obj, func)\r\n\r\n # we can preserve a little bit more aggressively with EA dtype\r\n # because maybe_cast_pointwise_result will do a try/except\r\n # with _from_sequence. NB we are assuming here that _from_sequence\r\n # is sufficiently strict that it casts appropriately.\r\n preserve_dtype = True\r\n\r\n elif obj.index._has_complex_internals:\r\n # Preempt TypeError in _aggregate_series_fast\r\n result = self._aggregate_series_pure_python(obj, func)\r\n\r\n else:\r\n result = self._aggregate_series_fast(obj, func)\r\n\r\n npvalues = lib.maybe_convert_objects(result, try_float=False)\r\n if preserve_dtype:\r\n out = maybe_cast_pointwise_result(npvalues, obj.dtype, numeric_only=True)\r\n else:\r\n out = npvalues\r\n return out\r\n\r\n def _aggregate_series_fast(self, obj: Series, func: F) -> np.ndarray:\r\n # -> np.ndarray[object]\r\n\r\n # At this point we have already checked that\r\n # - obj.index is not a MultiIndex\r\n # - obj is backed by an ndarray, not ExtensionArray\r\n # - len(obj) > 0\r\n func = com.is_builtin_func(func)\r\n\r\n ids, _, ngroups = self.group_info\r\n\r\n # avoids object / Series creation overhead\r\n indexer = get_group_index_sorter(ids, ngroups)\r\n obj = obj.take(indexer)\r\n ids = ids.take(indexer)\r\n sgrouper = libreduction.SeriesGrouper(obj, func, ids, ngroups)\r\n result, _ = sgrouper.get_result()\r\n return result\r\n\r\n @final\r\n def _aggregate_series_pure_python(self, obj: Series, func: F) -> np.ndarray:\r\n # -> np.ndarray[object]\r\n ids, _, ngroups = self.group_info\r\n\r\n counts = np.zeros(ngroups, dtype=int)\r\n result = np.empty(ngroups, dtype=\"O\")\r\n initialized = False\r\n\r\n # equiv: splitter = self._get_splitter(obj, axis=0)\r\n splitter = get_splitter(obj, ids, ngroups, axis=0)\r\n\r\n for i, group in enumerate(splitter):\r\n\r\n # Each step of this loop corresponds to\r\n # libreduction._BaseGrouper._apply_to_group\r\n res = func(group)\r\n res = libreduction.extract_result(res)\r\n\r\n if not initialized:\r\n # We only do this validation on the first iteration\r\n libreduction.check_result_array(res, group.dtype)\r\n initialized = True\r\n\r\n counts[i] = group.shape[0]\r\n result[i] = res\r\n\r\n return result\r\n\r\n\r\nclass BinGrouper(BaseGrouper):\r\n \"\"\"\r\n This is an internal Grouper class\r\n\r\n Parameters\r\n ----------\r\n bins : the split index of binlabels to group the item of axis\r\n binlabels : the label list\r\n mutated : bool, default False\r\n indexer : np.ndarray[np.intp]\r\n\r\n Examples\r\n --------\r\n bins: [2, 4, 6, 8, 10]\r\n binlabels: DatetimeIndex(['2005-01-01', '2005-01-03',\r\n '2005-01-05', '2005-01-07', '2005-01-09'],\r\n dtype='datetime64[ns]', freq='2D')\r\n\r\n the group_info, which contains the label of each item in grouped\r\n axis, the index of label in label list, group number, is\r\n\r\n (array([0, 0, 1, 1, 2, 2, 3, 3, 4, 4]), array([0, 1, 2, 3, 4]), 5)\r\n\r\n means that, the grouped axis has 10 items, can be grouped into 5\r\n labels, the first and second items belong to the first label, the\r\n third and forth items belong to the second label, and so on\r\n\r\n \"\"\"\r\n\r\n bins: np.ndarray # np.ndarray[np.int64]\r\n binlabels: Index\r\n mutated: bool\r\n\r\n def __init__(\r\n self,\r\n bins,\r\n binlabels,\r\n mutated: bool = False,\r\n indexer=None,\r\n ):\r\n self.bins = ensure_int64(bins)\r\n self.binlabels = ensure_index(binlabels)\r\n self.mutated = mutated\r\n self.indexer = indexer\r\n\r\n # These lengths must match, otherwise we could call agg_series\r\n # with empty self.bins, which would raise in libreduction.\r\n assert len(self.binlabels) == len(self.bins)\r\n\r\n @cache_readonly\r\n def groups(self):\r\n \"\"\"dict {group name -> group labels}\"\"\"\r\n # this is mainly for compat\r\n # GH 3881\r\n result = {\r\n key: value\r\n for key, value in zip(self.binlabels, self.bins)\r\n if key is not NaT\r\n }\r\n return result\r\n\r\n @property\r\n def nkeys(self) -> int:\r\n # still matches len(self.groupings), but we can hard-code\r\n return 1\r\n\r\n def _get_grouper(self):\r\n \"\"\"\r\n We are a grouper as part of another's groupings.\r\n\r\n We have a specific method of grouping, so cannot\r\n convert to a Index for our grouper.\r\n \"\"\"\r\n return self\r\n\r\n def get_iterator(self, data: FrameOrSeries, axis: int = 0):\r\n \"\"\"\r\n Groupby iterator\r\n\r\n Returns\r\n -------\r\n Generator yielding sequence of (name, subsetted object)\r\n for each group\r\n \"\"\"\r\n if axis == 0:\r\n slicer = lambda start, edge: data.iloc[start:edge]\r\n else:\r\n slicer = lambda start, edge: data.iloc[:, start:edge]\r\n\r\n length = len(data.axes[axis])\r\n\r\n start = 0\r\n for edge, label in zip(self.bins, self.binlabels):\r\n if label is not NaT:\r\n yield label, slicer(start, edge)\r\n start = edge\r\n\r\n if start < length:\r\n yield self.binlabels[-1], slicer(start, None)\r\n\r\n @cache_readonly\r\n def indices(self):\r\n indices = collections.defaultdict(list)\r\n\r\n i = 0\r\n for label, bin in zip(self.binlabels, self.bins):\r\n if i < bin:\r\n if label is not NaT:\r\n indices[label] = list(range(i, bin))\r\n i = bin\r\n return indices\r\n\r\n @cache_readonly\r\n def group_info(self):\r\n ngroups = self.ngroups\r\n obs_group_ids = np.arange(ngroups, dtype=np.int64)\r\n rep = np.diff(np.r_[0, self.bins])\r\n\r\n rep = ensure_platform_int(rep)\r\n if ngroups == len(self.bins):\r\n comp_ids = np.repeat(np.arange(ngroups), rep)\r\n else:\r\n comp_ids = np.repeat(np.r_[-1, np.arange(ngroups)], rep)\r\n\r\n return (\r\n ensure_platform_int(comp_ids),\r\n obs_group_ids,\r\n ngroups,\r\n )\r\n\r\n @cache_readonly\r\n def reconstructed_codes(self) -> list[np.ndarray]:\r\n # get unique result indices, and prepend 0 as groupby starts from the first\r\n return [np.r_[0, np.flatnonzero(self.bins[1:] != self.bins[:-1]) + 1]]\r\n\r\n @cache_readonly\r\n def result_index(self):\r\n if len(self.binlabels) != 0 and isna(self.binlabels[0]):\r\n return self.binlabels[1:]\r\n\r\n return self.binlabels\r\n\r\n @property\r\n def levels(self) -> list[Index]:\r\n return [self.binlabels]\r\n\r\n @property\r\n def names(self) -> list[Hashable]:\r\n return [self.binlabels.name]\r\n\r\n @property\r\n def groupings(self) -> list[grouper.Grouping]:\r\n lev = self.binlabels\r\n ping = grouper.Grouping(lev, lev, in_axis=False, level=None)\r\n return [ping]\r\n\r\n def _aggregate_series_fast(self, obj: Series, func: F) -> np.ndarray:\r\n # -> np.ndarray[object]\r\n\r\n # At this point we have already checked that\r\n # - obj.index is not a MultiIndex\r\n # - obj is backed by an ndarray, not ExtensionArray\r\n # - ngroups != 0\r\n # - len(self.bins) > 0\r\n sbg = libreduction.SeriesBinGrouper(obj, func, self.bins)\r\n result, _ = sbg.get_result()\r\n return result\r\n\r\n\r\ndef _is_indexed_like(obj, axes, axis: int) -> bool:\r\n if isinstance(obj, Series):\r\n if len(axes) > 1:\r\n return False\r\n return obj.axes[axis].equals(axes[axis])\r\n elif isinstance(obj, DataFrame):\r\n return obj.axes[axis].equals(axes[axis])\r\n\r\n return False\r\n\r\n\r\n# ----------------------------------------------------------------------\r\n# Splitting / application\r\n\r\n\r\nclass DataSplitter(Generic[FrameOrSeries]):\r\n def __init__(self, data: FrameOrSeries, labels, ngroups: int, axis: int = 0):\r\n self.data = data\r\n self.labels = ensure_platform_int(labels) # _should_ already be np.intp\r\n self.ngroups = ngroups\r\n\r\n self.axis = axis\r\n assert isinstance(axis, int), axis\r\n\r\n @cache_readonly\r\n def slabels(self) -> np.ndarray: # np.ndarray[np.intp]\r\n # Sorted labels\r\n return self.labels.take(self._sort_idx)\r\n\r\n @cache_readonly\r\n def _sort_idx(self) -> np.ndarray: # np.ndarray[np.intp]\r\n # Counting sort indexer\r\n return get_group_index_sorter(self.labels, self.ngroups)\r\n\r\n def __iter__(self):\r\n sdata = self.sorted_data\r\n\r\n if self.ngroups == 0:\r\n # we are inside a generator, rather than raise StopIteration\r\n # we merely return signal the end\r\n return\r\n\r\n starts, ends = lib.generate_slices(self.slabels, self.ngroups)\r\n\r\n for start, end in zip(starts, ends):\r\n yield self._chop(sdata, slice(start, end))\r\n\r\n @cache_readonly\r\n def sorted_data(self) -> FrameOrSeries:\r\n return self.data.take(self._sort_idx, axis=self.axis)\r\n\r\n def _chop(self, sdata, slice_obj: slice) -> NDFrame:\r\n raise AbstractMethodError(self)\r\n\r\n\r\nclass SeriesSplitter(DataSplitter):\r\n def _chop(self, sdata: Series, slice_obj: slice) -> Series:\r\n # fastpath equivalent to `sdata.iloc[slice_obj]`\r\n mgr = sdata._mgr.get_slice(slice_obj)\r\n # __finalize__ not called here, must be applied by caller if applicable\r\n\r\n # fastpath equivalent to:\r\n # `return sdata._constructor(mgr, name=sdata.name, fastpath=True)`\r\n obj = type(sdata)._from_mgr(mgr)\r\n object.__setattr__(obj, \"_flags\", sdata._flags)\r\n object.__setattr__(obj, \"_name\", sdata._name)\r\n return obj\r\n\r\n\r\nclass FrameSplitter(DataSplitter):\r\n def fast_apply(self, f: F, sdata: FrameOrSeries, names):\r\n # must return keys::list, values::list, mutated::bool\r\n starts, ends = lib.generate_slices(self.slabels, self.ngroups)\r\n return libreduction.apply_frame_axis0(sdata, f, names, starts, ends)\r\n\r\n def _chop(self, sdata: DataFrame, slice_obj: slice) -> DataFrame:\r\n # Fastpath equivalent to:\r\n # if self.axis == 0:\r\n # return sdata.iloc[slice_obj]\r\n # else:\r\n # return sdata.iloc[:, slice_obj]\r\n mgr = sdata._mgr.get_slice(slice_obj, axis=1 - self.axis)\r\n # __finalize__ not called here, must be applied by caller if applicable\r\n\r\n # fastpath equivalent to `return sdata._constructor(mgr)`\r\n obj = type(sdata)._from_mgr(mgr)\r\n object.__setattr__(obj, \"_flags\", sdata._flags)\r\n return obj\r\n\r\n\r\ndef get_splitter(\r\n data: FrameOrSeries, labels: np.ndarray, ngroups: int, axis: int = 0\r\n) -> DataSplitter:\r\n if isinstance(data, Series):\r\n klass: type[DataSplitter] = SeriesSplitter\r\n else:\r\n # i.e. DataFrame\r\n klass = FrameSplitter\r\n\r\n return klass(data, labels, ngroups, axis)\r\n",
"import pytest\r\n\r\nimport pandas as pd\r\nfrom pandas import (\r\n Categorical,\r\n DataFrame,\r\n Series,\r\n)\r\nimport pandas._testing as tm\r\n\r\n\r\ndef _assert_series_equal_both(a, b, **kwargs):\r\n \"\"\"\r\n Check that two Series equal.\r\n\r\n This check is performed commutatively.\r\n\r\n Parameters\r\n ----------\r\n a : Series\r\n The first Series to compare.\r\n b : Series\r\n The second Series to compare.\r\n kwargs : dict\r\n The arguments passed to `tm.assert_series_equal`.\r\n \"\"\"\r\n tm.assert_series_equal(a, b, **kwargs)\r\n tm.assert_series_equal(b, a, **kwargs)\r\n\r\n\r\ndef _assert_not_series_equal(a, b, **kwargs):\r\n \"\"\"\r\n Check that two Series are not equal.\r\n\r\n Parameters\r\n ----------\r\n a : Series\r\n The first Series to compare.\r\n b : Series\r\n The second Series to compare.\r\n kwargs : dict\r\n The arguments passed to `tm.assert_series_equal`.\r\n \"\"\"\r\n try:\r\n tm.assert_series_equal(a, b, **kwargs)\r\n msg = \"The two Series were equal when they shouldn't have been\"\r\n\r\n pytest.fail(msg=msg)\r\n except AssertionError:\r\n pass\r\n\r\n\r\ndef _assert_not_series_equal_both(a, b, **kwargs):\r\n \"\"\"\r\n Check that two Series are not equal.\r\n\r\n This check is performed commutatively.\r\n\r\n Parameters\r\n ----------\r\n a : Series\r\n The first Series to compare.\r\n b : Series\r\n The second Series to compare.\r\n kwargs : dict\r\n The arguments passed to `tm.assert_series_equal`.\r\n \"\"\"\r\n _assert_not_series_equal(a, b, **kwargs)\r\n _assert_not_series_equal(b, a, **kwargs)\r\n\r\n\r\[email protected](\"data\", [range(3), list(\"abc\"), list(\"áàä\")])\r\ndef test_series_equal(data):\r\n _assert_series_equal_both(Series(data), Series(data))\r\n\r\n\r\[email protected](\r\n \"data1,data2\",\r\n [\r\n (range(3), range(1, 4)),\r\n (list(\"abc\"), list(\"xyz\")),\r\n (list(\"áàä\"), list(\"éèë\")),\r\n (list(\"áàä\"), list(b\"aaa\")),\r\n (range(3), range(4)),\r\n ],\r\n)\r\ndef test_series_not_equal_value_mismatch(data1, data2):\r\n _assert_not_series_equal_both(Series(data1), Series(data2))\r\n\r\n\r\[email protected](\r\n \"kwargs\",\r\n [\r\n {\"dtype\": \"float64\"}, # dtype mismatch\r\n {\"index\": [1, 2, 4]}, # index mismatch\r\n {\"name\": \"foo\"}, # name mismatch\r\n ],\r\n)\r\ndef test_series_not_equal_metadata_mismatch(kwargs):\r\n data = range(3)\r\n s1 = Series(data)\r\n\r\n s2 = Series(data, **kwargs)\r\n _assert_not_series_equal_both(s1, s2)\r\n\r\n\r\[email protected](\"data1,data2\", [(0.12345, 0.12346), (0.1235, 0.1236)])\r\[email protected](\"dtype\", [\"float32\", \"float64\"])\r\[email protected](\"decimals\", [0, 1, 2, 3, 5, 10])\r\ndef test_less_precise(data1, data2, dtype, decimals):\r\n rtol = 10 ** -decimals\r\n s1 = Series([data1], dtype=dtype)\r\n s2 = Series([data2], dtype=dtype)\r\n\r\n if (decimals == 5 or decimals == 10) or (\r\n decimals >= 3 and abs(data1 - data2) >= 0.0005\r\n ):\r\n msg = \"Series values are different\"\r\n with pytest.raises(AssertionError, match=msg):\r\n tm.assert_series_equal(s1, s2, rtol=rtol)\r\n else:\r\n _assert_series_equal_both(s1, s2, rtol=rtol)\r\n\r\n\r\[email protected](\r\n \"s1,s2,msg\",\r\n [\r\n # Index\r\n (\r\n Series([\"l1\", \"l2\"], index=[1, 2]),\r\n Series([\"l1\", \"l2\"], index=[1.0, 2.0]),\r\n \"Series\\\\.index are different\",\r\n ),\r\n # MultiIndex\r\n (\r\n DataFrame.from_records(\r\n {\"a\": [1, 2], \"b\": [2.1, 1.5], \"c\": [\"l1\", \"l2\"]}, index=[\"a\", \"b\"]\r\n ).c,\r\n DataFrame.from_records(\r\n {\"a\": [1.0, 2.0], \"b\": [2.1, 1.5], \"c\": [\"l1\", \"l2\"]}, index=[\"a\", \"b\"]\r\n ).c,\r\n \"MultiIndex level \\\\[0\\\\] are different\",\r\n ),\r\n ],\r\n)\r\ndef test_series_equal_index_dtype(s1, s2, msg, check_index_type):\r\n kwargs = {\"check_index_type\": check_index_type}\r\n\r\n if check_index_type:\r\n with pytest.raises(AssertionError, match=msg):\r\n tm.assert_series_equal(s1, s2, **kwargs)\r\n else:\r\n tm.assert_series_equal(s1, s2, **kwargs)\r\n\r\n\r\ndef test_series_equal_length_mismatch(rtol):\r\n msg = \"\"\"Series are different\r\n\r\nSeries length are different\r\n\\\\[left\\\\]: 3, RangeIndex\\\\(start=0, stop=3, step=1\\\\)\r\n\\\\[right\\\\]: 4, RangeIndex\\\\(start=0, stop=4, step=1\\\\)\"\"\"\r\n\r\n s1 = Series([1, 2, 3])\r\n s2 = Series([1, 2, 3, 4])\r\n\r\n with pytest.raises(AssertionError, match=msg):\r\n tm.assert_series_equal(s1, s2, rtol=rtol)\r\n\r\n\r\ndef test_series_equal_numeric_values_mismatch(rtol):\r\n msg = \"\"\"Series are different\r\n\r\nSeries values are different \\\\(33\\\\.33333 %\\\\)\r\n\\\\[index\\\\]: \\\\[0, 1, 2\\\\]\r\n\\\\[left\\\\]: \\\\[1, 2, 3\\\\]\r\n\\\\[right\\\\]: \\\\[1, 2, 4\\\\]\"\"\"\r\n\r\n s1 = Series([1, 2, 3])\r\n s2 = Series([1, 2, 4])\r\n\r\n with pytest.raises(AssertionError, match=msg):\r\n tm.assert_series_equal(s1, s2, rtol=rtol)\r\n\r\n\r\ndef test_series_equal_categorical_values_mismatch(rtol):\r\n msg = \"\"\"Series are different\r\n\r\nSeries values are different \\\\(66\\\\.66667 %\\\\)\r\n\\\\[index\\\\]: \\\\[0, 1, 2\\\\]\r\n\\\\[left\\\\]: \\\\['a', 'b', 'c'\\\\]\r\nCategories \\\\(3, object\\\\): \\\\['a', 'b', 'c'\\\\]\r\n\\\\[right\\\\]: \\\\['a', 'c', 'b'\\\\]\r\nCategories \\\\(3, object\\\\): \\\\['a', 'b', 'c'\\\\]\"\"\"\r\n\r\n s1 = Series(Categorical([\"a\", \"b\", \"c\"]))\r\n s2 = Series(Categorical([\"a\", \"c\", \"b\"]))\r\n\r\n with pytest.raises(AssertionError, match=msg):\r\n tm.assert_series_equal(s1, s2, rtol=rtol)\r\n\r\n\r\ndef test_series_equal_datetime_values_mismatch(rtol):\r\n msg = \"\"\"numpy array are different\r\n\r\nnumpy array values are different \\\\(100.0 %\\\\)\r\n\\\\[index\\\\]: \\\\[0, 1, 2\\\\]\r\n\\\\[left\\\\]: \\\\[1514764800000000000, 1514851200000000000, 1514937600000000000\\\\]\r\n\\\\[right\\\\]: \\\\[1549065600000000000, 1549152000000000000, 1549238400000000000\\\\]\"\"\"\r\n\r\n s1 = Series(pd.date_range(\"2018-01-01\", periods=3, freq=\"D\"))\r\n s2 = Series(pd.date_range(\"2019-02-02\", periods=3, freq=\"D\"))\r\n\r\n with pytest.raises(AssertionError, match=msg):\r\n tm.assert_series_equal(s1, s2, rtol=rtol)\r\n\r\n\r\ndef test_series_equal_categorical_mismatch(check_categorical):\r\n msg = \"\"\"Attributes of Series are different\r\n\r\nAttribute \"dtype\" are different\r\n\\\\[left\\\\]: CategoricalDtype\\\\(categories=\\\\['a', 'b'\\\\], ordered=False\\\\)\r\n\\\\[right\\\\]: CategoricalDtype\\\\(categories=\\\\['a', 'b', 'c'\\\\], \\\r\nordered=False\\\\)\"\"\"\r\n\r\n s1 = Series(Categorical([\"a\", \"b\"]))\r\n s2 = Series(Categorical([\"a\", \"b\"], categories=list(\"abc\")))\r\n\r\n if check_categorical:\r\n with pytest.raises(AssertionError, match=msg):\r\n tm.assert_series_equal(s1, s2, check_categorical=check_categorical)\r\n else:\r\n _assert_series_equal_both(s1, s2, check_categorical=check_categorical)\r\n\r\n\r\ndef test_assert_series_equal_extension_dtype_mismatch():\r\n # https://github.com/pandas-dev/pandas/issues/32747\r\n left = Series(pd.array([1, 2, 3], dtype=\"Int64\"))\r\n right = left.astype(int)\r\n\r\n msg = \"\"\"Attributes of Series are different\r\n\r\nAttribute \"dtype\" are different\r\n\\\\[left\\\\]: Int64\r\n\\\\[right\\\\]: int[32|64]\"\"\"\r\n\r\n tm.assert_series_equal(left, right, check_dtype=False)\r\n\r\n with pytest.raises(AssertionError, match=msg):\r\n tm.assert_series_equal(left, right, check_dtype=True)\r\n\r\n\r\ndef test_assert_series_equal_interval_dtype_mismatch():\r\n # https://github.com/pandas-dev/pandas/issues/32747\r\n left = Series([pd.Interval(0, 1)], dtype=\"interval\")\r\n right = left.astype(object)\r\n\r\n msg = \"\"\"Attributes of Series are different\r\n\r\nAttribute \"dtype\" are different\r\n\\\\[left\\\\]: interval\\\\[int64, right\\\\]\r\n\\\\[right\\\\]: object\"\"\"\r\n\r\n tm.assert_series_equal(left, right, check_dtype=False)\r\n\r\n with pytest.raises(AssertionError, match=msg):\r\n tm.assert_series_equal(left, right, check_dtype=True)\r\n\r\n\r\ndef test_series_equal_series_type():\r\n class MySeries(Series):\r\n pass\r\n\r\n s1 = Series([1, 2])\r\n s2 = Series([1, 2])\r\n s3 = MySeries([1, 2])\r\n\r\n tm.assert_series_equal(s1, s2, check_series_type=False)\r\n tm.assert_series_equal(s1, s2, check_series_type=True)\r\n\r\n tm.assert_series_equal(s1, s3, check_series_type=False)\r\n tm.assert_series_equal(s3, s1, check_series_type=False)\r\n\r\n with pytest.raises(AssertionError, match=\"Series classes are different\"):\r\n tm.assert_series_equal(s1, s3, check_series_type=True)\r\n\r\n with pytest.raises(AssertionError, match=\"Series classes are different\"):\r\n tm.assert_series_equal(s3, s1, check_series_type=True)\r\n\r\n\r\ndef test_series_equal_exact_for_nonnumeric():\r\n # https://github.com/pandas-dev/pandas/issues/35446\r\n s1 = Series([\"a\", \"b\"])\r\n s2 = Series([\"a\", \"b\"])\r\n s3 = Series([\"b\", \"a\"])\r\n\r\n tm.assert_series_equal(s1, s2, check_exact=True)\r\n tm.assert_series_equal(s2, s1, check_exact=True)\r\n\r\n msg = \"\"\"Series are different\r\n\r\nSeries values are different \\\\(100\\\\.0 %\\\\)\r\n\\\\[index\\\\]: \\\\[0, 1\\\\]\r\n\\\\[left\\\\]: \\\\[a, b\\\\]\r\n\\\\[right\\\\]: \\\\[b, a\\\\]\"\"\"\r\n with pytest.raises(AssertionError, match=msg):\r\n tm.assert_series_equal(s1, s3, check_exact=True)\r\n\r\n msg = \"\"\"Series are different\r\n\r\nSeries values are different \\\\(100\\\\.0 %\\\\)\r\n\\\\[index\\\\]: \\\\[0, 1\\\\]\r\n\\\\[left\\\\]: \\\\[b, a\\\\]\r\n\\\\[right\\\\]: \\\\[a, b\\\\]\"\"\"\r\n with pytest.raises(AssertionError, match=msg):\r\n tm.assert_series_equal(s3, s1, check_exact=True)\r\n\r\n\r\[email protected](\"right_dtype\", [\"Int32\", \"int64\"])\r\ndef test_assert_series_equal_ignore_extension_dtype_mismatch(right_dtype):\r\n # https://github.com/pandas-dev/pandas/issues/35715\r\n left = Series([1, 2, 3], dtype=\"Int64\")\r\n right = Series([1, 2, 3], dtype=right_dtype)\r\n tm.assert_series_equal(left, right, check_dtype=False)\r\n\r\n\r\ndef test_allows_duplicate_labels():\r\n left = Series([1])\r\n right = Series([1]).set_flags(allows_duplicate_labels=False)\r\n tm.assert_series_equal(left, left)\r\n tm.assert_series_equal(right, right)\r\n tm.assert_series_equal(left, right, check_flags=False)\r\n tm.assert_series_equal(right, left, check_flags=False)\r\n\r\n with pytest.raises(AssertionError, match=\"<Flags\"):\r\n tm.assert_series_equal(left, right)\r\n\r\n with pytest.raises(AssertionError, match=\"<Flags\"):\r\n tm.assert_series_equal(left, right)\r\n\r\n\r\ndef test_assert_series_equal_identical_na(nulls_fixture):\r\n ser = Series([nulls_fixture])\r\n\r\n tm.assert_series_equal(ser, ser.copy())\r\n\r\n # while we're here do Index too\r\n idx = pd.Index(ser)\r\n tm.assert_index_equal(idx, idx.copy(deep=True))\r\n",
"# Author: Alexandre Gramfort <[email protected]>\r\n# Fabian Pedregosa <[email protected]>\r\n# Olivier Grisel <[email protected]>\r\n# Gael Varoquaux <[email protected]>\r\n#\r\n# License: BSD 3 clause\r\n\r\nimport sys\r\nimport warnings\r\nimport numbers\r\nfrom abc import ABC, abstractmethod\r\n\r\nimport numpy as np\r\nfrom scipy import sparse\r\nfrom joblib import Parallel, effective_n_jobs\r\n\r\nfrom ._base import LinearModel, _pre_fit\r\nfrom ..base import RegressorMixin, MultiOutputMixin\r\nfrom ._base import _preprocess_data, _deprecate_normalize\r\nfrom ..utils import check_array\r\nfrom ..utils.validation import check_random_state\r\nfrom ..model_selection import check_cv\r\nfrom ..utils.extmath import safe_sparse_dot\r\nfrom ..utils.fixes import _astype_copy_false, _joblib_parallel_args\r\nfrom ..utils.validation import (\r\n _check_sample_weight,\r\n check_consistent_length,\r\n check_is_fitted,\r\n column_or_1d,\r\n)\r\nfrom ..utils.fixes import delayed\r\n\r\n# mypy error: Module 'sklearn.linear_model' has no attribute '_cd_fast'\r\nfrom . import _cd_fast as cd_fast # type: ignore\r\n\r\n\r\ndef _set_order(X, y, order=\"C\"):\r\n \"\"\"Change the order of X and y if necessary.\r\n\r\n Parameters\r\n ----------\r\n X : {array-like, sparse matrix} of shape (n_samples, n_features)\r\n Training data.\r\n\r\n y : ndarray of shape (n_samples,)\r\n Target values.\r\n\r\n order : {None, 'C', 'F'}\r\n If 'C', dense arrays are returned as C-ordered, sparse matrices in csr\r\n format. If 'F', dense arrays are return as F-ordered, sparse matrices\r\n in csc format.\r\n\r\n Returns\r\n -------\r\n X : {array-like, sparse matrix} of shape (n_samples, n_features)\r\n Training data with guaranteed order.\r\n\r\n y : ndarray of shape (n_samples,)\r\n Target values with guaranteed order.\r\n \"\"\"\r\n if order not in [None, \"C\", \"F\"]:\r\n raise ValueError(\r\n \"Unknown value for order. Got {} instead of None, 'C' or 'F'.\".format(order)\r\n )\r\n sparse_X = sparse.issparse(X)\r\n sparse_y = sparse.issparse(y)\r\n if order is not None:\r\n sparse_format = \"csc\" if order == \"F\" else \"csr\"\r\n if sparse_X:\r\n # As of scipy 1.1.0, new argument copy=False by default.\r\n # This is what we want.\r\n X = X.asformat(sparse_format, **_astype_copy_false(X))\r\n else:\r\n X = np.asarray(X, order=order)\r\n if sparse_y:\r\n y = y.asformat(sparse_format)\r\n else:\r\n y = np.asarray(y, order=order)\r\n return X, y\r\n\r\n\r\n###############################################################################\r\n# Paths functions\r\n\r\n\r\ndef _alpha_grid(\r\n X,\r\n y,\r\n Xy=None,\r\n l1_ratio=1.0,\r\n fit_intercept=True,\r\n eps=1e-3,\r\n n_alphas=100,\r\n normalize=False,\r\n copy_X=True,\r\n):\r\n \"\"\"Compute the grid of alpha values for elastic net parameter search\r\n\r\n Parameters\r\n ----------\r\n X : {array-like, sparse matrix} of shape (n_samples, n_features)\r\n Training data. Pass directly as Fortran-contiguous data to avoid\r\n unnecessary memory duplication\r\n\r\n y : ndarray of shape (n_samples,) or (n_samples, n_outputs)\r\n Target values\r\n\r\n Xy : array-like of shape (n_features,) or (n_features, n_outputs),\\\r\n default=None\r\n Xy = np.dot(X.T, y) that can be precomputed.\r\n\r\n l1_ratio : float, default=1.0\r\n The elastic net mixing parameter, with ``0 < l1_ratio <= 1``.\r\n For ``l1_ratio = 0`` the penalty is an L2 penalty. (currently not\r\n supported) ``For l1_ratio = 1`` it is an L1 penalty. For\r\n ``0 < l1_ratio <1``, the penalty is a combination of L1 and L2.\r\n\r\n eps : float, default=1e-3\r\n Length of the path. ``eps=1e-3`` means that\r\n ``alpha_min / alpha_max = 1e-3``\r\n\r\n n_alphas : int, default=100\r\n Number of alphas along the regularization path\r\n\r\n fit_intercept : bool, default=True\r\n Whether to fit an intercept or not\r\n\r\n normalize : bool, default=False\r\n This parameter is ignored when ``fit_intercept`` is set to False.\r\n If True, the regressors X will be normalized before regression by\r\n subtracting the mean and dividing by the l2-norm.\r\n If you wish to standardize, please use\r\n :class:`~sklearn.preprocessing.StandardScaler` before calling ``fit``\r\n on an estimator with ``normalize=False``.\r\n\r\n .. deprecated:: 1.0\r\n ``normalize`` was deprecated in version 1.0 and will be removed in\r\n 1.2.\r\n\r\n copy_X : bool, default=True\r\n If ``True``, X will be copied; else, it may be overwritten.\r\n \"\"\"\r\n if l1_ratio == 0:\r\n raise ValueError(\r\n \"Automatic alpha grid generation is not supported for\"\r\n \" l1_ratio=0. Please supply a grid by providing \"\r\n \"your estimator with the appropriate `alphas=` \"\r\n \"argument.\"\r\n )\r\n n_samples = len(y)\r\n\r\n sparse_center = False\r\n if Xy is None:\r\n X_sparse = sparse.isspmatrix(X)\r\n sparse_center = X_sparse and (fit_intercept or normalize)\r\n X = check_array(\r\n X, accept_sparse=\"csc\", copy=(copy_X and fit_intercept and not X_sparse)\r\n )\r\n if not X_sparse:\r\n # X can be touched inplace thanks to the above line\r\n X, y, _, _, _ = _preprocess_data(X, y, fit_intercept, normalize, copy=False)\r\n Xy = safe_sparse_dot(X.T, y, dense_output=True)\r\n\r\n if sparse_center:\r\n # Workaround to find alpha_max for sparse matrices.\r\n # since we should not destroy the sparsity of such matrices.\r\n _, _, X_offset, _, X_scale = _preprocess_data(\r\n X, y, fit_intercept, normalize, return_mean=True\r\n )\r\n mean_dot = X_offset * np.sum(y)\r\n\r\n if Xy.ndim == 1:\r\n Xy = Xy[:, np.newaxis]\r\n\r\n if sparse_center:\r\n if fit_intercept:\r\n Xy -= mean_dot[:, np.newaxis]\r\n if normalize:\r\n Xy /= X_scale[:, np.newaxis]\r\n\r\n alpha_max = np.sqrt(np.sum(Xy ** 2, axis=1)).max() / (n_samples * l1_ratio)\r\n\r\n if alpha_max <= np.finfo(float).resolution:\r\n alphas = np.empty(n_alphas)\r\n alphas.fill(np.finfo(float).resolution)\r\n return alphas\r\n\r\n return np.logspace(np.log10(alpha_max * eps), np.log10(alpha_max), num=n_alphas)[\r\n ::-1\r\n ]\r\n\r\n\r\ndef lasso_path(\r\n X,\r\n y,\r\n *,\r\n eps=1e-3,\r\n n_alphas=100,\r\n alphas=None,\r\n precompute=\"auto\",\r\n Xy=None,\r\n copy_X=True,\r\n coef_init=None,\r\n verbose=False,\r\n return_n_iter=False,\r\n positive=False,\r\n **params,\r\n):\r\n \"\"\"Compute Lasso path with coordinate descent.\r\n\r\n The Lasso optimization function varies for mono and multi-outputs.\r\n\r\n For mono-output tasks it is::\r\n\r\n (1 / (2 * n_samples)) * ||y - Xw||^2_2 + alpha * ||w||_1\r\n\r\n For multi-output tasks it is::\r\n\r\n (1 / (2 * n_samples)) * ||Y - XW||^2_Fro + alpha * ||W||_21\r\n\r\n Where::\r\n\r\n ||W||_21 = \\\\sum_i \\\\sqrt{\\\\sum_j w_{ij}^2}\r\n\r\n i.e. the sum of norm of each row.\r\n\r\n Read more in the :ref:`User Guide <lasso>`.\r\n\r\n Parameters\r\n ----------\r\n X : {array-like, sparse matrix} of shape (n_samples, n_features)\r\n Training data. Pass directly as Fortran-contiguous data to avoid\r\n unnecessary memory duplication. If ``y`` is mono-output then ``X``\r\n can be sparse.\r\n\r\n y : {array-like, sparse matrix} of shape (n_samples,) or \\\r\n (n_samples, n_targets)\r\n Target values.\r\n\r\n eps : float, default=1e-3\r\n Length of the path. ``eps=1e-3`` means that\r\n ``alpha_min / alpha_max = 1e-3``.\r\n\r\n n_alphas : int, default=100\r\n Number of alphas along the regularization path.\r\n\r\n alphas : ndarray, default=None\r\n List of alphas where to compute the models.\r\n If ``None`` alphas are set automatically.\r\n\r\n precompute : 'auto', bool or array-like of shape \\\r\n (n_features, n_features), default='auto'\r\n Whether to use a precomputed Gram matrix to speed up\r\n calculations. If set to ``'auto'`` let us decide. The Gram\r\n matrix can also be passed as argument.\r\n\r\n Xy : array-like of shape (n_features,) or (n_features, n_targets),\\\r\n default=None\r\n Xy = np.dot(X.T, y) that can be precomputed. It is useful\r\n only when the Gram matrix is precomputed.\r\n\r\n copy_X : bool, default=True\r\n If ``True``, X will be copied; else, it may be overwritten.\r\n\r\n coef_init : ndarray of shape (n_features, ), default=None\r\n The initial values of the coefficients.\r\n\r\n verbose : bool or int, default=False\r\n Amount of verbosity.\r\n\r\n return_n_iter : bool, default=False\r\n Whether to return the number of iterations or not.\r\n\r\n positive : bool, default=False\r\n If set to True, forces coefficients to be positive.\r\n (Only allowed when ``y.ndim == 1``).\r\n\r\n **params : kwargs\r\n Keyword arguments passed to the coordinate descent solver.\r\n\r\n Returns\r\n -------\r\n alphas : ndarray of shape (n_alphas,)\r\n The alphas along the path where models are computed.\r\n\r\n coefs : ndarray of shape (n_features, n_alphas) or \\\r\n (n_targets, n_features, n_alphas)\r\n Coefficients along the path.\r\n\r\n dual_gaps : ndarray of shape (n_alphas,)\r\n The dual gaps at the end of the optimization for each alpha.\r\n\r\n n_iters : list of int\r\n The number of iterations taken by the coordinate descent optimizer to\r\n reach the specified tolerance for each alpha.\r\n\r\n See Also\r\n --------\r\n lars_path : Compute Least Angle Regression or Lasso path using LARS\r\n algorithm.\r\n Lasso : The Lasso is a linear model that estimates sparse coefficients.\r\n LassoLars : Lasso model fit with Least Angle Regression a.k.a. Lars.\r\n LassoCV : Lasso linear model with iterative fitting along a regularization\r\n path.\r\n LassoLarsCV : Cross-validated Lasso using the LARS algorithm.\r\n sklearn.decomposition.sparse_encode : Estimator that can be used to\r\n transform signals into sparse linear combination of atoms from a fixed.\r\n\r\n Notes\r\n -----\r\n For an example, see\r\n :ref:`examples/linear_model/plot_lasso_coordinate_descent_path.py\r\n <sphx_glr_auto_examples_linear_model_plot_lasso_coordinate_descent_path.py>`.\r\n\r\n To avoid unnecessary memory duplication the X argument of the fit method\r\n should be directly passed as a Fortran-contiguous numpy array.\r\n\r\n Note that in certain cases, the Lars solver may be significantly\r\n faster to implement this functionality. In particular, linear\r\n interpolation can be used to retrieve model coefficients between the\r\n values output by lars_path\r\n\r\n Examples\r\n --------\r\n\r\n Comparing lasso_path and lars_path with interpolation:\r\n\r\n >>> import numpy as np\r\n >>> from sklearn.linear_model import lasso_path\r\n >>> X = np.array([[1, 2, 3.1], [2.3, 5.4, 4.3]]).T\r\n >>> y = np.array([1, 2, 3.1])\r\n >>> # Use lasso_path to compute a coefficient path\r\n >>> _, coef_path, _ = lasso_path(X, y, alphas=[5., 1., .5])\r\n >>> print(coef_path)\r\n [[0. 0. 0.46874778]\r\n [0.2159048 0.4425765 0.23689075]]\r\n\r\n >>> # Now use lars_path and 1D linear interpolation to compute the\r\n >>> # same path\r\n >>> from sklearn.linear_model import lars_path\r\n >>> alphas, active, coef_path_lars = lars_path(X, y, method='lasso')\r\n >>> from scipy import interpolate\r\n >>> coef_path_continuous = interpolate.interp1d(alphas[::-1],\r\n ... coef_path_lars[:, ::-1])\r\n >>> print(coef_path_continuous([5., 1., .5]))\r\n [[0. 0. 0.46915237]\r\n [0.2159048 0.4425765 0.23668876]]\r\n \"\"\"\r\n return enet_path(\r\n X,\r\n y,\r\n l1_ratio=1.0,\r\n eps=eps,\r\n n_alphas=n_alphas,\r\n alphas=alphas,\r\n precompute=precompute,\r\n Xy=Xy,\r\n copy_X=copy_X,\r\n coef_init=coef_init,\r\n verbose=verbose,\r\n positive=positive,\r\n return_n_iter=return_n_iter,\r\n **params,\r\n )\r\n\r\n\r\ndef enet_path(\r\n X,\r\n y,\r\n *,\r\n l1_ratio=0.5,\r\n eps=1e-3,\r\n n_alphas=100,\r\n alphas=None,\r\n precompute=\"auto\",\r\n Xy=None,\r\n copy_X=True,\r\n coef_init=None,\r\n verbose=False,\r\n return_n_iter=False,\r\n positive=False,\r\n check_input=True,\r\n **params,\r\n):\r\n \"\"\"Compute elastic net path with coordinate descent.\r\n\r\n The elastic net optimization function varies for mono and multi-outputs.\r\n\r\n For mono-output tasks it is::\r\n\r\n 1 / (2 * n_samples) * ||y - Xw||^2_2\r\n + alpha * l1_ratio * ||w||_1\r\n + 0.5 * alpha * (1 - l1_ratio) * ||w||^2_2\r\n\r\n For multi-output tasks it is::\r\n\r\n (1 / (2 * n_samples)) * ||Y - XW||_Fro^2\r\n + alpha * l1_ratio * ||W||_21\r\n + 0.5 * alpha * (1 - l1_ratio) * ||W||_Fro^2\r\n\r\n Where::\r\n\r\n ||W||_21 = \\\\sum_i \\\\sqrt{\\\\sum_j w_{ij}^2}\r\n\r\n i.e. the sum of norm of each row.\r\n\r\n Read more in the :ref:`User Guide <elastic_net>`.\r\n\r\n Parameters\r\n ----------\r\n X : {array-like, sparse matrix} of shape (n_samples, n_features)\r\n Training data. Pass directly as Fortran-contiguous data to avoid\r\n unnecessary memory duplication. If ``y`` is mono-output then ``X``\r\n can be sparse.\r\n\r\n y : {array-like, sparse matrix} of shape (n_samples,) or \\\r\n (n_samples, n_targets)\r\n Target values.\r\n\r\n l1_ratio : float, default=0.5\r\n Number between 0 and 1 passed to elastic net (scaling between\r\n l1 and l2 penalties). ``l1_ratio=1`` corresponds to the Lasso.\r\n\r\n eps : float, default=1e-3\r\n Length of the path. ``eps=1e-3`` means that\r\n ``alpha_min / alpha_max = 1e-3``.\r\n\r\n n_alphas : int, default=100\r\n Number of alphas along the regularization path.\r\n\r\n alphas : ndarray, default=None\r\n List of alphas where to compute the models.\r\n If None alphas are set automatically.\r\n\r\n precompute : 'auto', bool or array-like of shape \\\r\n (n_features, n_features), default='auto'\r\n Whether to use a precomputed Gram matrix to speed up\r\n calculations. If set to ``'auto'`` let us decide. The Gram\r\n matrix can also be passed as argument.\r\n\r\n Xy : array-like of shape (n_features,) or (n_features, n_targets),\\\r\n default=None\r\n Xy = np.dot(X.T, y) that can be precomputed. It is useful\r\n only when the Gram matrix is precomputed.\r\n\r\n copy_X : bool, default=True\r\n If ``True``, X will be copied; else, it may be overwritten.\r\n\r\n coef_init : ndarray of shape (n_features, ), default=None\r\n The initial values of the coefficients.\r\n\r\n verbose : bool or int, default=False\r\n Amount of verbosity.\r\n\r\n return_n_iter : bool, default=False\r\n Whether to return the number of iterations or not.\r\n\r\n positive : bool, default=False\r\n If set to True, forces coefficients to be positive.\r\n (Only allowed when ``y.ndim == 1``).\r\n\r\n check_input : bool, default=True\r\n If set to False, the input validation checks are skipped (including the\r\n Gram matrix when provided). It is assumed that they are handled\r\n by the caller.\r\n\r\n **params : kwargs\r\n Keyword arguments passed to the coordinate descent solver.\r\n\r\n Returns\r\n -------\r\n alphas : ndarray of shape (n_alphas,)\r\n The alphas along the path where models are computed.\r\n\r\n coefs : ndarray of shape (n_features, n_alphas) or \\\r\n (n_targets, n_features, n_alphas)\r\n Coefficients along the path.\r\n\r\n dual_gaps : ndarray of shape (n_alphas,)\r\n The dual gaps at the end of the optimization for each alpha.\r\n\r\n n_iters : list of int\r\n The number of iterations taken by the coordinate descent optimizer to\r\n reach the specified tolerance for each alpha.\r\n (Is returned when ``return_n_iter`` is set to True).\r\n\r\n See Also\r\n --------\r\n MultiTaskElasticNet : Multi-task ElasticNet model trained with L1/L2 mixed-norm \\\r\n as regularizer.\r\n MultiTaskElasticNetCV : Multi-task L1/L2 ElasticNet with built-in cross-validation.\r\n ElasticNet : Linear regression with combined L1 and L2 priors as regularizer.\r\n ElasticNetCV : Elastic Net model with iterative fitting along a regularization path.\r\n\r\n Notes\r\n -----\r\n For an example, see\r\n :ref:`examples/linear_model/plot_lasso_coordinate_descent_path.py\r\n <sphx_glr_auto_examples_linear_model_plot_lasso_coordinate_descent_path.py>`.\r\n \"\"\"\r\n X_offset_param = params.pop(\"X_offset\", None)\r\n X_scale_param = params.pop(\"X_scale\", None)\r\n tol = params.pop(\"tol\", 1e-4)\r\n max_iter = params.pop(\"max_iter\", 1000)\r\n random_state = params.pop(\"random_state\", None)\r\n selection = params.pop(\"selection\", \"cyclic\")\r\n\r\n if len(params) > 0:\r\n raise ValueError(\"Unexpected parameters in params\", params.keys())\r\n\r\n # We expect X and y to be already Fortran ordered when bypassing\r\n # checks\r\n if check_input:\r\n X = check_array(\r\n X,\r\n accept_sparse=\"csc\",\r\n dtype=[np.float64, np.float32],\r\n order=\"F\",\r\n copy=copy_X,\r\n )\r\n y = check_array(\r\n y,\r\n accept_sparse=\"csc\",\r\n dtype=X.dtype.type,\r\n order=\"F\",\r\n copy=False,\r\n ensure_2d=False,\r\n )\r\n if Xy is not None:\r\n # Xy should be a 1d contiguous array or a 2D C ordered array\r\n Xy = check_array(\r\n Xy, dtype=X.dtype.type, order=\"C\", copy=False, ensure_2d=False\r\n )\r\n\r\n n_samples, n_features = X.shape\r\n\r\n multi_output = False\r\n if y.ndim != 1:\r\n multi_output = True\r\n n_targets = y.shape[1]\r\n\r\n if multi_output and positive:\r\n raise ValueError(\"positive=True is not allowed for multi-output (y.ndim != 1)\")\r\n\r\n # MultiTaskElasticNet does not support sparse matrices\r\n if not multi_output and sparse.isspmatrix(X):\r\n if X_offset_param is not None:\r\n # As sparse matrices are not actually centered we need this\r\n # to be passed to the CD solver.\r\n X_sparse_scaling = X_offset_param / X_scale_param\r\n X_sparse_scaling = np.asarray(X_sparse_scaling, dtype=X.dtype)\r\n else:\r\n X_sparse_scaling = np.zeros(n_features, dtype=X.dtype)\r\n\r\n # X should be normalized and fit already if function is called\r\n # from ElasticNet.fit\r\n if check_input:\r\n X, y, X_offset, y_offset, X_scale, precompute, Xy = _pre_fit(\r\n X,\r\n y,\r\n Xy,\r\n precompute,\r\n normalize=False,\r\n fit_intercept=False,\r\n copy=False,\r\n check_input=check_input,\r\n )\r\n if alphas is None:\r\n # No need to normalize of fit_intercept: it has been done\r\n # above\r\n alphas = _alpha_grid(\r\n X,\r\n y,\r\n Xy=Xy,\r\n l1_ratio=l1_ratio,\r\n fit_intercept=False,\r\n eps=eps,\r\n n_alphas=n_alphas,\r\n normalize=False,\r\n copy_X=False,\r\n )\r\n else:\r\n alphas = np.sort(alphas)[::-1] # make sure alphas are properly ordered\r\n\r\n n_alphas = len(alphas)\r\n dual_gaps = np.empty(n_alphas)\r\n n_iters = []\r\n\r\n rng = check_random_state(random_state)\r\n if selection not in [\"random\", \"cyclic\"]:\r\n raise ValueError(\"selection should be either random or cyclic.\")\r\n random = selection == \"random\"\r\n\r\n if not multi_output:\r\n coefs = np.empty((n_features, n_alphas), dtype=X.dtype)\r\n else:\r\n coefs = np.empty((n_targets, n_features, n_alphas), dtype=X.dtype)\r\n\r\n if coef_init is None:\r\n coef_ = np.zeros(coefs.shape[:-1], dtype=X.dtype, order=\"F\")\r\n else:\r\n coef_ = np.asfortranarray(coef_init, dtype=X.dtype)\r\n\r\n for i, alpha in enumerate(alphas):\r\n # account for n_samples scaling in objectives between here and cd_fast\r\n l1_reg = alpha * l1_ratio * n_samples\r\n l2_reg = alpha * (1.0 - l1_ratio) * n_samples\r\n if not multi_output and sparse.isspmatrix(X):\r\n model = cd_fast.sparse_enet_coordinate_descent(\r\n coef_,\r\n l1_reg,\r\n l2_reg,\r\n X.data,\r\n X.indices,\r\n X.indptr,\r\n y,\r\n X_sparse_scaling,\r\n max_iter,\r\n tol,\r\n rng,\r\n random,\r\n positive,\r\n )\r\n elif multi_output:\r\n model = cd_fast.enet_coordinate_descent_multi_task(\r\n coef_, l1_reg, l2_reg, X, y, max_iter, tol, rng, random\r\n )\r\n elif isinstance(precompute, np.ndarray):\r\n # We expect precompute to be already Fortran ordered when bypassing\r\n # checks\r\n if check_input:\r\n precompute = check_array(precompute, dtype=X.dtype.type, order=\"C\")\r\n model = cd_fast.enet_coordinate_descent_gram(\r\n coef_,\r\n l1_reg,\r\n l2_reg,\r\n precompute,\r\n Xy,\r\n y,\r\n max_iter,\r\n tol,\r\n rng,\r\n random,\r\n positive,\r\n )\r\n elif precompute is False:\r\n model = cd_fast.enet_coordinate_descent(\r\n coef_, l1_reg, l2_reg, X, y, max_iter, tol, rng, random, positive\r\n )\r\n else:\r\n raise ValueError(\r\n \"Precompute should be one of True, False, 'auto' or array-like. Got %r\"\r\n % precompute\r\n )\r\n coef_, dual_gap_, eps_, n_iter_ = model\r\n coefs[..., i] = coef_\r\n # we correct the scale of the returned dual gap, as the objective\r\n # in cd_fast is n_samples * the objective in this docstring.\r\n dual_gaps[i] = dual_gap_ / n_samples\r\n n_iters.append(n_iter_)\r\n\r\n if verbose:\r\n if verbose > 2:\r\n print(model)\r\n elif verbose > 1:\r\n print(\"Path: %03i out of %03i\" % (i, n_alphas))\r\n else:\r\n sys.stderr.write(\".\")\r\n\r\n if return_n_iter:\r\n return alphas, coefs, dual_gaps, n_iters\r\n return alphas, coefs, dual_gaps\r\n\r\n\r\n###############################################################################\r\n# ElasticNet model\r\n\r\n\r\nclass ElasticNet(MultiOutputMixin, RegressorMixin, LinearModel):\r\n \"\"\"Linear regression with combined L1 and L2 priors as regularizer.\r\n\r\n Minimizes the objective function::\r\n\r\n 1 / (2 * n_samples) * ||y - Xw||^2_2\r\n + alpha * l1_ratio * ||w||_1\r\n + 0.5 * alpha * (1 - l1_ratio) * ||w||^2_2\r\n\r\n If you are interested in controlling the L1 and L2 penalty\r\n separately, keep in mind that this is equivalent to::\r\n\r\n a * ||w||_1 + 0.5 * b * ||w||_2^2\r\n\r\n where::\r\n\r\n alpha = a + b and l1_ratio = a / (a + b)\r\n\r\n The parameter l1_ratio corresponds to alpha in the glmnet R package while\r\n alpha corresponds to the lambda parameter in glmnet. Specifically, l1_ratio\r\n = 1 is the lasso penalty. Currently, l1_ratio <= 0.01 is not reliable,\r\n unless you supply your own sequence of alpha.\r\n\r\n Read more in the :ref:`User Guide <elastic_net>`.\r\n\r\n Parameters\r\n ----------\r\n alpha : float, default=1.0\r\n Constant that multiplies the penalty terms. Defaults to 1.0.\r\n See the notes for the exact mathematical meaning of this\r\n parameter. ``alpha = 0`` is equivalent to an ordinary least square,\r\n solved by the :class:`LinearRegression` object. For numerical\r\n reasons, using ``alpha = 0`` with the ``Lasso`` object is not advised.\r\n Given this, you should use the :class:`LinearRegression` object.\r\n\r\n l1_ratio : float, default=0.5\r\n The ElasticNet mixing parameter, with ``0 <= l1_ratio <= 1``. For\r\n ``l1_ratio = 0`` the penalty is an L2 penalty. ``For l1_ratio = 1`` it\r\n is an L1 penalty. For ``0 < l1_ratio < 1``, the penalty is a\r\n combination of L1 and L2.\r\n\r\n fit_intercept : bool, default=True\r\n Whether the intercept should be estimated or not. If ``False``, the\r\n data is assumed to be already centered.\r\n\r\n normalize : bool, default=False\r\n This parameter is ignored when ``fit_intercept`` is set to False.\r\n If True, the regressors X will be normalized before regression by\r\n subtracting the mean and dividing by the l2-norm.\r\n If you wish to standardize, please use\r\n :class:`~sklearn.preprocessing.StandardScaler` before calling ``fit``\r\n on an estimator with ``normalize=False``.\r\n\r\n .. deprecated:: 1.0\r\n ``normalize`` was deprecated in version 1.0 and will be removed in\r\n 1.2.\r\n\r\n precompute : bool or array-like of shape (n_features, n_features),\\\r\n default=False\r\n Whether to use a precomputed Gram matrix to speed up\r\n calculations. The Gram matrix can also be passed as argument.\r\n For sparse input this option is always ``False`` to preserve sparsity.\r\n\r\n max_iter : int, default=1000\r\n The maximum number of iterations.\r\n\r\n copy_X : bool, default=True\r\n If ``True``, X will be copied; else, it may be overwritten.\r\n\r\n tol : float, default=1e-4\r\n The tolerance for the optimization: if the updates are\r\n smaller than ``tol``, the optimization code checks the\r\n dual gap for optimality and continues until it is smaller\r\n than ``tol``.\r\n\r\n warm_start : bool, default=False\r\n When set to ``True``, reuse the solution of the previous call to fit as\r\n initialization, otherwise, just erase the previous solution.\r\n See :term:`the Glossary <warm_start>`.\r\n\r\n positive : bool, default=False\r\n When set to ``True``, forces the coefficients to be positive.\r\n\r\n random_state : int, RandomState instance, default=None\r\n The seed of the pseudo random number generator that selects a random\r\n feature to update. Used when ``selection`` == 'random'.\r\n Pass an int for reproducible output across multiple function calls.\r\n See :term:`Glossary <random_state>`.\r\n\r\n selection : {'cyclic', 'random'}, default='cyclic'\r\n If set to 'random', a random coefficient is updated every iteration\r\n rather than looping over features sequentially by default. This\r\n (setting to 'random') often leads to significantly faster convergence\r\n especially when tol is higher than 1e-4.\r\n\r\n Attributes\r\n ----------\r\n coef_ : ndarray of shape (n_features,) or (n_targets, n_features)\r\n Parameter vector (w in the cost function formula).\r\n\r\n sparse_coef_ : sparse matrix of shape (n_features,) or \\\r\n (n_targets, n_features)\r\n Sparse representation of the `coef_`.\r\n\r\n intercept_ : float or ndarray of shape (n_targets,)\r\n Independent term in decision function.\r\n\r\n n_iter_ : list of int\r\n Number of iterations run by the coordinate descent solver to reach\r\n the specified tolerance.\r\n\r\n dual_gap_ : float or ndarray of shape (n_targets,)\r\n Given param alpha, the dual gaps at the end of the optimization,\r\n same shape as each observation of y.\r\n\r\n n_features_in_ : int\r\n Number of features seen during :term:`fit`.\r\n\r\n .. versionadded:: 0.24\r\n\r\n feature_names_in_ : ndarray of shape (`n_features_in_`,)\r\n Names of features seen during :term:`fit`. Defined only when `X`\r\n has feature names that are all strings.\r\n\r\n .. versionadded:: 1.0\r\n\r\n See Also\r\n --------\r\n ElasticNetCV : Elastic net model with best model selection by\r\n cross-validation.\r\n SGDRegressor : Implements elastic net regression with incremental training.\r\n SGDClassifier : Implements logistic regression with elastic net penalty\r\n (``SGDClassifier(loss=\"log\", penalty=\"elasticnet\")``).\r\n\r\n Notes\r\n -----\r\n To avoid unnecessary memory duplication the X argument of the fit method\r\n should be directly passed as a Fortran-contiguous numpy array.\r\n\r\n Examples\r\n --------\r\n >>> from sklearn.linear_model import ElasticNet\r\n >>> from sklearn.datasets import make_regression\r\n\r\n >>> X, y = make_regression(n_features=2, random_state=0)\r\n >>> regr = ElasticNet(random_state=0)\r\n >>> regr.fit(X, y)\r\n ElasticNet(random_state=0)\r\n >>> print(regr.coef_)\r\n [18.83816048 64.55968825]\r\n >>> print(regr.intercept_)\r\n 1.451...\r\n >>> print(regr.predict([[0, 0]]))\r\n [1.451...]\r\n \"\"\"\r\n\r\n path = staticmethod(enet_path)\r\n\r\n def __init__(\r\n self,\r\n alpha=1.0,\r\n *,\r\n l1_ratio=0.5,\r\n fit_intercept=True,\r\n normalize=\"deprecated\",\r\n precompute=False,\r\n max_iter=1000,\r\n copy_X=True,\r\n tol=1e-4,\r\n warm_start=False,\r\n positive=False,\r\n random_state=None,\r\n selection=\"cyclic\",\r\n ):\r\n self.alpha = alpha\r\n self.l1_ratio = l1_ratio\r\n self.fit_intercept = fit_intercept\r\n self.normalize = normalize\r\n self.precompute = precompute\r\n self.max_iter = max_iter\r\n self.copy_X = copy_X\r\n self.tol = tol\r\n self.warm_start = warm_start\r\n self.positive = positive\r\n self.random_state = random_state\r\n self.selection = selection\r\n\r\n def fit(self, X, y, sample_weight=None, check_input=True):\r\n \"\"\"Fit model with coordinate descent.\r\n\r\n Parameters\r\n ----------\r\n X : {ndarray, sparse matrix} of (n_samples, n_features)\r\n Data.\r\n\r\n y : {ndarray, sparse matrix} of shape (n_samples,) or \\\r\n (n_samples, n_targets)\r\n Target. Will be cast to X's dtype if necessary.\r\n\r\n sample_weight : float or array-like of shape (n_samples,), default=None\r\n Sample weights. Internally, the `sample_weight` vector will be\r\n rescaled to sum to `n_samples`.\r\n\r\n .. versionadded:: 0.23\r\n\r\n check_input : bool, default=True\r\n Allow to bypass several input checking.\r\n Don't use this parameter unless you know what you do.\r\n\r\n Returns\r\n -------\r\n self : object\r\n Fitted estimator.\r\n\r\n Notes\r\n -----\r\n Coordinate descent is an algorithm that considers each column of\r\n data at a time hence it will automatically convert the X input\r\n as a Fortran-contiguous numpy array if necessary.\r\n\r\n To avoid memory re-allocation it is advised to allocate the\r\n initial data in memory directly using that format.\r\n \"\"\"\r\n _normalize = _deprecate_normalize(\r\n self.normalize, default=False, estimator_name=self.__class__.__name__\r\n )\r\n\r\n if self.alpha == 0:\r\n warnings.warn(\r\n \"With alpha=0, this algorithm does not converge \"\r\n \"well. You are advised to use the LinearRegression \"\r\n \"estimator\",\r\n stacklevel=2,\r\n )\r\n\r\n if isinstance(self.precompute, str):\r\n raise ValueError(\r\n \"precompute should be one of True, False or array-like. Got %r\"\r\n % self.precompute\r\n )\r\n\r\n if (\r\n not isinstance(self.l1_ratio, numbers.Number)\r\n or self.l1_ratio < 0\r\n or self.l1_ratio > 1\r\n ):\r\n raise ValueError(\r\n f\"l1_ratio must be between 0 and 1; got l1_ratio={self.l1_ratio}\"\r\n )\r\n\r\n # Remember if X is copied\r\n X_copied = False\r\n # We expect X and y to be float64 or float32 Fortran ordered arrays\r\n # when bypassing checks\r\n if check_input:\r\n X_copied = self.copy_X and self.fit_intercept\r\n X, y = self._validate_data(\r\n X,\r\n y,\r\n accept_sparse=\"csc\",\r\n order=\"F\",\r\n dtype=[np.float64, np.float32],\r\n copy=X_copied,\r\n multi_output=True,\r\n y_numeric=True,\r\n )\r\n y = check_array(\r\n y, order=\"F\", copy=False, dtype=X.dtype.type, ensure_2d=False\r\n )\r\n\r\n n_samples, n_features = X.shape\r\n alpha = self.alpha\r\n\r\n if isinstance(sample_weight, numbers.Number):\r\n sample_weight = None\r\n if sample_weight is not None:\r\n if check_input:\r\n if sparse.issparse(X):\r\n raise ValueError(\r\n \"Sample weights do not (yet) support sparse matrices.\"\r\n )\r\n sample_weight = _check_sample_weight(sample_weight, X, dtype=X.dtype)\r\n # TLDR: Rescale sw to sum up to n_samples.\r\n # Long: The objective function of Enet\r\n #\r\n # 1/2 * np.average(squared error, weights=sw)\r\n # + alpha * penalty (1)\r\n #\r\n # is invariant under rescaling of sw.\r\n # But enet_path coordinate descent minimizes\r\n #\r\n # 1/2 * sum(squared error) + alpha * penalty\r\n #\r\n # and therefore sets\r\n #\r\n # alpha = n_samples * alpha\r\n #\r\n # inside its function body, which results in an objective\r\n # equivalent to (1) without sw.\r\n # With sw, however, enet_path should set\r\n #\r\n # alpha = sum(sw) * alpha (2)\r\n #\r\n # Therefore, using the freedom of Eq. (1) to rescale alpha before\r\n # calling enet_path, we do\r\n #\r\n # alpha = sum(sw) / n_samples * alpha\r\n #\r\n # such that the rescaling inside enet_path is exactly Eq. (2)\r\n # because now sum(sw) = n_samples.\r\n sample_weight = sample_weight * (n_samples / np.sum(sample_weight))\r\n # Note: Alternatively, we could also have rescaled alpha instead\r\n # of sample_weight:\r\n #\r\n # alpha *= np.sum(sample_weight) / n_samples\r\n\r\n # Ensure copying happens only once, don't do it again if done above.\r\n # X and y will be rescaled if sample_weight is not None, order='F'\r\n # ensures that the returned X and y are still F-contiguous.\r\n should_copy = self.copy_X and not X_copied\r\n X, y, X_offset, y_offset, X_scale, precompute, Xy = _pre_fit(\r\n X,\r\n y,\r\n None,\r\n self.precompute,\r\n _normalize,\r\n self.fit_intercept,\r\n copy=should_copy,\r\n check_input=check_input,\r\n sample_weight=sample_weight,\r\n )\r\n # coordinate descent needs F-ordered arrays and _pre_fit might have\r\n # called _rescale_data\r\n if check_input or sample_weight is not None:\r\n X, y = _set_order(X, y, order=\"F\")\r\n if y.ndim == 1:\r\n y = y[:, np.newaxis]\r\n if Xy is not None and Xy.ndim == 1:\r\n Xy = Xy[:, np.newaxis]\r\n\r\n n_targets = y.shape[1]\r\n\r\n if self.selection not in [\"cyclic\", \"random\"]:\r\n raise ValueError(\"selection should be either random or cyclic.\")\r\n\r\n if not self.warm_start or not hasattr(self, \"coef_\"):\r\n coef_ = np.zeros((n_targets, n_features), dtype=X.dtype, order=\"F\")\r\n else:\r\n coef_ = self.coef_\r\n if coef_.ndim == 1:\r\n coef_ = coef_[np.newaxis, :]\r\n\r\n dual_gaps_ = np.zeros(n_targets, dtype=X.dtype)\r\n self.n_iter_ = []\r\n\r\n for k in range(n_targets):\r\n if Xy is not None:\r\n this_Xy = Xy[:, k]\r\n else:\r\n this_Xy = None\r\n _, this_coef, this_dual_gap, this_iter = self.path(\r\n X,\r\n y[:, k],\r\n l1_ratio=self.l1_ratio,\r\n eps=None,\r\n n_alphas=None,\r\n alphas=[alpha],\r\n precompute=precompute,\r\n Xy=this_Xy,\r\n copy_X=True,\r\n verbose=False,\r\n tol=self.tol,\r\n positive=self.positive,\r\n X_offset=X_offset,\r\n X_scale=X_scale,\r\n return_n_iter=True,\r\n coef_init=coef_[k],\r\n max_iter=self.max_iter,\r\n random_state=self.random_state,\r\n selection=self.selection,\r\n check_input=False,\r\n )\r\n coef_[k] = this_coef[:, 0]\r\n dual_gaps_[k] = this_dual_gap[0]\r\n self.n_iter_.append(this_iter[0])\r\n\r\n if n_targets == 1:\r\n self.n_iter_ = self.n_iter_[0]\r\n self.coef_ = coef_[0]\r\n self.dual_gap_ = dual_gaps_[0]\r\n else:\r\n self.coef_ = coef_\r\n self.dual_gap_ = dual_gaps_\r\n\r\n self._set_intercept(X_offset, y_offset, X_scale)\r\n\r\n # workaround since _set_intercept will cast self.coef_ into X.dtype\r\n self.coef_ = np.asarray(self.coef_, dtype=X.dtype)\r\n\r\n # return self for chaining fit and predict calls\r\n return self\r\n\r\n @property\r\n def sparse_coef_(self):\r\n \"\"\"Sparse representation of the fitted `coef_`.\"\"\"\r\n return sparse.csr_matrix(self.coef_)\r\n\r\n def _decision_function(self, X):\r\n \"\"\"Decision function of the linear model.\r\n\r\n Parameters\r\n ----------\r\n X : numpy array or scipy.sparse matrix of shape (n_samples, n_features)\r\n\r\n Returns\r\n -------\r\n T : ndarray of shape (n_samples,)\r\n The predicted decision function.\r\n \"\"\"\r\n check_is_fitted(self)\r\n if sparse.isspmatrix(X):\r\n return safe_sparse_dot(X, self.coef_.T, dense_output=True) + self.intercept_\r\n else:\r\n return super()._decision_function(X)\r\n\r\n\r\n###############################################################################\r\n# Lasso model\r\n\r\n\r\nclass Lasso(ElasticNet):\r\n \"\"\"Linear Model trained with L1 prior as regularizer (aka the Lasso).\r\n\r\n The optimization objective for Lasso is::\r\n\r\n (1 / (2 * n_samples)) * ||y - Xw||^2_2 + alpha * ||w||_1\r\n\r\n Technically the Lasso model is optimizing the same objective function as\r\n the Elastic Net with ``l1_ratio=1.0`` (no L2 penalty).\r\n\r\n Read more in the :ref:`User Guide <lasso>`.\r\n\r\n Parameters\r\n ----------\r\n alpha : float, default=1.0\r\n Constant that multiplies the L1 term. Defaults to 1.0.\r\n ``alpha = 0`` is equivalent to an ordinary least square, solved\r\n by the :class:`LinearRegression` object. For numerical\r\n reasons, using ``alpha = 0`` with the ``Lasso`` object is not advised.\r\n Given this, you should use the :class:`LinearRegression` object.\r\n\r\n fit_intercept : bool, default=True\r\n Whether to calculate the intercept for this model. If set\r\n to False, no intercept will be used in calculations\r\n (i.e. data is expected to be centered).\r\n\r\n normalize : bool, default=False\r\n This parameter is ignored when ``fit_intercept`` is set to False.\r\n If True, the regressors X will be normalized before regression by\r\n subtracting the mean and dividing by the l2-norm.\r\n If you wish to standardize, please use\r\n :class:`~sklearn.preprocessing.StandardScaler` before calling ``fit``\r\n on an estimator with ``normalize=False``.\r\n\r\n .. deprecated:: 1.0\r\n ``normalize`` was deprecated in version 1.0 and will be removed in\r\n 1.2.\r\n\r\n precompute : 'auto', bool or array-like of shape (n_features, n_features),\\\r\n precompute : bool or array-like of shape (n_features, n_features),\\\r\n default=False\r\n Whether to use a precomputed Gram matrix to speed up\r\n calculations. The Gram matrix can also be passed as argument.\r\n For sparse input this option is always ``False`` to preserve sparsity.\r\n\r\n copy_X : bool, default=True\r\n If ``True``, X will be copied; else, it may be overwritten.\r\n\r\n max_iter : int, default=1000\r\n The maximum number of iterations.\r\n\r\n tol : float, default=1e-4\r\n The tolerance for the optimization: if the updates are\r\n smaller than ``tol``, the optimization code checks the\r\n dual gap for optimality and continues until it is smaller\r\n than ``tol``.\r\n\r\n warm_start : bool, default=False\r\n When set to True, reuse the solution of the previous call to fit as\r\n initialization, otherwise, just erase the previous solution.\r\n See :term:`the Glossary <warm_start>`.\r\n\r\n positive : bool, default=False\r\n When set to ``True``, forces the coefficients to be positive.\r\n\r\n random_state : int, RandomState instance, default=None\r\n The seed of the pseudo random number generator that selects a random\r\n feature to update. Used when ``selection`` == 'random'.\r\n Pass an int for reproducible output across multiple function calls.\r\n See :term:`Glossary <random_state>`.\r\n\r\n selection : {'cyclic', 'random'}, default='cyclic'\r\n If set to 'random', a random coefficient is updated every iteration\r\n rather than looping over features sequentially by default. This\r\n (setting to 'random') often leads to significantly faster convergence\r\n especially when tol is higher than 1e-4.\r\n\r\n Attributes\r\n ----------\r\n coef_ : ndarray of shape (n_features,) or (n_targets, n_features)\r\n Parameter vector (w in the cost function formula).\r\n\r\n dual_gap_ : float or ndarray of shape (n_targets,)\r\n Given param alpha, the dual gaps at the end of the optimization,\r\n same shape as each observation of y.\r\n\r\n sparse_coef_ : sparse matrix of shape (n_features, 1) or \\\r\n (n_targets, n_features)\r\n Readonly property derived from ``coef_``.\r\n\r\n intercept_ : float or ndarray of shape (n_targets,)\r\n Independent term in decision function.\r\n\r\n n_iter_ : int or list of int\r\n Number of iterations run by the coordinate descent solver to reach\r\n the specified tolerance.\r\n\r\n n_features_in_ : int\r\n Number of features seen during :term:`fit`.\r\n\r\n .. versionadded:: 0.24\r\n\r\n feature_names_in_ : ndarray of shape (`n_features_in_`,)\r\n Names of features seen during :term:`fit`. Defined only when `X`\r\n has feature names that are all strings.\r\n\r\n .. versionadded:: 1.0\r\n\r\n See Also\r\n --------\r\n lars_path : Regularization path using LARS.\r\n lasso_path : Regularization path using Lasso.\r\n LassoLars : Lasso Path along the regularization parameter usingLARS algorithm.\r\n LassoCV : Lasso alpha parameter by cross-validation.\r\n LassoLarsCV : Lasso least angle parameter algorithm by cross-validation.\r\n sklearn.decomposition.sparse_encode : Sparse coding array estimator.\r\n\r\n Notes\r\n -----\r\n The algorithm used to fit the model is coordinate descent.\r\n\r\n To avoid unnecessary memory duplication the X argument of the fit method\r\n should be directly passed as a Fortran-contiguous numpy array.\r\n\r\n Examples\r\n --------\r\n >>> from sklearn import linear_model\r\n >>> clf = linear_model.Lasso(alpha=0.1)\r\n >>> clf.fit([[0,0], [1, 1], [2, 2]], [0, 1, 2])\r\n Lasso(alpha=0.1)\r\n >>> print(clf.coef_)\r\n [0.85 0. ]\r\n >>> print(clf.intercept_)\r\n 0.15...\r\n \"\"\"\r\n\r\n path = staticmethod(enet_path)\r\n\r\n def __init__(\r\n self,\r\n alpha=1.0,\r\n *,\r\n fit_intercept=True,\r\n normalize=\"deprecated\",\r\n precompute=False,\r\n copy_X=True,\r\n max_iter=1000,\r\n tol=1e-4,\r\n warm_start=False,\r\n positive=False,\r\n random_state=None,\r\n selection=\"cyclic\",\r\n ):\r\n super().__init__(\r\n alpha=alpha,\r\n l1_ratio=1.0,\r\n fit_intercept=fit_intercept,\r\n normalize=normalize,\r\n precompute=precompute,\r\n copy_X=copy_X,\r\n max_iter=max_iter,\r\n tol=tol,\r\n warm_start=warm_start,\r\n positive=positive,\r\n random_state=random_state,\r\n selection=selection,\r\n )\r\n\r\n\r\n###############################################################################\r\n# Functions for CV with paths functions\r\n\r\n\r\ndef _path_residuals(\r\n X,\r\n y,\r\n sample_weight,\r\n train,\r\n test,\r\n normalize,\r\n fit_intercept,\r\n path,\r\n path_params,\r\n alphas=None,\r\n l1_ratio=1,\r\n X_order=None,\r\n dtype=None,\r\n):\r\n \"\"\"Returns the MSE for the models computed by 'path'.\r\n\r\n Parameters\r\n ----------\r\n X : {array-like, sparse matrix} of shape (n_samples, n_features)\r\n Training data.\r\n\r\n y : array-like of shape (n_samples,) or (n_samples, n_targets)\r\n Target values.\r\n\r\n sample_weight : None or array-like of shape (n_samples,)\r\n Sample weights.\r\n\r\n train : list of indices\r\n The indices of the train set.\r\n\r\n test : list of indices\r\n The indices of the test set.\r\n\r\n path : callable\r\n Function returning a list of models on the path. See\r\n enet_path for an example of signature.\r\n\r\n path_params : dictionary\r\n Parameters passed to the path function.\r\n\r\n alphas : array-like, default=None\r\n Array of float that is used for cross-validation. If not\r\n provided, computed using 'path'.\r\n\r\n l1_ratio : float, default=1\r\n float between 0 and 1 passed to ElasticNet (scaling between\r\n l1 and l2 penalties). For ``l1_ratio = 0`` the penalty is an\r\n L2 penalty. For ``l1_ratio = 1`` it is an L1 penalty. For ``0\r\n < l1_ratio < 1``, the penalty is a combination of L1 and L2.\r\n\r\n X_order : {'F', 'C'}, default=None\r\n The order of the arrays expected by the path function to\r\n avoid memory copies.\r\n\r\n dtype : a numpy dtype, default=None\r\n The dtype of the arrays expected by the path function to\r\n avoid memory copies.\r\n \"\"\"\r\n X_train = X[train]\r\n y_train = y[train]\r\n X_test = X[test]\r\n y_test = y[test]\r\n if sample_weight is None:\r\n sw_train, sw_test = None, None\r\n else:\r\n sw_train = sample_weight[train]\r\n sw_test = sample_weight[test]\r\n n_samples = X_train.shape[0]\r\n # TLDR: Rescale sw_train to sum up to n_samples on the training set.\r\n # See TLDR and long comment inside ElasticNet.fit.\r\n sw_train *= n_samples / np.sum(sw_train)\r\n # Note: Alternatively, we could also have rescaled alpha instead\r\n # of sample_weight:\r\n #\r\n # alpha *= np.sum(sample_weight) / n_samples\r\n\r\n if not sparse.issparse(X):\r\n for array, array_input in (\r\n (X_train, X),\r\n (y_train, y),\r\n (X_test, X),\r\n (y_test, y),\r\n ):\r\n if array.base is not array_input and not array.flags[\"WRITEABLE\"]:\r\n # fancy indexing should create a writable copy but it doesn't\r\n # for read-only memmaps (cf. numpy#14132).\r\n array.setflags(write=True)\r\n\r\n if y.ndim == 1:\r\n precompute = path_params[\"precompute\"]\r\n else:\r\n # No Gram variant of multi-task exists right now.\r\n # Fall back to default enet_multitask\r\n precompute = False\r\n\r\n X_train, y_train, X_offset, y_offset, X_scale, precompute, Xy = _pre_fit(\r\n X_train,\r\n y_train,\r\n None,\r\n precompute,\r\n normalize,\r\n fit_intercept,\r\n copy=False,\r\n sample_weight=sw_train,\r\n )\r\n\r\n path_params = path_params.copy()\r\n path_params[\"Xy\"] = Xy\r\n path_params[\"X_offset\"] = X_offset\r\n path_params[\"X_scale\"] = X_scale\r\n path_params[\"precompute\"] = precompute\r\n path_params[\"copy_X\"] = False\r\n path_params[\"alphas\"] = alphas\r\n\r\n if \"l1_ratio\" in path_params:\r\n path_params[\"l1_ratio\"] = l1_ratio\r\n\r\n # Do the ordering and type casting here, as if it is done in the path,\r\n # X is copied and a reference is kept here\r\n X_train = check_array(X_train, accept_sparse=\"csc\", dtype=dtype, order=X_order)\r\n alphas, coefs, _ = path(X_train, y_train, **path_params)\r\n del X_train, y_train\r\n\r\n if y.ndim == 1:\r\n # Doing this so that it becomes coherent with multioutput.\r\n coefs = coefs[np.newaxis, :, :]\r\n y_offset = np.atleast_1d(y_offset)\r\n y_test = y_test[:, np.newaxis]\r\n\r\n if normalize:\r\n nonzeros = np.flatnonzero(X_scale)\r\n coefs[:, nonzeros] /= X_scale[nonzeros][:, np.newaxis]\r\n\r\n intercepts = y_offset[:, np.newaxis] - np.dot(X_offset, coefs)\r\n X_test_coefs = safe_sparse_dot(X_test, coefs)\r\n residues = X_test_coefs - y_test[:, :, np.newaxis]\r\n residues += intercepts\r\n if sample_weight is None:\r\n this_mse = (residues ** 2).mean(axis=0)\r\n else:\r\n this_mse = np.average(residues ** 2, weights=sw_test, axis=0)\r\n\r\n return this_mse.mean(axis=0)\r\n\r\n\r\nclass LinearModelCV(MultiOutputMixin, LinearModel, ABC):\r\n \"\"\"Base class for iterative model fitting along a regularization path.\"\"\"\r\n\r\n @abstractmethod\r\n def __init__(\r\n self,\r\n eps=1e-3,\r\n n_alphas=100,\r\n alphas=None,\r\n fit_intercept=True,\r\n normalize=\"deprecated\",\r\n precompute=\"auto\",\r\n max_iter=1000,\r\n tol=1e-4,\r\n copy_X=True,\r\n cv=None,\r\n verbose=False,\r\n n_jobs=None,\r\n positive=False,\r\n random_state=None,\r\n selection=\"cyclic\",\r\n ):\r\n self.eps = eps\r\n self.n_alphas = n_alphas\r\n self.alphas = alphas\r\n self.fit_intercept = fit_intercept\r\n self.normalize = normalize\r\n self.precompute = precompute\r\n self.max_iter = max_iter\r\n self.tol = tol\r\n self.copy_X = copy_X\r\n self.cv = cv\r\n self.verbose = verbose\r\n self.n_jobs = n_jobs\r\n self.positive = positive\r\n self.random_state = random_state\r\n self.selection = selection\r\n\r\n @abstractmethod\r\n def _get_estimator(self):\r\n \"\"\"Model to be fitted after the best alpha has been determined.\"\"\"\r\n\r\n @abstractmethod\r\n def _is_multitask(self):\r\n \"\"\"Bool indicating if class is meant for multidimensional target.\"\"\"\r\n\r\n @staticmethod\r\n @abstractmethod\r\n def path(X, y, **kwargs):\r\n \"\"\"Compute path with coordinate descent.\"\"\"\r\n\r\n def fit(self, X, y, sample_weight=None):\r\n \"\"\"Fit linear model with coordinate descent.\r\n\r\n Fit is on grid of alphas and best alpha estimated by cross-validation.\r\n\r\n Parameters\r\n ----------\r\n X : {array-like, sparse matrix} of shape (n_samples, n_features)\r\n Training data. Pass directly as Fortran-contiguous data\r\n to avoid unnecessary memory duplication. If y is mono-output,\r\n X can be sparse.\r\n\r\n y : array-like of shape (n_samples,) or (n_samples, n_targets)\r\n Target values.\r\n\r\n sample_weight : float or array-like of shape (n_samples,), \\\r\n default=None\r\n Sample weights used for fitting and evaluation of the weighted\r\n mean squared error of each cv-fold. Note that the cross validated\r\n MSE that is finally used to find the best model is the unweighted\r\n mean over the (weighted) MSEs of each test fold.\r\n\r\n Returns\r\n -------\r\n self : object\r\n Returns an instance of fitted model.\r\n \"\"\"\r\n\r\n # Do as _deprecate_normalize but without warning as it's raised\r\n # below during the refitting on the best alpha.\r\n _normalize = self.normalize\r\n if _normalize == \"deprecated\":\r\n _normalize = False\r\n\r\n # This makes sure that there is no duplication in memory.\r\n # Dealing right with copy_X is important in the following:\r\n # Multiple functions touch X and subsamples of X and can induce a\r\n # lot of duplication of memory\r\n copy_X = self.copy_X and self.fit_intercept\r\n\r\n check_y_params = dict(\r\n copy=False, dtype=[np.float64, np.float32], ensure_2d=False\r\n )\r\n if isinstance(X, np.ndarray) or sparse.isspmatrix(X):\r\n # Keep a reference to X\r\n reference_to_old_X = X\r\n # Let us not impose fortran ordering so far: it is\r\n # not useful for the cross-validation loop and will be done\r\n # by the model fitting itself\r\n\r\n # Need to validate separately here.\r\n # We can't pass multi_ouput=True because that would allow y to be\r\n # csr. We also want to allow y to be 64 or 32 but check_X_y only\r\n # allows to convert for 64.\r\n check_X_params = dict(\r\n accept_sparse=\"csc\", dtype=[np.float64, np.float32], copy=False\r\n )\r\n X, y = self._validate_data(\r\n X, y, validate_separately=(check_X_params, check_y_params)\r\n )\r\n if sparse.isspmatrix(X):\r\n if hasattr(reference_to_old_X, \"data\") and not np.may_share_memory(\r\n reference_to_old_X.data, X.data\r\n ):\r\n # X is a sparse matrix and has been copied\r\n copy_X = False\r\n elif not np.may_share_memory(reference_to_old_X, X):\r\n # X has been copied\r\n copy_X = False\r\n del reference_to_old_X\r\n else:\r\n # Need to validate separately here.\r\n # We can't pass multi_ouput=True because that would allow y to be\r\n # csr. We also want to allow y to be 64 or 32 but check_X_y only\r\n # allows to convert for 64.\r\n check_X_params = dict(\r\n accept_sparse=\"csc\",\r\n dtype=[np.float64, np.float32],\r\n order=\"F\",\r\n copy=copy_X,\r\n )\r\n X, y = self._validate_data(\r\n X, y, validate_separately=(check_X_params, check_y_params)\r\n )\r\n copy_X = False\r\n\r\n check_consistent_length(X, y)\r\n\r\n if not self._is_multitask():\r\n if y.ndim > 1 and y.shape[1] > 1:\r\n raise ValueError(\r\n \"For multi-task outputs, use MultiTask%s\" % self.__class__.__name__\r\n )\r\n y = column_or_1d(y, warn=True)\r\n else:\r\n if sparse.isspmatrix(X):\r\n raise TypeError(\"X should be dense but a sparse matrix waspassed\")\r\n elif y.ndim == 1:\r\n raise ValueError(\r\n \"For mono-task outputs, use %sCV\" % self.__class__.__name__[9:]\r\n )\r\n\r\n if isinstance(sample_weight, numbers.Number):\r\n sample_weight = None\r\n if sample_weight is not None:\r\n if sparse.issparse(X):\r\n raise ValueError(\"Sample weights do not (yet) support sparse matrices.\")\r\n sample_weight = _check_sample_weight(sample_weight, X, dtype=X.dtype)\r\n\r\n model = self._get_estimator()\r\n\r\n if self.selection not in [\"random\", \"cyclic\"]:\r\n raise ValueError(\"selection should be either random or cyclic.\")\r\n\r\n # All LinearModelCV parameters except 'cv' are acceptable\r\n path_params = self.get_params()\r\n\r\n # FIXME: 'normalize' to be removed in 1.2\r\n # path_params[\"normalize\"] = _normalize\r\n # Pop `intercept` and `normalize` that are not parameter of the path\r\n # function\r\n path_params.pop(\"normalize\", None)\r\n path_params.pop(\"fit_intercept\", None)\r\n\r\n if \"l1_ratio\" in path_params:\r\n l1_ratios = np.atleast_1d(path_params[\"l1_ratio\"])\r\n # For the first path, we need to set l1_ratio\r\n path_params[\"l1_ratio\"] = l1_ratios[0]\r\n else:\r\n l1_ratios = [\r\n 1,\r\n ]\r\n path_params.pop(\"cv\", None)\r\n path_params.pop(\"n_jobs\", None)\r\n\r\n alphas = self.alphas\r\n n_l1_ratio = len(l1_ratios)\r\n if alphas is None:\r\n alphas = [\r\n _alpha_grid(\r\n X,\r\n y,\r\n l1_ratio=l1_ratio,\r\n fit_intercept=self.fit_intercept,\r\n eps=self.eps,\r\n n_alphas=self.n_alphas,\r\n normalize=_normalize,\r\n copy_X=self.copy_X,\r\n )\r\n for l1_ratio in l1_ratios\r\n ]\r\n else:\r\n # Making sure alphas is properly ordered.\r\n alphas = np.tile(np.sort(alphas)[::-1], (n_l1_ratio, 1))\r\n # We want n_alphas to be the number of alphas used for each l1_ratio.\r\n n_alphas = len(alphas[0])\r\n path_params.update({\"n_alphas\": n_alphas})\r\n\r\n path_params[\"copy_X\"] = copy_X\r\n # We are not computing in parallel, we can modify X\r\n # inplace in the folds\r\n if effective_n_jobs(self.n_jobs) > 1:\r\n path_params[\"copy_X\"] = False\r\n\r\n # init cross-validation generator\r\n cv = check_cv(self.cv)\r\n\r\n # Compute path for all folds and compute MSE to get the best alpha\r\n folds = list(cv.split(X, y))\r\n best_mse = np.inf\r\n\r\n # We do a double for loop folded in one, in order to be able to\r\n # iterate in parallel on l1_ratio and folds\r\n jobs = (\r\n delayed(_path_residuals)(\r\n X,\r\n y,\r\n sample_weight,\r\n train,\r\n test,\r\n _normalize,\r\n self.fit_intercept,\r\n self.path,\r\n path_params,\r\n alphas=this_alphas,\r\n l1_ratio=this_l1_ratio,\r\n X_order=\"F\",\r\n dtype=X.dtype.type,\r\n )\r\n for this_l1_ratio, this_alphas in zip(l1_ratios, alphas)\r\n for train, test in folds\r\n )\r\n mse_paths = Parallel(\r\n n_jobs=self.n_jobs,\r\n verbose=self.verbose,\r\n **_joblib_parallel_args(prefer=\"threads\"),\r\n )(jobs)\r\n mse_paths = np.reshape(mse_paths, (n_l1_ratio, len(folds), -1))\r\n # The mean is computed over folds.\r\n mean_mse = np.mean(mse_paths, axis=1)\r\n self.mse_path_ = np.squeeze(np.moveaxis(mse_paths, 2, 1))\r\n for l1_ratio, l1_alphas, mse_alphas in zip(l1_ratios, alphas, mean_mse):\r\n i_best_alpha = np.argmin(mse_alphas)\r\n this_best_mse = mse_alphas[i_best_alpha]\r\n if this_best_mse < best_mse:\r\n best_alpha = l1_alphas[i_best_alpha]\r\n best_l1_ratio = l1_ratio\r\n best_mse = this_best_mse\r\n\r\n self.l1_ratio_ = best_l1_ratio\r\n self.alpha_ = best_alpha\r\n if self.alphas is None:\r\n self.alphas_ = np.asarray(alphas)\r\n if n_l1_ratio == 1:\r\n self.alphas_ = self.alphas_[0]\r\n # Remove duplicate alphas in case alphas is provided.\r\n else:\r\n self.alphas_ = np.asarray(alphas[0])\r\n\r\n # Refit the model with the parameters selected\r\n common_params = {\r\n name: value\r\n for name, value in self.get_params().items()\r\n if name in model.get_params()\r\n }\r\n model.set_params(**common_params)\r\n model.alpha = best_alpha\r\n model.l1_ratio = best_l1_ratio\r\n model.copy_X = copy_X\r\n precompute = getattr(self, \"precompute\", None)\r\n if isinstance(precompute, str) and precompute == \"auto\":\r\n model.precompute = False\r\n\r\n if sample_weight is None:\r\n # MultiTaskElasticNetCV does not (yet) support sample_weight, even\r\n # not sample_weight=None.\r\n model.fit(X, y)\r\n else:\r\n model.fit(X, y, sample_weight=sample_weight)\r\n if not hasattr(self, \"l1_ratio\"):\r\n del self.l1_ratio_\r\n self.coef_ = model.coef_\r\n self.intercept_ = model.intercept_\r\n self.dual_gap_ = model.dual_gap_\r\n self.n_iter_ = model.n_iter_\r\n return self\r\n\r\n def _more_tags(self):\r\n # Note: check_sample_weights_invariance(kind='ones') should work, but\r\n # currently we can only mark a whole test as xfail.\r\n return {\r\n \"_xfail_checks\": {\r\n \"check_sample_weights_invariance\": (\r\n \"zero sample_weight is not equivalent to removing samples\"\r\n ),\r\n }\r\n }\r\n\r\n\r\nclass LassoCV(RegressorMixin, LinearModelCV):\r\n \"\"\"Lasso linear model with iterative fitting along a regularization path.\r\n\r\n See glossary entry for :term:`cross-validation estimator`.\r\n\r\n The best model is selected by cross-validation.\r\n\r\n The optimization objective for Lasso is::\r\n\r\n (1 / (2 * n_samples)) * ||y - Xw||^2_2 + alpha * ||w||_1\r\n\r\n Read more in the :ref:`User Guide <lasso>`.\r\n\r\n Parameters\r\n ----------\r\n eps : float, default=1e-3\r\n Length of the path. ``eps=1e-3`` means that\r\n ``alpha_min / alpha_max = 1e-3``.\r\n\r\n n_alphas : int, default=100\r\n Number of alphas along the regularization path.\r\n\r\n alphas : ndarray, default=None\r\n List of alphas where to compute the models.\r\n If ``None`` alphas are set automatically.\r\n\r\n fit_intercept : bool, default=True\r\n Whether to calculate the intercept for this model. If set\r\n to false, no intercept will be used in calculations\r\n (i.e. data is expected to be centered).\r\n\r\n normalize : bool, default=False\r\n This parameter is ignored when ``fit_intercept`` is set to False.\r\n If True, the regressors X will be normalized before regression by\r\n subtracting the mean and dividing by the l2-norm.\r\n If you wish to standardize, please use\r\n :class:`~sklearn.preprocessing.StandardScaler` before calling ``fit``\r\n on an estimator with ``normalize=False``.\r\n\r\n .. deprecated:: 1.0\r\n ``normalize`` was deprecated in version 1.0 and will be removed in\r\n 1.2.\r\n\r\n precompute : 'auto', bool or array-like of shape \\\r\n (n_features, n_features), default='auto'\r\n Whether to use a precomputed Gram matrix to speed up\r\n calculations. If set to ``'auto'`` let us decide. The Gram\r\n matrix can also be passed as argument.\r\n\r\n max_iter : int, default=1000\r\n The maximum number of iterations.\r\n\r\n tol : float, default=1e-4\r\n The tolerance for the optimization: if the updates are\r\n smaller than ``tol``, the optimization code checks the\r\n dual gap for optimality and continues until it is smaller\r\n than ``tol``.\r\n\r\n copy_X : bool, default=True\r\n If ``True``, X will be copied; else, it may be overwritten.\r\n\r\n cv : int, cross-validation generator or 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.\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, :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 verbose : bool or int, default=False\r\n Amount of verbosity.\r\n\r\n n_jobs : int, default=None\r\n Number of CPUs to use during the cross validation.\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 positive : bool, default=False\r\n If positive, restrict regression coefficients to be positive.\r\n\r\n random_state : int, RandomState instance, default=None\r\n The seed of the pseudo random number generator that selects a random\r\n feature to update. Used when ``selection`` == 'random'.\r\n Pass an int for reproducible output across multiple function calls.\r\n See :term:`Glossary <random_state>`.\r\n\r\n selection : {'cyclic', 'random'}, default='cyclic'\r\n If set to 'random', a random coefficient is updated every iteration\r\n rather than looping over features sequentially by default. This\r\n (setting to 'random') often leads to significantly faster convergence\r\n especially when tol is higher than 1e-4.\r\n\r\n Attributes\r\n ----------\r\n alpha_ : float\r\n The amount of penalization chosen by cross validation.\r\n\r\n coef_ : ndarray of shape (n_features,) or (n_targets, n_features)\r\n Parameter vector (w in the cost function formula).\r\n\r\n intercept_ : float or ndarray of shape (n_targets,)\r\n Independent term in decision function.\r\n\r\n mse_path_ : ndarray of shape (n_alphas, n_folds)\r\n Mean square error for the test set on each fold, varying alpha.\r\n\r\n alphas_ : ndarray of shape (n_alphas,)\r\n The grid of alphas used for fitting.\r\n\r\n dual_gap_ : float or ndarray of shape (n_targets,)\r\n The dual gap at the end of the optimization for the optimal alpha\r\n (``alpha_``).\r\n\r\n n_iter_ : int\r\n Number of iterations run by the coordinate descent solver to reach\r\n the specified tolerance for the optimal alpha.\r\n\r\n n_features_in_ : int\r\n Number of features seen during :term:`fit`.\r\n\r\n .. versionadded:: 0.24\r\n\r\n feature_names_in_ : ndarray of shape (`n_features_in_`,)\r\n Names of features seen during :term:`fit`. Defined only when `X`\r\n has feature names that are all strings.\r\n\r\n .. versionadded:: 1.0\r\n\r\n See Also\r\n --------\r\n lars_path : Compute Least Angle Regression or Lasso path using LARS\r\n algorithm.\r\n lasso_path : Compute Lasso path with coordinate descent.\r\n Lasso : The Lasso is a linear model that estimates sparse coefficients.\r\n LassoLars : Lasso model fit with Least Angle Regression a.k.a. Lars.\r\n LassoCV : Lasso linear model with iterative fitting along a regularization\r\n path.\r\n LassoLarsCV : Cross-validated Lasso using the LARS algorithm.\r\n\r\n Notes\r\n -----\r\n For an example, see\r\n :ref:`examples/linear_model/plot_lasso_model_selection.py\r\n <sphx_glr_auto_examples_linear_model_plot_lasso_model_selection.py>`.\r\n\r\n To avoid unnecessary memory duplication the X argument of the fit method\r\n should be directly passed as a Fortran-contiguous numpy array.\r\n\r\n Examples\r\n --------\r\n >>> from sklearn.linear_model import LassoCV\r\n >>> from sklearn.datasets import make_regression\r\n >>> X, y = make_regression(noise=4, random_state=0)\r\n >>> reg = LassoCV(cv=5, random_state=0).fit(X, y)\r\n >>> reg.score(X, y)\r\n 0.9993...\r\n >>> reg.predict(X[:1,])\r\n array([-78.4951...])\r\n \"\"\"\r\n\r\n path = staticmethod(lasso_path)\r\n\r\n def __init__(\r\n self,\r\n *,\r\n eps=1e-3,\r\n n_alphas=100,\r\n alphas=None,\r\n fit_intercept=True,\r\n normalize=\"deprecated\",\r\n precompute=\"auto\",\r\n max_iter=1000,\r\n tol=1e-4,\r\n copy_X=True,\r\n cv=None,\r\n verbose=False,\r\n n_jobs=None,\r\n positive=False,\r\n random_state=None,\r\n selection=\"cyclic\",\r\n ):\r\n super().__init__(\r\n eps=eps,\r\n n_alphas=n_alphas,\r\n alphas=alphas,\r\n fit_intercept=fit_intercept,\r\n normalize=normalize,\r\n precompute=precompute,\r\n max_iter=max_iter,\r\n tol=tol,\r\n copy_X=copy_X,\r\n cv=cv,\r\n verbose=verbose,\r\n n_jobs=n_jobs,\r\n positive=positive,\r\n random_state=random_state,\r\n selection=selection,\r\n )\r\n\r\n def _get_estimator(self):\r\n return Lasso()\r\n\r\n def _is_multitask(self):\r\n return False\r\n\r\n def _more_tags(self):\r\n return {\"multioutput\": False}\r\n\r\n\r\nclass ElasticNetCV(RegressorMixin, LinearModelCV):\r\n \"\"\"Elastic Net model with iterative fitting along a regularization path.\r\n\r\n See glossary entry for :term:`cross-validation estimator`.\r\n\r\n Read more in the :ref:`User Guide <elastic_net>`.\r\n\r\n Parameters\r\n ----------\r\n l1_ratio : float or list of float, default=0.5\r\n Float between 0 and 1 passed to ElasticNet (scaling between\r\n l1 and l2 penalties). For ``l1_ratio = 0``\r\n the penalty is an L2 penalty. For ``l1_ratio = 1`` it is an L1 penalty.\r\n For ``0 < l1_ratio < 1``, the penalty is a combination of L1 and L2\r\n This parameter can be a list, in which case the different\r\n values are tested by cross-validation and the one giving the best\r\n prediction score is used. Note that a good choice of list of\r\n values for l1_ratio is often to put more values close to 1\r\n (i.e. Lasso) and less close to 0 (i.e. Ridge), as in ``[.1, .5, .7,\r\n .9, .95, .99, 1]``.\r\n\r\n eps : float, default=1e-3\r\n Length of the path. ``eps=1e-3`` means that\r\n ``alpha_min / alpha_max = 1e-3``.\r\n\r\n n_alphas : int, default=100\r\n Number of alphas along the regularization path, used for each l1_ratio.\r\n\r\n alphas : ndarray, default=None\r\n List of alphas where to compute the models.\r\n If None alphas are set automatically.\r\n\r\n fit_intercept : bool, default=True\r\n Whether to calculate the intercept for this model. If set\r\n to false, no intercept will be used in calculations\r\n (i.e. data is expected to be centered).\r\n\r\n normalize : bool, default=False\r\n This parameter is ignored when ``fit_intercept`` is set to False.\r\n If True, the regressors X will be normalized before regression by\r\n subtracting the mean and dividing by the l2-norm.\r\n If you wish to standardize, please use\r\n :class:`~sklearn.preprocessing.StandardScaler` before calling ``fit``\r\n on an estimator with ``normalize=False``.\r\n\r\n .. deprecated:: 1.0\r\n ``normalize`` was deprecated in version 1.0 and will be removed in\r\n 1.2.\r\n\r\n precompute : 'auto', bool or array-like of shape \\\r\n (n_features, n_features), default='auto'\r\n Whether to use a precomputed Gram matrix to speed up\r\n calculations. If set to ``'auto'`` let us decide. The Gram\r\n matrix can also be passed as argument.\r\n\r\n max_iter : int, default=1000\r\n The maximum number of iterations.\r\n\r\n tol : float, default=1e-4\r\n The tolerance for the optimization: if the updates are\r\n smaller than ``tol``, the optimization code checks the\r\n dual gap for optimality and continues until it is smaller\r\n than ``tol``.\r\n\r\n cv : int, cross-validation generator or 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.\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, :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 copy_X : bool, default=True\r\n If ``True``, X will be copied; else, it may be overwritten.\r\n\r\n verbose : bool or int, default=0\r\n Amount of verbosity.\r\n\r\n n_jobs : int, default=None\r\n Number of CPUs to use during the cross validation.\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 positive : bool, default=False\r\n When set to ``True``, forces the coefficients to be positive.\r\n\r\n random_state : int, RandomState instance, default=None\r\n The seed of the pseudo random number generator that selects a random\r\n feature to update. Used when ``selection`` == 'random'.\r\n Pass an int for reproducible output across multiple function calls.\r\n See :term:`Glossary <random_state>`.\r\n\r\n selection : {'cyclic', 'random'}, default='cyclic'\r\n If set to 'random', a random coefficient is updated every iteration\r\n rather than looping over features sequentially by default. This\r\n (setting to 'random') often leads to significantly faster convergence\r\n especially when tol is higher than 1e-4.\r\n\r\n Attributes\r\n ----------\r\n alpha_ : float\r\n The amount of penalization chosen by cross validation.\r\n\r\n l1_ratio_ : float\r\n The compromise between l1 and l2 penalization chosen by\r\n cross validation.\r\n\r\n coef_ : ndarray of shape (n_features,) or (n_targets, n_features)\r\n Parameter vector (w in the cost function formula).\r\n\r\n intercept_ : float or ndarray of shape (n_targets, n_features)\r\n Independent term in the decision function.\r\n\r\n mse_path_ : ndarray of shape (n_l1_ratio, n_alpha, n_folds)\r\n Mean square error for the test set on each fold, varying l1_ratio and\r\n alpha.\r\n\r\n alphas_ : ndarray of shape (n_alphas,) or (n_l1_ratio, n_alphas)\r\n The grid of alphas used for fitting, for each l1_ratio.\r\n\r\n dual_gap_ : float\r\n The dual gaps at the end of the optimization for the optimal alpha.\r\n\r\n n_iter_ : int\r\n Number of iterations run by the coordinate descent solver to reach\r\n the specified tolerance for the optimal alpha.\r\n\r\n n_features_in_ : int\r\n Number of features seen during :term:`fit`.\r\n\r\n .. versionadded:: 0.24\r\n\r\n feature_names_in_ : ndarray of shape (`n_features_in_`,)\r\n Names of features seen during :term:`fit`. Defined only when `X`\r\n has feature names that are all strings.\r\n\r\n .. versionadded:: 1.0\r\n\r\n See Also\r\n --------\r\n enet_path : Compute elastic net path with coordinate descent.\r\n ElasticNet : Linear regression with combined L1 and L2 priors as regularizer.\r\n\r\n Notes\r\n -----\r\n For an example, see\r\n :ref:`examples/linear_model/plot_lasso_model_selection.py\r\n <sphx_glr_auto_examples_linear_model_plot_lasso_model_selection.py>`.\r\n\r\n To avoid unnecessary memory duplication the X argument of the fit method\r\n should be directly passed as a Fortran-contiguous numpy array.\r\n\r\n The parameter l1_ratio corresponds to alpha in the glmnet R package\r\n while alpha corresponds to the lambda parameter in glmnet.\r\n More specifically, the optimization objective is::\r\n\r\n 1 / (2 * n_samples) * ||y - Xw||^2_2\r\n + alpha * l1_ratio * ||w||_1\r\n + 0.5 * alpha * (1 - l1_ratio) * ||w||^2_2\r\n\r\n If you are interested in controlling the L1 and L2 penalty\r\n separately, keep in mind that this is equivalent to::\r\n\r\n a * L1 + b * L2\r\n\r\n for::\r\n\r\n alpha = a + b and l1_ratio = a / (a + b).\r\n\r\n Examples\r\n --------\r\n >>> from sklearn.linear_model import ElasticNetCV\r\n >>> from sklearn.datasets import make_regression\r\n\r\n >>> X, y = make_regression(n_features=2, random_state=0)\r\n >>> regr = ElasticNetCV(cv=5, random_state=0)\r\n >>> regr.fit(X, y)\r\n ElasticNetCV(cv=5, random_state=0)\r\n >>> print(regr.alpha_)\r\n 0.199...\r\n >>> print(regr.intercept_)\r\n 0.398...\r\n >>> print(regr.predict([[0, 0]]))\r\n [0.398...]\r\n \"\"\"\r\n\r\n path = staticmethod(enet_path)\r\n\r\n def __init__(\r\n self,\r\n *,\r\n l1_ratio=0.5,\r\n eps=1e-3,\r\n n_alphas=100,\r\n alphas=None,\r\n fit_intercept=True,\r\n normalize=\"deprecated\",\r\n precompute=\"auto\",\r\n max_iter=1000,\r\n tol=1e-4,\r\n cv=None,\r\n copy_X=True,\r\n verbose=0,\r\n n_jobs=None,\r\n positive=False,\r\n random_state=None,\r\n selection=\"cyclic\",\r\n ):\r\n self.l1_ratio = l1_ratio\r\n self.eps = eps\r\n self.n_alphas = n_alphas\r\n self.alphas = alphas\r\n self.fit_intercept = fit_intercept\r\n self.normalize = normalize\r\n self.precompute = precompute\r\n self.max_iter = max_iter\r\n self.tol = tol\r\n self.cv = cv\r\n self.copy_X = copy_X\r\n self.verbose = verbose\r\n self.n_jobs = n_jobs\r\n self.positive = positive\r\n self.random_state = random_state\r\n self.selection = selection\r\n\r\n def _get_estimator(self):\r\n return ElasticNet()\r\n\r\n def _is_multitask(self):\r\n return False\r\n\r\n def _more_tags(self):\r\n return {\"multioutput\": False}\r\n\r\n\r\n###############################################################################\r\n# Multi Task ElasticNet and Lasso models (with joint feature selection)\r\n\r\n\r\nclass MultiTaskElasticNet(Lasso):\r\n \"\"\"Multi-task ElasticNet model trained with L1/L2 mixed-norm as regularizer.\r\n\r\n The optimization objective for MultiTaskElasticNet is::\r\n\r\n (1 / (2 * n_samples)) * ||Y - XW||_Fro^2\r\n + alpha * l1_ratio * ||W||_21\r\n + 0.5 * alpha * (1 - l1_ratio) * ||W||_Fro^2\r\n\r\n Where::\r\n\r\n ||W||_21 = sum_i sqrt(sum_j W_ij ^ 2)\r\n\r\n i.e. the sum of norms of each row.\r\n\r\n Read more in the :ref:`User Guide <multi_task_elastic_net>`.\r\n\r\n Parameters\r\n ----------\r\n alpha : float, default=1.0\r\n Constant that multiplies the L1/L2 term. Defaults to 1.0.\r\n\r\n l1_ratio : float, default=0.5\r\n The ElasticNet mixing parameter, with 0 < l1_ratio <= 1.\r\n For l1_ratio = 1 the penalty is an L1/L2 penalty. For l1_ratio = 0 it\r\n is an L2 penalty.\r\n For ``0 < l1_ratio < 1``, the penalty is a combination of L1/L2 and L2.\r\n\r\n fit_intercept : bool, default=True\r\n Whether to calculate the intercept for this model. If set\r\n to false, no intercept will be used in calculations\r\n (i.e. data is expected to be centered).\r\n\r\n normalize : bool, default=False\r\n This parameter is ignored when ``fit_intercept`` is set to False.\r\n If True, the regressors X will be normalized before regression by\r\n subtracting the mean and dividing by the l2-norm.\r\n If you wish to standardize, please use\r\n :class:`~sklearn.preprocessing.StandardScaler` before calling ``fit``\r\n on an estimator with ``normalize=False``.\r\n\r\n .. deprecated:: 1.0\r\n ``normalize`` was deprecated in version 1.0 and will be removed in\r\n 1.2.\r\n\r\n copy_X : bool, default=True\r\n If ``True``, X will be copied; else, it may be overwritten.\r\n\r\n max_iter : int, default=1000\r\n The maximum number of iterations.\r\n\r\n tol : float, default=1e-4\r\n The tolerance for the optimization: if the updates are\r\n smaller than ``tol``, the optimization code checks the\r\n dual gap for optimality and continues until it is smaller\r\n than ``tol``.\r\n\r\n warm_start : bool, default=False\r\n When set to ``True``, reuse the solution of the previous call to fit as\r\n initialization, otherwise, just erase the previous solution.\r\n See :term:`the Glossary <warm_start>`.\r\n\r\n random_state : int, RandomState instance, default=None\r\n The seed of the pseudo random number generator that selects a random\r\n feature to update. Used when ``selection`` == 'random'.\r\n Pass an int for reproducible output across multiple function calls.\r\n See :term:`Glossary <random_state>`.\r\n\r\n selection : {'cyclic', 'random'}, default='cyclic'\r\n If set to 'random', a random coefficient is updated every iteration\r\n rather than looping over features sequentially by default. This\r\n (setting to 'random') often leads to significantly faster convergence\r\n especially when tol is higher than 1e-4.\r\n\r\n Attributes\r\n ----------\r\n intercept_ : ndarray of shape (n_targets,)\r\n Independent term in decision function.\r\n\r\n coef_ : ndarray of shape (n_targets, n_features)\r\n Parameter vector (W in the cost function formula). If a 1D y is\r\n passed in at fit (non multi-task usage), ``coef_`` is then a 1D array.\r\n Note that ``coef_`` stores the transpose of ``W``, ``W.T``.\r\n\r\n n_iter_ : int\r\n Number of iterations run by the coordinate descent solver to reach\r\n the specified tolerance.\r\n\r\n dual_gap_ : float\r\n The dual gaps at the end of the optimization.\r\n\r\n eps_ : float\r\n The tolerance scaled scaled by the variance of the target `y`.\r\n\r\n sparse_coef_ : sparse matrix of shape (n_features,) or \\\r\n (n_targets, n_features)\r\n Sparse representation of the `coef_`.\r\n\r\n n_features_in_ : int\r\n Number of features seen during :term:`fit`.\r\n\r\n .. versionadded:: 0.24\r\n\r\n feature_names_in_ : ndarray of shape (`n_features_in_`,)\r\n Names of features seen during :term:`fit`. Defined only when `X`\r\n has feature names that are all strings.\r\n\r\n .. versionadded:: 1.0\r\n\r\n See Also\r\n --------\r\n MultiTaskElasticNetCV : Multi-task L1/L2 ElasticNet with built-in\r\n cross-validation.\r\n ElasticNet : Linear regression with combined L1 and L2 priors as regularizer.\r\n MultiTaskLasso : Multi-task L1/L2 Lasso with built-in cross-validation.\r\n\r\n Notes\r\n -----\r\n The algorithm used to fit the model is coordinate descent.\r\n\r\n To avoid unnecessary memory duplication the X and y arguments of the fit\r\n method should be directly passed as Fortran-contiguous numpy arrays.\r\n\r\n Examples\r\n --------\r\n >>> from sklearn import linear_model\r\n >>> clf = linear_model.MultiTaskElasticNet(alpha=0.1)\r\n >>> clf.fit([[0,0], [1, 1], [2, 2]], [[0, 0], [1, 1], [2, 2]])\r\n MultiTaskElasticNet(alpha=0.1)\r\n >>> print(clf.coef_)\r\n [[0.45663524 0.45612256]\r\n [0.45663524 0.45612256]]\r\n >>> print(clf.intercept_)\r\n [0.0872422 0.0872422]\r\n \"\"\"\r\n\r\n def __init__(\r\n self,\r\n alpha=1.0,\r\n *,\r\n l1_ratio=0.5,\r\n fit_intercept=True,\r\n normalize=\"deprecated\",\r\n copy_X=True,\r\n max_iter=1000,\r\n tol=1e-4,\r\n warm_start=False,\r\n random_state=None,\r\n selection=\"cyclic\",\r\n ):\r\n self.l1_ratio = l1_ratio\r\n self.alpha = alpha\r\n self.fit_intercept = fit_intercept\r\n self.normalize = normalize\r\n self.max_iter = max_iter\r\n self.copy_X = copy_X\r\n self.tol = tol\r\n self.warm_start = warm_start\r\n self.random_state = random_state\r\n self.selection = selection\r\n\r\n def fit(self, X, y):\r\n \"\"\"Fit MultiTaskElasticNet model with coordinate descent.\r\n\r\n Parameters\r\n ----------\r\n X : ndarray of shape (n_samples, n_features)\r\n Data.\r\n y : ndarray of shape (n_samples, n_targets)\r\n Target. Will be cast to X's dtype if necessary.\r\n\r\n Returns\r\n -------\r\n self : object\r\n Fitted estimator.\r\n\r\n Notes\r\n -----\r\n Coordinate descent is an algorithm that considers each column of\r\n data at a time hence it will automatically convert the X input\r\n as a Fortran-contiguous numpy array if necessary.\r\n\r\n To avoid memory re-allocation it is advised to allocate the\r\n initial data in memory directly using that format.\r\n \"\"\"\r\n _normalize = _deprecate_normalize(\r\n self.normalize, default=False, estimator_name=self.__class__.__name__\r\n )\r\n\r\n # Need to validate separately here.\r\n # We can't pass multi_ouput=True because that would allow y to be csr.\r\n check_X_params = dict(\r\n dtype=[np.float64, np.float32],\r\n order=\"F\",\r\n copy=self.copy_X and self.fit_intercept,\r\n )\r\n check_y_params = dict(ensure_2d=False, order=\"F\")\r\n X, y = self._validate_data(\r\n X, y, validate_separately=(check_X_params, check_y_params)\r\n )\r\n check_consistent_length(X, y)\r\n y = y.astype(X.dtype)\r\n\r\n if hasattr(self, \"l1_ratio\"):\r\n model_str = \"ElasticNet\"\r\n else:\r\n model_str = \"Lasso\"\r\n if y.ndim == 1:\r\n raise ValueError(\"For mono-task outputs, use %s\" % model_str)\r\n\r\n n_samples, n_features = X.shape\r\n n_targets = y.shape[1]\r\n\r\n X, y, X_offset, y_offset, X_scale = _preprocess_data(\r\n X, y, self.fit_intercept, _normalize, copy=False\r\n )\r\n\r\n if not self.warm_start or not hasattr(self, \"coef_\"):\r\n self.coef_ = np.zeros(\r\n (n_targets, n_features), dtype=X.dtype.type, order=\"F\"\r\n )\r\n\r\n l1_reg = self.alpha * self.l1_ratio * n_samples\r\n l2_reg = self.alpha * (1.0 - self.l1_ratio) * n_samples\r\n\r\n self.coef_ = np.asfortranarray(self.coef_) # coef contiguous in memory\r\n\r\n if self.selection not in [\"random\", \"cyclic\"]:\r\n raise ValueError(\"selection should be either random or cyclic.\")\r\n random = self.selection == \"random\"\r\n\r\n (\r\n self.coef_,\r\n self.dual_gap_,\r\n self.eps_,\r\n self.n_iter_,\r\n ) = cd_fast.enet_coordinate_descent_multi_task(\r\n self.coef_,\r\n l1_reg,\r\n l2_reg,\r\n X,\r\n y,\r\n self.max_iter,\r\n self.tol,\r\n check_random_state(self.random_state),\r\n random,\r\n )\r\n\r\n # account for different objective scaling here and in cd_fast\r\n self.dual_gap_ /= n_samples\r\n\r\n self._set_intercept(X_offset, y_offset, X_scale)\r\n\r\n # return self for chaining fit and predict calls\r\n return self\r\n\r\n def _more_tags(self):\r\n return {\"multioutput_only\": True}\r\n\r\n\r\nclass MultiTaskLasso(MultiTaskElasticNet):\r\n \"\"\"Multi-task Lasso model trained with L1/L2 mixed-norm as regularizer.\r\n\r\n The optimization objective for Lasso is::\r\n\r\n (1 / (2 * n_samples)) * ||Y - XW||^2_Fro + alpha * ||W||_21\r\n\r\n Where::\r\n\r\n ||W||_21 = \\\\sum_i \\\\sqrt{\\\\sum_j w_{ij}^2}\r\n\r\n i.e. the sum of norm of each row.\r\n\r\n Read more in the :ref:`User Guide <multi_task_lasso>`.\r\n\r\n Parameters\r\n ----------\r\n alpha : float, default=1.0\r\n Constant that multiplies the L1/L2 term. Defaults to 1.0.\r\n\r\n fit_intercept : bool, default=True\r\n Whether to calculate the intercept for this model. If set\r\n to false, no intercept will be used in calculations\r\n (i.e. data is expected to be centered).\r\n\r\n normalize : bool, default=False\r\n This parameter is ignored when ``fit_intercept`` is set to False.\r\n If True, the regressors X will be normalized before regression by\r\n subtracting the mean and dividing by the l2-norm.\r\n If you wish to standardize, please use\r\n :class:`~sklearn.preprocessing.StandardScaler` before calling ``fit``\r\n on an estimator with ``normalize=False``.\r\n\r\n .. deprecated:: 1.0\r\n ``normalize`` was deprecated in version 1.0 and will be removed in\r\n 1.2.\r\n\r\n copy_X : bool, default=True\r\n If ``True``, X will be copied; else, it may be overwritten.\r\n\r\n max_iter : int, default=1000\r\n The maximum number of iterations.\r\n\r\n tol : float, default=1e-4\r\n The tolerance for the optimization: if the updates are\r\n smaller than ``tol``, the optimization code checks the\r\n dual gap for optimality and continues until it is smaller\r\n than ``tol``.\r\n\r\n warm_start : bool, default=False\r\n When set to ``True``, reuse the solution of the previous call to fit as\r\n initialization, otherwise, just erase the previous solution.\r\n See :term:`the Glossary <warm_start>`.\r\n\r\n random_state : int, RandomState instance, default=None\r\n The seed of the pseudo random number generator that selects a random\r\n feature to update. Used when ``selection`` == 'random'.\r\n Pass an int for reproducible output across multiple function calls.\r\n See :term:`Glossary <random_state>`.\r\n\r\n selection : {'cyclic', 'random'}, default='cyclic'\r\n If set to 'random', a random coefficient is updated every iteration\r\n rather than looping over features sequentially by default. This\r\n (setting to 'random') often leads to significantly faster convergence\r\n especially when tol is higher than 1e-4.\r\n\r\n Attributes\r\n ----------\r\n coef_ : ndarray of shape (n_targets, n_features)\r\n Parameter vector (W in the cost function formula).\r\n Note that ``coef_`` stores the transpose of ``W``, ``W.T``.\r\n\r\n intercept_ : ndarray of shape (n_targets,)\r\n Independent term in decision function.\r\n\r\n n_iter_ : int\r\n Number of iterations run by the coordinate descent solver to reach\r\n the specified tolerance.\r\n\r\n dual_gap_ : ndarray of shape (n_alphas,)\r\n The dual gaps at the end of the optimization for each alpha.\r\n\r\n eps_ : float\r\n The tolerance scaled scaled by the variance of the target `y`.\r\n\r\n sparse_coef_ : sparse matrix of shape (n_features,) or \\\r\n (n_targets, n_features)\r\n Sparse representation of the `coef_`.\r\n\r\n n_features_in_ : int\r\n Number of features seen during :term:`fit`.\r\n\r\n .. versionadded:: 0.24\r\n\r\n feature_names_in_ : ndarray of shape (`n_features_in_`,)\r\n Names of features seen during :term:`fit`. Defined only when `X`\r\n has feature names that are all strings.\r\n\r\n .. versionadded:: 1.0\r\n\r\n See Also\r\n --------\r\n Lasso: Linear Model trained with L1 prior as regularizer (aka the Lasso).\r\n MultiTaskLasso: Multi-task L1/L2 Lasso with built-in cross-validation.\r\n MultiTaskElasticNet: Multi-task L1/L2 ElasticNet with built-in cross-validation.\r\n\r\n Notes\r\n -----\r\n The algorithm used to fit the model is coordinate descent.\r\n\r\n To avoid unnecessary memory duplication the X and y arguments of the fit\r\n method should be directly passed as Fortran-contiguous numpy arrays.\r\n\r\n Examples\r\n --------\r\n >>> from sklearn import linear_model\r\n >>> clf = linear_model.MultiTaskLasso(alpha=0.1)\r\n >>> clf.fit([[0, 1], [1, 2], [2, 4]], [[0, 0], [1, 1], [2, 3]])\r\n MultiTaskLasso(alpha=0.1)\r\n >>> print(clf.coef_)\r\n [[0. 0.60809415]\r\n [0. 0.94592424]]\r\n >>> print(clf.intercept_)\r\n [-0.41888636 -0.87382323]\r\n \"\"\"\r\n\r\n def __init__(\r\n self,\r\n alpha=1.0,\r\n *,\r\n fit_intercept=True,\r\n normalize=\"deprecated\",\r\n copy_X=True,\r\n max_iter=1000,\r\n tol=1e-4,\r\n warm_start=False,\r\n random_state=None,\r\n selection=\"cyclic\",\r\n ):\r\n self.alpha = alpha\r\n self.fit_intercept = fit_intercept\r\n self.normalize = normalize\r\n self.max_iter = max_iter\r\n self.copy_X = copy_X\r\n self.tol = tol\r\n self.warm_start = warm_start\r\n self.l1_ratio = 1.0\r\n self.random_state = random_state\r\n self.selection = selection\r\n\r\n\r\nclass MultiTaskElasticNetCV(RegressorMixin, LinearModelCV):\r\n \"\"\"Multi-task L1/L2 ElasticNet with built-in cross-validation.\r\n\r\n See glossary entry for :term:`cross-validation estimator`.\r\n\r\n The optimization objective for MultiTaskElasticNet is::\r\n\r\n (1 / (2 * n_samples)) * ||Y - XW||^Fro_2\r\n + alpha * l1_ratio * ||W||_21\r\n + 0.5 * alpha * (1 - l1_ratio) * ||W||_Fro^2\r\n\r\n Where::\r\n\r\n ||W||_21 = \\\\sum_i \\\\sqrt{\\\\sum_j w_{ij}^2}\r\n\r\n i.e. the sum of norm of each row.\r\n\r\n Read more in the :ref:`User Guide <multi_task_elastic_net>`.\r\n\r\n .. versionadded:: 0.15\r\n\r\n Parameters\r\n ----------\r\n l1_ratio : float or list of float, default=0.5\r\n The ElasticNet mixing parameter, with 0 < l1_ratio <= 1.\r\n For l1_ratio = 1 the penalty is an L1/L2 penalty. For l1_ratio = 0 it\r\n is an L2 penalty.\r\n For ``0 < l1_ratio < 1``, the penalty is a combination of L1/L2 and L2.\r\n This parameter can be a list, in which case the different\r\n values are tested by cross-validation and the one giving the best\r\n prediction score is used. Note that a good choice of list of\r\n values for l1_ratio is often to put more values close to 1\r\n (i.e. Lasso) and less close to 0 (i.e. Ridge), as in ``[.1, .5, .7,\r\n .9, .95, .99, 1]``.\r\n\r\n eps : float, default=1e-3\r\n Length of the path. ``eps=1e-3`` means that\r\n ``alpha_min / alpha_max = 1e-3``.\r\n\r\n n_alphas : int, default=100\r\n Number of alphas along the regularization path.\r\n\r\n alphas : array-like, default=None\r\n List of alphas where to compute the models.\r\n If not provided, set automatically.\r\n\r\n fit_intercept : bool, default=True\r\n Whether to calculate the intercept for this model. If set\r\n to false, no intercept will be used in calculations\r\n (i.e. data is expected to be centered).\r\n\r\n normalize : bool, default=False\r\n This parameter is ignored when ``fit_intercept`` is set to False.\r\n If True, the regressors X will be normalized before regression by\r\n subtracting the mean and dividing by the l2-norm.\r\n If you wish to standardize, please use\r\n :class:`~sklearn.preprocessing.StandardScaler` before calling ``fit``\r\n on an estimator with ``normalize=False``.\r\n\r\n .. deprecated:: 1.0\r\n ``normalize`` was deprecated in version 1.0 and will be removed in\r\n 1.2.\r\n\r\n max_iter : int, default=1000\r\n The maximum number of iterations.\r\n\r\n tol : float, default=1e-4\r\n The tolerance for the optimization: if the updates are\r\n smaller than ``tol``, the optimization code checks the\r\n dual gap for optimality and continues until it is smaller\r\n than ``tol``.\r\n\r\n cv : int, cross-validation generator or 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.\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, :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 copy_X : bool, default=True\r\n If ``True``, X will be copied; else, it may be overwritten.\r\n\r\n verbose : bool or int, default=0\r\n Amount of verbosity.\r\n\r\n n_jobs : int, default=None\r\n Number of CPUs to use during the cross validation. Note that this is\r\n used only if multiple values for l1_ratio are given.\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, default=None\r\n The seed of the pseudo random number generator that selects a random\r\n feature to update. Used when ``selection`` == 'random'.\r\n Pass an int for reproducible output across multiple function calls.\r\n See :term:`Glossary <random_state>`.\r\n\r\n selection : {'cyclic', 'random'}, default='cyclic'\r\n If set to 'random', a random coefficient is updated every iteration\r\n rather than looping over features sequentially by default. This\r\n (setting to 'random') often leads to significantly faster convergence\r\n especially when tol is higher than 1e-4.\r\n\r\n Attributes\r\n ----------\r\n intercept_ : ndarray of shape (n_targets,)\r\n Independent term in decision function.\r\n\r\n coef_ : ndarray of shape (n_targets, n_features)\r\n Parameter vector (W in the cost function formula).\r\n Note that ``coef_`` stores the transpose of ``W``, ``W.T``.\r\n\r\n alpha_ : float\r\n The amount of penalization chosen by cross validation.\r\n\r\n mse_path_ : ndarray of shape (n_alphas, n_folds) or \\\r\n (n_l1_ratio, n_alphas, n_folds)\r\n Mean square error for the test set on each fold, varying alpha.\r\n\r\n alphas_ : ndarray of shape (n_alphas,) or (n_l1_ratio, n_alphas)\r\n The grid of alphas used for fitting, for each l1_ratio.\r\n\r\n l1_ratio_ : float\r\n Best l1_ratio obtained by cross-validation.\r\n\r\n n_iter_ : int\r\n Number of iterations run by the coordinate descent solver to reach\r\n the specified tolerance for the optimal alpha.\r\n\r\n dual_gap_ : float\r\n The dual gap at the end of the optimization for the optimal alpha.\r\n\r\n n_features_in_ : int\r\n Number of features seen during :term:`fit`.\r\n\r\n .. versionadded:: 0.24\r\n\r\n feature_names_in_ : ndarray of shape (`n_features_in_`,)\r\n Names of features seen during :term:`fit`. Defined only when `X`\r\n has feature names that are all strings.\r\n\r\n .. versionadded:: 1.0\r\n\r\n See Also\r\n --------\r\n MultiTaskElasticNet : Multi-task L1/L2 ElasticNet with built-in cross-validation.\r\n ElasticNetCV : Elastic net model with best model selection by\r\n cross-validation.\r\n MultiTaskLassoCV : Multi-task Lasso model trained with L1/L2\r\n mixed-norm as regularizer.\r\n\r\n Notes\r\n -----\r\n The algorithm used to fit the model is coordinate descent.\r\n\r\n To avoid unnecessary memory duplication the X and y arguments of the fit\r\n method should be directly passed as Fortran-contiguous numpy arrays.\r\n\r\n Examples\r\n --------\r\n >>> from sklearn import linear_model\r\n >>> clf = linear_model.MultiTaskElasticNetCV(cv=3)\r\n >>> clf.fit([[0,0], [1, 1], [2, 2]],\r\n ... [[0, 0], [1, 1], [2, 2]])\r\n MultiTaskElasticNetCV(cv=3)\r\n >>> print(clf.coef_)\r\n [[0.52875032 0.46958558]\r\n [0.52875032 0.46958558]]\r\n >>> print(clf.intercept_)\r\n [0.00166409 0.00166409]\r\n \"\"\"\r\n\r\n path = staticmethod(enet_path)\r\n\r\n def __init__(\r\n self,\r\n *,\r\n l1_ratio=0.5,\r\n eps=1e-3,\r\n n_alphas=100,\r\n alphas=None,\r\n fit_intercept=True,\r\n normalize=\"deprecated\",\r\n max_iter=1000,\r\n tol=1e-4,\r\n cv=None,\r\n copy_X=True,\r\n verbose=0,\r\n n_jobs=None,\r\n random_state=None,\r\n selection=\"cyclic\",\r\n ):\r\n self.l1_ratio = l1_ratio\r\n self.eps = eps\r\n self.n_alphas = n_alphas\r\n self.alphas = alphas\r\n self.fit_intercept = fit_intercept\r\n self.normalize = normalize\r\n self.max_iter = max_iter\r\n self.tol = tol\r\n self.cv = cv\r\n self.copy_X = copy_X\r\n self.verbose = verbose\r\n self.n_jobs = n_jobs\r\n self.random_state = random_state\r\n self.selection = selection\r\n\r\n def _get_estimator(self):\r\n return MultiTaskElasticNet()\r\n\r\n def _is_multitask(self):\r\n return True\r\n\r\n def _more_tags(self):\r\n return {\"multioutput_only\": True}\r\n\r\n # This is necessary as LinearModelCV now supports sample_weight while\r\n # MultiTaskElasticNet does not (yet).\r\n def fit(self, X, y):\r\n \"\"\"Fit MultiTaskElasticNet model with coordinate descent.\r\n\r\n Fit is on grid of alphas and best alpha estimated by cross-validation.\r\n\r\n Parameters\r\n ----------\r\n X : ndarray of shape (n_samples, n_features)\r\n Training data.\r\n y : ndarray of shape (n_samples, n_targets)\r\n Training target variable. Will be cast to X's dtype if necessary.\r\n\r\n Returns\r\n -------\r\n self : object\r\n Returns MultiTaskElasticNet instance.\r\n \"\"\"\r\n return super().fit(X, y)\r\n\r\n\r\nclass MultiTaskLassoCV(RegressorMixin, LinearModelCV):\r\n \"\"\"Multi-task Lasso model trained with L1/L2 mixed-norm as regularizer.\r\n\r\n See glossary entry for :term:`cross-validation estimator`.\r\n\r\n The optimization objective for MultiTaskLasso is::\r\n\r\n (1 / (2 * n_samples)) * ||Y - XW||^Fro_2 + alpha * ||W||_21\r\n\r\n Where::\r\n\r\n ||W||_21 = \\\\sum_i \\\\sqrt{\\\\sum_j w_{ij}^2}\r\n\r\n i.e. the sum of norm of each row.\r\n\r\n Read more in the :ref:`User Guide <multi_task_lasso>`.\r\n\r\n .. versionadded:: 0.15\r\n\r\n Parameters\r\n ----------\r\n eps : float, default=1e-3\r\n Length of the path. ``eps=1e-3`` means that\r\n ``alpha_min / alpha_max = 1e-3``.\r\n\r\n n_alphas : int, default=100\r\n Number of alphas along the regularization path.\r\n\r\n alphas : array-like, default=None\r\n List of alphas where to compute the models.\r\n If not provided, set automatically.\r\n\r\n fit_intercept : bool, default=True\r\n Whether to calculate the intercept for this model. If set\r\n to false, no intercept will be used in calculations\r\n (i.e. data is expected to be centered).\r\n\r\n normalize : bool, default=False\r\n This parameter is ignored when ``fit_intercept`` is set to False.\r\n If True, the regressors X will be normalized before regression by\r\n subtracting the mean and dividing by the l2-norm.\r\n If you wish to standardize, please use\r\n :class:`~sklearn.preprocessing.StandardScaler` before calling ``fit``\r\n on an estimator with ``normalize=False``.\r\n\r\n .. deprecated:: 1.0\r\n ``normalize`` was deprecated in version 1.0 and will be removed in\r\n 1.2.\r\n\r\n max_iter : int, default=1000\r\n The maximum number of iterations.\r\n\r\n tol : float, default=1e-4\r\n The tolerance for the optimization: if the updates are\r\n smaller than ``tol``, the optimization code checks the\r\n dual gap for optimality and continues until it is smaller\r\n than ``tol``.\r\n\r\n copy_X : bool, default=True\r\n If ``True``, X will be copied; else, it may be overwritten.\r\n\r\n cv : int, cross-validation generator or 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.\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, :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 verbose : bool or int, default=False\r\n Amount of verbosity.\r\n\r\n n_jobs : int, default=None\r\n Number of CPUs to use during the cross validation. Note that this is\r\n used only if multiple values for l1_ratio are given.\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, default=None\r\n The seed of the pseudo random number generator that selects a random\r\n feature to update. Used when ``selection`` == 'random'.\r\n Pass an int for reproducible output across multiple function calls.\r\n See :term:`Glossary <random_state>`.\r\n\r\n selection : {'cyclic', 'random'}, default='cyclic'\r\n If set to 'random', a random coefficient is updated every iteration\r\n rather than looping over features sequentially by default. This\r\n (setting to 'random') often leads to significantly faster convergence\r\n especially when tol is higher than 1e-4.\r\n\r\n Attributes\r\n ----------\r\n intercept_ : ndarray of shape (n_targets,)\r\n Independent term in decision function.\r\n\r\n coef_ : ndarray of shape (n_targets, n_features)\r\n Parameter vector (W in the cost function formula).\r\n Note that ``coef_`` stores the transpose of ``W``, ``W.T``.\r\n\r\n alpha_ : float\r\n The amount of penalization chosen by cross validation.\r\n\r\n mse_path_ : ndarray of shape (n_alphas, n_folds)\r\n Mean square error for the test set on each fold, varying alpha.\r\n\r\n alphas_ : ndarray of shape (n_alphas,)\r\n The grid of alphas used for fitting.\r\n\r\n n_iter_ : int\r\n Number of iterations run by the coordinate descent solver to reach\r\n the specified tolerance for the optimal alpha.\r\n\r\n dual_gap_ : float\r\n The dual gap at the end of the optimization for the optimal alpha.\r\n\r\n n_features_in_ : int\r\n Number of features seen during :term:`fit`.\r\n\r\n .. versionadded:: 0.24\r\n\r\n feature_names_in_ : ndarray of shape (`n_features_in_`,)\r\n Names of features seen during :term:`fit`. Defined only when `X`\r\n has feature names that are all strings.\r\n\r\n .. versionadded:: 1.0\r\n\r\n See Also\r\n --------\r\n MultiTaskElasticNet : Multi-task ElasticNet model trained with L1/L2\r\n mixed-norm as regularizer.\r\n ElasticNetCV : Elastic net model with best model selection by\r\n cross-validation.\r\n MultiTaskElasticNetCV : Multi-task L1/L2 ElasticNet with built-in\r\n cross-validation.\r\n\r\n Notes\r\n -----\r\n The algorithm used to fit the model is coordinate descent.\r\n\r\n To avoid unnecessary memory duplication the X and y arguments of the fit\r\n method should be directly passed as Fortran-contiguous numpy arrays.\r\n\r\n Examples\r\n --------\r\n >>> from sklearn.linear_model import MultiTaskLassoCV\r\n >>> from sklearn.datasets import make_regression\r\n >>> from sklearn.metrics import r2_score\r\n >>> X, y = make_regression(n_targets=2, noise=4, random_state=0)\r\n >>> reg = MultiTaskLassoCV(cv=5, random_state=0).fit(X, y)\r\n >>> r2_score(y, reg.predict(X))\r\n 0.9994...\r\n >>> reg.alpha_\r\n 0.5713...\r\n >>> reg.predict(X[:1,])\r\n array([[153.7971..., 94.9015...]])\r\n \"\"\"\r\n\r\n path = staticmethod(lasso_path)\r\n\r\n def __init__(\r\n self,\r\n *,\r\n eps=1e-3,\r\n n_alphas=100,\r\n alphas=None,\r\n fit_intercept=True,\r\n normalize=\"deprecated\",\r\n max_iter=1000,\r\n tol=1e-4,\r\n copy_X=True,\r\n cv=None,\r\n verbose=False,\r\n n_jobs=None,\r\n random_state=None,\r\n selection=\"cyclic\",\r\n ):\r\n super().__init__(\r\n eps=eps,\r\n n_alphas=n_alphas,\r\n alphas=alphas,\r\n fit_intercept=fit_intercept,\r\n normalize=normalize,\r\n max_iter=max_iter,\r\n tol=tol,\r\n copy_X=copy_X,\r\n cv=cv,\r\n verbose=verbose,\r\n n_jobs=n_jobs,\r\n random_state=random_state,\r\n selection=selection,\r\n )\r\n\r\n def _get_estimator(self):\r\n return MultiTaskLasso()\r\n\r\n def _is_multitask(self):\r\n return True\r\n\r\n def _more_tags(self):\r\n return {\"multioutput_only\": True}\r\n\r\n # This is necessary as LinearModelCV now supports sample_weight while\r\n # MultiTaskElasticNet does not (yet).\r\n def fit(self, X, y):\r\n \"\"\"Fit MultiTaskLasso model with coordinate descent.\r\n\r\n Fit is on grid of alphas and best alpha estimated by cross-validation.\r\n\r\n Parameters\r\n ----------\r\n X : ndarray of shape (n_samples, n_features)\r\n Data.\r\n y : ndarray of shape (n_samples, n_targets)\r\n Target. Will be cast to X's dtype if necessary.\r\n\r\n Returns\r\n -------\r\n self : object\r\n Returns an instance of fitted model.\r\n \"\"\"\r\n return super().fit(X, y)\r\n",
"from __future__ import annotations\r\n\r\nfrom datetime import timedelta\r\nimport operator\r\nfrom sys import getsizeof\r\nfrom typing import (\r\n TYPE_CHECKING,\r\n Any,\r\n Callable,\r\n Hashable,\r\n List,\r\n cast,\r\n)\r\nimport warnings\r\n\r\nimport numpy as np\r\n\r\nfrom pandas._libs import index as libindex\r\nfrom pandas._libs.lib import no_default\r\nfrom pandas._typing import Dtype\r\nfrom pandas.compat.numpy import function as nv\r\nfrom pandas.util._decorators import (\r\n cache_readonly,\r\n doc,\r\n)\r\nfrom pandas.util._exceptions import rewrite_exception\r\n\r\nfrom pandas.core.dtypes.common import (\r\n ensure_platform_int,\r\n ensure_python_int,\r\n is_float,\r\n is_integer,\r\n is_scalar,\r\n is_signed_integer_dtype,\r\n is_timedelta64_dtype,\r\n)\r\nfrom pandas.core.dtypes.generic import ABCTimedeltaIndex\r\n\r\nfrom pandas.core import ops\r\nimport pandas.core.common as com\r\nfrom pandas.core.construction import extract_array\r\nimport pandas.core.indexes.base as ibase\r\nfrom pandas.core.indexes.base import maybe_extract_name\r\nfrom pandas.core.indexes.numeric import (\r\n Float64Index,\r\n Int64Index,\r\n NumericIndex,\r\n)\r\nfrom pandas.core.ops.common import unpack_zerodim_and_defer\r\n\r\nif TYPE_CHECKING:\r\n from pandas import Index\r\n\r\n_empty_range = range(0)\r\n\r\n\r\nclass RangeIndex(NumericIndex):\r\n \"\"\"\r\n Immutable Index implementing a monotonic integer range.\r\n\r\n RangeIndex is a memory-saving special case of Int64Index limited to\r\n representing monotonic ranges. Using RangeIndex may in some instances\r\n improve computing speed.\r\n\r\n This is the default index type used\r\n by DataFrame and Series when no explicit index is provided by the user.\r\n\r\n Parameters\r\n ----------\r\n start : int (default: 0), range, or other RangeIndex instance\r\n If int and \"stop\" is not given, interpreted as \"stop\" instead.\r\n stop : int (default: 0)\r\n step : int (default: 1)\r\n dtype : np.int64\r\n Unused, accepted for homogeneity with other index types.\r\n copy : bool, default False\r\n Unused, accepted for homogeneity with other index types.\r\n name : object, optional\r\n Name to be stored in the index.\r\n\r\n Attributes\r\n ----------\r\n start\r\n stop\r\n step\r\n\r\n Methods\r\n -------\r\n from_range\r\n\r\n See Also\r\n --------\r\n Index : The base pandas Index type.\r\n Int64Index : Index of int64 data.\r\n \"\"\"\r\n\r\n _typ = \"rangeindex\"\r\n _engine_type = libindex.Int64Engine\r\n _dtype_validation_metadata = (is_signed_integer_dtype, \"signed integer\")\r\n _range: range\r\n\r\n # --------------------------------------------------------------------\r\n # Constructors\r\n\r\n def __new__(\r\n cls,\r\n start=None,\r\n stop=None,\r\n step=None,\r\n dtype: Dtype | None = None,\r\n copy: bool = False,\r\n name: Hashable = None,\r\n ) -> RangeIndex:\r\n cls._validate_dtype(dtype)\r\n name = maybe_extract_name(name, start, cls)\r\n\r\n # RangeIndex\r\n if isinstance(start, RangeIndex):\r\n return start.copy(name=name)\r\n elif isinstance(start, range):\r\n return cls._simple_new(start, name=name)\r\n\r\n # validate the arguments\r\n if com.all_none(start, stop, step):\r\n raise TypeError(\"RangeIndex(...) must be called with integers\")\r\n\r\n start = ensure_python_int(start) if start is not None else 0\r\n\r\n if stop is None:\r\n start, stop = 0, start\r\n else:\r\n stop = ensure_python_int(stop)\r\n\r\n step = ensure_python_int(step) if step is not None else 1\r\n if step == 0:\r\n raise ValueError(\"Step must not be zero\")\r\n\r\n rng = range(start, stop, step)\r\n return cls._simple_new(rng, name=name)\r\n\r\n @classmethod\r\n def from_range(\r\n cls, data: range, name=None, dtype: Dtype | None = None\r\n ) -> RangeIndex:\r\n \"\"\"\r\n Create RangeIndex from a range object.\r\n\r\n Returns\r\n -------\r\n RangeIndex\r\n \"\"\"\r\n if not isinstance(data, range):\r\n raise TypeError(\r\n f\"{cls.__name__}(...) must be called with object coercible to a \"\r\n f\"range, {repr(data)} was passed\"\r\n )\r\n cls._validate_dtype(dtype)\r\n return cls._simple_new(data, name=name)\r\n\r\n @classmethod\r\n def _simple_new(cls, values: range, name: Hashable = None) -> RangeIndex:\r\n result = object.__new__(cls)\r\n\r\n assert isinstance(values, range)\r\n\r\n result._range = values\r\n result._name = name\r\n result._cache = {}\r\n result._reset_identity()\r\n return result\r\n\r\n # --------------------------------------------------------------------\r\n\r\n @cache_readonly\r\n def _constructor(self) -> type[Int64Index]:\r\n \"\"\"return the class to use for construction\"\"\"\r\n return Int64Index\r\n\r\n @cache_readonly\r\n def _data(self) -> np.ndarray:\r\n \"\"\"\r\n An int array that for performance reasons is created only when needed.\r\n\r\n The constructed array is saved in ``_cache``.\r\n \"\"\"\r\n return np.arange(self.start, self.stop, self.step, dtype=np.int64)\r\n\r\n @cache_readonly\r\n def _cached_int64index(self) -> Int64Index:\r\n return Int64Index._simple_new(self._data, name=self.name)\r\n\r\n @property\r\n def _int64index(self) -> Int64Index:\r\n # wrap _cached_int64index so we can be sure its name matches self.name\r\n res = self._cached_int64index\r\n res._name = self._name\r\n return res\r\n\r\n def _get_data_as_items(self):\r\n \"\"\"return a list of tuples of start, stop, step\"\"\"\r\n rng = self._range\r\n return [(\"start\", rng.start), (\"stop\", rng.stop), (\"step\", rng.step)]\r\n\r\n def __reduce__(self):\r\n d = self._get_attributes_dict()\r\n d.update(dict(self._get_data_as_items()))\r\n return ibase._new_Index, (type(self), d), None\r\n\r\n # --------------------------------------------------------------------\r\n # Rendering Methods\r\n\r\n def _format_attrs(self):\r\n \"\"\"\r\n Return a list of tuples of the (attr, formatted_value)\r\n \"\"\"\r\n attrs = self._get_data_as_items()\r\n if self.name is not None:\r\n attrs.append((\"name\", ibase.default_pprint(self.name)))\r\n return attrs\r\n\r\n def _format_data(self, name=None):\r\n # we are formatting thru the attributes\r\n return None\r\n\r\n def _format_with_header(self, header: list[str], na_rep: str = \"NaN\") -> list[str]:\r\n if not len(self._range):\r\n return header\r\n first_val_str = str(self._range[0])\r\n last_val_str = str(self._range[-1])\r\n max_length = max(len(first_val_str), len(last_val_str))\r\n\r\n return header + [f\"{x:<{max_length}}\" for x in self._range]\r\n\r\n # --------------------------------------------------------------------\r\n _deprecation_message = (\r\n \"RangeIndex.{} is deprecated and will be \"\r\n \"removed in a future version. Use RangeIndex.{} \"\r\n \"instead\"\r\n )\r\n\r\n @property\r\n def start(self) -> int:\r\n \"\"\"\r\n The value of the `start` parameter (``0`` if this was not supplied).\r\n \"\"\"\r\n # GH 25710\r\n return self._range.start\r\n\r\n @property\r\n def _start(self) -> int:\r\n \"\"\"\r\n The value of the `start` parameter (``0`` if this was not supplied).\r\n\r\n .. deprecated:: 0.25.0\r\n Use ``start`` instead.\r\n \"\"\"\r\n warnings.warn(\r\n self._deprecation_message.format(\"_start\", \"start\"),\r\n FutureWarning,\r\n stacklevel=2,\r\n )\r\n return self.start\r\n\r\n @property\r\n def stop(self) -> int:\r\n \"\"\"\r\n The value of the `stop` parameter.\r\n \"\"\"\r\n return self._range.stop\r\n\r\n @property\r\n def _stop(self) -> int:\r\n \"\"\"\r\n The value of the `stop` parameter.\r\n\r\n .. deprecated:: 0.25.0\r\n Use ``stop`` instead.\r\n \"\"\"\r\n # GH 25710\r\n warnings.warn(\r\n self._deprecation_message.format(\"_stop\", \"stop\"),\r\n FutureWarning,\r\n stacklevel=2,\r\n )\r\n return self.stop\r\n\r\n @property\r\n def step(self) -> int:\r\n \"\"\"\r\n The value of the `step` parameter (``1`` if this was not supplied).\r\n \"\"\"\r\n # GH 25710\r\n return self._range.step\r\n\r\n @property\r\n def _step(self) -> int:\r\n \"\"\"\r\n The value of the `step` parameter (``1`` if this was not supplied).\r\n\r\n .. deprecated:: 0.25.0\r\n Use ``step`` instead.\r\n \"\"\"\r\n # GH 25710\r\n warnings.warn(\r\n self._deprecation_message.format(\"_step\", \"step\"),\r\n FutureWarning,\r\n stacklevel=2,\r\n )\r\n return self.step\r\n\r\n @cache_readonly\r\n def nbytes(self) -> int:\r\n \"\"\"\r\n Return the number of bytes in the underlying data.\r\n \"\"\"\r\n rng = self._range\r\n return getsizeof(rng) + sum(\r\n getsizeof(getattr(rng, attr_name))\r\n for attr_name in [\"start\", \"stop\", \"step\"]\r\n )\r\n\r\n def memory_usage(self, deep: bool = False) -> int:\r\n \"\"\"\r\n Memory usage of my values\r\n\r\n Parameters\r\n ----------\r\n deep : bool\r\n Introspect the data deeply, interrogate\r\n `object` dtypes for system-level memory consumption\r\n\r\n Returns\r\n -------\r\n bytes used\r\n\r\n Notes\r\n -----\r\n Memory usage does not include memory consumed by elements that\r\n are not components of the array if deep=False\r\n\r\n See Also\r\n --------\r\n numpy.ndarray.nbytes\r\n \"\"\"\r\n return self.nbytes\r\n\r\n @property\r\n def dtype(self) -> np.dtype:\r\n return np.dtype(np.int64)\r\n\r\n @property\r\n def is_unique(self) -> bool:\r\n \"\"\"return if the index has unique values\"\"\"\r\n return True\r\n\r\n @cache_readonly\r\n def is_monotonic_increasing(self) -> bool:\r\n return self._range.step > 0 or len(self) <= 1\r\n\r\n @cache_readonly\r\n def is_monotonic_decreasing(self) -> bool:\r\n return self._range.step < 0 or len(self) <= 1\r\n\r\n def __contains__(self, key: Any) -> bool:\r\n hash(key)\r\n try:\r\n key = ensure_python_int(key)\r\n except TypeError:\r\n return False\r\n return key in self._range\r\n\r\n @property\r\n def inferred_type(self) -> str:\r\n return \"integer\"\r\n\r\n # --------------------------------------------------------------------\r\n # Indexing Methods\r\n\r\n @doc(Int64Index.get_loc)\r\n def get_loc(self, key, method=None, tolerance=None):\r\n if method is None and tolerance is None:\r\n if is_integer(key) or (is_float(key) and key.is_integer()):\r\n new_key = int(key)\r\n try:\r\n return self._range.index(new_key)\r\n except ValueError as err:\r\n raise KeyError(key) from err\r\n raise KeyError(key)\r\n return super().get_loc(key, method=method, tolerance=tolerance)\r\n\r\n def _get_indexer(\r\n self,\r\n target: Index,\r\n method: str | None = None,\r\n limit: int | None = None,\r\n tolerance=None,\r\n ) -> np.ndarray:\r\n # -> np.ndarray[np.intp]\r\n if com.any_not_none(method, tolerance, limit):\r\n return super()._get_indexer(\r\n target, method=method, tolerance=tolerance, limit=limit\r\n )\r\n\r\n if self.step > 0:\r\n start, stop, step = self.start, self.stop, self.step\r\n else:\r\n # GH 28678: work on reversed range for simplicity\r\n reverse = self._range[::-1]\r\n start, stop, step = reverse.start, reverse.stop, reverse.step\r\n\r\n if not is_signed_integer_dtype(target):\r\n # checks/conversions/roundings are delegated to general method\r\n return super()._get_indexer(target, method=method, tolerance=tolerance)\r\n\r\n target_array = np.asarray(target)\r\n locs = target_array - start\r\n valid = (locs % step == 0) & (locs >= 0) & (target_array < stop)\r\n locs[~valid] = -1\r\n locs[valid] = locs[valid] / step\r\n\r\n if step != self.step:\r\n # We reversed this range: transform to original locs\r\n locs[valid] = len(self) - 1 - locs[valid]\r\n return ensure_platform_int(locs)\r\n\r\n # --------------------------------------------------------------------\r\n\r\n def repeat(self, repeats, axis=None) -> Int64Index:\r\n return self._int64index.repeat(repeats, axis=axis)\r\n\r\n def delete(self, loc) -> Int64Index: # type: ignore[override]\r\n return self._int64index.delete(loc)\r\n\r\n def take(\r\n self, indices, axis: int = 0, allow_fill: bool = True, fill_value=None, **kwargs\r\n ) -> Int64Index:\r\n with rewrite_exception(\"Int64Index\", type(self).__name__):\r\n return self._int64index.take(\r\n indices,\r\n axis=axis,\r\n allow_fill=allow_fill,\r\n fill_value=fill_value,\r\n **kwargs,\r\n )\r\n\r\n def tolist(self) -> list[int]:\r\n return list(self._range)\r\n\r\n @doc(Int64Index.__iter__)\r\n def __iter__(self):\r\n yield from self._range\r\n\r\n @doc(Int64Index._shallow_copy)\r\n def _shallow_copy(self, values, name: Hashable = no_default):\r\n name = self.name if name is no_default else name\r\n\r\n if values.dtype.kind == \"f\":\r\n return Float64Index(values, name=name)\r\n return Int64Index._simple_new(values, name=name)\r\n\r\n def _view(self: RangeIndex) -> RangeIndex:\r\n result = type(self)._simple_new(self._range, name=self._name)\r\n result._cache = self._cache\r\n return result\r\n\r\n @doc(Int64Index.copy)\r\n def copy(\r\n self,\r\n name: Hashable = None,\r\n deep: bool = False,\r\n dtype: Dtype | None = None,\r\n names=None,\r\n ):\r\n name = self._validate_names(name=name, names=names, deep=deep)[0]\r\n new_index = self._rename(name=name)\r\n\r\n if dtype:\r\n warnings.warn(\r\n \"parameter dtype is deprecated and will be removed in a future \"\r\n \"version. Use the astype method instead.\",\r\n FutureWarning,\r\n stacklevel=2,\r\n )\r\n new_index = new_index.astype(dtype)\r\n return new_index\r\n\r\n def _minmax(self, meth: str):\r\n no_steps = len(self) - 1\r\n if no_steps == -1:\r\n return np.nan\r\n elif (meth == \"min\" and self.step > 0) or (meth == \"max\" and self.step < 0):\r\n return self.start\r\n\r\n return self.start + self.step * no_steps\r\n\r\n def min(self, axis=None, skipna: bool = True, *args, **kwargs) -> int:\r\n \"\"\"The minimum value of the RangeIndex\"\"\"\r\n nv.validate_minmax_axis(axis)\r\n nv.validate_min(args, kwargs)\r\n return self._minmax(\"min\")\r\n\r\n def max(self, axis=None, skipna: bool = True, *args, **kwargs) -> int:\r\n \"\"\"The maximum value of the RangeIndex\"\"\"\r\n nv.validate_minmax_axis(axis)\r\n nv.validate_max(args, kwargs)\r\n return self._minmax(\"max\")\r\n\r\n def argsort(self, *args, **kwargs) -> np.ndarray:\r\n \"\"\"\r\n Returns the indices that would sort the index and its\r\n underlying data.\r\n\r\n Returns\r\n -------\r\n np.ndarray[np.intp]\r\n\r\n See Also\r\n --------\r\n numpy.ndarray.argsort\r\n \"\"\"\r\n ascending = kwargs.pop(\"ascending\", True) # EA compat\r\n nv.validate_argsort(args, kwargs)\r\n\r\n if self._range.step > 0:\r\n result = np.arange(len(self), dtype=np.intp)\r\n else:\r\n result = np.arange(len(self) - 1, -1, -1, dtype=np.intp)\r\n\r\n if not ascending:\r\n result = result[::-1]\r\n return result\r\n\r\n def factorize(\r\n self, sort: bool = False, na_sentinel: int | None = -1\r\n ) -> tuple[np.ndarray, RangeIndex]:\r\n codes = np.arange(len(self), dtype=np.intp)\r\n uniques = self\r\n if sort and self.step < 0:\r\n codes = codes[::-1]\r\n uniques = uniques[::-1]\r\n return codes, uniques\r\n\r\n def equals(self, other: object) -> bool:\r\n \"\"\"\r\n Determines if two Index objects contain the same elements.\r\n \"\"\"\r\n if isinstance(other, RangeIndex):\r\n return self._range == other._range\r\n return super().equals(other)\r\n\r\n # --------------------------------------------------------------------\r\n # Set Operations\r\n\r\n def _intersection(self, other: Index, sort=False):\r\n\r\n if not isinstance(other, RangeIndex):\r\n # Int64Index\r\n return super()._intersection(other, sort=sort)\r\n\r\n if not len(self) or not len(other):\r\n return self._simple_new(_empty_range)\r\n\r\n first = self._range[::-1] if self.step < 0 else self._range\r\n second = other._range[::-1] if other.step < 0 else other._range\r\n\r\n # check whether intervals intersect\r\n # deals with in- and decreasing ranges\r\n int_low = max(first.start, second.start)\r\n int_high = min(first.stop, second.stop)\r\n if int_high <= int_low:\r\n return self._simple_new(_empty_range)\r\n\r\n # Method hint: linear Diophantine equation\r\n # solve intersection problem\r\n # performance hint: for identical step sizes, could use\r\n # cheaper alternative\r\n gcd, s, _ = self._extended_gcd(first.step, second.step)\r\n\r\n # check whether element sets intersect\r\n if (first.start - second.start) % gcd:\r\n return self._simple_new(_empty_range)\r\n\r\n # calculate parameters for the RangeIndex describing the\r\n # intersection disregarding the lower bounds\r\n tmp_start = first.start + (second.start - first.start) * first.step // gcd * s\r\n new_step = first.step * second.step // gcd\r\n new_range = range(tmp_start, int_high, new_step)\r\n new_index = self._simple_new(new_range)\r\n\r\n # adjust index to limiting interval\r\n new_start = new_index._min_fitting_element(int_low)\r\n new_range = range(new_start, new_index.stop, new_index.step)\r\n new_index = self._simple_new(new_range)\r\n\r\n if (self.step < 0 and other.step < 0) is not (new_index.step < 0):\r\n new_index = new_index[::-1]\r\n if sort is None:\r\n new_index = new_index.sort_values()\r\n\r\n return new_index\r\n\r\n def _min_fitting_element(self, lower_limit: int) -> int:\r\n \"\"\"Returns the smallest element greater than or equal to the limit\"\"\"\r\n no_steps = -(-(lower_limit - self.start) // abs(self.step))\r\n return self.start + abs(self.step) * no_steps\r\n\r\n def _extended_gcd(self, a: int, b: int) -> tuple[int, int, int]:\r\n \"\"\"\r\n Extended Euclidean algorithms to solve Bezout's identity:\r\n a*x + b*y = gcd(x, y)\r\n Finds one particular solution for x, y: s, t\r\n Returns: gcd, s, t\r\n \"\"\"\r\n s, old_s = 0, 1\r\n t, old_t = 1, 0\r\n r, old_r = b, a\r\n while r:\r\n quotient = old_r // r\r\n old_r, r = r, old_r - quotient * r\r\n old_s, s = s, old_s - quotient * s\r\n old_t, t = t, old_t - quotient * t\r\n return old_r, old_s, old_t\r\n\r\n def _union(self, other: Index, sort):\r\n \"\"\"\r\n Form the union of two Index objects and sorts if possible\r\n\r\n Parameters\r\n ----------\r\n other : Index or array-like\r\n\r\n sort : False or None, default None\r\n Whether to sort resulting index. ``sort=None`` returns a\r\n monotonically increasing ``RangeIndex`` if possible or a sorted\r\n ``Int64Index`` if not. ``sort=False`` always returns an\r\n unsorted ``Int64Index``\r\n\r\n .. versionadded:: 0.25.0\r\n\r\n Returns\r\n -------\r\n union : Index\r\n \"\"\"\r\n if isinstance(other, RangeIndex) and sort is None:\r\n start_s, step_s = self.start, self.step\r\n end_s = self.start + self.step * (len(self) - 1)\r\n start_o, step_o = other.start, other.step\r\n end_o = other.start + other.step * (len(other) - 1)\r\n if self.step < 0:\r\n start_s, step_s, end_s = end_s, -step_s, start_s\r\n if other.step < 0:\r\n start_o, step_o, end_o = end_o, -step_o, start_o\r\n if len(self) == 1 and len(other) == 1:\r\n step_s = step_o = abs(self.start - other.start)\r\n elif len(self) == 1:\r\n step_s = step_o\r\n elif len(other) == 1:\r\n step_o = step_s\r\n start_r = min(start_s, start_o)\r\n end_r = max(end_s, end_o)\r\n if step_o == step_s:\r\n if (\r\n (start_s - start_o) % step_s == 0\r\n and (start_s - end_o) <= step_s\r\n and (start_o - end_s) <= step_s\r\n ):\r\n return type(self)(start_r, end_r + step_s, step_s)\r\n if (\r\n (step_s % 2 == 0)\r\n and (abs(start_s - start_o) <= step_s / 2)\r\n and (abs(end_s - end_o) <= step_s / 2)\r\n ):\r\n return type(self)(start_r, end_r + step_s / 2, step_s / 2)\r\n elif step_o % step_s == 0:\r\n if (\r\n (start_o - start_s) % step_s == 0\r\n and (start_o + step_s >= start_s)\r\n and (end_o - step_s <= end_s)\r\n ):\r\n return type(self)(start_r, end_r + step_s, step_s)\r\n elif step_s % step_o == 0:\r\n if (\r\n (start_s - start_o) % step_o == 0\r\n and (start_s + step_o >= start_o)\r\n and (end_s - step_o <= end_o)\r\n ):\r\n return type(self)(start_r, end_r + step_o, step_o)\r\n return self._int64index._union(other, sort=sort)\r\n\r\n def _difference(self, other, sort=None):\r\n # optimized set operation if we have another RangeIndex\r\n self._validate_sort_keyword(sort)\r\n self._assert_can_do_setop(other)\r\n other, result_name = self._convert_can_do_setop(other)\r\n\r\n if not isinstance(other, RangeIndex):\r\n return super()._difference(other, sort=sort)\r\n\r\n res_name = ops.get_op_result_name(self, other)\r\n\r\n first = self._range[::-1] if self.step < 0 else self._range\r\n overlap = self.intersection(other)\r\n if overlap.step < 0:\r\n overlap = overlap[::-1]\r\n\r\n if len(overlap) == 0:\r\n return self.rename(name=res_name)\r\n if len(overlap) == len(self):\r\n return self[:0].rename(res_name)\r\n if not isinstance(overlap, RangeIndex):\r\n # We won't end up with RangeIndex, so fall back\r\n return super()._difference(other, sort=sort)\r\n if overlap.step != first.step:\r\n # In some cases we might be able to get a RangeIndex back,\r\n # but not worth the effort.\r\n return super()._difference(other, sort=sort)\r\n\r\n if overlap[0] == first.start:\r\n # The difference is everything after the intersection\r\n new_rng = range(overlap[-1] + first.step, first.stop, first.step)\r\n elif overlap[-1] == first[-1]:\r\n # The difference is everything before the intersection\r\n new_rng = range(first.start, overlap[0], first.step)\r\n else:\r\n # The difference is not range-like\r\n return super()._difference(other, sort=sort)\r\n\r\n new_index = type(self)._simple_new(new_rng, name=res_name)\r\n if first is not self._range:\r\n new_index = new_index[::-1]\r\n return new_index\r\n\r\n def symmetric_difference(self, other, result_name: Hashable = None, sort=None):\r\n if not isinstance(other, RangeIndex) or sort is not None:\r\n return super().symmetric_difference(other, result_name, sort)\r\n\r\n left = self.difference(other)\r\n right = other.difference(self)\r\n result = left.union(right)\r\n\r\n if result_name is not None:\r\n result = result.rename(result_name)\r\n return result\r\n\r\n # --------------------------------------------------------------------\r\n\r\n def _concat(self, indexes: list[Index], name: Hashable) -> Index:\r\n \"\"\"\r\n Overriding parent method for the case of all RangeIndex instances.\r\n\r\n When all members of \"indexes\" are of type RangeIndex: result will be\r\n RangeIndex if possible, Int64Index otherwise. E.g.:\r\n indexes = [RangeIndex(3), RangeIndex(3, 6)] -> RangeIndex(6)\r\n indexes = [RangeIndex(3), RangeIndex(4, 6)] -> Int64Index([0,1,2,4,5])\r\n \"\"\"\r\n if not all(isinstance(x, RangeIndex) for x in indexes):\r\n return super()._concat(indexes, name)\r\n\r\n elif len(indexes) == 1:\r\n return indexes[0]\r\n\r\n rng_indexes = cast(List[RangeIndex], indexes)\r\n\r\n start = step = next_ = None\r\n\r\n # Filter the empty indexes\r\n non_empty_indexes = [obj for obj in rng_indexes if len(obj)]\r\n\r\n for obj in non_empty_indexes:\r\n rng = obj._range\r\n\r\n if start is None:\r\n # This is set by the first non-empty index\r\n start = rng.start\r\n if step is None and len(rng) > 1:\r\n step = rng.step\r\n elif step is None:\r\n # First non-empty index had only one element\r\n if rng.start == start:\r\n values = np.concatenate([x._values for x in rng_indexes])\r\n result = Int64Index(values)\r\n return result.rename(name)\r\n\r\n step = rng.start - start\r\n\r\n non_consecutive = (step != rng.step and len(rng) > 1) or (\r\n next_ is not None and rng.start != next_\r\n )\r\n if non_consecutive:\r\n result = Int64Index(np.concatenate([x._values for x in rng_indexes]))\r\n return result.rename(name)\r\n\r\n if step is not None:\r\n next_ = rng[-1] + step\r\n\r\n if non_empty_indexes:\r\n # Get the stop value from \"next\" or alternatively\r\n # from the last non-empty index\r\n stop = non_empty_indexes[-1].stop if next_ is None else next_\r\n return RangeIndex(start, stop, step).rename(name)\r\n\r\n # Here all \"indexes\" had 0 length, i.e. were empty.\r\n # In this case return an empty range index.\r\n return RangeIndex(0, 0).rename(name)\r\n\r\n def __len__(self) -> int:\r\n \"\"\"\r\n return the length of the RangeIndex\r\n \"\"\"\r\n return len(self._range)\r\n\r\n @property\r\n def size(self) -> int:\r\n return len(self)\r\n\r\n def __getitem__(self, key):\r\n \"\"\"\r\n Conserve RangeIndex type for scalar and slice keys.\r\n \"\"\"\r\n if isinstance(key, slice):\r\n new_range = self._range[key]\r\n return self._simple_new(new_range, name=self._name)\r\n elif is_integer(key):\r\n new_key = int(key)\r\n try:\r\n return self._range[new_key]\r\n except IndexError as err:\r\n raise IndexError(\r\n f\"index {key} is out of bounds for axis 0 with size {len(self)}\"\r\n ) from err\r\n elif is_scalar(key):\r\n raise IndexError(\r\n \"only integers, slices (`:`), \"\r\n \"ellipsis (`...`), numpy.newaxis (`None`) \"\r\n \"and integer or boolean \"\r\n \"arrays are valid indices\"\r\n )\r\n # fall back to Int64Index\r\n return super().__getitem__(key)\r\n\r\n def _getitem_slice(self: RangeIndex, slobj: slice) -> RangeIndex:\r\n \"\"\"\r\n Fastpath for __getitem__ when we know we have a slice.\r\n \"\"\"\r\n res = self._range[slobj]\r\n return type(self)._simple_new(res, name=self._name)\r\n\r\n @unpack_zerodim_and_defer(\"__floordiv__\")\r\n def __floordiv__(self, other):\r\n\r\n if is_integer(other) and other != 0:\r\n if len(self) == 0 or self.start % other == 0 and self.step % other == 0:\r\n start = self.start // other\r\n step = self.step // other\r\n stop = start + len(self) * step\r\n new_range = range(start, stop, step or 1)\r\n return self._simple_new(new_range, name=self.name)\r\n if len(self) == 1:\r\n start = self.start // other\r\n new_range = range(start, start + 1, 1)\r\n return self._simple_new(new_range, name=self.name)\r\n return self._int64index // other\r\n\r\n # --------------------------------------------------------------------\r\n # Reductions\r\n\r\n def all(self, *args, **kwargs) -> bool:\r\n return 0 not in self._range\r\n\r\n def any(self, *args, **kwargs) -> bool:\r\n return any(self._range)\r\n\r\n # --------------------------------------------------------------------\r\n\r\n def _cmp_method(self, other, op):\r\n if isinstance(other, RangeIndex) and self._range == other._range:\r\n # Both are immutable so if ._range attr. are equal, shortcut is possible\r\n return super()._cmp_method(self, op)\r\n return super()._cmp_method(other, op)\r\n\r\n def _arith_method(self, other, op):\r\n \"\"\"\r\n Parameters\r\n ----------\r\n other : Any\r\n op : callable that accepts 2 params\r\n perform the binary op\r\n \"\"\"\r\n\r\n if isinstance(other, ABCTimedeltaIndex):\r\n # Defer to TimedeltaIndex implementation\r\n return NotImplemented\r\n elif isinstance(other, (timedelta, np.timedelta64)):\r\n # GH#19333 is_integer evaluated True on timedelta64,\r\n # so we need to catch these explicitly\r\n return op(self._int64index, other)\r\n elif is_timedelta64_dtype(other):\r\n # Must be an np.ndarray; GH#22390\r\n return op(self._int64index, other)\r\n\r\n if op in [\r\n operator.pow,\r\n ops.rpow,\r\n operator.mod,\r\n ops.rmod,\r\n ops.rfloordiv,\r\n divmod,\r\n ops.rdivmod,\r\n ]:\r\n return op(self._int64index, other)\r\n\r\n step: Callable | None = None\r\n if op in [operator.mul, ops.rmul, operator.truediv, ops.rtruediv]:\r\n step = op\r\n\r\n # TODO: if other is a RangeIndex we may have more efficient options\r\n other = extract_array(other, extract_numpy=True, extract_range=True)\r\n attrs = self._get_attributes_dict()\r\n\r\n left, right = self, other\r\n\r\n try:\r\n # apply if we have an override\r\n if step:\r\n with np.errstate(all=\"ignore\"):\r\n rstep = step(left.step, right)\r\n\r\n # we don't have a representable op\r\n # so return a base index\r\n if not is_integer(rstep) or not rstep:\r\n raise ValueError\r\n\r\n else:\r\n rstep = left.step\r\n\r\n with np.errstate(all=\"ignore\"):\r\n rstart = op(left.start, right)\r\n rstop = op(left.stop, right)\r\n\r\n result = type(self)(rstart, rstop, rstep, **attrs)\r\n\r\n # for compat with numpy / Int64Index\r\n # even if we can represent as a RangeIndex, return\r\n # as a Float64Index if we have float-like descriptors\r\n if not all(is_integer(x) for x in [rstart, rstop, rstep]):\r\n result = result.astype(\"float64\")\r\n\r\n return result\r\n\r\n except (ValueError, TypeError, ZeroDivisionError):\r\n # Defer to Int64Index implementation\r\n return op(self._int64index, other)\r\n # TODO: Do attrs get handled reliably?\r\n",
"# Author: Nikolay Mayorov <[email protected]>\r\n# License: 3-clause BSD\r\n\r\nimport numpy as np\r\nfrom scipy.sparse import issparse\r\nfrom scipy.special import digamma\r\n\r\nfrom ..metrics.cluster import mutual_info_score\r\nfrom ..neighbors import NearestNeighbors, KDTree\r\nfrom ..preprocessing import scale\r\nfrom ..utils import check_random_state\r\nfrom ..utils.fixes import _astype_copy_false\r\nfrom ..utils.validation import check_array, check_X_y\r\nfrom ..utils.multiclass import check_classification_targets\r\n\r\n\r\ndef _compute_mi_cc(x, y, n_neighbors):\r\n \"\"\"Compute mutual information between two continuous variables.\r\n\r\n Parameters\r\n ----------\r\n x, y : ndarray, shape (n_samples,)\r\n Samples of two continuous random variables, must have an identical\r\n shape.\r\n\r\n n_neighbors : int\r\n Number of nearest neighbors to search for each point, see [1]_.\r\n\r\n Returns\r\n -------\r\n mi : float\r\n Estimated mutual information. If it turned out to be negative it is\r\n replace by 0.\r\n\r\n Notes\r\n -----\r\n True mutual information can't be negative. If its estimate by a numerical\r\n method is negative, it means (providing the method is adequate) that the\r\n mutual information is close to 0 and replacing it by 0 is a reasonable\r\n strategy.\r\n\r\n References\r\n ----------\r\n .. [1] A. Kraskov, H. Stogbauer and P. Grassberger, \"Estimating mutual\r\n information\". Phys. Rev. E 69, 2004.\r\n \"\"\"\r\n n_samples = x.size\r\n\r\n x = x.reshape((-1, 1))\r\n y = y.reshape((-1, 1))\r\n xy = np.hstack((x, y))\r\n\r\n # Here we rely on NearestNeighbors to select the fastest algorithm.\r\n nn = NearestNeighbors(metric=\"chebyshev\", n_neighbors=n_neighbors)\r\n\r\n nn.fit(xy)\r\n radius = nn.kneighbors()[0]\r\n radius = np.nextafter(radius[:, -1], 0)\r\n\r\n # KDTree is explicitly fit to allow for the querying of number of\r\n # neighbors within a specified radius\r\n kd = KDTree(x, metric=\"chebyshev\")\r\n nx = kd.query_radius(x, radius, count_only=True, return_distance=False)\r\n nx = np.array(nx) - 1.0\r\n\r\n kd = KDTree(y, metric=\"chebyshev\")\r\n ny = kd.query_radius(y, radius, count_only=True, return_distance=False)\r\n ny = np.array(ny) - 1.0\r\n\r\n mi = (\r\n digamma(n_samples)\r\n + digamma(n_neighbors)\r\n - np.mean(digamma(nx + 1))\r\n - np.mean(digamma(ny + 1))\r\n )\r\n\r\n return max(0, mi)\r\n\r\n\r\ndef _compute_mi_cd(c, d, n_neighbors):\r\n \"\"\"Compute mutual information between continuous and discrete variables.\r\n\r\n Parameters\r\n ----------\r\n c : ndarray, shape (n_samples,)\r\n Samples of a continuous random variable.\r\n\r\n d : ndarray, shape (n_samples,)\r\n Samples of a discrete random variable.\r\n\r\n n_neighbors : int\r\n Number of nearest neighbors to search for each point, see [1]_.\r\n\r\n Returns\r\n -------\r\n mi : float\r\n Estimated mutual information. If it turned out to be negative it is\r\n replace by 0.\r\n\r\n Notes\r\n -----\r\n True mutual information can't be negative. If its estimate by a numerical\r\n method is negative, it means (providing the method is adequate) that the\r\n mutual information is close to 0 and replacing it by 0 is a reasonable\r\n strategy.\r\n\r\n References\r\n ----------\r\n .. [1] B. C. Ross \"Mutual Information between Discrete and Continuous\r\n Data Sets\". PLoS ONE 9(2), 2014.\r\n \"\"\"\r\n n_samples = c.shape[0]\r\n c = c.reshape((-1, 1))\r\n\r\n radius = np.empty(n_samples)\r\n label_counts = np.empty(n_samples)\r\n k_all = np.empty(n_samples)\r\n nn = NearestNeighbors()\r\n for label in np.unique(d):\r\n mask = d == label\r\n count = np.sum(mask)\r\n if count > 1:\r\n k = min(n_neighbors, count - 1)\r\n nn.set_params(n_neighbors=k)\r\n nn.fit(c[mask])\r\n r = nn.kneighbors()[0]\r\n radius[mask] = np.nextafter(r[:, -1], 0)\r\n k_all[mask] = k\r\n label_counts[mask] = count\r\n\r\n # Ignore points with unique labels.\r\n mask = label_counts > 1\r\n n_samples = np.sum(mask)\r\n label_counts = label_counts[mask]\r\n k_all = k_all[mask]\r\n c = c[mask]\r\n radius = radius[mask]\r\n\r\n kd = KDTree(c)\r\n m_all = kd.query_radius(c, radius, count_only=True, return_distance=False)\r\n m_all = np.array(m_all) - 1.0\r\n\r\n mi = (\r\n digamma(n_samples)\r\n + np.mean(digamma(k_all))\r\n - np.mean(digamma(label_counts))\r\n - np.mean(digamma(m_all + 1))\r\n )\r\n\r\n return max(0, mi)\r\n\r\n\r\ndef _compute_mi(x, y, x_discrete, y_discrete, n_neighbors=3):\r\n \"\"\"Compute mutual information between two variables.\r\n\r\n This is a simple wrapper which selects a proper function to call based on\r\n whether `x` and `y` are discrete or not.\r\n \"\"\"\r\n if x_discrete and y_discrete:\r\n return mutual_info_score(x, y)\r\n elif x_discrete and not y_discrete:\r\n return _compute_mi_cd(y, x, n_neighbors)\r\n elif not x_discrete and y_discrete:\r\n return _compute_mi_cd(x, y, n_neighbors)\r\n else:\r\n return _compute_mi_cc(x, y, n_neighbors)\r\n\r\n\r\ndef _iterate_columns(X, columns=None):\r\n \"\"\"Iterate over columns of a matrix.\r\n\r\n Parameters\r\n ----------\r\n X : ndarray or csc_matrix, shape (n_samples, n_features)\r\n Matrix over which to iterate.\r\n\r\n columns : iterable or None, default=None\r\n Indices of columns to iterate over. If None, iterate over all columns.\r\n\r\n Yields\r\n ------\r\n x : ndarray, shape (n_samples,)\r\n Columns of `X` in dense format.\r\n \"\"\"\r\n if columns is None:\r\n columns = range(X.shape[1])\r\n\r\n if issparse(X):\r\n for i in columns:\r\n x = np.zeros(X.shape[0])\r\n start_ptr, end_ptr = X.indptr[i], X.indptr[i + 1]\r\n x[X.indices[start_ptr:end_ptr]] = X.data[start_ptr:end_ptr]\r\n yield x\r\n else:\r\n for i in columns:\r\n yield X[:, i]\r\n\r\n\r\ndef _estimate_mi(\r\n X,\r\n y,\r\n discrete_features=\"auto\",\r\n discrete_target=False,\r\n n_neighbors=3,\r\n copy=True,\r\n random_state=None,\r\n):\r\n \"\"\"Estimate mutual information between the features and the target.\r\n\r\n Parameters\r\n ----------\r\n X : array-like or sparse matrix, shape (n_samples, n_features)\r\n Feature matrix.\r\n\r\n y : array-like of shape (n_samples,)\r\n Target vector.\r\n\r\n discrete_features : {'auto', bool, array-like}, default='auto'\r\n If bool, then determines whether to consider all features discrete\r\n or continuous. If array, then it should be either a boolean mask\r\n with shape (n_features,) or array with indices of discrete features.\r\n If 'auto', it is assigned to False for dense `X` and to True for\r\n sparse `X`.\r\n\r\n discrete_target : bool, default=False\r\n Whether to consider `y` as a discrete variable.\r\n\r\n n_neighbors : int, default=3\r\n Number of neighbors to use for MI estimation for continuous variables,\r\n see [1]_ and [2]_. Higher values reduce variance of the estimation, but\r\n could introduce a bias.\r\n\r\n copy : bool, default=True\r\n Whether to make a copy of the given data. If set to False, the initial\r\n data will be overwritten.\r\n\r\n random_state : int, RandomState instance or None, default=None\r\n Determines random number generation for adding small noise to\r\n continuous variables in order to remove repeated values.\r\n Pass an int for reproducible results across multiple function calls.\r\n See :term:`Glossary <random_state>`.\r\n\r\n Returns\r\n -------\r\n mi : ndarray, shape (n_features,)\r\n Estimated mutual information between each feature and the target.\r\n A negative value will be replaced by 0.\r\n\r\n References\r\n ----------\r\n .. [1] A. Kraskov, H. Stogbauer and P. Grassberger, \"Estimating mutual\r\n information\". Phys. Rev. E 69, 2004.\r\n .. [2] B. C. Ross \"Mutual Information between Discrete and Continuous\r\n Data Sets\". PLoS ONE 9(2), 2014.\r\n \"\"\"\r\n X, y = check_X_y(X, y, accept_sparse=\"csc\", y_numeric=not discrete_target)\r\n n_samples, n_features = X.shape\r\n\r\n if isinstance(discrete_features, (str, bool)):\r\n if isinstance(discrete_features, str):\r\n if discrete_features == \"auto\":\r\n discrete_features = issparse(X)\r\n else:\r\n raise ValueError(\"Invalid string value for discrete_features.\")\r\n discrete_mask = np.empty(n_features, dtype=bool)\r\n discrete_mask.fill(discrete_features)\r\n else:\r\n discrete_features = check_array(discrete_features, ensure_2d=False)\r\n if discrete_features.dtype != \"bool\":\r\n discrete_mask = np.zeros(n_features, dtype=bool)\r\n discrete_mask[discrete_features] = True\r\n else:\r\n discrete_mask = discrete_features\r\n\r\n continuous_mask = ~discrete_mask\r\n if np.any(continuous_mask) and issparse(X):\r\n raise ValueError(\"Sparse matrix `X` can't have continuous features.\")\r\n\r\n rng = check_random_state(random_state)\r\n if np.any(continuous_mask):\r\n if copy:\r\n X = X.copy()\r\n\r\n if not discrete_target:\r\n X[:, continuous_mask] = scale(\r\n X[:, continuous_mask], with_mean=False, copy=False\r\n )\r\n\r\n # Add small noise to continuous features as advised in Kraskov et. al.\r\n X = X.astype(float, **_astype_copy_false(X))\r\n means = np.maximum(1, np.mean(np.abs(X[:, continuous_mask]), axis=0))\r\n X[:, continuous_mask] += (\r\n 1e-10 * means * rng.randn(n_samples, np.sum(continuous_mask))\r\n )\r\n\r\n if not discrete_target:\r\n y = scale(y, with_mean=False)\r\n y += 1e-10 * np.maximum(1, np.mean(np.abs(y))) * rng.randn(n_samples)\r\n\r\n mi = [\r\n _compute_mi(x, y, discrete_feature, discrete_target, n_neighbors)\r\n for x, discrete_feature in zip(_iterate_columns(X), discrete_mask)\r\n ]\r\n\r\n return np.array(mi)\r\n\r\n\r\ndef mutual_info_regression(\r\n X, y, *, discrete_features=\"auto\", n_neighbors=3, copy=True, random_state=None\r\n):\r\n \"\"\"Estimate mutual information for a continuous target variable.\r\n\r\n Mutual information (MI) [1]_ between two random variables is a non-negative\r\n value, which measures the dependency between the variables. It is equal\r\n to zero if and only if two random variables are independent, and higher\r\n values mean higher dependency.\r\n\r\n The function relies on nonparametric methods based on entropy estimation\r\n from k-nearest neighbors distances as described in [2]_ and [3]_. Both\r\n methods are based on the idea originally proposed in [4]_.\r\n\r\n It can be used for univariate features selection, read more in the\r\n :ref:`User Guide <univariate_feature_selection>`.\r\n\r\n Parameters\r\n ----------\r\n X : array-like or sparse matrix, shape (n_samples, n_features)\r\n Feature matrix.\r\n\r\n y : array-like of shape (n_samples,)\r\n Target vector.\r\n\r\n discrete_features : {'auto', bool, array-like}, default='auto'\r\n If bool, then determines whether to consider all features discrete\r\n or continuous. If array, then it should be either a boolean mask\r\n with shape (n_features,) or array with indices of discrete features.\r\n If 'auto', it is assigned to False for dense `X` and to True for\r\n sparse `X`.\r\n\r\n n_neighbors : int, default=3\r\n Number of neighbors to use for MI estimation for continuous variables,\r\n see [2]_ and [3]_. Higher values reduce variance of the estimation, but\r\n could introduce a bias.\r\n\r\n copy : bool, default=True\r\n Whether to make a copy of the given data. If set to False, the initial\r\n data will be overwritten.\r\n\r\n random_state : int, RandomState instance or None, default=None\r\n Determines random number generation for adding small noise to\r\n continuous variables in order to remove repeated values.\r\n Pass an int for reproducible results across multiple function calls.\r\n See :term:`Glossary <random_state>`.\r\n\r\n Returns\r\n -------\r\n mi : ndarray, shape (n_features,)\r\n Estimated mutual information between each feature and the target.\r\n\r\n Notes\r\n -----\r\n 1. The term \"discrete features\" is used instead of naming them\r\n \"categorical\", because it describes the essence more accurately.\r\n For example, pixel intensities of an image are discrete features\r\n (but hardly categorical) and you will get better results if mark them\r\n as such. Also note, that treating a continuous variable as discrete and\r\n vice versa will usually give incorrect results, so be attentive about\r\n that.\r\n 2. True mutual information can't be negative. If its estimate turns out\r\n to be negative, it is replaced by zero.\r\n\r\n References\r\n ----------\r\n .. [1] `Mutual Information\r\n <https://en.wikipedia.org/wiki/Mutual_information>`_\r\n on Wikipedia.\r\n .. [2] A. Kraskov, H. Stogbauer and P. Grassberger, \"Estimating mutual\r\n information\". Phys. Rev. E 69, 2004.\r\n .. [3] B. C. Ross \"Mutual Information between Discrete and Continuous\r\n Data Sets\". PLoS ONE 9(2), 2014.\r\n .. [4] L. F. Kozachenko, N. N. Leonenko, \"Sample Estimate of the Entropy\r\n of a Random Vector\", Probl. Peredachi Inf., 23:2 (1987), 9-16\r\n \"\"\"\r\n return _estimate_mi(X, y, discrete_features, False, n_neighbors, copy, random_state)\r\n\r\n\r\ndef mutual_info_classif(\r\n X, y, *, discrete_features=\"auto\", n_neighbors=3, copy=True, random_state=None\r\n):\r\n \"\"\"Estimate mutual information for a discrete target variable.\r\n\r\n Mutual information (MI) [1]_ between two random variables is a non-negative\r\n value, which measures the dependency between the variables. It is equal\r\n to zero if and only if two random variables are independent, and higher\r\n values mean higher dependency.\r\n\r\n The function relies on nonparametric methods based on entropy estimation\r\n from k-nearest neighbors distances as described in [2]_ and [3]_. Both\r\n methods are based on the idea originally proposed in [4]_.\r\n\r\n It can be used for univariate features selection, read more in the\r\n :ref:`User Guide <univariate_feature_selection>`.\r\n\r\n Parameters\r\n ----------\r\n X : array-like or sparse matrix, shape (n_samples, n_features)\r\n Feature matrix.\r\n\r\n y : array-like of shape (n_samples,)\r\n Target vector.\r\n\r\n discrete_features : {'auto', bool, array-like}, default='auto'\r\n If bool, then determines whether to consider all features discrete\r\n or continuous. If array, then it should be either a boolean mask\r\n with shape (n_features,) or array with indices of discrete features.\r\n If 'auto', it is assigned to False for dense `X` and to True for\r\n sparse `X`.\r\n\r\n n_neighbors : int, default=3\r\n Number of neighbors to use for MI estimation for continuous variables,\r\n see [2]_ and [3]_. Higher values reduce variance of the estimation, but\r\n could introduce a bias.\r\n\r\n copy : bool, default=True\r\n Whether to make a copy of the given data. If set to False, the initial\r\n data will be overwritten.\r\n\r\n random_state : int, RandomState instance or None, default=None\r\n Determines random number generation for adding small noise to\r\n continuous variables in order to remove repeated values.\r\n Pass an int for reproducible results across multiple function calls.\r\n See :term:`Glossary <random_state>`.\r\n\r\n Returns\r\n -------\r\n mi : ndarray, shape (n_features,)\r\n Estimated mutual information between each feature and the target.\r\n\r\n Notes\r\n -----\r\n 1. The term \"discrete features\" is used instead of naming them\r\n \"categorical\", because it describes the essence more accurately.\r\n For example, pixel intensities of an image are discrete features\r\n (but hardly categorical) and you will get better results if mark them\r\n as such. Also note, that treating a continuous variable as discrete and\r\n vice versa will usually give incorrect results, so be attentive about\r\n that.\r\n 2. True mutual information can't be negative. If its estimate turns out\r\n to be negative, it is replaced by zero.\r\n\r\n References\r\n ----------\r\n .. [1] `Mutual Information\r\n <https://en.wikipedia.org/wiki/Mutual_information>`_\r\n on Wikipedia.\r\n .. [2] A. Kraskov, H. Stogbauer and P. Grassberger, \"Estimating mutual\r\n information\". Phys. Rev. E 69, 2004.\r\n .. [3] B. C. Ross \"Mutual Information between Discrete and Continuous\r\n Data Sets\". PLoS ONE 9(2), 2014.\r\n .. [4] L. F. Kozachenko, N. N. Leonenko, \"Sample Estimate of the Entropy\r\n of a Random Vector:, Probl. Peredachi Inf., 23:2 (1987), 9-16\r\n \"\"\"\r\n check_classification_targets(y)\r\n return _estimate_mi(X, y, discrete_features, True, n_neighbors, copy, random_state)\r\n",
"import numpy as np\r\nfrom scipy.stats.mstats import mquantiles\r\n\r\nimport pytest\r\nfrom numpy.testing import assert_allclose\r\n\r\nfrom sklearn.datasets import load_diabetes\r\nfrom sklearn.datasets import load_iris\r\nfrom sklearn.datasets import make_classification, make_regression\r\nfrom sklearn.ensemble import GradientBoostingRegressor\r\nfrom sklearn.ensemble import GradientBoostingClassifier\r\nfrom sklearn.linear_model import LinearRegression\r\nfrom sklearn.utils._testing import _convert_container\r\n\r\nfrom sklearn.inspection import plot_partial_dependence as plot_partial_dependence_func\r\nfrom sklearn.inspection import PartialDependenceDisplay\r\n\r\n\r\n# TODO: Remove when https://github.com/numpy/numpy/issues/14397 is resolved\r\npytestmark = pytest.mark.filterwarnings(\r\n \"ignore:In future, it will be an error for 'np.bool_':DeprecationWarning:\"\r\n \"matplotlib.*\",\r\n # TODO: Remove in 1.2 and convert test to only use\r\n # PartialDependenceDisplay.from_estimator\r\n \"ignore:Function plot_partial_dependence is deprecated\",\r\n)\r\n\r\n\r\n# TODO: Remove in 1.2 and convert test to only use\r\n# PartialDependenceDisplay.from_estimator\r\[email protected](\r\n params=[PartialDependenceDisplay.from_estimator, plot_partial_dependence_func],\r\n ids=[\"from_estimator\", \"function\"],\r\n)\r\ndef plot_partial_dependence(request):\r\n return request.param\r\n\r\n\r\[email protected](scope=\"module\")\r\ndef diabetes():\r\n return load_diabetes()\r\n\r\n\r\[email protected](scope=\"module\")\r\ndef clf_diabetes(diabetes):\r\n clf = GradientBoostingRegressor(n_estimators=10, random_state=1)\r\n clf.fit(diabetes.data, diabetes.target)\r\n return clf\r\n\r\n\r\ndef test_plot_partial_dependence_deprecation(pyplot, clf_diabetes, diabetes):\r\n \"\"\"Check that plot_partial_dependence is deprecated\"\"\"\r\n with pytest.warns(FutureWarning):\r\n plot_partial_dependence_func(clf_diabetes, diabetes.data, [0])\r\n\r\n\r\[email protected](\"ignore:A Bunch will be returned\")\r\[email protected](\"grid_resolution\", [10, 20])\r\ndef test_plot_partial_dependence(\r\n plot_partial_dependence, grid_resolution, pyplot, clf_diabetes, diabetes\r\n):\r\n # Test partial dependence plot function.\r\n # Use columns 0 & 2 as 1 is not quantitative (sex)\r\n feature_names = diabetes.feature_names\r\n disp = plot_partial_dependence(\r\n clf_diabetes,\r\n diabetes.data,\r\n [0, 2, (0, 2)],\r\n grid_resolution=grid_resolution,\r\n feature_names=feature_names,\r\n contour_kw={\"cmap\": \"jet\"},\r\n )\r\n fig = pyplot.gcf()\r\n axs = fig.get_axes()\r\n assert disp.figure_ is fig\r\n assert len(axs) == 4\r\n\r\n assert disp.bounding_ax_ is not None\r\n assert disp.axes_.shape == (1, 3)\r\n assert disp.lines_.shape == (1, 3)\r\n assert disp.contours_.shape == (1, 3)\r\n assert disp.deciles_vlines_.shape == (1, 3)\r\n assert disp.deciles_hlines_.shape == (1, 3)\r\n\r\n assert disp.lines_[0, 2] is None\r\n assert disp.contours_[0, 0] is None\r\n assert disp.contours_[0, 1] is None\r\n\r\n # deciles lines: always show on xaxis, only show on yaxis if 2-way PDP\r\n for i in range(3):\r\n assert disp.deciles_vlines_[0, i] is not None\r\n assert disp.deciles_hlines_[0, 0] is None\r\n assert disp.deciles_hlines_[0, 1] is None\r\n assert disp.deciles_hlines_[0, 2] is not None\r\n\r\n assert disp.features == [(0,), (2,), (0, 2)]\r\n assert np.all(disp.feature_names == feature_names)\r\n assert len(disp.deciles) == 2\r\n for i in [0, 2]:\r\n assert_allclose(\r\n disp.deciles[i],\r\n mquantiles(diabetes.data[:, i], prob=np.arange(0.1, 1.0, 0.1)),\r\n )\r\n\r\n single_feature_positions = [(0, (0, 0)), (2, (0, 1))]\r\n expected_ylabels = [\"Partial dependence\", \"\"]\r\n\r\n for i, (feat_col, pos) in enumerate(single_feature_positions):\r\n ax = disp.axes_[pos]\r\n assert ax.get_ylabel() == expected_ylabels[i]\r\n assert ax.get_xlabel() == diabetes.feature_names[feat_col]\r\n assert_allclose(ax.get_ylim(), disp.pdp_lim[1])\r\n\r\n line = disp.lines_[pos]\r\n\r\n avg_preds = disp.pd_results[i]\r\n assert avg_preds.average.shape == (1, grid_resolution)\r\n target_idx = disp.target_idx\r\n\r\n line_data = line.get_data()\r\n assert_allclose(line_data[0], avg_preds[\"values\"][0])\r\n assert_allclose(line_data[1], avg_preds.average[target_idx].ravel())\r\n\r\n # two feature position\r\n ax = disp.axes_[0, 2]\r\n coutour = disp.contours_[0, 2]\r\n expected_levels = np.linspace(*disp.pdp_lim[2], num=8)\r\n assert_allclose(coutour.levels, expected_levels)\r\n assert coutour.get_cmap().name == \"jet\"\r\n assert ax.get_xlabel() == diabetes.feature_names[0]\r\n assert ax.get_ylabel() == diabetes.feature_names[2]\r\n\r\n\r\[email protected](\"ignore:A Bunch will be returned\")\r\[email protected](\r\n \"kind, subsample, shape\",\r\n [\r\n (\"average\", None, (1, 3)),\r\n (\"individual\", None, (1, 3, 442)),\r\n (\"both\", None, (1, 3, 443)),\r\n (\"individual\", 50, (1, 3, 50)),\r\n (\"both\", 50, (1, 3, 51)),\r\n (\"individual\", 0.5, (1, 3, 221)),\r\n (\"both\", 0.5, (1, 3, 222)),\r\n ],\r\n)\r\ndef test_plot_partial_dependence_kind(\r\n plot_partial_dependence, pyplot, kind, subsample, shape, clf_diabetes, diabetes\r\n):\r\n disp = plot_partial_dependence(\r\n clf_diabetes, diabetes.data, [0, 1, 2], kind=kind, subsample=subsample\r\n )\r\n\r\n assert disp.axes_.shape == (1, 3)\r\n assert disp.lines_.shape == shape\r\n assert disp.contours_.shape == (1, 3)\r\n\r\n assert disp.contours_[0, 0] is None\r\n assert disp.contours_[0, 1] is None\r\n assert disp.contours_[0, 2] is None\r\n\r\n\r\[email protected](\"ignore:A Bunch will be returned\")\r\[email protected](\r\n \"input_type, feature_names_type\",\r\n [\r\n (\"dataframe\", None),\r\n (\"dataframe\", \"list\"),\r\n (\"list\", \"list\"),\r\n (\"array\", \"list\"),\r\n (\"dataframe\", \"array\"),\r\n (\"list\", \"array\"),\r\n (\"array\", \"array\"),\r\n (\"dataframe\", \"series\"),\r\n (\"list\", \"series\"),\r\n (\"array\", \"series\"),\r\n (\"dataframe\", \"index\"),\r\n (\"list\", \"index\"),\r\n (\"array\", \"index\"),\r\n ],\r\n)\r\ndef test_plot_partial_dependence_str_features(\r\n plot_partial_dependence,\r\n pyplot,\r\n clf_diabetes,\r\n diabetes,\r\n input_type,\r\n feature_names_type,\r\n):\r\n if input_type == \"dataframe\":\r\n pd = pytest.importorskip(\"pandas\")\r\n X = pd.DataFrame(diabetes.data, columns=diabetes.feature_names)\r\n elif input_type == \"list\":\r\n X = diabetes.data.tolist()\r\n else:\r\n X = diabetes.data\r\n\r\n if feature_names_type is None:\r\n feature_names = None\r\n else:\r\n feature_names = _convert_container(diabetes.feature_names, feature_names_type)\r\n\r\n grid_resolution = 25\r\n # check with str features and array feature names and single column\r\n disp = plot_partial_dependence(\r\n clf_diabetes,\r\n X,\r\n [(\"age\", \"bmi\"), \"bmi\"],\r\n grid_resolution=grid_resolution,\r\n feature_names=feature_names,\r\n n_cols=1,\r\n line_kw={\"alpha\": 0.8},\r\n )\r\n fig = pyplot.gcf()\r\n axs = fig.get_axes()\r\n assert len(axs) == 3\r\n\r\n assert disp.figure_ is fig\r\n assert disp.axes_.shape == (2, 1)\r\n assert disp.lines_.shape == (2, 1)\r\n assert disp.contours_.shape == (2, 1)\r\n assert disp.deciles_vlines_.shape == (2, 1)\r\n assert disp.deciles_hlines_.shape == (2, 1)\r\n\r\n assert disp.lines_[0, 0] is None\r\n assert disp.deciles_vlines_[0, 0] is not None\r\n assert disp.deciles_hlines_[0, 0] is not None\r\n assert disp.contours_[1, 0] is None\r\n assert disp.deciles_hlines_[1, 0] is None\r\n assert disp.deciles_vlines_[1, 0] is not None\r\n\r\n # line\r\n ax = disp.axes_[1, 0]\r\n assert ax.get_xlabel() == \"bmi\"\r\n assert ax.get_ylabel() == \"Partial dependence\"\r\n\r\n line = disp.lines_[1, 0]\r\n avg_preds = disp.pd_results[1]\r\n target_idx = disp.target_idx\r\n assert line.get_alpha() == 0.8\r\n\r\n line_data = line.get_data()\r\n assert_allclose(line_data[0], avg_preds[\"values\"][0])\r\n assert_allclose(line_data[1], avg_preds.average[target_idx].ravel())\r\n\r\n # contour\r\n ax = disp.axes_[0, 0]\r\n coutour = disp.contours_[0, 0]\r\n expect_levels = np.linspace(*disp.pdp_lim[2], num=8)\r\n assert_allclose(coutour.levels, expect_levels)\r\n assert ax.get_xlabel() == \"age\"\r\n assert ax.get_ylabel() == \"bmi\"\r\n\r\n\r\[email protected](\"ignore:A Bunch will be returned\")\r\ndef test_plot_partial_dependence_custom_axes(\r\n plot_partial_dependence, pyplot, clf_diabetes, diabetes\r\n):\r\n grid_resolution = 25\r\n fig, (ax1, ax2) = pyplot.subplots(1, 2)\r\n disp = plot_partial_dependence(\r\n clf_diabetes,\r\n diabetes.data,\r\n [\"age\", (\"age\", \"bmi\")],\r\n grid_resolution=grid_resolution,\r\n feature_names=diabetes.feature_names,\r\n ax=[ax1, ax2],\r\n )\r\n assert fig is disp.figure_\r\n assert disp.bounding_ax_ is None\r\n assert disp.axes_.shape == (2,)\r\n assert disp.axes_[0] is ax1\r\n assert disp.axes_[1] is ax2\r\n\r\n ax = disp.axes_[0]\r\n assert ax.get_xlabel() == \"age\"\r\n assert ax.get_ylabel() == \"Partial dependence\"\r\n\r\n line = disp.lines_[0]\r\n avg_preds = disp.pd_results[0]\r\n target_idx = disp.target_idx\r\n\r\n line_data = line.get_data()\r\n assert_allclose(line_data[0], avg_preds[\"values\"][0])\r\n assert_allclose(line_data[1], avg_preds.average[target_idx].ravel())\r\n\r\n # contour\r\n ax = disp.axes_[1]\r\n coutour = disp.contours_[1]\r\n expect_levels = np.linspace(*disp.pdp_lim[2], num=8)\r\n assert_allclose(coutour.levels, expect_levels)\r\n assert ax.get_xlabel() == \"age\"\r\n assert ax.get_ylabel() == \"bmi\"\r\n\r\n\r\[email protected](\"ignore:A Bunch will be returned\")\r\[email protected](\r\n \"kind, lines\", [(\"average\", 1), (\"individual\", 442), (\"both\", 443)]\r\n)\r\ndef test_plot_partial_dependence_passing_numpy_axes(\r\n plot_partial_dependence, pyplot, clf_diabetes, diabetes, kind, lines\r\n):\r\n grid_resolution = 25\r\n feature_names = diabetes.feature_names\r\n disp1 = plot_partial_dependence(\r\n clf_diabetes,\r\n diabetes.data,\r\n [\"age\", \"bmi\"],\r\n kind=kind,\r\n grid_resolution=grid_resolution,\r\n feature_names=feature_names,\r\n )\r\n assert disp1.axes_.shape == (1, 2)\r\n assert disp1.axes_[0, 0].get_ylabel() == \"Partial dependence\"\r\n assert disp1.axes_[0, 1].get_ylabel() == \"\"\r\n assert len(disp1.axes_[0, 0].get_lines()) == lines\r\n assert len(disp1.axes_[0, 1].get_lines()) == lines\r\n\r\n lr = LinearRegression()\r\n lr.fit(diabetes.data, diabetes.target)\r\n\r\n disp2 = plot_partial_dependence(\r\n lr,\r\n diabetes.data,\r\n [\"age\", \"bmi\"],\r\n kind=kind,\r\n grid_resolution=grid_resolution,\r\n feature_names=feature_names,\r\n ax=disp1.axes_,\r\n )\r\n\r\n assert np.all(disp1.axes_ == disp2.axes_)\r\n assert len(disp2.axes_[0, 0].get_lines()) == 2 * lines\r\n assert len(disp2.axes_[0, 1].get_lines()) == 2 * lines\r\n\r\n\r\[email protected](\"ignore:A Bunch will be returned\")\r\[email protected](\"nrows, ncols\", [(2, 2), (3, 1)])\r\ndef test_plot_partial_dependence_incorrent_num_axes(\r\n plot_partial_dependence, pyplot, clf_diabetes, diabetes, nrows, ncols\r\n):\r\n grid_resolution = 5\r\n fig, axes = pyplot.subplots(nrows, ncols)\r\n axes_formats = [list(axes.ravel()), tuple(axes.ravel()), axes]\r\n\r\n msg = \"Expected ax to have 2 axes, got {}\".format(nrows * ncols)\r\n\r\n disp = plot_partial_dependence(\r\n clf_diabetes,\r\n diabetes.data,\r\n [\"age\", \"bmi\"],\r\n grid_resolution=grid_resolution,\r\n feature_names=diabetes.feature_names,\r\n )\r\n\r\n for ax_format in axes_formats:\r\n with pytest.raises(ValueError, match=msg):\r\n plot_partial_dependence(\r\n clf_diabetes,\r\n diabetes.data,\r\n [\"age\", \"bmi\"],\r\n grid_resolution=grid_resolution,\r\n feature_names=diabetes.feature_names,\r\n ax=ax_format,\r\n )\r\n\r\n # with axes object\r\n with pytest.raises(ValueError, match=msg):\r\n disp.plot(ax=ax_format)\r\n\r\n\r\[email protected](\"ignore:A Bunch will be returned\")\r\ndef test_plot_partial_dependence_with_same_axes(\r\n plot_partial_dependence, pyplot, clf_diabetes, diabetes\r\n):\r\n # The first call to plot_partial_dependence will create two new axes to\r\n # place in the space of the passed in axes, which results in a total of\r\n # three axes in the figure.\r\n # Currently the API does not allow for the second call to\r\n # plot_partial_dependence to use the same axes again, because it will\r\n # create two new axes in the space resulting in five axes. To get the\r\n # expected behavior one needs to pass the generated axes into the second\r\n # call:\r\n # disp1 = plot_partial_dependence(...)\r\n # disp2 = plot_partial_dependence(..., ax=disp1.axes_)\r\n\r\n grid_resolution = 25\r\n fig, ax = pyplot.subplots()\r\n plot_partial_dependence(\r\n clf_diabetes,\r\n diabetes.data,\r\n [\"age\", \"bmi\"],\r\n grid_resolution=grid_resolution,\r\n feature_names=diabetes.feature_names,\r\n ax=ax,\r\n )\r\n\r\n msg = (\r\n \"The ax was already used in another plot function, please set \"\r\n \"ax=display.axes_ instead\"\r\n )\r\n\r\n with pytest.raises(ValueError, match=msg):\r\n plot_partial_dependence(\r\n clf_diabetes,\r\n diabetes.data,\r\n [\"age\", \"bmi\"],\r\n grid_resolution=grid_resolution,\r\n feature_names=diabetes.feature_names,\r\n ax=ax,\r\n )\r\n\r\n\r\[email protected](\"ignore:A Bunch will be returned\")\r\ndef test_plot_partial_dependence_feature_name_reuse(\r\n plot_partial_dependence, pyplot, clf_diabetes, diabetes\r\n):\r\n # second call to plot does not change the feature names from the first\r\n # call\r\n\r\n feature_names = diabetes.feature_names\r\n disp = plot_partial_dependence(\r\n clf_diabetes,\r\n diabetes.data,\r\n [0, 1],\r\n grid_resolution=10,\r\n feature_names=feature_names,\r\n )\r\n\r\n plot_partial_dependence(\r\n clf_diabetes, diabetes.data, [0, 1], grid_resolution=10, ax=disp.axes_\r\n )\r\n\r\n for i, ax in enumerate(disp.axes_.ravel()):\r\n assert ax.get_xlabel() == feature_names[i]\r\n\r\n\r\[email protected](\"ignore:A Bunch will be returned\")\r\ndef test_plot_partial_dependence_multiclass(plot_partial_dependence, pyplot):\r\n grid_resolution = 25\r\n clf_int = GradientBoostingClassifier(n_estimators=10, random_state=1)\r\n iris = load_iris()\r\n\r\n # Test partial dependence plot function on multi-class input.\r\n clf_int.fit(iris.data, iris.target)\r\n disp_target_0 = plot_partial_dependence(\r\n clf_int, iris.data, [0, 1], target=0, grid_resolution=grid_resolution\r\n )\r\n assert disp_target_0.figure_ is pyplot.gcf()\r\n assert disp_target_0.axes_.shape == (1, 2)\r\n assert disp_target_0.lines_.shape == (1, 2)\r\n assert disp_target_0.contours_.shape == (1, 2)\r\n assert disp_target_0.deciles_vlines_.shape == (1, 2)\r\n assert disp_target_0.deciles_hlines_.shape == (1, 2)\r\n assert all(c is None for c in disp_target_0.contours_.flat)\r\n assert disp_target_0.target_idx == 0\r\n\r\n # now with symbol labels\r\n target = iris.target_names[iris.target]\r\n clf_symbol = GradientBoostingClassifier(n_estimators=10, random_state=1)\r\n clf_symbol.fit(iris.data, target)\r\n disp_symbol = plot_partial_dependence(\r\n clf_symbol, iris.data, [0, 1], target=\"setosa\", grid_resolution=grid_resolution\r\n )\r\n assert disp_symbol.figure_ is pyplot.gcf()\r\n assert disp_symbol.axes_.shape == (1, 2)\r\n assert disp_symbol.lines_.shape == (1, 2)\r\n assert disp_symbol.contours_.shape == (1, 2)\r\n assert disp_symbol.deciles_vlines_.shape == (1, 2)\r\n assert disp_symbol.deciles_hlines_.shape == (1, 2)\r\n assert all(c is None for c in disp_symbol.contours_.flat)\r\n assert disp_symbol.target_idx == 0\r\n\r\n for int_result, symbol_result in zip(\r\n disp_target_0.pd_results, disp_symbol.pd_results\r\n ):\r\n assert_allclose(int_result.average, symbol_result.average)\r\n assert_allclose(int_result[\"values\"], symbol_result[\"values\"])\r\n\r\n # check that the pd plots are different for another target\r\n disp_target_1 = plot_partial_dependence(\r\n clf_int, iris.data, [0, 1], target=1, grid_resolution=grid_resolution\r\n )\r\n target_0_data_y = disp_target_0.lines_[0, 0].get_data()[1]\r\n target_1_data_y = disp_target_1.lines_[0, 0].get_data()[1]\r\n assert any(target_0_data_y != target_1_data_y)\r\n\r\n\r\nmultioutput_regression_data = make_regression(n_samples=50, n_targets=2, random_state=0)\r\n\r\n\r\[email protected](\"ignore:A Bunch will be returned\")\r\[email protected](\"target\", [0, 1])\r\ndef test_plot_partial_dependence_multioutput(plot_partial_dependence, pyplot, target):\r\n # Test partial dependence plot function on multi-output input.\r\n X, y = multioutput_regression_data\r\n clf = LinearRegression().fit(X, y)\r\n\r\n grid_resolution = 25\r\n disp = plot_partial_dependence(\r\n clf, X, [0, 1], target=target, grid_resolution=grid_resolution\r\n )\r\n fig = pyplot.gcf()\r\n axs = fig.get_axes()\r\n assert len(axs) == 3\r\n assert disp.target_idx == target\r\n assert disp.bounding_ax_ is not None\r\n\r\n positions = [(0, 0), (0, 1)]\r\n expected_label = [\"Partial dependence\", \"\"]\r\n\r\n for i, pos in enumerate(positions):\r\n ax = disp.axes_[pos]\r\n assert ax.get_ylabel() == expected_label[i]\r\n assert ax.get_xlabel() == \"{}\".format(i)\r\n\r\n\r\[email protected](\"ignore:A Bunch will be returned\")\r\ndef test_plot_partial_dependence_dataframe(\r\n plot_partial_dependence, pyplot, clf_diabetes, diabetes\r\n):\r\n pd = pytest.importorskip(\"pandas\")\r\n df = pd.DataFrame(diabetes.data, columns=diabetes.feature_names)\r\n\r\n grid_resolution = 25\r\n\r\n plot_partial_dependence(\r\n clf_diabetes,\r\n df,\r\n [\"bp\", \"s1\"],\r\n grid_resolution=grid_resolution,\r\n feature_names=df.columns.tolist(),\r\n )\r\n\r\n\r\ndummy_classification_data = make_classification(random_state=0)\r\n\r\n\r\[email protected](\"ignore:A Bunch will be returned\")\r\[email protected](\r\n \"data, params, err_msg\",\r\n [\r\n (\r\n multioutput_regression_data,\r\n {\"target\": None, \"features\": [0]},\r\n \"target must be specified for multi-output\",\r\n ),\r\n (\r\n multioutput_regression_data,\r\n {\"target\": -1, \"features\": [0]},\r\n r\"target must be in \\[0, n_tasks\\]\",\r\n ),\r\n (\r\n multioutput_regression_data,\r\n {\"target\": 100, \"features\": [0]},\r\n r\"target must be in \\[0, n_tasks\\]\",\r\n ),\r\n (\r\n dummy_classification_data,\r\n {\"features\": [\"foobar\"], \"feature_names\": None},\r\n \"Feature foobar not in feature_names\",\r\n ),\r\n (\r\n dummy_classification_data,\r\n {\"features\": [\"foobar\"], \"feature_names\": [\"abcd\", \"def\"]},\r\n \"Feature foobar not in feature_names\",\r\n ),\r\n (\r\n dummy_classification_data,\r\n {\"features\": [(1, 2, 3)]},\r\n \"Each entry in features must be either an int, \",\r\n ),\r\n (\r\n dummy_classification_data,\r\n {\"features\": [1, {}]},\r\n \"Each entry in features must be either an int, \",\r\n ),\r\n (\r\n dummy_classification_data,\r\n {\"features\": [tuple()]},\r\n \"Each entry in features must be either an int, \",\r\n ),\r\n (\r\n dummy_classification_data,\r\n {\"features\": [123], \"feature_names\": [\"blahblah\"]},\r\n \"All entries of features must be less than \",\r\n ),\r\n (\r\n dummy_classification_data,\r\n {\"features\": [0, 1, 2], \"feature_names\": [\"a\", \"b\", \"a\"]},\r\n \"feature_names should not contain duplicates\",\r\n ),\r\n (\r\n dummy_classification_data,\r\n {\"features\": [(1, 2)], \"kind\": \"individual\"},\r\n \"It is not possible to display individual effects for more than one\",\r\n ),\r\n (\r\n dummy_classification_data,\r\n {\"features\": [(1, 2)], \"kind\": \"both\"},\r\n \"It is not possible to display individual effects for more than one\",\r\n ),\r\n (\r\n dummy_classification_data,\r\n {\"features\": [1], \"subsample\": -1},\r\n \"When an integer, subsample=-1 should be positive.\",\r\n ),\r\n (\r\n dummy_classification_data,\r\n {\"features\": [1], \"subsample\": 1.2},\r\n r\"When a floating-point, subsample=1.2 should be in the \\(0, 1\\) range\",\r\n ),\r\n ],\r\n)\r\ndef test_plot_partial_dependence_error(\r\n plot_partial_dependence, pyplot, data, params, err_msg\r\n):\r\n X, y = data\r\n estimator = LinearRegression().fit(X, y)\r\n\r\n with pytest.raises(ValueError, match=err_msg):\r\n plot_partial_dependence(estimator, X, **params)\r\n\r\n\r\[email protected](\"ignore:A Bunch will be returned\")\r\[email protected](\r\n \"params, err_msg\",\r\n [\r\n ({\"target\": 4, \"features\": [0]}, \"target not in est.classes_, got 4\"),\r\n ({\"target\": None, \"features\": [0]}, \"target must be specified for multi-class\"),\r\n (\r\n {\"target\": 1, \"features\": [4.5]},\r\n \"Each entry in features must be either an int,\",\r\n ),\r\n ],\r\n)\r\ndef test_plot_partial_dependence_multiclass_error(\r\n plot_partial_dependence, pyplot, params, err_msg\r\n):\r\n iris = load_iris()\r\n clf = GradientBoostingClassifier(n_estimators=10, random_state=1)\r\n clf.fit(iris.data, iris.target)\r\n\r\n with pytest.raises(ValueError, match=err_msg):\r\n plot_partial_dependence(clf, iris.data, **params)\r\n\r\n\r\ndef test_plot_partial_dependence_does_not_override_ylabel(\r\n plot_partial_dependence, pyplot, clf_diabetes, diabetes\r\n):\r\n # Non-regression test to be sure to not override the ylabel if it has been\r\n # See https://github.com/scikit-learn/scikit-learn/issues/15772\r\n _, axes = pyplot.subplots(1, 2)\r\n axes[0].set_ylabel(\"Hello world\")\r\n plot_partial_dependence(clf_diabetes, diabetes.data, [0, 1], ax=axes)\r\n\r\n assert axes[0].get_ylabel() == \"Hello world\"\r\n assert axes[1].get_ylabel() == \"Partial dependence\"\r\n\r\n\r\[email protected](\r\n \"kind, expected_shape\",\r\n [(\"average\", (1, 2)), (\"individual\", (1, 2, 50)), (\"both\", (1, 2, 51))],\r\n)\r\ndef test_plot_partial_dependence_subsampling(\r\n plot_partial_dependence, pyplot, clf_diabetes, diabetes, kind, expected_shape\r\n):\r\n # check that the subsampling is properly working\r\n # non-regression test for:\r\n # https://github.com/scikit-learn/scikit-learn/pull/18359\r\n matplotlib = pytest.importorskip(\"matplotlib\")\r\n grid_resolution = 25\r\n feature_names = diabetes.feature_names\r\n\r\n disp1 = plot_partial_dependence(\r\n clf_diabetes,\r\n diabetes.data,\r\n [\"age\", \"bmi\"],\r\n kind=kind,\r\n grid_resolution=grid_resolution,\r\n feature_names=feature_names,\r\n subsample=50,\r\n random_state=0,\r\n )\r\n\r\n assert disp1.lines_.shape == expected_shape\r\n assert all(\r\n [isinstance(line, matplotlib.lines.Line2D) for line in disp1.lines_.ravel()]\r\n )\r\n\r\n\r\[email protected](\r\n \"kind, line_kw, label\",\r\n [\r\n (\"individual\", {}, None),\r\n (\"individual\", {\"label\": \"xxx\"}, None),\r\n (\"average\", {}, None),\r\n (\"average\", {\"label\": \"xxx\"}, \"xxx\"),\r\n (\"both\", {}, \"average\"),\r\n (\"both\", {\"label\": \"xxx\"}, \"xxx\"),\r\n ],\r\n)\r\ndef test_partial_dependence_overwrite_labels(\r\n plot_partial_dependence,\r\n pyplot,\r\n clf_diabetes,\r\n diabetes,\r\n kind,\r\n line_kw,\r\n label,\r\n):\r\n \"\"\"Test that make sure that we can overwrite the label of the PDP plot\"\"\"\r\n disp = plot_partial_dependence(\r\n clf_diabetes,\r\n diabetes.data,\r\n [0, 2],\r\n grid_resolution=25,\r\n feature_names=diabetes.feature_names,\r\n kind=kind,\r\n line_kw=line_kw,\r\n )\r\n\r\n for ax in disp.axes_.ravel():\r\n if label is None:\r\n assert ax.get_legend() is None\r\n else:\r\n legend_text = ax.get_legend().get_texts()\r\n assert len(legend_text) == 1\r\n assert legend_text[0].get_text() == label\r\n\r\n\r\[email protected](\"ignore:A Bunch will be returned\")\r\[email protected](\r\n \"line_kw, pd_line_kw, ice_lines_kw, expected_colors\",\r\n [\r\n ({\"color\": \"r\"}, {\"color\": \"g\"}, {\"color\": \"b\"}, (\"g\", \"b\")),\r\n (None, {\"color\": \"g\"}, {\"color\": \"b\"}, (\"g\", \"b\")),\r\n ({\"color\": \"r\"}, None, {\"color\": \"b\"}, (\"r\", \"b\")),\r\n ({\"color\": \"r\"}, {\"color\": \"g\"}, None, (\"g\", \"r\")),\r\n ({\"color\": \"r\"}, None, None, (\"r\", \"r\")),\r\n ({\"color\": \"r\"}, {\"linestyle\": \"--\"}, {\"linestyle\": \"-.\"}, (\"r\", \"r\")),\r\n ],\r\n)\r\ndef test_plot_partial_dependence_lines_kw(\r\n plot_partial_dependence,\r\n pyplot,\r\n clf_diabetes,\r\n diabetes,\r\n line_kw,\r\n pd_line_kw,\r\n ice_lines_kw,\r\n expected_colors,\r\n):\r\n \"\"\"Check that passing `pd_line_kw` and `ice_lines_kw` will act on the\r\n specific lines in the plot.\r\n \"\"\"\r\n\r\n disp = plot_partial_dependence(\r\n clf_diabetes,\r\n diabetes.data,\r\n [0, 2],\r\n grid_resolution=20,\r\n feature_names=diabetes.feature_names,\r\n n_cols=2,\r\n kind=\"both\",\r\n line_kw=line_kw,\r\n pd_line_kw=pd_line_kw,\r\n ice_lines_kw=ice_lines_kw,\r\n )\r\n\r\n line = disp.lines_[0, 0, -1]\r\n assert line.get_color() == expected_colors[0]\r\n if pd_line_kw is not None and \"linestyle\" in pd_line_kw:\r\n assert line.get_linestyle() == pd_line_kw[\"linestyle\"]\r\n else:\r\n assert line.get_linestyle() == \"-\"\r\n\r\n line = disp.lines_[0, 0, 0]\r\n assert line.get_color() == expected_colors[1]\r\n if ice_lines_kw is not None and \"linestyle\" in ice_lines_kw:\r\n assert line.get_linestyle() == ice_lines_kw[\"linestyle\"]\r\n else:\r\n assert line.get_linestyle() == \"-\"\r\n",
"\"\"\"\r\nTests for behavior if an author does *not* implement EA methods.\r\n\"\"\"\r\nimport numpy as np\r\nimport pytest\r\n\r\nfrom pandas.core.arrays import ExtensionArray\r\n\r\n\r\nclass MyEA(ExtensionArray):\r\n def __init__(self, values):\r\n self._values = values\r\n\r\n\r\[email protected]\r\ndef data():\r\n arr = np.arange(10)\r\n return MyEA(arr)\r\n\r\n\r\nclass TestExtensionArray:\r\n def test_errors(self, data, all_arithmetic_operators):\r\n # invalid ops\r\n op_name = all_arithmetic_operators\r\n with pytest.raises(AttributeError):\r\n getattr(data, op_name)\r\n",
"from string import ascii_letters as letters\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 (\r\n DataFrame,\r\n Series,\r\n Timestamp,\r\n date_range,\r\n option_context,\r\n)\r\nimport pandas._testing as tm\r\nimport pandas.core.common as com\r\n\r\nmsg = \"A value is trying to be set on a copy of a slice from a DataFrame\"\r\n\r\n\r\ndef random_text(nobs=100):\r\n df = []\r\n for i in range(nobs):\r\n idx = np.random.randint(len(letters), size=2)\r\n idx.sort()\r\n\r\n df.append([letters[idx[0] : idx[1]]])\r\n\r\n return DataFrame(df, columns=[\"letters\"])\r\n\r\n\r\nclass TestCaching:\r\n def test_slice_consolidate_invalidate_item_cache(self):\r\n\r\n # this is chained assignment, but will 'work'\r\n with option_context(\"chained_assignment\", None):\r\n\r\n # #3970\r\n df = DataFrame({\"aa\": np.arange(5), \"bb\": [2.2] * 5})\r\n\r\n # Creates a second float block\r\n df[\"cc\"] = 0.0\r\n\r\n # caches a reference to the 'bb' series\r\n df[\"bb\"]\r\n\r\n # repr machinery triggers consolidation\r\n repr(df)\r\n\r\n # Assignment to wrong series\r\n df[\"bb\"].iloc[0] = 0.17\r\n df._clear_item_cache()\r\n tm.assert_almost_equal(df[\"bb\"][0], 0.17)\r\n\r\n @pytest.mark.parametrize(\"do_ref\", [True, False])\r\n def test_setitem_cache_updating(self, do_ref):\r\n # GH 5424\r\n cont = [\"one\", \"two\", \"three\", \"four\", \"five\", \"six\", \"seven\"]\r\n\r\n df = DataFrame({\"a\": cont, \"b\": cont[3:] + cont[:3], \"c\": np.arange(7)})\r\n\r\n # ref the cache\r\n if do_ref:\r\n df.loc[0, \"c\"]\r\n\r\n # set it\r\n df.loc[7, \"c\"] = 1\r\n\r\n assert df.loc[0, \"c\"] == 0.0\r\n assert df.loc[7, \"c\"] == 1.0\r\n\r\n def test_setitem_cache_updating_slices(self):\r\n # GH 7084\r\n # not updating cache on series setting with slices\r\n expected = DataFrame(\r\n {\"A\": [600, 600, 600]}, index=date_range(\"5/7/2014\", \"5/9/2014\")\r\n )\r\n out = DataFrame({\"A\": [0, 0, 0]}, index=date_range(\"5/7/2014\", \"5/9/2014\"))\r\n df = DataFrame({\"C\": [\"A\", \"A\", \"A\"], \"D\": [100, 200, 300]})\r\n\r\n # loop through df to update out\r\n six = Timestamp(\"5/7/2014\")\r\n eix = Timestamp(\"5/9/2014\")\r\n for ix, row in df.iterrows():\r\n out.loc[six:eix, row[\"C\"]] = out.loc[six:eix, row[\"C\"]] + row[\"D\"]\r\n\r\n tm.assert_frame_equal(out, expected)\r\n tm.assert_series_equal(out[\"A\"], expected[\"A\"])\r\n\r\n # try via a chain indexing\r\n # this actually works\r\n out = DataFrame({\"A\": [0, 0, 0]}, index=date_range(\"5/7/2014\", \"5/9/2014\"))\r\n for ix, row in df.iterrows():\r\n v = out[row[\"C\"]][six:eix] + row[\"D\"]\r\n out[row[\"C\"]][six:eix] = v\r\n\r\n tm.assert_frame_equal(out, expected)\r\n tm.assert_series_equal(out[\"A\"], expected[\"A\"])\r\n\r\n out = DataFrame({\"A\": [0, 0, 0]}, index=date_range(\"5/7/2014\", \"5/9/2014\"))\r\n for ix, row in df.iterrows():\r\n out.loc[six:eix, row[\"C\"]] += row[\"D\"]\r\n\r\n tm.assert_frame_equal(out, expected)\r\n tm.assert_series_equal(out[\"A\"], expected[\"A\"])\r\n\r\n def test_altering_series_clears_parent_cache(self):\r\n # GH #33675\r\n df = DataFrame([[1, 2], [3, 4]], index=[\"a\", \"b\"], columns=[\"A\", \"B\"])\r\n ser = df[\"A\"]\r\n\r\n assert \"A\" in df._item_cache\r\n\r\n # Adding a new entry to ser swaps in a new array, so \"A\" needs to\r\n # be removed from df._item_cache\r\n ser[\"c\"] = 5\r\n assert len(ser) == 3\r\n assert \"A\" not in df._item_cache\r\n assert df[\"A\"] is not ser\r\n assert len(df[\"A\"]) == 2\r\n\r\n\r\nclass TestChaining:\r\n def test_setitem_chained_setfault(self):\r\n\r\n # GH6026\r\n data = [\"right\", \"left\", \"left\", \"left\", \"right\", \"left\", \"timeout\"]\r\n mdata = [\"right\", \"left\", \"left\", \"left\", \"right\", \"left\", \"none\"]\r\n\r\n df = DataFrame({\"response\": np.array(data)})\r\n mask = df.response == \"timeout\"\r\n df.response[mask] = \"none\"\r\n tm.assert_frame_equal(df, DataFrame({\"response\": mdata}))\r\n\r\n recarray = np.rec.fromarrays([data], names=[\"response\"])\r\n df = DataFrame(recarray)\r\n mask = df.response == \"timeout\"\r\n df.response[mask] = \"none\"\r\n tm.assert_frame_equal(df, DataFrame({\"response\": mdata}))\r\n\r\n df = DataFrame({\"response\": data, \"response1\": data})\r\n mask = df.response == \"timeout\"\r\n df.response[mask] = \"none\"\r\n tm.assert_frame_equal(df, DataFrame({\"response\": mdata, \"response1\": data}))\r\n\r\n # GH 6056\r\n expected = DataFrame({\"A\": [np.nan, \"bar\", \"bah\", \"foo\", \"bar\"]})\r\n df = DataFrame({\"A\": np.array([\"foo\", \"bar\", \"bah\", \"foo\", \"bar\"])})\r\n df[\"A\"].iloc[0] = np.nan\r\n result = df.head()\r\n tm.assert_frame_equal(result, expected)\r\n\r\n df = DataFrame({\"A\": np.array([\"foo\", \"bar\", \"bah\", \"foo\", \"bar\"])})\r\n df.A.iloc[0] = np.nan\r\n result = df.head()\r\n tm.assert_frame_equal(result, expected)\r\n\r\n @pytest.mark.arm_slow\r\n def test_detect_chained_assignment(self):\r\n\r\n pd.set_option(\"chained_assignment\", \"raise\")\r\n\r\n # work with the chain\r\n expected = DataFrame([[-5, 1], [-6, 3]], columns=list(\"AB\"))\r\n df = DataFrame(np.arange(4).reshape(2, 2), columns=list(\"AB\"), dtype=\"int64\")\r\n assert df._is_copy is None\r\n\r\n df[\"A\"][0] = -5\r\n df[\"A\"][1] = -6\r\n tm.assert_frame_equal(df, expected)\r\n\r\n @pytest.mark.arm_slow\r\n def test_detect_chained_assignment_raises(self, using_array_manager):\r\n\r\n # test with the chaining\r\n df = DataFrame(\r\n {\r\n \"A\": Series(range(2), dtype=\"int64\"),\r\n \"B\": np.array(np.arange(2, 4), dtype=np.float64),\r\n }\r\n )\r\n assert df._is_copy is None\r\n\r\n if not using_array_manager:\r\n with pytest.raises(com.SettingWithCopyError, match=msg):\r\n df[\"A\"][0] = -5\r\n\r\n with pytest.raises(com.SettingWithCopyError, match=msg):\r\n df[\"A\"][1] = np.nan\r\n\r\n assert df[\"A\"]._is_copy is None\r\n\r\n else:\r\n # INFO(ArrayManager) for ArrayManager it doesn't matter that it's\r\n # a mixed dataframe\r\n df[\"A\"][0] = -5\r\n df[\"A\"][1] = -6\r\n expected = DataFrame([[-5, 2], [-6, 3]], columns=list(\"AB\"))\r\n expected[\"B\"] = expected[\"B\"].astype(\"float64\")\r\n tm.assert_frame_equal(df, expected)\r\n\r\n @pytest.mark.arm_slow\r\n def test_detect_chained_assignment_fails(self):\r\n\r\n # Using a copy (the chain), fails\r\n df = DataFrame(\r\n {\r\n \"A\": Series(range(2), dtype=\"int64\"),\r\n \"B\": np.array(np.arange(2, 4), dtype=np.float64),\r\n }\r\n )\r\n\r\n with pytest.raises(com.SettingWithCopyError, match=msg):\r\n df.loc[0][\"A\"] = -5\r\n\r\n @pytest.mark.arm_slow\r\n def test_detect_chained_assignment_doc_example(self):\r\n\r\n # Doc example\r\n df = DataFrame(\r\n {\r\n \"a\": [\"one\", \"one\", \"two\", \"three\", \"two\", \"one\", \"six\"],\r\n \"c\": Series(range(7), dtype=\"int64\"),\r\n }\r\n )\r\n assert df._is_copy is None\r\n\r\n with pytest.raises(com.SettingWithCopyError, match=msg):\r\n indexer = df.a.str.startswith(\"o\")\r\n df[indexer][\"c\"] = 42\r\n\r\n @pytest.mark.arm_slow\r\n def test_detect_chained_assignment_object_dtype(self, using_array_manager):\r\n\r\n expected = DataFrame({\"A\": [111, \"bbb\", \"ccc\"], \"B\": [1, 2, 3]})\r\n df = DataFrame({\"A\": [\"aaa\", \"bbb\", \"ccc\"], \"B\": [1, 2, 3]})\r\n\r\n with pytest.raises(com.SettingWithCopyError, match=msg):\r\n df.loc[0][\"A\"] = 111\r\n\r\n if not using_array_manager:\r\n with pytest.raises(com.SettingWithCopyError, match=msg):\r\n df[\"A\"][0] = 111\r\n\r\n df.loc[0, \"A\"] = 111\r\n else:\r\n # INFO(ArrayManager) for ArrayManager it doesn't matter that it's\r\n # a mixed dataframe\r\n df[\"A\"][0] = 111\r\n\r\n tm.assert_frame_equal(df, expected)\r\n\r\n @pytest.mark.arm_slow\r\n def test_detect_chained_assignment_is_copy_pickle(self):\r\n\r\n # gh-5475: Make sure that is_copy is picked up reconstruction\r\n df = DataFrame({\"A\": [1, 2]})\r\n assert df._is_copy is None\r\n\r\n with tm.ensure_clean(\"__tmp__pickle\") as path:\r\n df.to_pickle(path)\r\n df2 = pd.read_pickle(path)\r\n df2[\"B\"] = df2[\"A\"]\r\n df2[\"B\"] = df2[\"A\"]\r\n\r\n @pytest.mark.arm_slow\r\n def test_detect_chained_assignment_setting_entire_column(self):\r\n\r\n # gh-5597: a spurious raise as we are setting the entire column here\r\n\r\n df = random_text(100000)\r\n\r\n # Always a copy\r\n x = df.iloc[[0, 1, 2]]\r\n assert x._is_copy is not None\r\n\r\n x = df.iloc[[0, 1, 2, 4]]\r\n assert x._is_copy is not None\r\n\r\n # Explicitly copy\r\n indexer = df.letters.apply(lambda x: len(x) > 10)\r\n df = df.loc[indexer].copy()\r\n\r\n assert df._is_copy is None\r\n df[\"letters\"] = df[\"letters\"].apply(str.lower)\r\n\r\n @pytest.mark.arm_slow\r\n def test_detect_chained_assignment_implicit_take(self):\r\n\r\n # Implicitly take\r\n df = random_text(100000)\r\n indexer = df.letters.apply(lambda x: len(x) > 10)\r\n df = df.loc[indexer]\r\n\r\n assert df._is_copy is not None\r\n df[\"letters\"] = df[\"letters\"].apply(str.lower)\r\n\r\n @pytest.mark.arm_slow\r\n def test_detect_chained_assignment_implicit_take2(self):\r\n\r\n # Implicitly take 2\r\n df = random_text(100000)\r\n indexer = df.letters.apply(lambda x: len(x) > 10)\r\n\r\n df = df.loc[indexer]\r\n assert df._is_copy is not None\r\n df.loc[:, \"letters\"] = df[\"letters\"].apply(str.lower)\r\n\r\n # Should be ok even though it's a copy!\r\n assert df._is_copy is None\r\n\r\n df[\"letters\"] = df[\"letters\"].apply(str.lower)\r\n assert df._is_copy is None\r\n\r\n @pytest.mark.arm_slow\r\n def test_detect_chained_assignment_str(self):\r\n\r\n df = random_text(100000)\r\n indexer = df.letters.apply(lambda x: len(x) > 10)\r\n df.loc[indexer, \"letters\"] = df.loc[indexer, \"letters\"].apply(str.lower)\r\n\r\n @pytest.mark.arm_slow\r\n def test_detect_chained_assignment_is_copy(self):\r\n\r\n # an identical take, so no copy\r\n df = DataFrame({\"a\": [1]}).dropna()\r\n assert df._is_copy is None\r\n df[\"a\"] += 1\r\n\r\n @pytest.mark.arm_slow\r\n def test_detect_chained_assignment_sorting(self):\r\n\r\n df = DataFrame(np.random.randn(10, 4))\r\n ser = df.iloc[:, 0].sort_values()\r\n\r\n tm.assert_series_equal(ser, df.iloc[:, 0].sort_values())\r\n tm.assert_series_equal(ser, df[0].sort_values())\r\n\r\n @pytest.mark.arm_slow\r\n def test_detect_chained_assignment_false_positives(self):\r\n\r\n # see gh-6025: false positives\r\n df = DataFrame({\"column1\": [\"a\", \"a\", \"a\"], \"column2\": [4, 8, 9]})\r\n str(df)\r\n\r\n df[\"column1\"] = df[\"column1\"] + \"b\"\r\n str(df)\r\n\r\n df = df[df[\"column2\"] != 8]\r\n str(df)\r\n\r\n df[\"column1\"] = df[\"column1\"] + \"c\"\r\n str(df)\r\n\r\n @pytest.mark.arm_slow\r\n def test_detect_chained_assignment_undefined_column(self):\r\n\r\n # from SO:\r\n # https://stackoverflow.com/questions/24054495/potential-bug-setting-value-for-undefined-column-using-iloc\r\n df = DataFrame(np.arange(0, 9), columns=[\"count\"])\r\n df[\"group\"] = \"b\"\r\n\r\n with pytest.raises(com.SettingWithCopyError, match=msg):\r\n df.iloc[0:5][\"group\"] = \"a\"\r\n\r\n @pytest.mark.arm_slow\r\n def test_detect_chained_assignment_changing_dtype(self, using_array_manager):\r\n\r\n # Mixed type setting but same dtype & changing dtype\r\n df = DataFrame(\r\n {\r\n \"A\": date_range(\"20130101\", periods=5),\r\n \"B\": np.random.randn(5),\r\n \"C\": np.arange(5, dtype=\"int64\"),\r\n \"D\": [\"a\", \"b\", \"c\", \"d\", \"e\"],\r\n }\r\n )\r\n\r\n with pytest.raises(com.SettingWithCopyError, match=msg):\r\n df.loc[2][\"D\"] = \"foo\"\r\n\r\n with pytest.raises(com.SettingWithCopyError, match=msg):\r\n df.loc[2][\"C\"] = \"foo\"\r\n\r\n if not using_array_manager:\r\n with pytest.raises(com.SettingWithCopyError, match=msg):\r\n df[\"C\"][2] = \"foo\"\r\n else:\r\n # INFO(ArrayManager) for ArrayManager it doesn't matter if it's\r\n # changing the dtype or not\r\n df[\"C\"][2] = \"foo\"\r\n assert df.loc[2, \"C\"] == \"foo\"\r\n\r\n def test_setting_with_copy_bug(self):\r\n\r\n # operating on a copy\r\n df = DataFrame(\r\n {\"a\": list(range(4)), \"b\": list(\"ab..\"), \"c\": [\"a\", \"b\", np.nan, \"d\"]}\r\n )\r\n mask = pd.isna(df.c)\r\n\r\n with pytest.raises(com.SettingWithCopyError, match=msg):\r\n df[[\"c\"]][mask] = df[[\"b\"]][mask]\r\n\r\n def test_setting_with_copy_bug_no_warning(self):\r\n # invalid warning as we are returning a new object\r\n # GH 8730\r\n df1 = DataFrame({\"x\": Series([\"a\", \"b\", \"c\"]), \"y\": Series([\"d\", \"e\", \"f\"])})\r\n df2 = df1[[\"x\"]]\r\n\r\n # this should not raise\r\n df2[\"y\"] = [\"g\", \"h\", \"i\"]\r\n\r\n def test_detect_chained_assignment_warnings_errors(self):\r\n df = DataFrame({\"A\": [\"aaa\", \"bbb\", \"ccc\"], \"B\": [1, 2, 3]})\r\n with option_context(\"chained_assignment\", \"warn\"):\r\n with tm.assert_produces_warning(com.SettingWithCopyWarning):\r\n df.loc[0][\"A\"] = 111\r\n\r\n with option_context(\"chained_assignment\", \"raise\"):\r\n with pytest.raises(com.SettingWithCopyError, match=msg):\r\n df.loc[0][\"A\"] = 111\r\n\r\n def test_detect_chained_assignment_warnings_filter_and_dupe_cols(self):\r\n # xref gh-13017.\r\n with option_context(\"chained_assignment\", \"warn\"):\r\n df = DataFrame([[1, 2, 3], [4, 5, 6], [7, 8, -9]], columns=[\"a\", \"a\", \"c\"])\r\n\r\n with tm.assert_produces_warning(com.SettingWithCopyWarning):\r\n df.c.loc[df.c > 0] = None\r\n\r\n expected = DataFrame(\r\n [[1, 2, 3], [4, 5, 6], [7, 8, -9]], columns=[\"a\", \"a\", \"c\"]\r\n )\r\n tm.assert_frame_equal(df, expected)\r\n\r\n @pytest.mark.parametrize(\"rhs\", [3, DataFrame({0: [1, 2, 3, 4]})])\r\n def test_detect_chained_assignment_warning_stacklevel(self, rhs):\r\n # GH#42570\r\n df = DataFrame(np.arange(25).reshape(5, 5))\r\n chained = df.loc[:3]\r\n with option_context(\"chained_assignment\", \"warn\"):\r\n with tm.assert_produces_warning(com.SettingWithCopyWarning) as t:\r\n chained[2] = rhs\r\n assert t[0].filename == __file__\r\n\r\n # TODO(ArrayManager) fast_xs with array-like scalars is not yet working\r\n @td.skip_array_manager_not_yet_implemented\r\n def test_chained_getitem_with_lists(self):\r\n\r\n # GH6394\r\n # Regression in chained getitem indexing with embedded list-like from\r\n # 0.12\r\n\r\n df = DataFrame({\"A\": 5 * [np.zeros(3)], \"B\": 5 * [np.ones(3)]})\r\n expected = df[\"A\"].iloc[2]\r\n result = df.loc[2, \"A\"]\r\n tm.assert_numpy_array_equal(result, expected)\r\n result2 = df.iloc[2][\"A\"]\r\n tm.assert_numpy_array_equal(result2, expected)\r\n result3 = df[\"A\"].loc[2]\r\n tm.assert_numpy_array_equal(result3, expected)\r\n result4 = df[\"A\"].iloc[2]\r\n tm.assert_numpy_array_equal(result4, expected)\r\n\r\n def test_cache_updating(self):\r\n # GH 4939, make sure to update the cache on setitem\r\n\r\n df = tm.makeDataFrame()\r\n df[\"A\"] # cache series\r\n df.loc[\"Hello Friend\"] = df.iloc[0]\r\n assert \"Hello Friend\" in df[\"A\"].index\r\n assert \"Hello Friend\" in df[\"B\"].index\r\n\r\n def test_cache_updating2(self):\r\n # 10264\r\n df = DataFrame(\r\n np.zeros((5, 5), dtype=\"int64\"),\r\n columns=[\"a\", \"b\", \"c\", \"d\", \"e\"],\r\n index=range(5),\r\n )\r\n df[\"f\"] = 0\r\n df.f.values[3] = 1\r\n\r\n df.f.values[3] = 2\r\n expected = DataFrame(\r\n np.zeros((5, 6), dtype=\"int64\"),\r\n columns=[\"a\", \"b\", \"c\", \"d\", \"e\", \"f\"],\r\n index=range(5),\r\n )\r\n expected.at[3, \"f\"] = 2\r\n tm.assert_frame_equal(df, expected)\r\n expected = Series([0, 0, 0, 2, 0], name=\"f\")\r\n tm.assert_series_equal(df.f, expected)\r\n\r\n def test_iloc_setitem_chained_assignment(self):\r\n # GH#3970\r\n with option_context(\"chained_assignment\", None):\r\n df = DataFrame({\"aa\": range(5), \"bb\": [2.2] * 5})\r\n df[\"cc\"] = 0.0\r\n\r\n ck = [True] * len(df)\r\n\r\n df[\"bb\"].iloc[0] = 0.13\r\n\r\n # TODO: unused\r\n df_tmp = df.iloc[ck] # noqa\r\n\r\n df[\"bb\"].iloc[0] = 0.15\r\n assert df[\"bb\"].iloc[0] == 0.15\r\n\r\n def test_getitem_loc_assignment_slice_state(self):\r\n # GH 13569\r\n df = DataFrame({\"a\": [10, 20, 30]})\r\n df[\"a\"].loc[4] = 40\r\n tm.assert_frame_equal(df, DataFrame({\"a\": [10, 20, 30]}))\r\n tm.assert_series_equal(df[\"a\"], Series([10, 20, 30], name=\"a\"))\r\n",
"\"\"\"\r\nA collection of functions and objects for creating or placing inset axes.\r\n\"\"\"\r\n\r\nfrom matplotlib import _api, docstring\r\nfrom matplotlib.offsetbox import AnchoredOffsetbox\r\nfrom matplotlib.patches import Patch, Rectangle\r\nfrom matplotlib.path import Path\r\nfrom matplotlib.transforms import Bbox, BboxTransformTo\r\nfrom matplotlib.transforms import IdentityTransform, TransformedBbox\r\n\r\nfrom . import axes_size as Size\r\nfrom .parasite_axes import HostAxes\r\n\r\n\r\nclass InsetPosition:\r\n @docstring.dedent_interpd\r\n def __init__(self, parent, lbwh):\r\n \"\"\"\r\n An object for positioning an inset axes.\r\n\r\n This is created by specifying the normalized coordinates in the axes,\r\n instead of the figure.\r\n\r\n Parameters\r\n ----------\r\n parent : `matplotlib.axes.Axes`\r\n Axes to use for normalizing coordinates.\r\n\r\n lbwh : iterable of four floats\r\n The left edge, bottom edge, width, and height of the inset axes, in\r\n units of the normalized coordinate of the *parent* axes.\r\n\r\n See Also\r\n --------\r\n :meth:`matplotlib.axes.Axes.set_axes_locator`\r\n\r\n Examples\r\n --------\r\n The following bounds the inset axes to a box with 20%% of the parent\r\n axes's height and 40%% of the width. The size of the axes specified\r\n ([0, 0, 1, 1]) ensures that the axes completely fills the bounding box:\r\n\r\n >>> parent_axes = plt.gca()\r\n >>> ax_ins = plt.axes([0, 0, 1, 1])\r\n >>> ip = InsetPosition(ax, [0.5, 0.1, 0.4, 0.2])\r\n >>> ax_ins.set_axes_locator(ip)\r\n \"\"\"\r\n self.parent = parent\r\n self.lbwh = lbwh\r\n\r\n def __call__(self, ax, renderer):\r\n bbox_parent = self.parent.get_position(original=False)\r\n trans = BboxTransformTo(bbox_parent)\r\n bbox_inset = Bbox.from_bounds(*self.lbwh)\r\n bb = TransformedBbox(bbox_inset, trans)\r\n return bb\r\n\r\n\r\nclass AnchoredLocatorBase(AnchoredOffsetbox):\r\n def __init__(self, bbox_to_anchor, offsetbox, loc,\r\n borderpad=0.5, bbox_transform=None):\r\n super().__init__(\r\n loc, pad=0., child=None, borderpad=borderpad,\r\n bbox_to_anchor=bbox_to_anchor, bbox_transform=bbox_transform\r\n )\r\n\r\n def draw(self, renderer):\r\n raise RuntimeError(\"No draw method should be called\")\r\n\r\n def __call__(self, ax, renderer):\r\n self.axes = ax\r\n\r\n fontsize = renderer.points_to_pixels(self.prop.get_size_in_points())\r\n self._update_offset_func(renderer, fontsize)\r\n\r\n width, height, xdescent, ydescent = self.get_extent(renderer)\r\n\r\n px, py = self.get_offset(width, height, 0, 0, renderer)\r\n bbox_canvas = Bbox.from_bounds(px, py, width, height)\r\n tr = ax.figure.transFigure.inverted()\r\n bb = TransformedBbox(bbox_canvas, tr)\r\n\r\n return bb\r\n\r\n\r\nclass AnchoredSizeLocator(AnchoredLocatorBase):\r\n def __init__(self, bbox_to_anchor, x_size, y_size, loc,\r\n borderpad=0.5, bbox_transform=None):\r\n super().__init__(\r\n bbox_to_anchor, None, loc,\r\n borderpad=borderpad, bbox_transform=bbox_transform\r\n )\r\n\r\n self.x_size = Size.from_any(x_size)\r\n self.y_size = Size.from_any(y_size)\r\n\r\n def get_extent(self, renderer):\r\n bbox = self.get_bbox_to_anchor()\r\n dpi = renderer.points_to_pixels(72.)\r\n\r\n r, a = self.x_size.get_size(renderer)\r\n width = bbox.width * r + a * dpi\r\n r, a = self.y_size.get_size(renderer)\r\n height = bbox.height * r + a * dpi\r\n\r\n xd, yd = 0, 0\r\n\r\n fontsize = renderer.points_to_pixels(self.prop.get_size_in_points())\r\n pad = self.pad * fontsize\r\n\r\n return width + 2 * pad, height + 2 * pad, xd + pad, yd + pad\r\n\r\n\r\nclass AnchoredZoomLocator(AnchoredLocatorBase):\r\n def __init__(self, parent_axes, zoom, loc,\r\n borderpad=0.5,\r\n bbox_to_anchor=None,\r\n bbox_transform=None):\r\n self.parent_axes = parent_axes\r\n self.zoom = zoom\r\n if bbox_to_anchor is None:\r\n bbox_to_anchor = parent_axes.bbox\r\n super().__init__(\r\n bbox_to_anchor, None, loc, borderpad=borderpad,\r\n bbox_transform=bbox_transform)\r\n\r\n def get_extent(self, renderer):\r\n bb = TransformedBbox(self.axes.viewLim, self.parent_axes.transData)\r\n fontsize = renderer.points_to_pixels(self.prop.get_size_in_points())\r\n pad = self.pad * fontsize\r\n return (abs(bb.width * self.zoom) + 2 * pad,\r\n abs(bb.height * self.zoom) + 2 * pad,\r\n pad, pad)\r\n\r\n\r\nclass BboxPatch(Patch):\r\n @docstring.dedent_interpd\r\n def __init__(self, bbox, **kwargs):\r\n \"\"\"\r\n Patch showing the shape bounded by a Bbox.\r\n\r\n Parameters\r\n ----------\r\n bbox : `matplotlib.transforms.Bbox`\r\n Bbox to use for the extents of this patch.\r\n\r\n **kwargs\r\n Patch properties. Valid arguments include:\r\n\r\n %(Patch:kwdoc)s\r\n \"\"\"\r\n if \"transform\" in kwargs:\r\n raise ValueError(\"transform should not be set\")\r\n\r\n kwargs[\"transform\"] = IdentityTransform()\r\n super().__init__(**kwargs)\r\n self.bbox = bbox\r\n\r\n def get_path(self):\r\n # docstring inherited\r\n x0, y0, x1, y1 = self.bbox.extents\r\n return Path([(x0, y0), (x1, y0), (x1, y1), (x0, y1), (x0, y0)],\r\n closed=True)\r\n\r\n\r\nclass BboxConnector(Patch):\r\n @staticmethod\r\n def get_bbox_edge_pos(bbox, loc):\r\n \"\"\"\r\n Helper function to obtain the location of a corner of a bbox\r\n\r\n Parameters\r\n ----------\r\n bbox : `matplotlib.transforms.Bbox`\r\n\r\n loc : {1, 2, 3, 4}\r\n Corner of *bbox*. Valid values are::\r\n\r\n 'upper right' : 1,\r\n 'upper left' : 2,\r\n 'lower left' : 3,\r\n 'lower right' : 4\r\n\r\n Returns\r\n -------\r\n x, y : float\r\n Coordinates of the corner specified by *loc*.\r\n \"\"\"\r\n x0, y0, x1, y1 = bbox.extents\r\n if loc == 1:\r\n return x1, y1\r\n elif loc == 2:\r\n return x0, y1\r\n elif loc == 3:\r\n return x0, y0\r\n elif loc == 4:\r\n return x1, y0\r\n\r\n @staticmethod\r\n def connect_bbox(bbox1, bbox2, loc1, loc2=None):\r\n \"\"\"\r\n Helper function to obtain a Path from one bbox to another.\r\n\r\n Parameters\r\n ----------\r\n bbox1, bbox2 : `matplotlib.transforms.Bbox`\r\n Bounding boxes to connect.\r\n\r\n loc1 : {1, 2, 3, 4}\r\n Corner of *bbox1* to use. Valid values are::\r\n\r\n 'upper right' : 1,\r\n 'upper left' : 2,\r\n 'lower left' : 3,\r\n 'lower right' : 4\r\n\r\n loc2 : {1, 2, 3, 4}, optional\r\n Corner of *bbox2* to use. If None, defaults to *loc1*.\r\n Valid values are::\r\n\r\n 'upper right' : 1,\r\n 'upper left' : 2,\r\n 'lower left' : 3,\r\n 'lower right' : 4\r\n\r\n Returns\r\n -------\r\n path : `matplotlib.path.Path`\r\n A line segment from the *loc1* corner of *bbox1* to the *loc2*\r\n corner of *bbox2*.\r\n \"\"\"\r\n if isinstance(bbox1, Rectangle):\r\n bbox1 = TransformedBbox(Bbox.unit(), bbox1.get_transform())\r\n if isinstance(bbox2, Rectangle):\r\n bbox2 = TransformedBbox(Bbox.unit(), bbox2.get_transform())\r\n if loc2 is None:\r\n loc2 = loc1\r\n x1, y1 = BboxConnector.get_bbox_edge_pos(bbox1, loc1)\r\n x2, y2 = BboxConnector.get_bbox_edge_pos(bbox2, loc2)\r\n return Path([[x1, y1], [x2, y2]])\r\n\r\n @docstring.dedent_interpd\r\n def __init__(self, bbox1, bbox2, loc1, loc2=None, **kwargs):\r\n \"\"\"\r\n Connect two bboxes with a straight line.\r\n\r\n Parameters\r\n ----------\r\n bbox1, bbox2 : `matplotlib.transforms.Bbox`\r\n Bounding boxes to connect.\r\n\r\n loc1 : {1, 2, 3, 4}\r\n Corner of *bbox1* to draw the line. Valid values are::\r\n\r\n 'upper right' : 1,\r\n 'upper left' : 2,\r\n 'lower left' : 3,\r\n 'lower right' : 4\r\n\r\n loc2 : {1, 2, 3, 4}, optional\r\n Corner of *bbox2* to draw the line. If None, defaults to *loc1*.\r\n Valid values are::\r\n\r\n 'upper right' : 1,\r\n 'upper left' : 2,\r\n 'lower left' : 3,\r\n 'lower right' : 4\r\n\r\n **kwargs\r\n Patch properties for the line drawn. Valid arguments include:\r\n\r\n %(Patch:kwdoc)s\r\n \"\"\"\r\n if \"transform\" in kwargs:\r\n raise ValueError(\"transform should not be set\")\r\n\r\n kwargs[\"transform\"] = IdentityTransform()\r\n if 'fill' in kwargs:\r\n super().__init__(**kwargs)\r\n else:\r\n fill = bool({'fc', 'facecolor', 'color'}.intersection(kwargs))\r\n super().__init__(fill=fill, **kwargs)\r\n self.bbox1 = bbox1\r\n self.bbox2 = bbox2\r\n self.loc1 = loc1\r\n self.loc2 = loc2\r\n\r\n def get_path(self):\r\n # docstring inherited\r\n return self.connect_bbox(self.bbox1, self.bbox2,\r\n self.loc1, self.loc2)\r\n\r\n\r\nclass BboxConnectorPatch(BboxConnector):\r\n @docstring.dedent_interpd\r\n def __init__(self, bbox1, bbox2, loc1a, loc2a, loc1b, loc2b, **kwargs):\r\n \"\"\"\r\n Connect two bboxes with a quadrilateral.\r\n\r\n The quadrilateral is specified by two lines that start and end at\r\n corners of the bboxes. The four sides of the quadrilateral are defined\r\n by the two lines given, the line between the two corners specified in\r\n *bbox1* and the line between the two corners specified in *bbox2*.\r\n\r\n Parameters\r\n ----------\r\n bbox1, bbox2 : `matplotlib.transforms.Bbox`\r\n Bounding boxes to connect.\r\n\r\n loc1a, loc2a : {1, 2, 3, 4}\r\n Corners of *bbox1* and *bbox2* to draw the first line.\r\n Valid values are::\r\n\r\n 'upper right' : 1,\r\n 'upper left' : 2,\r\n 'lower left' : 3,\r\n 'lower right' : 4\r\n\r\n loc1b, loc2b : {1, 2, 3, 4}\r\n Corners of *bbox1* and *bbox2* to draw the second line.\r\n Valid values are::\r\n\r\n 'upper right' : 1,\r\n 'upper left' : 2,\r\n 'lower left' : 3,\r\n 'lower right' : 4\r\n\r\n **kwargs\r\n Patch properties for the line drawn:\r\n\r\n %(Patch:kwdoc)s\r\n \"\"\"\r\n if \"transform\" in kwargs:\r\n raise ValueError(\"transform should not be set\")\r\n super().__init__(bbox1, bbox2, loc1a, loc2a, **kwargs)\r\n self.loc1b = loc1b\r\n self.loc2b = loc2b\r\n\r\n def get_path(self):\r\n # docstring inherited\r\n path1 = self.connect_bbox(self.bbox1, self.bbox2, self.loc1, self.loc2)\r\n path2 = self.connect_bbox(self.bbox2, self.bbox1,\r\n self.loc2b, self.loc1b)\r\n path_merged = [*path1.vertices, *path2.vertices, path1.vertices[0]]\r\n return Path(path_merged)\r\n\r\n\r\ndef _add_inset_axes(parent_axes, inset_axes):\r\n \"\"\"Helper function to add an inset axes and disable navigation in it.\"\"\"\r\n parent_axes.figure.add_axes(inset_axes)\r\n inset_axes.set_navigate(False)\r\n\r\n\r\[email protected]_interpd\r\ndef inset_axes(parent_axes, width, height, loc='upper right',\r\n bbox_to_anchor=None, bbox_transform=None,\r\n axes_class=None, axes_kwargs=None,\r\n borderpad=0.5):\r\n \"\"\"\r\n Create an inset axes with a given width and height.\r\n\r\n Both sizes used can be specified either in inches or percentage.\r\n For example,::\r\n\r\n inset_axes(parent_axes, width='40%%', height='30%%', loc='lower left')\r\n\r\n creates in inset axes in the lower left corner of *parent_axes* which spans\r\n over 30%% in height and 40%% in width of the *parent_axes*. Since the usage\r\n of `.inset_axes` may become slightly tricky when exceeding such standard\r\n cases, it is recommended to read :doc:`the examples\r\n </gallery/axes_grid1/inset_locator_demo>`.\r\n\r\n Notes\r\n -----\r\n The meaning of *bbox_to_anchor* and *bbox_to_transform* is interpreted\r\n differently from that of legend. The value of bbox_to_anchor\r\n (or the return value of its get_points method; the default is\r\n *parent_axes.bbox*) is transformed by the bbox_transform (the default\r\n is Identity transform) and then interpreted as points in the pixel\r\n coordinate (which is dpi dependent).\r\n\r\n Thus, following three calls are identical and creates an inset axes\r\n with respect to the *parent_axes*::\r\n\r\n axins = inset_axes(parent_axes, \"30%%\", \"40%%\")\r\n axins = inset_axes(parent_axes, \"30%%\", \"40%%\",\r\n bbox_to_anchor=parent_axes.bbox)\r\n axins = inset_axes(parent_axes, \"30%%\", \"40%%\",\r\n bbox_to_anchor=(0, 0, 1, 1),\r\n bbox_transform=parent_axes.transAxes)\r\n\r\n Parameters\r\n ----------\r\n parent_axes : `matplotlib.axes.Axes`\r\n Axes to place the inset axes.\r\n\r\n width, height : float or str\r\n Size of the inset axes to create. If a float is provided, it is\r\n the size in inches, e.g. *width=1.3*. If a string is provided, it is\r\n the size in relative units, e.g. *width='40%%'*. By default, i.e. if\r\n neither *bbox_to_anchor* nor *bbox_transform* are specified, those\r\n are relative to the parent_axes. Otherwise they are to be understood\r\n relative to the bounding box provided via *bbox_to_anchor*.\r\n\r\n loc : str, default: 'upper right'\r\n Location to place the inset axes. Valid locations are\r\n 'upper left', 'upper center', 'upper right',\r\n 'center left', 'center', 'center right',\r\n 'lower left', 'lower center, 'lower right'.\r\n For backward compatibility, numeric values are accepted as well.\r\n See the parameter *loc* of `.Legend` for details.\r\n\r\n bbox_to_anchor : tuple or `matplotlib.transforms.BboxBase`, optional\r\n Bbox that the inset axes will be anchored to. If None,\r\n a tuple of (0, 0, 1, 1) is used if *bbox_transform* is set\r\n to *parent_axes.transAxes* or *parent_axes.figure.transFigure*.\r\n Otherwise, *parent_axes.bbox* is used. If a tuple, can be either\r\n [left, bottom, width, height], or [left, bottom].\r\n If the kwargs *width* and/or *height* are specified in relative units,\r\n the 2-tuple [left, bottom] cannot be used. Note that,\r\n unless *bbox_transform* is set, the units of the bounding box\r\n are interpreted in the pixel coordinate. When using *bbox_to_anchor*\r\n with tuple, it almost always makes sense to also specify\r\n a *bbox_transform*. This might often be the axes transform\r\n *parent_axes.transAxes*.\r\n\r\n bbox_transform : `matplotlib.transforms.Transform`, optional\r\n Transformation for the bbox that contains the inset axes.\r\n If None, a `.transforms.IdentityTransform` is used. The value\r\n of *bbox_to_anchor* (or the return value of its get_points method)\r\n is transformed by the *bbox_transform* and then interpreted\r\n as points in the pixel coordinate (which is dpi dependent).\r\n You may provide *bbox_to_anchor* in some normalized coordinate,\r\n and give an appropriate transform (e.g., *parent_axes.transAxes*).\r\n\r\n axes_class : `matplotlib.axes.Axes` type, default: `.HostAxes`\r\n The type of the newly created inset axes.\r\n\r\n axes_kwargs : dict, optional\r\n Keyword arguments to pass to the constructor of the inset axes.\r\n Valid arguments include:\r\n\r\n %(Axes:kwdoc)s\r\n\r\n borderpad : float, default: 0.5\r\n Padding between inset axes and the bbox_to_anchor.\r\n The units are axes font size, i.e. for a default font size of 10 points\r\n *borderpad = 0.5* is equivalent to a padding of 5 points.\r\n\r\n Returns\r\n -------\r\n inset_axes : *axes_class*\r\n Inset axes object created.\r\n \"\"\"\r\n\r\n if axes_class is None:\r\n axes_class = HostAxes\r\n if axes_kwargs is None:\r\n axes_kwargs = {}\r\n inset_axes = axes_class(parent_axes.figure, parent_axes.get_position(),\r\n **axes_kwargs)\r\n\r\n if bbox_transform in [parent_axes.transAxes,\r\n parent_axes.figure.transFigure]:\r\n if bbox_to_anchor is None:\r\n _api.warn_external(\"Using the axes or figure transform requires a \"\r\n \"bounding box in the respective coordinates. \"\r\n \"Using bbox_to_anchor=(0, 0, 1, 1) now.\")\r\n bbox_to_anchor = (0, 0, 1, 1)\r\n\r\n if bbox_to_anchor is None:\r\n bbox_to_anchor = parent_axes.bbox\r\n\r\n if (isinstance(bbox_to_anchor, tuple) and\r\n (isinstance(width, str) or isinstance(height, str))):\r\n if len(bbox_to_anchor) != 4:\r\n raise ValueError(\"Using relative units for width or height \"\r\n \"requires to provide a 4-tuple or a \"\r\n \"`Bbox` instance to `bbox_to_anchor.\")\r\n\r\n axes_locator = AnchoredSizeLocator(bbox_to_anchor,\r\n width, height,\r\n loc=loc,\r\n bbox_transform=bbox_transform,\r\n borderpad=borderpad)\r\n\r\n inset_axes.set_axes_locator(axes_locator)\r\n\r\n _add_inset_axes(parent_axes, inset_axes)\r\n\r\n return inset_axes\r\n\r\n\r\[email protected]_interpd\r\ndef zoomed_inset_axes(parent_axes, zoom, loc='upper right',\r\n bbox_to_anchor=None, bbox_transform=None,\r\n axes_class=None, axes_kwargs=None,\r\n borderpad=0.5):\r\n \"\"\"\r\n Create an anchored inset axes by scaling a parent axes. For usage, also see\r\n :doc:`the examples </gallery/axes_grid1/inset_locator_demo2>`.\r\n\r\n Parameters\r\n ----------\r\n parent_axes : `matplotlib.axes.Axes`\r\n Axes to place the inset axes.\r\n\r\n zoom : float\r\n Scaling factor of the data axes. *zoom* > 1 will enlarge the\r\n coordinates (i.e., \"zoomed in\"), while *zoom* < 1 will shrink the\r\n coordinates (i.e., \"zoomed out\").\r\n\r\n loc : str, default: 'upper right'\r\n Location to place the inset axes. Valid locations are\r\n 'upper left', 'upper center', 'upper right',\r\n 'center left', 'center', 'center right',\r\n 'lower left', 'lower center, 'lower right'.\r\n For backward compatibility, numeric values are accepted as well.\r\n See the parameter *loc* of `.Legend` for details.\r\n\r\n bbox_to_anchor : tuple or `matplotlib.transforms.BboxBase`, optional\r\n Bbox that the inset axes will be anchored to. If None,\r\n *parent_axes.bbox* is used. If a tuple, can be either\r\n [left, bottom, width, height], or [left, bottom].\r\n If the kwargs *width* and/or *height* are specified in relative units,\r\n the 2-tuple [left, bottom] cannot be used. Note that\r\n the units of the bounding box are determined through the transform\r\n in use. When using *bbox_to_anchor* it almost always makes sense to\r\n also specify a *bbox_transform*. This might often be the axes transform\r\n *parent_axes.transAxes*.\r\n\r\n bbox_transform : `matplotlib.transforms.Transform`, optional\r\n Transformation for the bbox that contains the inset axes.\r\n If None, a `.transforms.IdentityTransform` is used (i.e. pixel\r\n coordinates). This is useful when not providing any argument to\r\n *bbox_to_anchor*. When using *bbox_to_anchor* it almost always makes\r\n sense to also specify a *bbox_transform*. This might often be the\r\n axes transform *parent_axes.transAxes*. Inversely, when specifying\r\n the axes- or figure-transform here, be aware that not specifying\r\n *bbox_to_anchor* will use *parent_axes.bbox*, the units of which are\r\n in display (pixel) coordinates.\r\n\r\n axes_class : `matplotlib.axes.Axes` type, default: `.HostAxes`\r\n The type of the newly created inset axes.\r\n\r\n axes_kwargs : dict, optional\r\n Keyword arguments to pass to the constructor of the inset axes.\r\n Valid arguments include:\r\n\r\n %(Axes:kwdoc)s\r\n\r\n borderpad : float, default: 0.5\r\n Padding between inset axes and the bbox_to_anchor.\r\n The units are axes font size, i.e. for a default font size of 10 points\r\n *borderpad = 0.5* is equivalent to a padding of 5 points.\r\n\r\n Returns\r\n -------\r\n inset_axes : *axes_class*\r\n Inset axes object created.\r\n \"\"\"\r\n\r\n if axes_class is None:\r\n axes_class = HostAxes\r\n if axes_kwargs is None:\r\n axes_kwargs = {}\r\n inset_axes = axes_class(parent_axes.figure, parent_axes.get_position(),\r\n **axes_kwargs)\r\n\r\n axes_locator = AnchoredZoomLocator(parent_axes, zoom=zoom, loc=loc,\r\n bbox_to_anchor=bbox_to_anchor,\r\n bbox_transform=bbox_transform,\r\n borderpad=borderpad)\r\n inset_axes.set_axes_locator(axes_locator)\r\n\r\n _add_inset_axes(parent_axes, inset_axes)\r\n\r\n return inset_axes\r\n\r\n\r\[email protected]_interpd\r\ndef mark_inset(parent_axes, inset_axes, loc1, loc2, **kwargs):\r\n \"\"\"\r\n Draw a box to mark the location of an area represented by an inset axes.\r\n\r\n This function draws a box in *parent_axes* at the bounding box of\r\n *inset_axes*, and shows a connection with the inset axes by drawing lines\r\n at the corners, giving a \"zoomed in\" effect.\r\n\r\n Parameters\r\n ----------\r\n parent_axes : `matplotlib.axes.Axes`\r\n Axes which contains the area of the inset axes.\r\n\r\n inset_axes : `matplotlib.axes.Axes`\r\n The inset axes.\r\n\r\n loc1, loc2 : {1, 2, 3, 4}\r\n Corners to use for connecting the inset axes and the area in the\r\n parent axes.\r\n\r\n **kwargs\r\n Patch properties for the lines and box drawn:\r\n\r\n %(Patch:kwdoc)s\r\n\r\n Returns\r\n -------\r\n pp : `matplotlib.patches.Patch`\r\n The patch drawn to represent the area of the inset axes.\r\n\r\n p1, p2 : `matplotlib.patches.Patch`\r\n The patches connecting two corners of the inset axes and its area.\r\n \"\"\"\r\n rect = TransformedBbox(inset_axes.viewLim, parent_axes.transData)\r\n\r\n if 'fill' in kwargs:\r\n pp = BboxPatch(rect, **kwargs)\r\n else:\r\n fill = bool({'fc', 'facecolor', 'color'}.intersection(kwargs))\r\n pp = BboxPatch(rect, fill=fill, **kwargs)\r\n parent_axes.add_patch(pp)\r\n\r\n p1 = BboxConnector(inset_axes.bbox, rect, loc1=loc1, **kwargs)\r\n inset_axes.add_patch(p1)\r\n p1.set_clip_on(False)\r\n p2 = BboxConnector(inset_axes.bbox, rect, loc1=loc2, **kwargs)\r\n inset_axes.add_patch(p2)\r\n p2.set_clip_on(False)\r\n\r\n return pp, p1, p2\r\n",
"from __future__ import annotations\r\n\r\nimport numbers\r\nfrom typing import TYPE_CHECKING\r\nimport warnings\r\n\r\nimport numpy as np\r\n\r\nfrom pandas._libs import (\r\n lib,\r\n missing as libmissing,\r\n)\r\nfrom pandas._typing import (\r\n ArrayLike,\r\n Dtype,\r\n type_t,\r\n)\r\nfrom pandas.compat.numpy import function as nv\r\n\r\nfrom pandas.core.dtypes.common import (\r\n is_bool_dtype,\r\n is_float,\r\n is_float_dtype,\r\n is_integer_dtype,\r\n is_list_like,\r\n is_numeric_dtype,\r\n pandas_dtype,\r\n)\r\nfrom pandas.core.dtypes.dtypes import (\r\n ExtensionDtype,\r\n register_extension_dtype,\r\n)\r\nfrom pandas.core.dtypes.missing import isna\r\n\r\nfrom pandas.core import ops\r\nfrom pandas.core.arrays.masked import (\r\n BaseMaskedArray,\r\n BaseMaskedDtype,\r\n)\r\n\r\nif TYPE_CHECKING:\r\n import pyarrow\r\n\r\n\r\n@register_extension_dtype\r\nclass BooleanDtype(BaseMaskedDtype):\r\n \"\"\"\r\n Extension dtype for boolean data.\r\n\r\n .. versionadded:: 1.0.0\r\n\r\n .. warning::\r\n\r\n BooleanDtype is considered experimental. The implementation and\r\n parts of the API may change without warning.\r\n\r\n Attributes\r\n ----------\r\n None\r\n\r\n Methods\r\n -------\r\n None\r\n\r\n Examples\r\n --------\r\n >>> pd.BooleanDtype()\r\n BooleanDtype\r\n \"\"\"\r\n\r\n name = \"boolean\"\r\n\r\n # https://github.com/python/mypy/issues/4125\r\n # error: Signature of \"type\" incompatible with supertype \"BaseMaskedDtype\"\r\n @property\r\n def type(self) -> type: # type: ignore[override]\r\n return np.bool_\r\n\r\n @property\r\n def kind(self) -> str:\r\n return \"b\"\r\n\r\n @property\r\n def numpy_dtype(self) -> np.dtype:\r\n return np.dtype(\"bool\")\r\n\r\n @classmethod\r\n def construct_array_type(cls) -> type_t[BooleanArray]:\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 return BooleanArray\r\n\r\n def __repr__(self) -> str:\r\n return \"BooleanDtype\"\r\n\r\n @property\r\n def _is_boolean(self) -> bool:\r\n return True\r\n\r\n @property\r\n def _is_numeric(self) -> bool:\r\n return True\r\n\r\n def __from_arrow__(\r\n self, array: pyarrow.Array | pyarrow.ChunkedArray\r\n ) -> BooleanArray:\r\n \"\"\"\r\n Construct BooleanArray from pyarrow Array/ChunkedArray.\r\n \"\"\"\r\n import pyarrow\r\n\r\n if array.type != pyarrow.bool_():\r\n raise TypeError(f\"Expected array of boolean type, got {array.type} instead\")\r\n\r\n if isinstance(array, pyarrow.Array):\r\n chunks = [array]\r\n else:\r\n # pyarrow.ChunkedArray\r\n chunks = array.chunks\r\n\r\n results = []\r\n for arr in chunks:\r\n buflist = arr.buffers()\r\n data = pyarrow.BooleanArray.from_buffers(\r\n arr.type, len(arr), [None, buflist[1]], offset=arr.offset\r\n ).to_numpy(zero_copy_only=False)\r\n if arr.null_count != 0:\r\n mask = pyarrow.BooleanArray.from_buffers(\r\n arr.type, len(arr), [None, buflist[0]], offset=arr.offset\r\n ).to_numpy(zero_copy_only=False)\r\n mask = ~mask\r\n else:\r\n mask = np.zeros(len(arr), dtype=bool)\r\n\r\n bool_arr = BooleanArray(data, mask)\r\n results.append(bool_arr)\r\n\r\n if not results:\r\n return BooleanArray(\r\n np.array([], dtype=np.bool_), np.array([], dtype=np.bool_)\r\n )\r\n else:\r\n return BooleanArray._concat_same_type(results)\r\n\r\n\r\ndef coerce_to_array(\r\n values, mask=None, copy: bool = False\r\n) -> tuple[np.ndarray, np.ndarray]:\r\n \"\"\"\r\n Coerce the input values array to numpy arrays with a mask.\r\n\r\n Parameters\r\n ----------\r\n values : 1D list-like\r\n mask : bool 1D array, optional\r\n copy : bool, default False\r\n if True, copy the input\r\n\r\n Returns\r\n -------\r\n tuple of (values, mask)\r\n \"\"\"\r\n if isinstance(values, BooleanArray):\r\n if mask is not None:\r\n raise ValueError(\"cannot pass mask for BooleanArray input\")\r\n values, mask = values._data, values._mask\r\n if copy:\r\n values = values.copy()\r\n mask = mask.copy()\r\n return values, mask\r\n\r\n mask_values = None\r\n if isinstance(values, np.ndarray) and values.dtype == np.bool_:\r\n if copy:\r\n values = values.copy()\r\n elif isinstance(values, np.ndarray) and is_numeric_dtype(values.dtype):\r\n mask_values = isna(values)\r\n\r\n values_bool = np.zeros(len(values), dtype=bool)\r\n values_bool[~mask_values] = values[~mask_values].astype(bool)\r\n\r\n if not np.all(\r\n values_bool[~mask_values].astype(values.dtype) == values[~mask_values]\r\n ):\r\n raise TypeError(\"Need to pass bool-like values\")\r\n\r\n values = values_bool\r\n else:\r\n values_object = np.asarray(values, dtype=object)\r\n\r\n inferred_dtype = lib.infer_dtype(values_object, skipna=True)\r\n integer_like = (\"floating\", \"integer\", \"mixed-integer-float\")\r\n if inferred_dtype not in (\"boolean\", \"empty\") + integer_like:\r\n raise TypeError(\"Need to pass bool-like values\")\r\n\r\n mask_values = isna(values_object)\r\n values = np.zeros(len(values), dtype=bool)\r\n values[~mask_values] = values_object[~mask_values].astype(bool)\r\n\r\n # if the values were integer-like, validate it were actually 0/1's\r\n if (inferred_dtype in integer_like) and not (\r\n np.all(\r\n values[~mask_values].astype(float)\r\n == values_object[~mask_values].astype(float)\r\n )\r\n ):\r\n raise TypeError(\"Need to pass bool-like values\")\r\n\r\n if mask is None and mask_values is None:\r\n mask = np.zeros(len(values), dtype=bool)\r\n elif mask is None:\r\n mask = mask_values\r\n else:\r\n if isinstance(mask, np.ndarray) and mask.dtype == np.bool_:\r\n if mask_values is not None:\r\n mask = mask | mask_values\r\n else:\r\n if copy:\r\n mask = mask.copy()\r\n else:\r\n mask = np.array(mask, dtype=bool)\r\n if mask_values is not None:\r\n mask = mask | mask_values\r\n\r\n if values.ndim != 1:\r\n raise ValueError(\"values must be a 1D list-like\")\r\n if mask.ndim != 1:\r\n raise ValueError(\"mask must be a 1D list-like\")\r\n\r\n return values, mask\r\n\r\n\r\nclass BooleanArray(BaseMaskedArray):\r\n \"\"\"\r\n Array of boolean (True/False) data with missing values.\r\n\r\n This is a pandas Extension array for boolean data, under the hood\r\n represented by 2 numpy arrays: a boolean array with the data and\r\n a boolean array with the mask (True indicating missing).\r\n\r\n BooleanArray implements Kleene logic (sometimes called three-value\r\n logic) for logical operations. See :ref:`boolean.kleene` for more.\r\n\r\n To construct an BooleanArray from generic array-like input, use\r\n :func:`pandas.array` specifying ``dtype=\"boolean\"`` (see examples\r\n below).\r\n\r\n .. versionadded:: 1.0.0\r\n\r\n .. warning::\r\n\r\n BooleanArray is considered experimental. The implementation and\r\n parts of the API may change without warning.\r\n\r\n Parameters\r\n ----------\r\n values : numpy.ndarray\r\n A 1-d boolean-dtype array with the data.\r\n mask : numpy.ndarray\r\n A 1-d boolean-dtype array indicating missing values (True\r\n indicates missing).\r\n copy : bool, default False\r\n Whether to copy the `values` and `mask` arrays.\r\n\r\n Attributes\r\n ----------\r\n None\r\n\r\n Methods\r\n -------\r\n None\r\n\r\n Returns\r\n -------\r\n BooleanArray\r\n\r\n Examples\r\n --------\r\n Create an BooleanArray with :func:`pandas.array`:\r\n\r\n >>> pd.array([True, False, None], dtype=\"boolean\")\r\n <BooleanArray>\r\n [True, False, <NA>]\r\n Length: 3, dtype: boolean\r\n \"\"\"\r\n\r\n # The value used to fill '_data' to avoid upcasting\r\n _internal_fill_value = False\r\n _TRUE_VALUES = {\"True\", \"TRUE\", \"true\", \"1\", \"1.0\"}\r\n _FALSE_VALUES = {\"False\", \"FALSE\", \"false\", \"0\", \"0.0\"}\r\n\r\n def __init__(self, values: np.ndarray, mask: np.ndarray, copy: bool = False):\r\n if not (isinstance(values, np.ndarray) and values.dtype == np.bool_):\r\n raise TypeError(\r\n \"values should be boolean numpy array. Use \"\r\n \"the 'pd.array' function instead\"\r\n )\r\n self._dtype = BooleanDtype()\r\n super().__init__(values, mask, copy=copy)\r\n\r\n @property\r\n def dtype(self) -> BooleanDtype:\r\n return self._dtype\r\n\r\n @classmethod\r\n def _from_sequence(\r\n cls, scalars, *, dtype: Dtype | None = None, copy: bool = False\r\n ) -> BooleanArray:\r\n if dtype:\r\n assert dtype == \"boolean\"\r\n values, mask = coerce_to_array(scalars, copy=copy)\r\n return BooleanArray(values, mask)\r\n\r\n @classmethod\r\n def _from_sequence_of_strings(\r\n cls,\r\n strings: list[str],\r\n *,\r\n dtype: Dtype | None = None,\r\n copy: bool = False,\r\n true_values: list[str] | None = None,\r\n false_values: list[str] | None = None,\r\n ) -> BooleanArray:\r\n true_values_union = cls._TRUE_VALUES.union(true_values or [])\r\n false_values_union = cls._FALSE_VALUES.union(false_values or [])\r\n\r\n def map_string(s):\r\n if isna(s):\r\n return s\r\n elif s in true_values_union:\r\n return True\r\n elif s in false_values_union:\r\n return False\r\n else:\r\n raise ValueError(f\"{s} cannot be cast to bool\")\r\n\r\n scalars = [map_string(x) for x in strings]\r\n return cls._from_sequence(scalars, dtype=dtype, copy=copy)\r\n\r\n _HANDLED_TYPES = (np.ndarray, numbers.Number, bool, np.bool_)\r\n\r\n def __array_ufunc__(self, ufunc: np.ufunc, method: str, *inputs, **kwargs):\r\n # For BooleanArray inputs, we apply the ufunc to ._data\r\n # and mask the result.\r\n if method == \"reduce\":\r\n # Not clear how to handle missing values in reductions. Raise.\r\n raise NotImplementedError(\"The 'reduce' method is not supported.\")\r\n out = kwargs.get(\"out\", ())\r\n\r\n for x in inputs + out:\r\n if not isinstance(x, self._HANDLED_TYPES + (BooleanArray,)):\r\n return NotImplemented\r\n\r\n # for binary ops, use our custom dunder methods\r\n result = ops.maybe_dispatch_ufunc_to_dunder_op(\r\n self, ufunc, method, *inputs, **kwargs\r\n )\r\n if result is not NotImplemented:\r\n return result\r\n\r\n mask = np.zeros(len(self), dtype=bool)\r\n inputs2 = []\r\n for x in inputs:\r\n if isinstance(x, BooleanArray):\r\n mask |= x._mask\r\n inputs2.append(x._data)\r\n else:\r\n inputs2.append(x)\r\n\r\n def reconstruct(x):\r\n # we don't worry about scalar `x` here, since we\r\n # raise for reduce up above.\r\n\r\n if is_bool_dtype(x.dtype):\r\n m = mask.copy()\r\n return BooleanArray(x, m)\r\n else:\r\n x[mask] = np.nan\r\n return x\r\n\r\n result = getattr(ufunc, method)(*inputs2, **kwargs)\r\n if isinstance(result, tuple):\r\n tuple(reconstruct(x) for x in result)\r\n else:\r\n return reconstruct(result)\r\n\r\n def _coerce_to_array(self, value) -> tuple[np.ndarray, np.ndarray]:\r\n return coerce_to_array(value)\r\n\r\n def astype(self, dtype, copy: bool = True) -> ArrayLike:\r\n \"\"\"\r\n Cast to a NumPy array or ExtensionArray with 'dtype'.\r\n\r\n Parameters\r\n ----------\r\n dtype : str or dtype\r\n Typecode or data-type to which the array is cast.\r\n copy : bool, default True\r\n Whether to copy the data, even if not necessary. If False,\r\n a copy is made only if the old dtype does not match the\r\n new dtype.\r\n\r\n Returns\r\n -------\r\n ndarray or ExtensionArray\r\n NumPy ndarray, BooleanArray or IntegerArray with 'dtype' for its dtype.\r\n\r\n Raises\r\n ------\r\n TypeError\r\n if incompatible type with an BooleanDtype, equivalent of same_kind\r\n casting\r\n \"\"\"\r\n dtype = pandas_dtype(dtype)\r\n\r\n if isinstance(dtype, ExtensionDtype):\r\n return super().astype(dtype, copy)\r\n\r\n if is_bool_dtype(dtype):\r\n # astype_nansafe converts np.nan to True\r\n if self._hasna:\r\n raise ValueError(\"cannot convert float NaN to bool\")\r\n else:\r\n return self._data.astype(dtype, copy=copy)\r\n\r\n # for integer, error if there are missing values\r\n if is_integer_dtype(dtype) and self._hasna:\r\n raise ValueError(\"cannot convert NA to integer\")\r\n\r\n # for float dtype, ensure we use np.nan before casting (numpy cannot\r\n # deal with pd.NA)\r\n na_value = self._na_value\r\n if is_float_dtype(dtype):\r\n na_value = np.nan\r\n # coerce\r\n return self.to_numpy(dtype=dtype, na_value=na_value, copy=False)\r\n\r\n def _values_for_argsort(self) -> np.ndarray:\r\n \"\"\"\r\n Return values for sorting.\r\n\r\n Returns\r\n -------\r\n ndarray\r\n The transformed values should maintain the ordering between values\r\n within the array.\r\n\r\n See Also\r\n --------\r\n ExtensionArray.argsort : Return the indices that would sort this array.\r\n \"\"\"\r\n data = self._data.copy()\r\n data[self._mask] = -1\r\n return data\r\n\r\n def any(self, *, skipna: bool = True, **kwargs):\r\n \"\"\"\r\n Return whether any element is True.\r\n\r\n Returns False unless there is at least one element that is True.\r\n By default, NAs are skipped. If ``skipna=False`` is specified and\r\n missing values are present, similar :ref:`Kleene logic <boolean.kleene>`\r\n is used as for logical operations.\r\n\r\n Parameters\r\n ----------\r\n skipna : bool, default True\r\n Exclude NA values. If the entire array is NA and `skipna` is\r\n True, then the result will be False, as for an empty array.\r\n If `skipna` is False, the result will still be True if there is\r\n at least one element that is True, otherwise NA will be returned\r\n if there are NA's present.\r\n **kwargs : any, default None\r\n Additional keywords have no effect but might be accepted for\r\n compatibility with NumPy.\r\n\r\n Returns\r\n -------\r\n bool or :attr:`pandas.NA`\r\n\r\n See Also\r\n --------\r\n numpy.any : Numpy version of this method.\r\n BooleanArray.all : Return whether all elements are True.\r\n\r\n Examples\r\n --------\r\n The result indicates whether any element is True (and by default\r\n skips NAs):\r\n\r\n >>> pd.array([True, False, True]).any()\r\n True\r\n >>> pd.array([True, False, pd.NA]).any()\r\n True\r\n >>> pd.array([False, False, pd.NA]).any()\r\n False\r\n >>> pd.array([], dtype=\"boolean\").any()\r\n False\r\n >>> pd.array([pd.NA], dtype=\"boolean\").any()\r\n False\r\n\r\n With ``skipna=False``, the result can be NA if this is logically\r\n required (whether ``pd.NA`` is True or False influences the result):\r\n\r\n >>> pd.array([True, False, pd.NA]).any(skipna=False)\r\n True\r\n >>> pd.array([False, False, pd.NA]).any(skipna=False)\r\n <NA>\r\n \"\"\"\r\n kwargs.pop(\"axis\", None)\r\n nv.validate_any((), kwargs)\r\n\r\n values = self._data.copy()\r\n np.putmask(values, self._mask, False)\r\n result = values.any()\r\n if skipna:\r\n return result\r\n else:\r\n if result or len(self) == 0 or not self._mask.any():\r\n return result\r\n else:\r\n return self.dtype.na_value\r\n\r\n def all(self, *, skipna: bool = True, **kwargs):\r\n \"\"\"\r\n Return whether all elements are True.\r\n\r\n Returns True unless there is at least one element that is False.\r\n By default, NAs are skipped. If ``skipna=False`` is specified and\r\n missing values are present, similar :ref:`Kleene logic <boolean.kleene>`\r\n is used as for logical operations.\r\n\r\n Parameters\r\n ----------\r\n skipna : bool, default True\r\n Exclude NA values. If the entire array is NA and `skipna` is\r\n True, then the result will be True, as for an empty array.\r\n If `skipna` is False, the result will still be False if there is\r\n at least one element that is False, otherwise NA will be returned\r\n if there are NA's present.\r\n **kwargs : any, default None\r\n Additional keywords have no effect but might be accepted for\r\n compatibility with NumPy.\r\n\r\n Returns\r\n -------\r\n bool or :attr:`pandas.NA`\r\n\r\n See Also\r\n --------\r\n numpy.all : Numpy version of this method.\r\n BooleanArray.any : Return whether any element is True.\r\n\r\n Examples\r\n --------\r\n The result indicates whether any element is True (and by default\r\n skips NAs):\r\n\r\n >>> pd.array([True, True, pd.NA]).all()\r\n True\r\n >>> pd.array([True, False, pd.NA]).all()\r\n False\r\n >>> pd.array([], dtype=\"boolean\").all()\r\n True\r\n >>> pd.array([pd.NA], dtype=\"boolean\").all()\r\n True\r\n\r\n With ``skipna=False``, the result can be NA if this is logically\r\n required (whether ``pd.NA`` is True or False influences the result):\r\n\r\n >>> pd.array([True, True, pd.NA]).all(skipna=False)\r\n <NA>\r\n >>> pd.array([True, False, pd.NA]).all(skipna=False)\r\n False\r\n \"\"\"\r\n kwargs.pop(\"axis\", None)\r\n nv.validate_all((), kwargs)\r\n\r\n values = self._data.copy()\r\n np.putmask(values, self._mask, True)\r\n result = values.all()\r\n\r\n if skipna:\r\n return result\r\n else:\r\n if not result or len(self) == 0 or not self._mask.any():\r\n return result\r\n else:\r\n return self.dtype.na_value\r\n\r\n def _logical_method(self, other, op):\r\n\r\n assert op.__name__ in {\"or_\", \"ror_\", \"and_\", \"rand_\", \"xor\", \"rxor\"}\r\n other_is_booleanarray = isinstance(other, BooleanArray)\r\n other_is_scalar = lib.is_scalar(other)\r\n mask = None\r\n\r\n if other_is_booleanarray:\r\n other, mask = other._data, other._mask\r\n elif is_list_like(other):\r\n other = np.asarray(other, dtype=\"bool\")\r\n if other.ndim > 1:\r\n raise NotImplementedError(\"can only perform ops with 1-d structures\")\r\n other, mask = coerce_to_array(other, copy=False)\r\n elif isinstance(other, np.bool_):\r\n other = other.item()\r\n\r\n if other_is_scalar and other is not libmissing.NA and not lib.is_bool(other):\r\n raise TypeError(\r\n \"'other' should be pandas.NA or a bool. \"\r\n f\"Got {type(other).__name__} instead.\"\r\n )\r\n\r\n if not other_is_scalar and len(self) != len(other):\r\n raise ValueError(\"Lengths must match to compare\")\r\n\r\n if op.__name__ in {\"or_\", \"ror_\"}:\r\n result, mask = ops.kleene_or(self._data, other, self._mask, mask)\r\n elif op.__name__ in {\"and_\", \"rand_\"}:\r\n result, mask = ops.kleene_and(self._data, other, self._mask, mask)\r\n elif op.__name__ in {\"xor\", \"rxor\"}:\r\n result, mask = ops.kleene_xor(self._data, other, self._mask, mask)\r\n\r\n # error: Argument 2 to \"BooleanArray\" has incompatible type \"Optional[Any]\";\r\n # expected \"ndarray\"\r\n return BooleanArray(result, mask) # type: ignore[arg-type]\r\n\r\n def _cmp_method(self, other, op):\r\n from pandas.arrays import (\r\n FloatingArray,\r\n IntegerArray,\r\n )\r\n\r\n if isinstance(other, (IntegerArray, FloatingArray)):\r\n return NotImplemented\r\n\r\n mask = None\r\n\r\n if isinstance(other, BooleanArray):\r\n other, mask = other._data, other._mask\r\n\r\n elif is_list_like(other):\r\n other = np.asarray(other)\r\n if other.ndim > 1:\r\n raise NotImplementedError(\"can only perform ops with 1-d structures\")\r\n if len(self) != len(other):\r\n raise ValueError(\"Lengths must match to compare\")\r\n\r\n if other is libmissing.NA:\r\n # numpy does not handle pd.NA well as \"other\" scalar (it returns\r\n # a scalar False instead of an array)\r\n result = np.zeros_like(self._data)\r\n mask = np.ones_like(self._data)\r\n else:\r\n # numpy will show a DeprecationWarning on invalid elementwise\r\n # comparisons, this will raise in the future\r\n with warnings.catch_warnings():\r\n warnings.filterwarnings(\"ignore\", \"elementwise\", FutureWarning)\r\n with np.errstate(all=\"ignore\"):\r\n result = op(self._data, other)\r\n\r\n # nans propagate\r\n if mask is None:\r\n mask = self._mask.copy()\r\n else:\r\n mask = self._mask | mask\r\n\r\n return BooleanArray(result, mask, copy=False)\r\n\r\n def _arith_method(self, other, op):\r\n mask = None\r\n op_name = op.__name__\r\n\r\n if isinstance(other, BooleanArray):\r\n other, mask = other._data, other._mask\r\n\r\n elif is_list_like(other):\r\n other = np.asarray(other)\r\n if other.ndim > 1:\r\n raise NotImplementedError(\"can only perform ops with 1-d structures\")\r\n if len(self) != len(other):\r\n raise ValueError(\"Lengths must match\")\r\n\r\n # nans propagate\r\n if mask is None:\r\n mask = self._mask\r\n if other is libmissing.NA:\r\n mask |= True\r\n else:\r\n mask = self._mask | mask\r\n\r\n if other is libmissing.NA:\r\n # if other is NA, the result will be all NA and we can't run the\r\n # actual op, so we need to choose the resulting dtype manually\r\n if op_name in {\"floordiv\", \"rfloordiv\", \"mod\", \"rmod\", \"pow\", \"rpow\"}:\r\n dtype = \"int8\"\r\n else:\r\n dtype = \"bool\"\r\n result = np.zeros(len(self._data), dtype=dtype)\r\n else:\r\n if op_name in {\"pow\", \"rpow\"} and isinstance(other, np.bool_):\r\n # Avoid DeprecationWarning: In future, it will be an error\r\n # for 'np.bool_' scalars to be interpreted as an index\r\n other = bool(other)\r\n\r\n with np.errstate(all=\"ignore\"):\r\n result = op(self._data, other)\r\n\r\n # divmod returns a tuple\r\n if op_name == \"divmod\":\r\n div, mod = result\r\n return (\r\n self._maybe_mask_result(div, mask, other, \"floordiv\"),\r\n self._maybe_mask_result(mod, mask, other, \"mod\"),\r\n )\r\n\r\n return self._maybe_mask_result(result, mask, other, op_name)\r\n\r\n def _reduce(self, name: str, *, skipna: bool = True, **kwargs):\r\n\r\n if name in {\"any\", \"all\"}:\r\n return getattr(self, name)(skipna=skipna, **kwargs)\r\n\r\n return super()._reduce(name, skipna=skipna, **kwargs)\r\n\r\n def _maybe_mask_result(self, result, mask, other, op_name: str):\r\n \"\"\"\r\n Parameters\r\n ----------\r\n result : array-like\r\n mask : array-like bool\r\n other : scalar or array-like\r\n op_name : str\r\n \"\"\"\r\n # if we have a float operand we are by-definition\r\n # a float result\r\n # or our op is a divide\r\n if (is_float_dtype(other) or is_float(other)) or (\r\n op_name in [\"rtruediv\", \"truediv\"]\r\n ):\r\n from pandas.core.arrays import FloatingArray\r\n\r\n return FloatingArray(result, mask, copy=False)\r\n\r\n elif is_bool_dtype(result):\r\n return BooleanArray(result, mask, copy=False)\r\n\r\n elif is_integer_dtype(result):\r\n from pandas.core.arrays import IntegerArray\r\n\r\n return IntegerArray(result, mask, copy=False)\r\n else:\r\n result[mask] = np.nan\r\n return result\r\n",
"import numpy as np\r\n\r\nfrom matplotlib import docstring\r\nfrom matplotlib.contour import ContourSet\r\nfrom matplotlib.tri.triangulation import Triangulation\r\n\r\n\r\[email protected]_interpd\r\nclass TriContourSet(ContourSet):\r\n \"\"\"\r\n Create and store a set of contour lines or filled regions for\r\n a triangular grid.\r\n\r\n This class is typically not instantiated directly by the user but by\r\n `~.Axes.tricontour` and `~.Axes.tricontourf`.\r\n\r\n %(contour_set_attributes)s\r\n \"\"\"\r\n def __init__(self, ax, *args, **kwargs):\r\n \"\"\"\r\n Draw triangular grid contour lines or filled regions,\r\n depending on whether keyword arg 'filled' is False\r\n (default) or True.\r\n\r\n The first argument of the initializer must be an axes\r\n object. The remaining arguments and keyword arguments\r\n are described in the docstring of `~.Axes.tricontour`.\r\n \"\"\"\r\n super().__init__(ax, *args, **kwargs)\r\n\r\n def _process_args(self, *args, **kwargs):\r\n \"\"\"\r\n Process args and kwargs.\r\n \"\"\"\r\n if isinstance(args[0], TriContourSet):\r\n C = args[0]._contour_generator\r\n if self.levels is None:\r\n self.levels = args[0].levels\r\n self.zmin = args[0].zmin\r\n self.zmax = args[0].zmax\r\n self._mins = args[0]._mins\r\n self._maxs = args[0]._maxs\r\n else:\r\n from matplotlib import _tri\r\n tri, z = self._contour_args(args, kwargs)\r\n C = _tri.TriContourGenerator(tri.get_cpp_triangulation(), z)\r\n self._mins = [tri.x.min(), tri.y.min()]\r\n self._maxs = [tri.x.max(), tri.y.max()]\r\n\r\n self._contour_generator = C\r\n return kwargs\r\n\r\n def _contour_args(self, args, kwargs):\r\n if self.filled:\r\n fn = 'contourf'\r\n else:\r\n fn = 'contour'\r\n tri, args, kwargs = Triangulation.get_from_args_and_kwargs(*args,\r\n **kwargs)\r\n z = np.ma.asarray(args[0])\r\n if z.shape != tri.x.shape:\r\n raise ValueError('z array must have same length as triangulation x'\r\n ' and y arrays')\r\n\r\n # z values must be finite, only need to check points that are included\r\n # in the triangulation.\r\n z_check = z[np.unique(tri.get_masked_triangles())]\r\n if np.ma.is_masked(z_check):\r\n raise ValueError('z must not contain masked points within the '\r\n 'triangulation')\r\n if not np.isfinite(z_check).all():\r\n raise ValueError('z array must not contain non-finite values '\r\n 'within the triangulation')\r\n\r\n z = np.ma.masked_invalid(z, copy=False)\r\n self.zmax = float(z_check.max())\r\n self.zmin = float(z_check.min())\r\n if self.logscale and self.zmin <= 0:\r\n raise ValueError('Cannot %s log of negative values.' % fn)\r\n self._process_contour_level_args(args[1:])\r\n return (tri, z)\r\n\r\n\r\ndocstring.interpd.update(_tricontour_doc=\"\"\"\r\nDraw contour %(type)s on an unstructured triangular grid.\r\n\r\nThe triangulation can be specified in one of two ways; either ::\r\n\r\n %(func)s(triangulation, ...)\r\n\r\nwhere *triangulation* is a `.Triangulation` object, or ::\r\n\r\n %(func)s(x, y, ...)\r\n %(func)s(x, y, triangles, ...)\r\n %(func)s(x, y, triangles=triangles, ...)\r\n %(func)s(x, y, mask=mask, ...)\r\n %(func)s(x, y, triangles, mask=mask, ...)\r\n\r\nin which case a `.Triangulation` object will be created. See that class'\r\ndocstring for an explanation of these cases.\r\n\r\nThe remaining arguments may be::\r\n\r\n %(func)s(..., Z)\r\n\r\nwhere *Z* is the array of values to contour, one per point in the\r\ntriangulation. The level values are chosen automatically.\r\n\r\n::\r\n\r\n %(func)s(..., Z, levels)\r\n\r\ncontour up to *levels+1* automatically chosen contour levels (*levels*\r\nintervals).\r\n\r\n::\r\n\r\n %(func)s(..., Z, levels)\r\n\r\ndraw contour %(type)s at the values specified in sequence *levels*, which must\r\nbe in increasing order.\r\n\r\n::\r\n\r\n %(func)s(Z, **kwargs)\r\n\r\nUse keyword arguments to control colors, linewidth, origin, cmap ... see below\r\nfor more details.\r\n\r\nParameters\r\n----------\r\ntriangulation : `.Triangulation`, optional\r\n The unstructured triangular grid.\r\n\r\n If specified, then *x*, *y*, *triangles*, and *mask* are not accepted.\r\n\r\nx, y : array-like, optional\r\n The coordinates of the values in *Z*.\r\n\r\ntriangles : (ntri, 3) array-like of int, optional\r\n For each triangle, the indices of the three points that make up the\r\n triangle, ordered in an anticlockwise manner. If not specified, the\r\n Delaunay triangulation is calculated.\r\n\r\nmask : (ntri,) array-like of bool, optional\r\n Which triangles are masked out.\r\n\r\nZ : 2D array-like\r\n The height values over which the contour is drawn.\r\n\r\nlevels : int or array-like, optional\r\n Determines the number and positions of the contour lines / regions.\r\n\r\n If an int *n*, use `~matplotlib.ticker.MaxNLocator`, which tries to\r\n automatically choose no more than *n+1* \"nice\" contour levels between\r\n *vmin* and *vmax*.\r\n\r\n If array-like, draw contour lines at the specified levels. The values must\r\n be in increasing order.\r\n\r\nReturns\r\n-------\r\n`~matplotlib.tri.TriContourSet`\r\n\r\nOther Parameters\r\n----------------\r\ncolors : color string or sequence of colors, optional\r\n The colors of the levels, i.e., the contour %(type)s.\r\n\r\n The sequence is cycled for the levels in ascending order. If the sequence\r\n is shorter than the number of levels, it's repeated.\r\n\r\n As a shortcut, single color strings may be used in place of one-element\r\n lists, i.e. ``'red'`` instead of ``['red']`` to color all levels with the\r\n same color. This shortcut does only work for color strings, not for other\r\n ways of specifying colors.\r\n\r\n By default (value *None*), the colormap specified by *cmap* will be used.\r\n\r\nalpha : float, default: 1\r\n The alpha blending value, between 0 (transparent) and 1 (opaque).\r\n\r\ncmap : str or `.Colormap`, default: :rc:`image.cmap`\r\n A `.Colormap` instance or registered colormap name. The colormap maps the\r\n level values to colors.\r\n\r\n If both *colors* and *cmap* are given, an error is raised.\r\n\r\nnorm : `~matplotlib.colors.Normalize`, optional\r\n If a colormap is used, the `.Normalize` instance scales the level values to\r\n the canonical colormap range [0, 1] for mapping to colors. If not given,\r\n the default linear scaling is used.\r\n\r\nvmin, vmax : float, optional\r\n If not *None*, either or both of these values will be supplied to\r\n the `.Normalize` instance, overriding the default color scaling\r\n based on *levels*.\r\n\r\norigin : {*None*, 'upper', 'lower', 'image'}, default: None\r\n Determines the orientation and exact position of *Z* by specifying the\r\n position of ``Z[0, 0]``. This is only relevant, if *X*, *Y* are not given.\r\n\r\n - *None*: ``Z[0, 0]`` is at X=0, Y=0 in the lower left corner.\r\n - 'lower': ``Z[0, 0]`` is at X=0.5, Y=0.5 in the lower left corner.\r\n - 'upper': ``Z[0, 0]`` is at X=N+0.5, Y=0.5 in the upper left corner.\r\n - 'image': Use the value from :rc:`image.origin`.\r\n\r\nextent : (x0, x1, y0, y1), optional\r\n If *origin* is not *None*, then *extent* is interpreted as in `.imshow`: it\r\n gives the outer pixel boundaries. In this case, the position of Z[0, 0] is\r\n the center of the pixel, not a corner. If *origin* is *None*, then\r\n (*x0*, *y0*) is the position of Z[0, 0], and (*x1*, *y1*) is the position\r\n of Z[-1, -1].\r\n\r\n This argument is ignored if *X* and *Y* are specified in the call to\r\n contour.\r\n\r\nlocator : ticker.Locator subclass, optional\r\n The locator is used to determine the contour levels if they are not given\r\n explicitly via *levels*.\r\n Defaults to `~.ticker.MaxNLocator`.\r\n\r\nextend : {'neither', 'both', 'min', 'max'}, default: 'neither'\r\n Determines the ``%(func)s``-coloring of values that are outside the\r\n *levels* range.\r\n\r\n If 'neither', values outside the *levels* range are not colored. If 'min',\r\n 'max' or 'both', color the values below, above or below and above the\r\n *levels* range.\r\n\r\n Values below ``min(levels)`` and above ``max(levels)`` are mapped to the\r\n under/over values of the `.Colormap`. Note that most colormaps do not have\r\n dedicated colors for these by default, so that the over and under values\r\n are the edge values of the colormap. You may want to set these values\r\n explicitly using `.Colormap.set_under` and `.Colormap.set_over`.\r\n\r\n .. note::\r\n\r\n An existing `.TriContourSet` does not get notified if properties of its\r\n colormap are changed. Therefore, an explicit call to\r\n `.ContourSet.changed()` is needed after modifying the colormap. The\r\n explicit call can be left out, if a colorbar is assigned to the\r\n `.TriContourSet` because it internally calls `.ContourSet.changed()`.\r\n\r\nxunits, yunits : registered units, optional\r\n Override axis units by specifying an instance of a\r\n :class:`matplotlib.units.ConversionInterface`.\r\n\r\nantialiased : bool, optional\r\n Enable antialiasing, overriding the defaults. For\r\n filled contours, the default is *True*. For line contours,\r\n it is taken from :rc:`lines.antialiased`.\"\"\")\r\n\r\n\r\[email protected](func='tricontour', type='lines')\r\[email protected]_interpd\r\ndef tricontour(ax, *args, **kwargs):\r\n \"\"\"\r\n %(_tricontour_doc)s\r\n\r\n linewidths : float or array-like, default: :rc:`contour.linewidth`\r\n The line width of the contour lines.\r\n\r\n If a number, all levels will be plotted with this linewidth.\r\n\r\n If a sequence, the levels in ascending order will be plotted with\r\n the linewidths in the order specified.\r\n\r\n If None, this falls back to :rc:`lines.linewidth`.\r\n\r\n linestyles : {*None*, 'solid', 'dashed', 'dashdot', 'dotted'}, optional\r\n If *linestyles* is *None*, the default is 'solid' unless the lines are\r\n monochrome. In that case, negative contours will take their linestyle\r\n from :rc:`contour.negative_linestyle` setting.\r\n\r\n *linestyles* can also be an iterable of the above strings specifying a\r\n set of linestyles to be used. If this iterable is shorter than the\r\n number of contour levels it will be repeated as necessary.\r\n \"\"\"\r\n kwargs['filled'] = False\r\n return TriContourSet(ax, *args, **kwargs)\r\n\r\n\r\[email protected](func='tricontourf', type='regions')\r\[email protected]_interpd\r\ndef tricontourf(ax, *args, **kwargs):\r\n \"\"\"\r\n %(_tricontour_doc)s\r\n\r\n hatches : list[str], optional\r\n A list of cross hatch patterns to use on the filled areas.\r\n If None, no hatching will be added to the contour.\r\n Hatching is supported in the PostScript, PDF, SVG and Agg\r\n backends only.\r\n\r\n Notes\r\n -----\r\n `.tricontourf` fills intervals that are closed at the top; that is, for\r\n boundaries *z1* and *z2*, the filled region is::\r\n\r\n z1 < Z <= z2\r\n\r\n except for the lowest interval, which is closed on both sides (i.e. it\r\n includes the lowest value).\r\n \"\"\"\r\n kwargs['filled'] = True\r\n return TriContourSet(ax, *args, **kwargs)\r\n",
"from datetime import datetime\r\n\r\nimport dateutil\r\nimport numpy as np\r\nimport pytest\r\nimport pytz\r\n\r\nimport pandas as pd\r\nfrom pandas import (\r\n DatetimeIndex,\r\n Index,\r\n Int64Index,\r\n NaT,\r\n PeriodIndex,\r\n Timestamp,\r\n date_range,\r\n)\r\nimport pandas._testing as tm\r\n\r\n\r\nclass TestDatetimeIndex:\r\n def test_astype(self):\r\n # GH 13149, GH 13209\r\n idx = DatetimeIndex([\"2016-05-16\", \"NaT\", NaT, np.NaN], name=\"idx\")\r\n\r\n result = idx.astype(object)\r\n expected = Index(\r\n [Timestamp(\"2016-05-16\")] + [NaT] * 3, dtype=object, name=\"idx\"\r\n )\r\n tm.assert_index_equal(result, expected)\r\n\r\n with tm.assert_produces_warning(FutureWarning):\r\n result = idx.astype(int)\r\n expected = Int64Index(\r\n [1463356800000000000] + [-9223372036854775808] * 3,\r\n dtype=np.int64,\r\n name=\"idx\",\r\n )\r\n tm.assert_index_equal(result, expected)\r\n\r\n rng = date_range(\"1/1/2000\", periods=10, name=\"idx\")\r\n with tm.assert_produces_warning(FutureWarning):\r\n result = rng.astype(\"i8\")\r\n tm.assert_index_equal(result, Index(rng.asi8, name=\"idx\"))\r\n tm.assert_numpy_array_equal(result.values, rng.asi8)\r\n\r\n def test_astype_uint(self):\r\n arr = date_range(\"2000\", periods=2, name=\"idx\")\r\n expected = pd.UInt64Index(\r\n np.array([946684800000000000, 946771200000000000], dtype=\"uint64\"),\r\n name=\"idx\",\r\n )\r\n with tm.assert_produces_warning(FutureWarning):\r\n tm.assert_index_equal(arr.astype(\"uint64\"), expected)\r\n tm.assert_index_equal(arr.astype(\"uint32\"), expected)\r\n\r\n def test_astype_with_tz(self):\r\n\r\n # with tz\r\n rng = date_range(\"1/1/2000\", periods=10, tz=\"US/Eastern\")\r\n with tm.assert_produces_warning(FutureWarning):\r\n # deprecated\r\n result = rng.astype(\"datetime64[ns]\")\r\n with tm.assert_produces_warning(FutureWarning):\r\n # check DatetimeArray while we're here deprecated\r\n rng._data.astype(\"datetime64[ns]\")\r\n\r\n expected = (\r\n date_range(\"1/1/2000\", periods=10, tz=\"US/Eastern\")\r\n .tz_convert(\"UTC\")\r\n .tz_localize(None)\r\n )\r\n tm.assert_index_equal(result, expected)\r\n\r\n def test_astype_tzaware_to_tzaware(self):\r\n # GH 18951: tz-aware to tz-aware\r\n idx = date_range(\"20170101\", periods=4, tz=\"US/Pacific\")\r\n result = idx.astype(\"datetime64[ns, US/Eastern]\")\r\n expected = date_range(\"20170101 03:00:00\", periods=4, tz=\"US/Eastern\")\r\n tm.assert_index_equal(result, expected)\r\n assert result.freq == expected.freq\r\n\r\n def test_astype_tznaive_to_tzaware(self):\r\n # GH 18951: tz-naive to tz-aware\r\n idx = date_range(\"20170101\", periods=4)\r\n idx = idx._with_freq(None) # tz_localize does not preserve freq\r\n with tm.assert_produces_warning(FutureWarning):\r\n # dt64->dt64tz deprecated\r\n result = idx.astype(\"datetime64[ns, US/Eastern]\")\r\n with tm.assert_produces_warning(FutureWarning):\r\n # dt64->dt64tz deprecated\r\n idx._data.astype(\"datetime64[ns, US/Eastern]\")\r\n\r\n expected = date_range(\"20170101\", periods=4, tz=\"US/Eastern\")\r\n expected = expected._with_freq(None)\r\n tm.assert_index_equal(result, expected)\r\n\r\n def test_astype_str_nat(self):\r\n # GH 13149, GH 13209\r\n # verify that we are returning NaT as a string (and not unicode)\r\n\r\n idx = DatetimeIndex([\"2016-05-16\", \"NaT\", NaT, np.NaN])\r\n result = idx.astype(str)\r\n expected = Index([\"2016-05-16\", \"NaT\", \"NaT\", \"NaT\"], dtype=object)\r\n tm.assert_index_equal(result, expected)\r\n\r\n def test_astype_str(self):\r\n # test astype string - #10442\r\n dti = date_range(\"2012-01-01\", periods=4, name=\"test_name\")\r\n result = dti.astype(str)\r\n expected = Index(\r\n [\"2012-01-01\", \"2012-01-02\", \"2012-01-03\", \"2012-01-04\"],\r\n name=\"test_name\",\r\n dtype=object,\r\n )\r\n tm.assert_index_equal(result, expected)\r\n\r\n def test_astype_str_tz_and_name(self):\r\n # test astype string with tz and name\r\n dti = date_range(\"2012-01-01\", periods=3, name=\"test_name\", tz=\"US/Eastern\")\r\n result = dti.astype(str)\r\n expected = Index(\r\n [\r\n \"2012-01-01 00:00:00-05:00\",\r\n \"2012-01-02 00:00:00-05:00\",\r\n \"2012-01-03 00:00:00-05:00\",\r\n ],\r\n name=\"test_name\",\r\n dtype=object,\r\n )\r\n tm.assert_index_equal(result, expected)\r\n\r\n def test_astype_str_freq_and_name(self):\r\n # test astype string with freqH and name\r\n dti = date_range(\"1/1/2011\", periods=3, freq=\"H\", name=\"test_name\")\r\n result = dti.astype(str)\r\n expected = Index(\r\n [\"2011-01-01 00:00:00\", \"2011-01-01 01:00:00\", \"2011-01-01 02:00:00\"],\r\n name=\"test_name\",\r\n dtype=object,\r\n )\r\n tm.assert_index_equal(result, expected)\r\n\r\n def test_astype_str_freq_and_tz(self):\r\n # test astype string with freqH and timezone\r\n dti = date_range(\r\n \"3/6/2012 00:00\", periods=2, freq=\"H\", tz=\"Europe/London\", name=\"test_name\"\r\n )\r\n result = dti.astype(str)\r\n expected = Index(\r\n [\"2012-03-06 00:00:00+00:00\", \"2012-03-06 01:00:00+00:00\"],\r\n dtype=object,\r\n name=\"test_name\",\r\n )\r\n tm.assert_index_equal(result, expected)\r\n\r\n def test_astype_datetime64(self):\r\n # GH 13149, GH 13209\r\n idx = DatetimeIndex([\"2016-05-16\", \"NaT\", NaT, np.NaN], name=\"idx\")\r\n\r\n result = idx.astype(\"datetime64[ns]\")\r\n tm.assert_index_equal(result, idx)\r\n assert result is not idx\r\n\r\n result = idx.astype(\"datetime64[ns]\", copy=False)\r\n tm.assert_index_equal(result, idx)\r\n assert result is idx\r\n\r\n idx_tz = DatetimeIndex([\"2016-05-16\", \"NaT\", NaT, np.NaN], tz=\"EST\", name=\"idx\")\r\n with tm.assert_produces_warning(FutureWarning):\r\n # dt64tz->dt64 deprecated\r\n result = idx_tz.astype(\"datetime64[ns]\")\r\n expected = DatetimeIndex(\r\n [\"2016-05-16 05:00:00\", \"NaT\", \"NaT\", \"NaT\"],\r\n dtype=\"datetime64[ns]\",\r\n name=\"idx\",\r\n )\r\n tm.assert_index_equal(result, expected)\r\n\r\n def test_astype_object(self):\r\n rng = date_range(\"1/1/2000\", periods=20)\r\n\r\n casted = rng.astype(\"O\")\r\n exp_values = list(rng)\r\n\r\n tm.assert_index_equal(casted, Index(exp_values, dtype=np.object_))\r\n assert casted.tolist() == exp_values\r\n\r\n @pytest.mark.parametrize(\"tz\", [None, \"Asia/Tokyo\"])\r\n def test_astype_object_tz(self, tz):\r\n idx = date_range(start=\"2013-01-01\", periods=4, freq=\"M\", name=\"idx\", tz=tz)\r\n expected_list = [\r\n Timestamp(\"2013-01-31\", tz=tz),\r\n Timestamp(\"2013-02-28\", tz=tz),\r\n Timestamp(\"2013-03-31\", tz=tz),\r\n Timestamp(\"2013-04-30\", tz=tz),\r\n ]\r\n expected = Index(expected_list, dtype=object, name=\"idx\")\r\n result = idx.astype(object)\r\n tm.assert_index_equal(result, expected)\r\n assert idx.tolist() == expected_list\r\n\r\n def test_astype_object_with_nat(self):\r\n idx = DatetimeIndex(\r\n [datetime(2013, 1, 1), datetime(2013, 1, 2), NaT, datetime(2013, 1, 4)],\r\n name=\"idx\",\r\n )\r\n expected_list = [\r\n Timestamp(\"2013-01-01\"),\r\n Timestamp(\"2013-01-02\"),\r\n NaT,\r\n Timestamp(\"2013-01-04\"),\r\n ]\r\n expected = Index(expected_list, dtype=object, name=\"idx\")\r\n result = idx.astype(object)\r\n tm.assert_index_equal(result, expected)\r\n assert idx.tolist() == expected_list\r\n\r\n @pytest.mark.parametrize(\r\n \"dtype\",\r\n [float, \"timedelta64\", \"timedelta64[ns]\", \"datetime64\", \"datetime64[D]\"],\r\n )\r\n def test_astype_raises(self, dtype):\r\n # GH 13149, GH 13209\r\n idx = DatetimeIndex([\"2016-05-16\", \"NaT\", NaT, np.NaN])\r\n msg = \"Cannot cast DatetimeIndex to dtype\"\r\n with pytest.raises(TypeError, match=msg):\r\n idx.astype(dtype)\r\n\r\n def test_index_convert_to_datetime_array(self):\r\n def _check_rng(rng):\r\n converted = rng.to_pydatetime()\r\n assert isinstance(converted, np.ndarray)\r\n for x, stamp in zip(converted, rng):\r\n assert isinstance(x, datetime)\r\n assert x == stamp.to_pydatetime()\r\n assert x.tzinfo == stamp.tzinfo\r\n\r\n rng = date_range(\"20090415\", \"20090519\")\r\n rng_eastern = date_range(\"20090415\", \"20090519\", tz=\"US/Eastern\")\r\n rng_utc = date_range(\"20090415\", \"20090519\", tz=\"utc\")\r\n\r\n _check_rng(rng)\r\n _check_rng(rng_eastern)\r\n _check_rng(rng_utc)\r\n\r\n def test_index_convert_to_datetime_array_explicit_pytz(self):\r\n def _check_rng(rng):\r\n converted = rng.to_pydatetime()\r\n assert isinstance(converted, np.ndarray)\r\n for x, stamp in zip(converted, rng):\r\n assert isinstance(x, datetime)\r\n assert x == stamp.to_pydatetime()\r\n assert x.tzinfo == stamp.tzinfo\r\n\r\n rng = date_range(\"20090415\", \"20090519\")\r\n rng_eastern = date_range(\"20090415\", \"20090519\", tz=pytz.timezone(\"US/Eastern\"))\r\n rng_utc = date_range(\"20090415\", \"20090519\", tz=pytz.utc)\r\n\r\n _check_rng(rng)\r\n _check_rng(rng_eastern)\r\n _check_rng(rng_utc)\r\n\r\n def test_index_convert_to_datetime_array_dateutil(self):\r\n def _check_rng(rng):\r\n converted = rng.to_pydatetime()\r\n assert isinstance(converted, np.ndarray)\r\n for x, stamp in zip(converted, rng):\r\n assert isinstance(x, datetime)\r\n assert x == stamp.to_pydatetime()\r\n assert x.tzinfo == stamp.tzinfo\r\n\r\n rng = date_range(\"20090415\", \"20090519\")\r\n rng_eastern = date_range(\"20090415\", \"20090519\", tz=\"dateutil/US/Eastern\")\r\n rng_utc = date_range(\"20090415\", \"20090519\", tz=dateutil.tz.tzutc())\r\n\r\n _check_rng(rng)\r\n _check_rng(rng_eastern)\r\n _check_rng(rng_utc)\r\n\r\n @pytest.mark.parametrize(\r\n \"tz, dtype\",\r\n [[\"US/Pacific\", \"datetime64[ns, US/Pacific]\"], [None, \"datetime64[ns]\"]],\r\n )\r\n def test_integer_index_astype_datetime(self, tz, dtype):\r\n # GH 20997, 20964, 24559\r\n val = [Timestamp(\"2018-01-01\", tz=tz).value]\r\n result = Index(val, name=\"idx\").astype(dtype)\r\n expected = DatetimeIndex([\"2018-01-01\"], tz=tz, name=\"idx\")\r\n tm.assert_index_equal(result, expected)\r\n\r\n def test_dti_astype_period(self):\r\n idx = DatetimeIndex([NaT, \"2011-01-01\", \"2011-02-01\"], name=\"idx\")\r\n\r\n res = idx.astype(\"period[M]\")\r\n exp = PeriodIndex([\"NaT\", \"2011-01\", \"2011-02\"], freq=\"M\", name=\"idx\")\r\n tm.assert_index_equal(res, exp)\r\n\r\n res = idx.astype(\"period[3M]\")\r\n exp = PeriodIndex([\"NaT\", \"2011-01\", \"2011-02\"], freq=\"3M\", name=\"idx\")\r\n tm.assert_index_equal(res, exp)\r\n\r\n\r\nclass TestAstype:\r\n @pytest.mark.parametrize(\"tz\", [None, \"US/Central\"])\r\n def test_astype_category(self, tz):\r\n obj = date_range(\"2000\", periods=2, tz=tz, name=\"idx\")\r\n result = obj.astype(\"category\")\r\n expected = pd.CategoricalIndex(\r\n [Timestamp(\"2000-01-01\", tz=tz), Timestamp(\"2000-01-02\", tz=tz)],\r\n name=\"idx\",\r\n )\r\n tm.assert_index_equal(result, expected)\r\n\r\n result = obj._data.astype(\"category\")\r\n expected = expected.values\r\n tm.assert_categorical_equal(result, expected)\r\n\r\n @pytest.mark.parametrize(\"tz\", [None, \"US/Central\"])\r\n def test_astype_array_fallback(self, tz):\r\n obj = date_range(\"2000\", periods=2, tz=tz, name=\"idx\")\r\n result = obj.astype(bool)\r\n expected = Index(np.array([True, True]), name=\"idx\")\r\n tm.assert_index_equal(result, expected)\r\n\r\n result = obj._data.astype(bool)\r\n expected = np.array([True, True])\r\n tm.assert_numpy_array_equal(result, expected)\r\n"
] | [
[
"numpy.array",
"pandas.DataFrame",
"pandas.Float64Index",
"numpy.random.randn",
"numpy.arange",
"pandas.Series",
"pandas._testing.assert_series_equal",
"pandas._testing.makeDateIndex"
],
[
"pandas._libs.tslibs.timezones.maybe_get_tz",
"pandas.DataFrame",
"pandas.date_range",
"pandas._testing.assert_frame_equal",
"pandas._testing.assert_equal",
"pandas._libs.tslibs.timezones.tz_compare"
],
[
"numpy.array",
"numpy.asarray",
"numpy.log",
"pandas.DataFrame",
"pandas.date_range",
"numpy.sum",
"numpy.random.permutation",
"pandas._testing.assert_frame_equal",
"pandas._testing.assert_categorical_equal",
"pandas.Categorical",
"pandas._testing.assert_numpy_array_equal",
"numpy.random.randint",
"pandas.Series",
"pandas._testing.assert_series_equal"
],
[
"pandas.DataFrame",
"pandas.Index",
"numpy.random.random",
"pandas._testing.assert_frame_equal"
],
[
"numpy.any",
"numpy.get_printoptions",
"numpy.set_printoptions",
"numpy.nonzero"
],
[
"pandas.DatetimeIndex",
"pandas.concat",
"pandas.DataFrame",
"pandas.date_range",
"numpy.tile",
"pandas.Timestamp",
"pandas.Series",
"pandas._testing.assert_index_equal",
"pandas._testing.assert_series_equal"
],
[
"numpy.array",
"pandas._testing.assert_numpy_array_equal",
"numpy.arange",
"pandas.core.construction.sanitize_array",
"numpy.dtype"
],
[
"pandas._libs.reduction.SeriesBinGrouper",
"pandas.core.sorting.get_group_index",
"pandas.core.dtypes.cast.maybe_downcast_to_dtype",
"pandas.core.dtypes.common.is_datetime64_any_dtype",
"pandas.core.indexes.api.ensure_index",
"pandas.core.arrays.integer.Int64Dtype",
"pandas._libs.reduction.extract_result",
"pandas.core.dtypes.common.is_float_dtype",
"pandas.core.sorting.get_group_index_sorter",
"numpy.dtype",
"pandas.core.dtypes.common.ensure_platform_int",
"pandas._libs.reduction.apply_frame_axis0",
"numpy.bincount",
"pandas.core.dtypes.missing.isna",
"numpy.empty",
"pandas.core.common.is_builtin_func",
"pandas.core.indexes.api.Index",
"pandas.core.arrays.floating.Float64Dtype",
"numpy.arange",
"pandas.core.dtypes.common.is_integer_dtype",
"pandas.core.dtypes.common.is_1d_only_ea_obj",
"numpy.flatnonzero",
"pandas._libs.lib.maybe_convert_objects",
"pandas.errors.AbstractMethodError",
"numpy.zeros",
"numpy.lexsort",
"pandas.core.dtypes.cast.maybe_cast_pointwise_result",
"pandas.core.groupby.grouper.Grouping",
"numpy.diff",
"pandas.core.dtypes.common.is_timedelta64_dtype",
"pandas.core.dtypes.common.ensure_int64",
"pandas.core.dtypes.common.is_complex_dtype",
"pandas.core.sorting.decons_obs_group_ids",
"pandas.core.sorting.compress_group_index",
"pandas._libs.lib.generate_slices",
"pandas.core.common.get_callable_name",
"pandas.core.indexes.api.MultiIndex",
"pandas.core.series.Series",
"pandas.core.dtypes.common.is_sparse",
"pandas._libs.reduction.SeriesGrouper",
"pandas.core.dtypes.common.ensure_float64",
"pandas.core.dtypes.common.is_numeric_dtype",
"pandas.core.sorting.get_flattened_list",
"pandas.core.dtypes.common.needs_i8_conversion",
"pandas.core.dtypes.common.is_categorical_dtype",
"pandas.core.dtypes.common.is_bool_dtype",
"pandas._libs.reduction.check_result_array",
"pandas.core.sorting.get_indexer_dict"
],
[
"pandas.Index",
"pandas.DataFrame.from_records",
"pandas.Interval",
"pandas.array",
"pandas.date_range",
"pandas.Categorical",
"pandas.Series",
"pandas._testing.assert_series_equal"
],
[
"numpy.dot",
"numpy.argmin",
"numpy.asfortranarray",
"numpy.mean",
"numpy.finfo",
"numpy.sort",
"scipy.sparse.isspmatrix",
"numpy.empty",
"numpy.log10",
"scipy.sparse.csr_matrix",
"numpy.flatnonzero",
"scipy.sparse.issparse",
"numpy.zeros",
"numpy.asarray",
"numpy.sum",
"numpy.may_share_memory",
"numpy.atleast_1d",
"numpy.average",
"numpy.moveaxis"
],
[
"pandas.core.ops.common.unpack_zerodim_and_defer",
"pandas.core.indexes.numeric.Float64Index",
"pandas.compat.numpy.function.validate_max",
"pandas.core.dtypes.common.ensure_python_int",
"pandas.core.construction.extract_array",
"pandas.core.ops.get_op_result_name",
"numpy.dtype",
"pandas.core.dtypes.common.ensure_platform_int",
"numpy.concatenate",
"pandas.core.common.all_none",
"pandas.core.common.any_not_none",
"pandas.compat.numpy.function.validate_argsort",
"pandas.compat.numpy.function.validate_minmax_axis",
"numpy.arange",
"pandas.core.dtypes.common.is_signed_integer_dtype",
"pandas.core.indexes.base.maybe_extract_name",
"pandas.core.dtypes.common.is_scalar",
"pandas.util._decorators.doc",
"pandas.core.dtypes.common.is_integer",
"pandas.core.indexes.base.default_pprint",
"pandas.compat.numpy.function.validate_min",
"pandas.core.indexes.numeric.Int64Index",
"numpy.asarray",
"numpy.errstate",
"pandas.core.indexes.numeric.Int64Index._simple_new",
"pandas.core.dtypes.common.is_timedelta64_dtype",
"pandas.core.dtypes.common.is_float"
],
[
"numpy.nextafter",
"scipy.sparse.issparse",
"numpy.array",
"numpy.empty",
"numpy.zeros",
"numpy.sum",
"numpy.any",
"numpy.abs",
"numpy.hstack",
"scipy.special.digamma",
"numpy.unique"
],
[
"numpy.testing.assert_allclose",
"sklearn.ensemble.GradientBoostingRegressor",
"sklearn.ensemble.GradientBoostingClassifier",
"sklearn.linear_model.LinearRegression",
"sklearn.datasets.load_diabetes",
"sklearn.inspection.plot_partial_dependence",
"numpy.arange",
"sklearn.utils._testing._convert_container",
"sklearn.datasets.make_regression",
"numpy.all",
"numpy.linspace",
"sklearn.datasets.load_iris",
"sklearn.datasets.make_classification"
],
[
"numpy.arange"
],
[
"pandas.Timestamp",
"pandas._testing.assert_series_equal",
"pandas.read_pickle",
"pandas.set_option",
"pandas.DataFrame",
"numpy.arange",
"numpy.array",
"numpy.zeros",
"numpy.random.randn",
"pandas._testing.assert_frame_equal",
"numpy.rec.fromarrays",
"pandas._testing.makeDataFrame",
"pandas.isna",
"pandas._testing.assert_produces_warning",
"pandas.date_range",
"numpy.ones",
"pandas._testing.assert_almost_equal",
"pandas._testing.ensure_clean",
"pandas.option_context",
"pandas._testing.assert_numpy_array_equal",
"pandas.Series"
],
[
"matplotlib.path.Path",
"matplotlib.transforms.TransformedBbox",
"matplotlib.transforms.Bbox.from_bounds",
"matplotlib.transforms.BboxTransformTo",
"matplotlib.transforms.IdentityTransform",
"matplotlib._api.warn_external",
"matplotlib.transforms.Bbox.unit"
],
[
"pandas.compat.numpy.function.validate_any",
"numpy.ones_like",
"pandas.core.ops.kleene_and",
"pandas.core.dtypes.common.is_float_dtype",
"pandas._libs.lib.is_scalar",
"numpy.dtype",
"pandas.compat.numpy.function.validate_all",
"pandas.core.dtypes.missing.isna",
"pandas._libs.lib.infer_dtype",
"numpy.zeros_like",
"numpy.putmask",
"pandas.core.dtypes.common.pandas_dtype",
"pandas.core.ops.maybe_dispatch_ufunc_to_dunder_op",
"pandas.core.dtypes.common.is_integer_dtype",
"pandas.core.arrays.IntegerArray",
"numpy.array",
"pandas.core.ops.kleene_xor",
"pandas.core.dtypes.common.is_list_like",
"numpy.asarray",
"numpy.errstate",
"pandas.core.arrays.FloatingArray",
"pandas.core.dtypes.common.is_numeric_dtype",
"pandas.core.ops.kleene_or",
"pandas._libs.lib.is_bool",
"pandas.core.dtypes.common.is_float",
"pandas.core.dtypes.common.is_bool_dtype"
],
[
"matplotlib.tri.triangulation.Triangulation.get_from_args_and_kwargs",
"matplotlib.docstring.interpd.update",
"numpy.ma.asarray",
"numpy.ma.masked_invalid",
"matplotlib.docstring.Substitution",
"numpy.isfinite",
"numpy.ma.is_masked"
],
[
"pandas.Index",
"numpy.array",
"pandas.DatetimeIndex",
"pandas._testing.assert_produces_warning",
"pandas.Int64Index",
"pandas.date_range",
"pandas.PeriodIndex",
"pandas._testing.assert_categorical_equal",
"pandas.Timestamp",
"pandas._testing.assert_numpy_array_equal",
"pandas._testing.assert_index_equal"
]
] |
MountainRange/mobius_score | [
"fc900ab456b3e3431cfa6d9684b97ec6321d0a23"
] | [
"audiospec.py"
] | [
"\nimport numpy as np\nimport librosa\nfrom tqdm import tqdm\nfrom audiomisc import ks_key\n\nfrom constants import VERTICALCUTOFF, FFT_SIZE, FFT_HOP\n\ndef stft(x, fft_size, hopsamp):\n window = np.hanning(fft_size)\n return np.array([np.fft.rfft(window*x[i:i+fft_size])\n for i in range(0, len(x)-fft_size, hopsamp)])\n\ndef wav_to_spec(fn):\n input_signal, sample_rate = librosa.load(fn, sr=44100)\n stft_mag = np.array([])\n split = int(1e6)#int(264600)\n fft_size = FFT_SIZE\n hopsamp = fft_size // FFT_HOP\n for i in tqdm(range(len(input_signal)//split)):\n temp_signal = input_signal[(split*i):(split*(i+1))]\n stft_full = stft(temp_signal, fft_size, hopsamp)\n\n stft_full = abs(stft_full)\n if np.max(stft_full) != 0:\n stft_full = (stft_full - np.mean(stft_full)) / np.std(stft_full)\n stft_full += abs(np.min(stft_full))\n stft_full *= 255.0/np.max(stft_full)\n \n if stft_mag.shape[0] != 0:\n stft_mag = np.concatenate((stft_mag, stft_full))\n else:\n stft_mag = stft_full\n\n print(\"Calculating tempo\")\n tempo, _ = librosa.beat.beat_track(y=input_signal, sr=sample_rate, hop_length=512)\n\n print(\"Calculating music key\")\n chroma = librosa.feature.chroma_stft(y=input_signal, sr=sample_rate)\n chroma = [sum(x)/len(x) for x in chroma]\n bestmajor, bestminor = ks_key(chroma)\n if max(bestmajor) > max(bestminor):\n key = np.argmax(bestmajor)\n # C, Db, D, Eb, E, F, F#, G, Ab, A, Bb, B\n keymap = [0, -5, 2, -3, 4, -1, 6, 1, -4, 3, -2, 5]\n else:\n key = np.argmax(bestminor)\n # c, c#, d, eb, e, f, f#, g, g#, a, bb, b\n keymap = [-3, 4, -1, -6, 1, -4, 3, -2, 5, 0, -5, 2]\n \n return stft_mag[:, :VERTICALCUTOFF].T, tempo, keymap[key]"
] | [
[
"numpy.max",
"numpy.concatenate",
"numpy.array",
"numpy.fft.rfft",
"numpy.hanning",
"numpy.min",
"numpy.mean",
"numpy.std",
"numpy.argmax"
]
] |
Prasad9/Detect-Flags-SSD | [
"c0d662bde99ed8df33d72bd06d61d5eb869d31a5"
] | [
"detect/image_detector.py"
] | [
"from __future__ import print_function\nimport mxnet as mx\nimport numpy as np\nfrom timeit import default_timer as timer\nfrom dataset.iterator import DetTestImageIter\nimport cv2\n\nclass ImageDetector(object):\n\t\"\"\"\n\tSSD detector which hold a detection network and wraps detection API\n\n\tParameters:\n\t----------\n\tsymbol : mx.Symbol\n\t\tdetection network Symbol\n\tmodel_prefix : str\n\t\tname prefix of trained model\n\tepoch : int\n\t\tload epoch of trained model\n\tdata_shape : int\n\t\tinput data resize shape\n\tmean_pixels : tuple of float\n\t\t(mean_r, mean_g, mean_b)\n\tbatch_size : int\n\t\trun detection with batch size\n\tctx : mx.ctx\n\t\tdevice to use, if None, use mx.cpu() as default context\n\t\"\"\"\n\tdef __init__(self, symbol, model_prefix, epoch, data_shape, mean_pixels, \\\n\t\t\t\t\tclasses, thresh = 0.6, plot_confidence = True, batch_size=1, ctx=None):\n\t\tself.ctx = ctx\n\t\tif self.ctx is None:\n\t\t\tself.ctx = mx.cpu()\n\t\tload_symbol, args, auxs = mx.model.load_checkpoint(model_prefix, epoch)\n\t\tif symbol is None:\n\t\t\tsymbol = load_symbol\n\t\tself.mod = mx.mod.Module(symbol, label_names=None, context=ctx)\n\t\tself.data_shape = data_shape\n\t\tself.mod.bind(data_shapes=[('data', (batch_size, 3, data_shape, data_shape))])\n\t\tself.mod.set_params(args, auxs)\n\t\tself.data_shape = data_shape\n\t\tself.mean_pixels = mean_pixels\n\t\tself.classes = classes\n\t\tself.colors = []\n\t\tself.fill_random_colors_int()\n\t\tself.thresh = thresh\n\t\tself.plot_confidence = plot_confidence\n\n\tdef fill_random_colors(self):\n\t\timport random\n\t\tfor i in range(len(self.classes)):\n\t\t\tself.colors.append((random.random(), random.random(), random.random()))\n\n\t\t#print(self.colors)\n\n\tdef fill_random_colors_int(self):\n\t\timport random\n\t\tfor i in range(len(self.classes)):\n\t\t\tself.colors.append((random.randint(0, 255), random.randint(0, 255), random.randint(0, 255)))\n\n\t\t#print(self.colors)\n\n\n\tdef detect(self, det_iter, show_timer=False):\n\t\t\"\"\"\n\t\tdetect all images in iterator\n\n\t\tParameters:\n\t\t----------\n\t\tdet_iter : DetIter\n\t\t\titerator for all testing images\n\t\tshow_timer : Boolean\n\t\t\twhether to print out detection exec time\n\n\t\tReturns:\n\t\t----------\n\t\tlist of detection results\n\t\t\"\"\"\n\t\tnum_images = det_iter._size\n\t\tresult = []\n\t\tdetections = []\n\t\t#if not isinstance(det_iter, mx.io.PrefetchingIter):\n\t\t#\tdet_iter = mx.io.PrefetchingIter(det_iter)\n\t\tstart = timer()\n\t\tfor pred, _, _ in self.mod.iter_predict(det_iter):\n\t\t\tdetections.append(pred[0].asnumpy())\n\t\ttime_elapsed = timer() - start\n\t\tif show_timer:\n\t\t\tprint(\"Detection time for {} images: {:.4f} sec\".format(num_images, time_elapsed))\n\t\tfor output in detections:\n\t\t\tfor i in range(output.shape[0]):\n\t\t\t\tdet = output[i, :, :]\n\t\t\t\tres = det[np.where(det[:, 0] >= 0)[0]]\n\t\t\t\tresult.append(res)\n\t\tresized_img = det_iter.current_data()\n\t\treturn result, resized_img\n\n\tdef im_detect(self, img, show_timer=False):\n\t\t\"\"\"\n\t\twrapper for detecting multiple images\n\n\t\tParameters:\n\t\t----------\n\t\tim_list : list of str\n\t\t\timage path or list of image paths\n\t\troot_dir : str\n\t\t\tdirectory of input images, optional if image path already\n\t\t\thas full directory information\n\t\textension : str\n\t\t\timage extension, eg. \".jpg\", optional\n\n\t\tReturns:\n\t\t----------\n\t\tlist of detection results in format [det0, det1...], det is in\n\t\tformat np.array([id, score, xmin, ymin, xmax, ymax]...)\n\t\t\"\"\"\n\t\tim_list = [img]\n\t\ttest_iter = DetTestImageIter(im_list, 1, self.data_shape, self.mean_pixels)\n\t\treturn self.detect(test_iter, show_timer)\n\n\tdef plot_rects(self, img, dets):\n\t\timg_shape = img.shape\n\t\tfor i in range(dets.shape[0]):\n\t\t\tcls_id = int(dets[i, 0])\n\t\t\tif cls_id >= 0:\n\t\t\t\tscore = dets[i, 1]\n\t\t\t\t#print('Score is {}, class {}'.format(score, cls_id))\n\t\t\t\tif score > self.thresh:\n\t\t\t\t\txmin = int(dets[i, 2] * img_shape[1])\n\t\t\t\t\tymin = int(dets[i, 3] * img_shape[0])\n\t\t\t\t\txmax = int(dets[i, 4] * img_shape[1])\n\t\t\t\t\tymax = int(dets[i, 5] * img_shape[0])\n\n\t\t\t\t\tcv2.rectangle(img, (xmin, ymin), (xmax, ymax), self.colors[cls_id], 4)\n\n\t\t\t\t\tclass_name = self.classes[cls_id]\n\t\t\t\t\tcv2.putText(img, class_name, (xmin, ymin), cv2.FONT_HERSHEY_SIMPLEX, 2, (0, 0, 255), 4)\n\t\t\t\t\t#print('Class id = {}, Score = {}, Country = {}, rect = ({}, {}, {}, {})'.format(cls_id, score, class_name, xmin, ymin, xmax, ymax))\n\n\tdef detect_and_visualize_image(self, img, show_timer=False):\n\t\t\"\"\"\n\t\twrapper for im_detect and visualize_detection\n\n\t\tParameters:\n\t\t----------\n\t\tim_list : list of str or str\n\t\timage path or list of image paths\n\t\troot_dir : str or None\n\t\tdirectory of input images, optional if image path already\n\t\thas full directory information\n\t\textension : str or None\n\t\timage extension, eg. \".jpg\", optional\n\n\t\tReturns:\n\t\t----------\n\n\t\t\"\"\"\n\t\tdets, resized_img = self.im_detect(img, show_timer=show_timer)\n\t\tresized_img = resized_img.asnumpy()\n\t\tresized_img /= 255.0\n\t\tfor k, det in enumerate(dets):\n\t\t\tself.plot_rects(resized_img, det)\n\t\treturn resized_img\n\n\tdef scale_and_plot_rects(self, img, dets):\n\t\timg_shape = img.shape\n\t\tfor i in range(dets.shape[0]):\n\t\t\tcls_id = int(dets[i, 0])\n\t\t\tif cls_id >= 0:\n\t\t\t\tscore = dets[i, 1]\n\t\t\t\t#print('Score is {}, class {}'.format(score, cls_id))\n\t\t\t\tif score > self.thresh:\n\t\t\t\t\txmin = int(dets[i, 2] * img_shape[1])\n\t\t\t\t\tymin = int(dets[i, 3] * img_shape[0])\n\t\t\t\t\txmax = int(dets[i, 4] * img_shape[1])\n\t\t\t\t\tymax = int(dets[i, 5] * img_shape[0])\n\n\t\t\t\t\tcv2.rectangle(img, (xmin, ymin), (xmax, ymax), self.colors[cls_id], 4)\n\n\t\t\t\t\tclass_name = self.classes[cls_id]\n\t\t\t\t\tcv2.putText(img, class_name, (xmin, ymin - 15), cv2.FONT_HERSHEY_SIMPLEX, 2, (255, 0, 255), 3)\n\t\t\t\t\tif self.plot_confidence:\n\t\t\t\t\t\tscore_color = (0, 255, 0) if score > 0.5 else (255, 0, 0)\n\t\t\t\t\t\tcv2.putText(img, '{:.3f}'.format(score), (xmax - 60, ymin - 15), cv2.FONT_HERSHEY_SIMPLEX, 1, score_color, 1)\n\t\t\t\t\t\n\n\tdef detect_and_layover_image(self, img, show_timer=False):\n\t\t\"\"\"\n\t\twrapper for im_detect and visualize_detection\n\n\t\tParameters:\n\t\t----------\n\t\tim_list : list of str or str\n\t\timage path or list of image paths\n\t\troot_dir : str or None\n\t\tdirectory of input images, optional if image path already\n\t\thas full directory information\n\t\textension : str or None\n\t\timage extension, eg. \".jpg\", optional\n\n\t\tReturns:\n\t\t----------\n\n\t\t\"\"\"\n\t\tdets, _ = self.im_detect(img, show_timer=show_timer)\n\t\tfor k, det in enumerate(dets):\n\t\t\tself.scale_and_plot_rects(img, det)\n\t\treturn img\n"
] | [
[
"numpy.where"
]
] |
richardtjornhammar/graphtastic | [
"1e64d408ffb3e09d5ad068986c847032d5cfdcbd"
] | [
"src/graphtastic/clustering.py"
] | [
"\"\"\"\nCopyright 2022 RICHARD TJÖRNHAMMAR\n\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\"\"\"\nimport numpy as np\nimport typing\nimport sys\n\ntry :\n from numba import jit\n bUseNumba = True\nexcept ImportError :\n print ( \"ImportError:\",\" NUMBA. WILL NOT USE IT\")\n bUseNumba = False\nexcept OSError:\n print ( \"OSError:\",\" NUMBA. WILL NOT USE IT\")\n bUseNumba = False\n\n# THE FOLLOWING KMEANS ALGORITHM IS THE AUTHOR OWN LOCAL VERSION\nif bUseNumba :\n @jit(nopython=True)\n def seeded_kmeans( dat:np.array, cent:np.array ) :\n #\n # PYTHON ADAPTATION OF MY C++ CODE THAT CAN BE FOUND IN\n # https://github.com/richardtjornhammar/RichTools/blob/master/src/cluster.cc\n # AROUND LINE 2345\n # AGAIN CONSIDER USING THE C++ VERSION SINCE IT IS ALOT FASTER\n # HERE WE SPEED IT UP USING NUMBA IF THE USER HAS IT INSTALLED AS A MODULE\n #\n NN , MM = np.shape ( dat )\n KK , LL = np.shape ( cent )\n if not LL == MM :\n print ( 'WARNING DATA FORMAT ERROR. NON COALESCING COORDINATE AXIS' )\n\n labels = [ int(z) for z in np.zeros(NN) ]\n w = labels\n counts = np.zeros(KK)\n tmp_ce = np.zeros(KK*MM).reshape(KK,MM)\n old_error , error , TOL = 0. , 1. , 1.0E-10\n while abs ( error - old_error ) > TOL :\n old_error = error\n error = 0.\n counts = counts * 0.\n tmp_ce = tmp_ce * 0.\n # START BC\n for h in range ( NN ) :\n min_distance = 1.0E30\n for i in range ( KK ) :\n distance = np.sum( ( dat[h]-cent[i] )**2 )\n if distance < min_distance :\n labels[h] = i\n min_distance = distance\n tmp_ce[labels[h]] += dat[ h ]\n counts[labels[h]] += 1.0\n error += min_distance\n # END BC\n for i in range ( KK ) :\n if counts[i]>0:\n cent[i] = tmp_ce[i]/counts[i]\n centroids = cent\n return ( labels , centroids )\nelse :\n def seeded_kmeans( dat:np.array, cent:np.array ) :\n #\n # SLOW SLUGGISH KMEANS WITH A DUBBLE FOR LOOP\n # IN PYTHON! WOW! SUCH SPEED!\n #\n NN , MM = np.shape ( dat )\n KK , LL = np.shape ( cent )\n if not LL == MM :\n print ( 'WARNING DATA FORMAT ERROR. NON COALESCING COORDINATE AXIS' )\n\n labels = [ int(z) for z in np.zeros(NN) ]\n w = labels\n counts = np.zeros(KK)\n tmp_ce = np.zeros(KK*MM).reshape(KK,MM)\n old_error , error , TOL = 0. , 1. , 1.0E-10\n while abs ( error - old_error ) > TOL :\n old_error = error\n error = 0.\n counts = counts * 0.\n tmp_ce = tmp_ce * 0.\n # START BC\n for h in range ( NN ) :\n min_distance = 1.0E30\n for i in range ( KK ) :\n distance = np.sum( ( dat[h]-cent[i] )**2 )\n if distance < min_distance :\n labels[h] = i\n min_distance = distance\n tmp_ce[labels[h]] += dat[ h ]\n counts[labels[h]] += 1.0\n error += min_distance\n # END BC\n for i in range ( KK ) :\n if counts[i]>0:\n cent[i] = tmp_ce[i]/counts[i]\n centroids = cent\n return ( labels , centroids )\n\n\nif bUseNumba :\n @jit(nopython=True)\n def connectivity ( B:np.array , val:float , bVerbose:bool = False ) :\n description = \"\"\" This is a cutoff based clustering algorithm. The intended use is to supply a distance matrix and a cutoff value (then becomes symmetric positive). For a small distance cutoff, you should see all the parts of the system and for a large distance cutoff, you should see the entire system. It has been employed for statistical analysis work as well as the original application where it was employed to segment molecular systems.\"\"\"\n if bVerbose :\n print ( \"CONNECTIVITY CLUSTERING OF \", np.shape(B), \" MATRIX\" )\n # PYTHON ADAPTATION OF MY C++ CODE THAT CAN BE FOUND IN\n # https://github.com/richardtjornhammar/RichTools/blob/master/src/cluster.cc\n # AROUND LINE 2277\n # CONSIDER COMPILING AND USING THAT AS A MODULE INSTEAD OF THIS SINCE IT IS\n # A LOT FASTER\n # FOR A DESCRIPTION READ PAGE 30 (16 INTERNAL NUMBERING) of:\n # https://kth.diva-portal.org/smash/get/diva2:748464/FULLTEXT01.pdf\n #\n # https://github.com/richardtjornhammar/RichTools/blob/master/src/cluster.cc\n # ADDED TO RICHTOOLS HERE: https://github.com/richardtjornhammar/RichTools/commit/74b35df9c623bf03570707a24eafe828f461ed90#diff-25a6634263c1b1f6fc4697a04e2b9904ea4b042a89af59dc93ec1f5d44848a26\n # CONNECTIVITY SEARCH FOR (connectivity) CONNECTIVITY\n #\n nr_sq,mr_sq = np.shape(B)\n if nr_sq != mr_sq :\n print ( 'ERROR: FAILED' )\n N = mr_sq\n res , nvisi, s, NN, ndx, C = [0], [0], [0], [0], [0], 0\n res .append(0)\n for i in range(N) :\n nvisi.append(i+1)\n res.append(0); res.append(0)\n ndx.append(i)\n\n res = res[1:]\n nvisi = nvisi[1:]\n ndx = ndx[1:]\n while ( len(ndx)>0 ) :\n i = ndx[-1] ; ndx = ndx[:-1]\n NN = []\n if ( nvisi[i]>0 ) :\n C-=1\n for j in range(N) :\n if ( B[i,j]<=val ) :\n NN.append(j)\n while ( len(NN)>0 ) :\n # back pop_back\n k = NN[-1]; NN = NN[:-1]\n nvisi[k] = C\n for j in range(N):\n if ( B[j,k]<=val ) :\n for q in range(N) :\n if ( nvisi[q] == j+1 ) :\n NN.append(q)\n if bVerbose : # VERBOSE\n print ( \"INFO \"+str(-1*C) +\" clusters\" )\n Nc = [ 0 for i in range(-1*C) ]\n for q in range(N) :\n res[ q*2+1 ] = q;\n res[ q*2 ] = nvisi[q]-C;\n Nc [res[q*2]]+= 1;\n if bVerbose :\n print ( \" \"+str(res[q*2])+\" \"+str(res[2*q+1]) )\n if bVerbose :\n for i in range(-1*C) :\n print( \"CLUSTER \" +str(i)+ \" HAS \" + str(Nc[i]) + \" ELEMENTS\")\n return ( Nc , np.array(res[:-1]).reshape(-1,2) )\nelse :\n def connectivity ( B:np.array , val:float , bVerbose:bool = False ) :\n description=\"\"\"\nThis is a cutoff based clustering algorithm. The intended use is to supply a distance matrix and a cutoff value (then becomes symmetric positive). For a small distanc>\n \"\"\"\n if bVerbose :\n print ( \"CONNECTIVITY CLUSTERING OF \", np.shape(B), \" MATRIX\" )\n # PYTHON ADAPTATION OF MY C++ CODE THAT CAN BE FOUND IN\n # https://github.com/richardtjornhammar/RichTools/blob/master/src/cluster.cc\n # AROUND LINE 2277\n # CONSIDER COMPILING AND USING THAT AS A MODULE INSTEAD OF THIS SINCE IT IS\n # A LOT FASTER\n # FOR A DESCRIPTION READ PAGE 30 (16 INTERNAL NUMBERING) of:\n # https://kth.diva-portal.org/smash/get/diva2:748464/FULLTEXT01.pdf\n #\n nr_sq,mr_sq = np.shape(B)\n if nr_sq != mr_sq :\n print ( 'ERROR' )\n return ( -1 )\n N = mr_sq\n res , nvisi, s, NN, ndx, C = [], [], [], [], [], 0\n res .append(0)\n for i in range(N) :\n nvisi.append(i+1)\n res.append(0); res.append(0)\n ndx.append(i)\n while ( len(ndx)>0 ) :\n i = ndx[-1] ; ndx = ndx[:-1]\n NN = []\n if ( nvisi[i]>0 ) :\n C-=1\n for j in range(N) :\n if ( B[i,j]<=val ) :\n NN.append(j)\n while ( len(NN)>0 ) :\n # back pop_back\n k = NN[-1]; NN = NN[:-1]\n nvisi[k] = C\n for j in range(N):\n if ( B[j,k]<=val ) :\n for q in range(N) :\n if ( nvisi[q] == j+1 ) :\n NN.append(q)\n if bVerbose : # VERBOSE\n print ( \"INFO \"+str(-1*C) +\" clusters\" )\n Nc = [ 0 for i in range(-1*C) ]\n for q in range(N) :\n res[ q*2+1 ] = q;\n res[ q*2 ] = nvisi[q]-C;\n Nc [res[q*2]]+= 1;\n if bVerbose :\n print ( \" \"+str(res[q*2])+\" \"+str(res[2*q+1]) )\n if bVerbose:\n for i in range(-1*C) :\n print( \"CLUSTER \" +str(i)+ \" HAS \" + str(Nc[i]) + \" ELEMENTS\")\n return ( Nc , np.array(res[:-1]).reshape(-1,2) )\n\nif bUseNumba :\n @jit(nopython=True)\n def connectedness ( distm:np.array , alpha:float , n_connections:int=1 ) -> list :\n #\n # AN ALTERNATIVE METHOD\n # DOES THE SAME THING AS THE CONNECTIVITY CODE IN MY\n # CLUSTERING MODULE (in src/impetuous/clustering.py )\n # OR IN https://github.com/richardtjornhammar/RichTools/blob/master/src/cluster.cc\n # https://github.com/richardtjornhammar/RichTools/commit/74b35df9c623bf03570707a24eafe828f461ed90#diff-25a6634263c1b1f6fc4697a04e2b9904ea4b042a89af59dc93ec1f5d44848a26\n # CONNECTIVITY SEARCH FOR (connectivity) CONNECTIVITY\n #\n # THIS ROUTINE RETURNS A LIST BELONGING TO THE CLUSTERS\n # WITH THE SET OF INDICES THAT MAPS TO THE CLUSTER\n #\n if len ( distm.shape ) < 2 :\n print ( 'PLEASE SUBMIT A SQUARE DISTANCE MATRIX' )\n\n def b2i ( a:list ) -> list :\n return ( [ i for b,i in zip(a,range(len(a))) if b ] )\n def f2i ( a:list,alf:float ) -> list :\n return ( b2i( a<=alf ) )\n\n L = []\n for a in distm :\n bAdd = True\n ids = set( f2i(a,alpha) )\n for i in range(len(L)) :\n if len( L[i]&ids ) >= n_connections :\n L[i] = L[i] | ids\n bAdd = False\n break\n if bAdd and len(ids) >= n_connections :\n L .append( ids )\n return ( L )\nelse :\n def connectedness ( distm:np.array , alpha:float , n_connections:int=1 ) -> list :\n #\n # AN ALTERNATIVE METHOD\n # DOES THE SAME THING AS THE CONNECTIVITY CODE IN MY\n # CLUSTERING MODULE (in src/impetuous/clustering.py )\n # OR IN https://github.com/richardtjornhammar/RichTools/blob/master/src/cluster.cc\n # as of commit https://github.com/richardtjornhammar/RichTools/commit/76201bb07687017ae16a4e57cb1ed9fd8c394f18 2016\n # CONNECTIVITY SEARCH FOR (connectivity) CONNECTIVITY\n #\n # THIS ROUTINE RETURNS A LIST BELONGING TO THE CLUSTERS\n # WITH THE SET OF INDICES THAT MAPS TO THE CLUSTER\n #\n if len ( distm.shape ) < 2 :\n print ( 'PLEASE SUBMIT A SQUARE DISTANCE MATRIX' )\n\n def b2i ( a:list ) -> list :\n return ( [ i for b,i in zip(a,range(len(a))) if b ] )\n def f2i ( a:list,alf:float ) -> list :\n return ( b2i( a<=alf ) )\n\n L = []\n for a in distm :\n bAdd = True\n ids = set( f2i(a,alpha) )\n for i in range(len(L)) :\n if len( L[i]&ids ) >= n_connections :\n L[i] = L[i] | ids\n bAdd = False\n break\n if bAdd and len(ids) >= n_connections :\n L .append( ids )\n return ( L )\n\ndef dbscan ( coordinates:np.array = None , distance_matrix:np.array = None ,\n eps:float = None, minPts:int = None , bVerbose:bool = False ) -> dict :\n\n def absolute_coordinates_to_distance_matrix ( Q:np.array , power:int=2 , bInvPow:bool=False ) -> np.array :\n # UNUSED FALLBACK\n DP = np.array( [ np.sum((np.array(p)-np.array(q))**power) for p in Q for q in Q] ).reshape(np.shape(Q)[0],np.shape(Q)[0])\n if bInvPow :\n DP = DP**(1.0/power)\n return ( DP )\n\n if bVerbose :\n print ( \"THIS IMPLEMENTATION FOR DBSCAN\" )\n print ( \"ASSESSMENT OF NOISE DIFFERS FROM\" )\n print ( \"THE IMPLEMENTATION FOUND IN SKLEARN\" )\n print ( \"ASSUMES LINEAR DISTANCES, NOT SQUARED\" )\n #\n # FOR A DESCRIPTION OF THE CONNECTIVITY READ PAGE 30 (16 INTERNAL NUMBERING) of:\n # https://kth.diva-portal.org/smash/get/diva2:748464/FULLTEXT01.pdf\n #from impetuous.clustering import absolute_coordinates_to_distance_matrix\n #from impetuous.clustering import connectivity\n\n import operator\n if not operator.xor( coordinates is None , distance_matrix is None ) :\n print ( \"ONLY SUPPLY A SINGE DATA FRAME OR A DISTANCE MATRIX\" )\n print ( \"dbscan FAILED\" )\n print ( \"DATA MATRICES NEEDS TO BE SPECIFIED WITH \\\" distance_matrix = ... \\\" \" )\n exit(1)\n\n if distance_matrix is None :\n from graphtastic.fit import absolute_coordinates_to_distance_matrix\n distance_matrix_ = absolute_coordinates_to_distance_matrix ( coordinates )\n eps = eps**2.0\n else :\n distance_matrix_ = distance_matrix\n\n isNoise = np.sum(distance_matrix_<eps,0)-1 < minPts\n i_ = 0\n for ib in isNoise :\n if ib :\n distance_matrix_ [ i_] = ( 1+eps )*10.0\n distance_matrix_.T[i_] = ( 1+eps )*10.0\n distance_matrix_[i_][i_] = 0.\n i_ = i_+1\n clustercontent , clustercontacts = connectivity ( distance_matrix_ , eps )\n return ( {'cluster content': clustercontent, 'clusterid-particleid' : clustercontacts, 'is noise':isNoise} )\n\ndef reformat_dbscan_results ( results:dict ) -> dict :\n if True :\n clusters = {}\n for icontent in range(len(results['cluster content'])) :\n content = results[ 'cluster content' ][ icontent ]\n for c in results [ 'clusterid-particleid' ] :\n if c[0] == icontent :\n if results[ 'is noise' ][c[1]] :\n icontent=-1\n if icontent in clusters:\n clusters[ icontent ] .append( c[1] )\n else :\n clusters[ icontent ] = [ c[1] ]\n return ( clusters )\n"
] | [
[
"numpy.sum",
"numpy.array",
"numpy.zeros",
"numpy.shape"
]
] |
TochkaAI/Paddle | [
"f249a5f05f0f5832279244d88c8cb4eaaad1fbd4"
] | [
"python/paddle/fluid/tests/unittests/ir/inference/test_trt_activation_pass.py"
] | [
"# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport os\nimport shutil\nimport unittest\nimport numpy as np\nfrom inference_pass_test import InferencePassTest\nimport paddle.fluid as fluid\nimport paddle.fluid.core as core\nfrom paddle.fluid.core import PassVersionChecker\nfrom paddle.fluid.core import AnalysisConfig\n\n\nclass TensorRTSubgraphPassActivationTest(InferencePassTest):\n def setUpTensorRTParam(self):\n self.enable_trt = True\n self.trt_parameters = TensorRTSubgraphPassActivationTest.TensorRTParam(\n 1 << 30, 32, 0, AnalysisConfig.Precision.Float32, False, False)\n\n def setUp(self):\n self.setUpTensorRTParam()\n with fluid.program_guard(self.main_program, self.startup_program):\n data = fluid.data(\n name=\"data\", shape=[-1, 6, 64, 64], dtype=\"float32\")\n act_out = self.append_act(data)\n out = fluid.layers.batch_norm(act_out, is_test=True)\n self.feeds = {\n \"data\": np.random.random([1, 6, 64, 64]).astype(\"float32\"),\n }\n self.fetch_list = [out]\n\n def append_act(self, x):\n return fluid.layers.relu(x)\n\n def test_check_output(self):\n if core.is_compiled_with_cuda():\n use_gpu = True\n if os.path.exists(self.path + \"_opt_cache\"):\n shutil.rmtree(self.path + \"_opt_cache\")\n if self.trt_parameters.precision == AnalysisConfig.Precision.Float32:\n self.check_output_with_option(use_gpu)\n else:\n self.check_output_with_option(use_gpu, 1e-3)\n self.assertTrue(\n PassVersionChecker.IsCompatible('tensorrt_subgraph_pass'))\n\n\nclass TensorRTSubgraphPassLeakyReluTest(TensorRTSubgraphPassActivationTest):\n def append_act(self, x):\n return fluid.layers.leaky_relu(x)\n\n\nclass TensorRTSubgraphPassRelu6Test(TensorRTSubgraphPassActivationTest):\n def append_act(self, x):\n return fluid.layers.relu6(x)\n\n\nclass TensorRTSubgraphPassSoftMaxTest(TensorRTSubgraphPassActivationTest):\n def append_act(self, x):\n return fluid.layers.softmax(x)\n\n\nclass TensorRTSubgraphPassSigmoidTest(TensorRTSubgraphPassActivationTest):\n def append_act(self, x):\n return fluid.layers.sigmoid(x)\n\n\nclass TensorRTSubgraphPassHardSwishTest(TensorRTSubgraphPassActivationTest):\n def append_act(self, x):\n return fluid.layers.hard_swish(x)\n\n\nclass TensorRTSubgraphPassHardSigmoidTest(TensorRTSubgraphPassActivationTest):\n def append_act(self, x):\n return fluid.layers.hard_sigmoid(x)\n\n\nclass TensorRTSubgraphPassHardSwishPluginTest(\n TensorRTSubgraphPassActivationTest):\n def append_act(self, x):\n return fluid.layers.hard_swish(x, threshold=4.0, scale=8.0)\n\n\nclass TensorRTSubgraphPassClipTest(TensorRTSubgraphPassActivationTest):\n def append_act(self, x):\n return fluid.layers.clip(x, 0, 1)\n\n\nclass TensorRTSubgraphPassTanhTest(TensorRTSubgraphPassActivationTest):\n def append_act(self, x):\n return fluid.layers.tanh(x)\n\n\nclass TensorRTSubgraphPassSwishTest(TensorRTSubgraphPassActivationTest):\n def setUpTensorRTParam(self):\n self.enable_trt = True\n self.trt_parameters = TensorRTSubgraphPassActivationTest.TensorRTParam(\n 1 << 30, 32, 0, AnalysisConfig.Precision.Float32, True, False)\n\n def append_act(self, x):\n return fluid.layers.swish(x)\n\n\nclass TensorRTSubgraphPassSwishFp16SerializeTest(\n TensorRTSubgraphPassActivationTest):\n def setUpTensorRTParam(self):\n self.enable_trt = True\n self.trt_parameters = TensorRTSubgraphPassActivationTest.TensorRTParam(\n 1 << 30, 32, 0, AnalysisConfig.Precision.Half, True, False)\n\n def append_act(self, x):\n return fluid.layers.swish(x)\n\n\nclass TensorRTSubgraphPassDynamicSwishFp16SerializeTest(\n TensorRTSubgraphPassActivationTest):\n def setUpTensorRTParam(self):\n self.enable_trt = True\n self.trt_parameters = TensorRTSubgraphPassActivationTest.TensorRTParam(\n 1 << 30, 32, 0, AnalysisConfig.Precision.Half, True, False)\n self.dynamic_shape_params = TensorRTSubgraphPassActivationTest.DynamicShapeParam(\n {\n 'data': [1, 6, 8, 8]\n }, {'data': [1, 6, 512, 512]}, {'data': [1, 6, 256, 256]}, False)\n\n def append_act(self, x):\n return fluid.layers.swish(x)\n\n\nclass TensorRTSubgraphPassPreluAllTest(TensorRTSubgraphPassActivationTest):\n def append_act(self, x):\n return fluid.layers.prelu(x, mode='all')\n\n\nclass TensorRTSubgraphPassPreluChannelTest(TensorRTSubgraphPassActivationTest):\n def append_act(self, x):\n return fluid.layers.prelu(x, mode='channel')\n\n\nclass TensorRTSubgraphPassPreluElementTest(TensorRTSubgraphPassActivationTest):\n def append_act(self, x):\n return fluid.layers.prelu(x, mode='element')\n\n\nclass TensorRTSubgraphPassGeluTest(TensorRTSubgraphPassActivationTest):\n def append_act(self, x):\n return fluid.layers.gelu(x)\n\n\nclass TensorRTSubgraphPassGeluDynamicTest(TensorRTSubgraphPassActivationTest):\n def setUpTensorRTParam(self):\n self.enable_trt = True\n self.trt_parameters = TensorRTSubgraphPassActivationTest.TensorRTParam(\n 1 << 30, 32, 0, AnalysisConfig.Precision.Float32, False, False)\n self.dynamic_shape_params = TensorRTSubgraphPassActivationTest.DynamicShapeParam(\n {\n 'data': [1, 6, 8, 8]\n }, {'data': [1, 6, 512, 512]}, {'data': [1, 6, 256, 256]}, False)\n\n def append_act(self, x):\n return fluid.layers.gelu(x)\n\n\nclass TensorRTSubgraphPassGeluFp16Test(TensorRTSubgraphPassActivationTest):\n def setUpTensorRTParam(self):\n self.enable_trt = True\n self.trt_parameters = TensorRTSubgraphPassActivationTest.TensorRTParam(\n 1 << 30, 32, 0, AnalysisConfig.Precision.Half, False, False)\n\n def append_act(self, x):\n return fluid.layers.gelu(x)\n\n\nclass TensorRTSubgraphPassGeluFp16SerializeTest(\n TensorRTSubgraphPassActivationTest):\n def setUpTensorRTParam(self):\n self.enable_trt = True\n self.trt_parameters = TensorRTSubgraphPassActivationTest.TensorRTParam(\n 1 << 30, 32, 0, AnalysisConfig.Precision.Half, True, False)\n\n def append_act(self, x):\n return fluid.layers.gelu(x)\n\n\nclass TensorRTSubgraphPassGeluFp16DynamicTest(\n TensorRTSubgraphPassActivationTest):\n def setUpTensorRTParam(self):\n self.enable_trt = True\n self.trt_parameters = TensorRTSubgraphPassActivationTest.TensorRTParam(\n 1 << 30, 32, 0, AnalysisConfig.Precision.Half, False, False)\n self.dynamic_shape_params = TensorRTSubgraphPassActivationTest.DynamicShapeParam(\n {\n 'data': [1, 6, 8, 8]\n }, {'data': [1, 6, 512, 512]}, {'data': [1, 6, 256, 256]}, False)\n\n def append_act(self, x):\n return fluid.layers.gelu(x)\n\n\nclass TensorRTSubgraphPassGeluFp16DynamicSerializeTest(\n TensorRTSubgraphPassActivationTest):\n def setUpTensorRTParam(self):\n self.enable_trt = True\n self.trt_parameters = TensorRTSubgraphPassActivationTest.TensorRTParam(\n 1 << 30, 32, 0, AnalysisConfig.Precision.Half, True, False)\n self.dynamic_shape_params = TensorRTSubgraphPassActivationTest.DynamicShapeParam(\n {\n 'data': [1, 6, 8, 8]\n }, {'data': [1, 6, 512, 512]}, {'data': [1, 6, 256, 256]}, False)\n\n def append_act(self, x):\n return fluid.layers.gelu(x)\n\n\nif __name__ == \"__main__\":\n unittest.main()\n"
] | [
[
"numpy.random.random"
]
] |
naveenkambham/big_five_personality_machine_learning | [
"a4d673e7e72287f2448b6a7b2729e5231b4f7ab2"
] | [
"UnitTests/test_battery_sensor_features_extractor.py"
] | [
"\"\"\"\nDeveloper : Naveen Kambham\nDescription: Unit testing for battery sensor feature extractor code. Majority of the data extraction code has to be tested visually by looking at the plots distributions.\n\"\"\"\n#Importing the required libraries.\nimport unittest\nimport numpy as np\nfrom FeatureExtraction import battery_sensor_features_extractor\n\n\n\nclass BatterySensorTestCase(unittest.TestCase):\n \"\"\"\n Tests for battery_sensor_features_extractor.py\n \"\"\"\n def test_TakeMostProbableTimeInStudy(self):\n \"\"\"\n to test the most probable time functionality\n :return:\n \"\"\"\n #case 1 multiple values in each day\n result= battery_sensor_features_extractor.TakeMostProbableTimeInStudy([1,1,1,1,2,2,3,3,3,3,3,3,3,3],[1,2,0])\n self.assertEqual(result,3)\n\n # case 2 only one value in a day\n result = battery_sensor_features_extractor.TakeMostProbableTimeInStudy(\n [1, 1, 1, 1, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3], [1])\n self.assertEqual(result, 4)\n\n # case 3 only one value in a day and it is not exists in the study times so far seen\n result = battery_sensor_features_extractor.TakeMostProbableTimeInStudy(\n [1, 1, 1, 1, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3], [0])\n self.assertEqual(result, 0)\n\n def test_extract(self):\n \"\"\"\n testing the feature extractor code\n :return:\n \"\"\"\n #extracting the features\n df_battery=battery_sensor_features_extractor.extract(r\"/home/naveen/Data/Shed10/Filtered/battery_events.csv\")\n\n # charging should atleast be greater than 0\n self.assertTrue(np.min(df_battery['Battery_Charging_Duration'] >=0))\n self.assertTrue(np.min(df_battery['CharginTimeDaily'] >=0) and np.max(df_battery['CharginTimeDaily'] <=24))\n\n\nif __name__ == '__main__':\n unittest.main()"
] | [
[
"numpy.max",
"numpy.min"
]
] |
KOLANICH/qiskit-terra | [
"3947f258ddb31a2b8dd17aff5d2d041d29d74601"
] | [
"qiskit/quantum_info/operators/measures.py"
] | [
"# This code is part of Qiskit.\n#\n# (C) Copyright IBM 2017.\n#\n# This code is licensed under the Apache License, Version 2.0. You may\n# obtain a copy of this license in the LICENSE.txt file in the root directory\n# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.\n#\n# Any modifications or derivative works of this code must retain this\n# copyright notice, and modified files need to carry a notice indicating\n# that they have been altered from the originals.\n\n# pylint: disable=invalid-name\n\"\"\"\nA collection of useful quantum information functions for operators.\n\"\"\"\n\nimport warnings\nimport numpy as np\nfrom scipy import sparse\n\nfrom qiskit.exceptions import QiskitError\nfrom qiskit.circuit.gate import Gate\nfrom qiskit.quantum_info.operators.base_operator import BaseOperator\nfrom qiskit.quantum_info.operators.operator import Operator\nfrom qiskit.quantum_info.operators.channel.quantum_channel import QuantumChannel\nfrom qiskit.quantum_info.operators.channel import Choi, SuperOp\nfrom qiskit.quantum_info.states.densitymatrix import DensityMatrix\nfrom qiskit.quantum_info.states.measures import state_fidelity\n\ntry:\n import cvxpy\n _HAS_CVX = True\nexcept ImportError:\n _HAS_CVX = False\n\n\ndef process_fidelity(channel,\n target=None,\n require_cp=True,\n require_tp=False):\n r\"\"\"Return the process fidelity of a noisy quantum channel.\n\n\n The process fidelity :math:`F_{\\text{pro}}(\\mathcal{E}, \\methcal{F})`\n between two quantum channels :math:`\\mathcal{E}, \\mathcal{F}` is given by\n\n .. math:\n F_{\\text{pro}}(\\mathcal{E}, \\mathcal{F})\n = F(\\rho_{\\mathcal{E}}, \\rho_{\\mathcal{F}})\n\n where :math:`F` is the :func:`~qiskit.quantum_info.state_fidelity`,\n :math:`\\rho_{\\mathcal{E}} = \\Lambda_{\\mathcal{E}} / d` is the\n normalized :class:`~qiskit.quantum_info.Choi` matrix for the channel\n :math:`\\mathcal{E}`, and :math:`d` is the input dimension of\n :math:`\\mathcal{E}`.\n\n When the target channel is unitary this is equivalent to\n\n .. math::\n F_{\\text{pro}}(\\mathcal{E}, U)\n = \\frac{Tr[S_U^\\dagger S_{\\mathcal{E}}]}{d^2}\n\n where :math:`S_{\\mathcal{E}}, S_{U}` are the\n :class:`~qiskit.quantum_info.SuperOp` matrices for the *input* quantum\n channel :math:`\\mathcal{E}` and *target* unitary :math:`U` respectively,\n and :math:`d` is the input dimension of the channel.\n\n Args:\n channel (Operator or QuantumChannel): input quantum channel.\n target (Operator or QuantumChannel or None): target quantum channel.\n If `None` target is the identity operator [Default: None].\n require_cp (bool): require channel to be completely-positive\n [Default: True].\n require_tp (bool): require channel to be trace-preserving\n [Default: False].\n\n Returns:\n float: The process fidelity :math:`F_{\\text{pro}}`.\n\n Raises:\n QiskitError: if the channel and target do not have the same dimensions.\n QiskitError: if the channel and target are not completely-positive\n (with ``require_cp=True``) or not trace-preserving\n (with ``require_tp=True``).\n \"\"\"\n # Format inputs\n channel = _input_formatter(\n channel, SuperOp, 'process_fidelity', 'channel')\n target = _input_formatter(\n target, Operator, 'process_fidelity', 'target')\n\n if target:\n # Validate dimensions\n if channel.dim != target.dim:\n raise QiskitError(\n 'Input quantum channel and target unitary must have the same '\n 'dimensions ({} != {}).'.format(channel.dim, target.dim))\n\n # Validate complete-positivity and trace-preserving\n for label, chan in [('Input', channel), ('Target', target)]:\n if isinstance(chan, Operator) and (require_cp or require_tp):\n is_unitary = chan.is_unitary()\n # Validate as unitary\n if require_cp and not is_unitary:\n raise QiskitError('{} channel is not completely-positive'.format(label))\n if require_tp and not is_unitary:\n raise QiskitError('{} channel is not trace-preserving'.format(label))\n elif chan is not None:\n # Validate as QuantumChannel\n if require_cp and not chan.is_cp():\n raise QiskitError('{} channel is not completely-positive'.format(label))\n if require_tp and not chan.is_tp():\n raise QiskitError('{} channel is not trace-preserving'.format(label))\n\n if isinstance(target, Operator):\n # Compute fidelity with unitary target by applying the inverse\n # to channel and computing fidelity with the identity\n channel = channel @ target.adjoint()\n target = None\n\n input_dim, _ = channel.dim\n if target is None:\n # Compute process fidelity with identity channel\n if isinstance(channel, Operator):\n # |Tr[U]/dim| ** 2\n fid = np.abs(np.trace(channel.data) / input_dim)**2\n else:\n # Tr[S] / (dim ** 2)\n fid = np.trace(SuperOp(channel).data) / (input_dim**2)\n return float(np.real(fid))\n\n # For comparing two non-unitary channels we compute the state fidelity of\n # the normalized Choi-matrices. This is equivalent to the previous definition\n # when the target is a unitary channel.\n state1 = DensityMatrix(Choi(channel).data / input_dim)\n state2 = DensityMatrix(Choi(target).data / input_dim)\n return state_fidelity(state1, state2, validate=False)\n\n\ndef average_gate_fidelity(channel,\n target=None,\n require_cp=True,\n require_tp=False):\n r\"\"\"Return the average gate fidelity of a noisy quantum channel.\n\n The average gate fidelity :math:`F_{\\text{ave}}` is given by\n\n .. math::\n F_{\\text{ave}}(\\mathcal{E}, U)\n &= \\int d\\psi \\langle\\psi|U^\\dagger\n \\mathcal{E}(|\\psi\\rangle\\!\\langle\\psi|)U|\\psi\\rangle \\\\\n &= \\frac{d F_{\\text{pro}}(\\mathcal{E}, U) + 1}{d + 1}\n\n where :math:`F_{\\text{pro}}(\\mathcal{E}, U)` is the\n :meth:`~qiskit.quantum_info.process_fidelity` of the input quantum\n *channel* :math:`\\mathcal{E}` with a *target* unitary :math:`U`, and\n :math:`d` is the dimension of the *channel*.\n\n Args:\n channel (QuantumChannel or Operator): noisy quantum channel.\n target (Operator or None): target unitary operator.\n If `None` target is the identity operator [Default: None].\n require_cp (bool): require channel to be completely-positive\n [Default: True].\n require_tp (bool): require channel to be trace-preserving\n [Default: False].\n\n Returns:\n float: The average gate fidelity :math:`F_{\\text{ave}}`.\n\n Raises:\n QiskitError: if the channel and target do not have the same dimensions,\n or have different input and output dimensions.\n QiskitError: if the channel and target or are not completely-positive\n (with ``require_cp=True``) or not trace-preserving\n (with ``require_tp=True``).\n \"\"\"\n # Format inputs\n channel = _input_formatter(\n channel, SuperOp, 'average_gate_fidelity', 'channel')\n target = _input_formatter(\n target, Operator, 'average_gate_fidelity', 'target')\n\n if target is not None:\n try:\n target = Operator(target)\n except QiskitError:\n raise QiskitError(\n 'Target channel is not a unitary channel. To compare '\n 'two non-unitary channels use the '\n '`qiskit.quantum_info.process_fidelity` function instead.')\n dim, _ = channel.dim\n f_pro = process_fidelity(channel,\n target=target,\n require_cp=require_cp,\n require_tp=require_tp)\n return (dim * f_pro + 1) / (dim + 1)\n\n\ndef gate_error(channel, target=None, require_cp=True, require_tp=False):\n r\"\"\"Return the gate error of a noisy quantum channel.\n\n The gate error :math:`E` is given by the average gate infidelity\n\n .. math::\n E(\\mathcal{E}, U) = 1 - F_{\\text{ave}}(\\mathcal{E}, U)\n\n where :math:`F_{\\text{ave}}(\\mathcal{E}, U)` is the\n :meth:`~qiskit.quantum_info.average_gate_fidelity` of the input\n quantum *channel* :math:`\\mathcal{E}` with a *target* unitary\n :math:`U`.\n\n Args:\n channel (QuantumChannel): noisy quantum channel.\n target (Operator or None): target unitary operator.\n If `None` target is the identity operator [Default: None].\n require_cp (bool): require channel to be completely-positive\n [Default: True].\n require_tp (bool): require channel to be trace-preserving\n [Default: False].\n\n Returns:\n float: The average gate error :math:`E`.\n\n Raises:\n QiskitError: if the channel and target do not have the same dimensions,\n or have different input and output dimensions.\n QiskitError: if the channel and target or are not completely-positive\n (with ``require_cp=True``) or not trace-preserving\n (with ``require_tp=True``).\n \"\"\"\n # Format inputs\n channel = _input_formatter(\n channel, SuperOp, 'gate_error', 'channel')\n target = _input_formatter(\n target, Operator, 'gate_error', 'target')\n return 1 - average_gate_fidelity(\n channel, target=target, require_cp=require_cp, require_tp=require_tp)\n\n\ndef diamond_norm(choi, **kwargs):\n r\"\"\"Return the diamond norm of the input quantum channel object.\n\n This function computes the completely-bounded trace-norm (often\n referred to as the diamond-norm) of the input quantum channel object\n using the semidefinite-program from reference [1].\n\n Args:\n choi(Choi or QuantumChannel): a quantum channel object or\n Choi-matrix array.\n kwargs: optional arguments to pass to CVXPY solver.\n\n Returns:\n float: The completely-bounded trace norm\n :math:`\\|\\mathcal{E}\\|_{\\diamond}`.\n\n Raises:\n QiskitError: if CVXPY package cannot be found.\n\n Additional Information:\n The input to this function is typically *not* a CPTP quantum\n channel, but rather the *difference* between two quantum channels\n :math:`\\|\\Delta\\mathcal{E}\\|_\\diamond` where\n :math:`\\Delta\\mathcal{E} = \\mathcal{E}_1 - \\mathcal{E}_2`.\n\n Reference:\n J. Watrous. \"Simpler semidefinite programs for completely bounded\n norms\", arXiv:1207.5726 [quant-ph] (2012).\n\n .. note::\n\n This function requires the optional CVXPY package to be installed.\n Any additional kwargs will be passed to the ``cvxpy.solve``\n function. See the CVXPY documentation for information on available\n SDP solvers.\n \"\"\"\n _cvxpy_check('`diamond_norm`') # Check CVXPY is installed\n\n choi = Choi(_input_formatter(choi, Choi, 'diamond_norm', 'choi'))\n\n def cvx_bmat(mat_r, mat_i):\n \"\"\"Block matrix for embedding complex matrix in reals\"\"\"\n return cvxpy.bmat([[mat_r, -mat_i], [mat_i, mat_r]])\n\n # Dimension of input and output spaces\n dim_in = choi._input_dim\n dim_out = choi._output_dim\n size = dim_in * dim_out\n\n # SDP Variables to convert to real valued problem\n r0_r = cvxpy.Variable((dim_in, dim_in))\n r0_i = cvxpy.Variable((dim_in, dim_in))\n r0 = cvx_bmat(r0_r, r0_i)\n\n r1_r = cvxpy.Variable((dim_in, dim_in))\n r1_i = cvxpy.Variable((dim_in, dim_in))\n r1 = cvx_bmat(r1_r, r1_i)\n\n x_r = cvxpy.Variable((size, size))\n x_i = cvxpy.Variable((size, size))\n iden = sparse.eye(dim_out)\n\n # Watrous uses row-vec convention for his Choi matrix while we use\n # col-vec. It turns out row-vec convention is requried for CVXPY too\n # since the cvxpy.kron function must have a constant as its first argument.\n c_r = cvxpy.bmat([[cvxpy.kron(iden, r0_r), x_r], [x_r.T, cvxpy.kron(iden, r1_r)]])\n c_i = cvxpy.bmat([[cvxpy.kron(iden, r0_i), x_i], [-x_i.T, cvxpy.kron(iden, r1_i)]])\n c = cvx_bmat(c_r, c_i)\n\n # Convert col-vec convention Choi-matrix to row-vec convention and\n # then take Transpose: Choi_C -> Choi_R.T\n choi_rt = np.transpose(\n np.reshape(choi.data, (dim_in, dim_out, dim_in, dim_out)),\n (3, 2, 1, 0)).reshape(choi.data.shape)\n choi_rt_r = choi_rt.real\n choi_rt_i = choi_rt.imag\n\n # Constraints\n cons = [\n r0 >> 0, r0_r == r0_r.T, r0_i == - r0_i.T, cvxpy.trace(r0_r) == 1,\n r1 >> 0, r1_r == r1_r.T, r1_i == - r1_i.T, cvxpy.trace(r1_r) == 1,\n c >> 0\n ]\n\n # Objective function\n obj = cvxpy.Maximize(cvxpy.trace(choi_rt_r @ x_r) + cvxpy.trace(choi_rt_i @ x_i))\n prob = cvxpy.Problem(obj, cons)\n sol = prob.solve(**kwargs)\n return sol\n\n\ndef _cvxpy_check(name):\n \"\"\"Check that a supported CVXPY version is installed\"\"\"\n # Check if CVXPY package is installed\n if not _HAS_CVX:\n raise QiskitError(\n 'CVXPY backage is requried for {}. Install'\n ' with `pip install cvxpy` to use.'.format(name))\n # Check CVXPY version\n version = cvxpy.__version__\n if version[0] != '1':\n raise ImportError(\n 'Incompatible CVXPY version {} found.'\n ' Install version >=1.0.'.format(version))\n\n\n# pylint: disable=too-many-return-statements\ndef _input_formatter(obj, fallback_class, func_name, arg_name):\n \"\"\"Formatting function for input conversion\"\"\"\n # Empty input\n if obj is None:\n return obj\n\n # Channel-like input\n if isinstance(obj, QuantumChannel):\n return obj\n if hasattr(obj, 'to_quantumchannel'):\n return obj.to_quantumchannel()\n if hasattr(obj, 'to_channel'):\n return obj.to_channel()\n\n # Unitary-like input\n if isinstance(obj, (Gate, BaseOperator)):\n return Operator(obj)\n if hasattr(obj, 'to_operator'):\n return obj.to_operator()\n\n warnings.warn(\n 'Passing in a list or Numpy array to `{}` `{}` argument is '\n 'deprecated as of 0.17.0 since the matrix representation cannot be inferred '\n 'unambiguously. Use a Gate or BaseOperator subclass (eg. Operator, '\n 'SuperOp, Choi) object instead.'.format(func_name, arg_name),\n DeprecationWarning)\n warnings.warn(\n 'Treating array input as a {} object'.format(fallback_class.__name__))\n return fallback_class(obj)\n"
] | [
[
"numpy.reshape",
"numpy.trace",
"numpy.real",
"scipy.sparse.eye"
]
] |
noenfugler/jesse | [
"217a3168620a755c1a9576d9deb27105db7dccf8",
"217a3168620a755c1a9576d9deb27105db7dccf8",
"217a3168620a755c1a9576d9deb27105db7dccf8",
"217a3168620a755c1a9576d9deb27105db7dccf8"
] | [
"jesse/indicators/supersmoother.py",
"jesse/indicators/sinwma.py",
"jesse/indicators/damiani_volatmeter.py",
"jesse/indicators/alligator.py"
] | [
"from typing import Union\n\nimport numpy as np\nfrom numba import njit\n\nfrom jesse.helpers import get_candle_source, slice_candles\n\n\ndef supersmoother(candles: np.ndarray, period: int = 14, source_type: str = \"close\", sequential: bool = False) -> Union[\n float, np.ndarray]:\n \"\"\"\n Super Smoother Filter 2pole Butterworth\n This indicator was described by John F. Ehlers\n\n :param candles: np.ndarray\n :param period: int - default=14\n :param source_type: str - default: \"close\"\n :param sequential: bool - default=False\n\n :return: float | np.ndarray\n \"\"\"\n\n candles = slice_candles(candles, sequential)\n\n # Accept normal array too.\n if len(candles.shape) == 1:\n source = candles\n else:\n source = get_candle_source(candles, source_type=source_type)\n\n res = supersmoother_fast(source, period)\n\n return res if sequential else res[-1]\n\n\n@njit\ndef supersmoother_fast(source, period):\n a = np.exp(-1.414 * np.pi / period)\n b = 2 * a * np.cos(1.414 * np.pi / period)\n newseries = np.copy(source)\n for i in range(2, source.shape[0]):\n newseries[i] = (1 + a ** 2 - b) / 2 * (source[i] + source[i - 1]) \\\n + b * newseries[i - 1] - a ** 2 * newseries[i - 2]\n return newseries\n",
"from typing import Union\n\nimport numpy as np\nfrom numpy.lib.stride_tricks import sliding_window_view\n\nfrom jesse.helpers import get_candle_source, slice_candles, same_length\n\n\ndef sinwma(candles: np.ndarray, period: int = 14, source_type: str = \"close\", sequential: bool = False) -> Union[\n float, np.ndarray]:\n \"\"\"\n Sine Weighted Moving Average (SINWMA)\n\n :param candles: np.ndarray\n :param period: int - default: 14\n :param source_type: str - default: \"close\"\n :param sequential: bool - default=False\n\n :return: float | np.ndarray\n \"\"\"\n candles = slice_candles(candles, sequential)\n\n source = get_candle_source(candles, source_type=source_type)\n sines = np.array([np.sin((i + 1) * np.pi / (period + 1)) for i in range(0, period)])\n w = sines / sines.sum()\n swv = sliding_window_view(source, window_shape=period)\n res = np.average(swv, weights=w, axis=-1)\n\n return same_length(candles, res) if sequential else res[-1]\n",
"from collections import namedtuple\n\nimport numpy as np\nimport talib\nfrom numba import njit\n\nfrom jesse.helpers import get_candle_source\nfrom jesse.helpers import slice_candles\n\nDamianiVolatmeter = namedtuple('DamianiVolatmeter', ['vol', 'anti'])\n\n\ndef damiani_volatmeter(candles: np.ndarray, vis_atr: int = 13, vis_std: int = 20, sed_atr: int = 40, sed_std: int = 100,\n threshold: float = 1.4, source_type: str = \"close\",\n sequential: bool = False) -> DamianiVolatmeter:\n \"\"\"\n Damiani Volatmeter\n\n :param candles: np.ndarray\n :param vis_atr: int - default=13\n :param vis_std: int - default=20\n :param sed_atr: int - default=40\n :param sed_std: int - default=100\n :param threshold: float - default=1.4\n :param source_type: str - default: \"close\"\n :param sequential: bool - default=False\n\n :return: float | np.ndarray\n \"\"\"\n\n candles = slice_candles(candles, sequential)\n\n source = get_candle_source(candles, source_type=source_type)\n\n atrvis = talib.ATR(candles[:, 3], candles[:, 4], candles[:, 2], timeperiod=vis_atr)\n atrsed = talib.ATR(candles[:, 3], candles[:, 4], candles[:, 2], timeperiod=sed_atr)\n\n vol, t = damiani_volatmeter_fast(source, sed_std, atrvis, atrsed, vis_std, threshold)\n\n if sequential:\n return DamianiVolatmeter(vol, t)\n else:\n return DamianiVolatmeter(vol[-1], t[-1])\n\n\n@njit\ndef damiani_volatmeter_fast(source, sed_std, atrvis, atrsed, vis_std,\n threshold): # Function is compiled to machine code when called the first time\n lag_s = 0.5\n\n vol = np.full_like(source, 0)\n t = np.full_like(source, 0)\n for i in range(source.shape[0]):\n if not (i < sed_std):\n vol[i] = atrvis[i] / atrsed[i] + lag_s * (vol[i - 1] - vol[i - 3])\n anti_thres = np.std(source[i - vis_std:i]) / np.std(source[i - sed_std:i])\n t[i] = threshold - anti_thres\n return vol, t\n",
"from collections import namedtuple\n\nimport numpy as np\n\nfrom jesse.helpers import get_candle_source, np_shift, slice_candles\n\nAG = namedtuple('AG', ['jaw', 'teeth', 'lips'])\n\n\ndef alligator(candles: np.ndarray, source_type: str = \"close\", sequential: bool = False) -> AG:\n \"\"\"\n Alligator\n\n :param candles: np.ndarray\n :param source_type: str - default: \"close\"\n :param sequential: bool - default=False\n\n :return: AG(jaw, teeth, lips)\n \"\"\"\n candles = slice_candles(candles, sequential)\n\n source = get_candle_source(candles, source_type=source_type)\n\n jaw = np_shift(numpy_ewma(source, 13), 8, fill_value=np.nan)\n teeth = np_shift(numpy_ewma(source, 8), 5, fill_value=np.nan)\n lips = np_shift(numpy_ewma(source, 5), 3, fill_value=np.nan)\n\n if sequential:\n return AG(jaw, teeth, lips)\n else:\n return AG(jaw[-1], teeth[-1], lips[-1])\n\n\ndef numpy_ewma(data: np.ndarray, window: int):\n \"\"\"\n\n :param data:\n :param window:\n :return:\n \"\"\"\n alpha = 1 / window\n scale = 1 / (1 - alpha)\n n = data.shape[0]\n scale_arr = (1 - alpha) ** (-1 * np.arange(n))\n weights = (1 - alpha) ** np.arange(n)\n pw0 = (1 - alpha) ** (n - 1)\n mult = data * pw0 * scale_arr\n cumsums = mult.cumsum()\n out = cumsums * scale_arr[::-1] / weights.cumsum()\n\n return out\n"
] | [
[
"numpy.copy",
"numpy.exp",
"numpy.cos"
],
[
"numpy.average",
"numpy.sin",
"numpy.lib.stride_tricks.sliding_window_view"
],
[
"numpy.std",
"numpy.full_like"
],
[
"numpy.arange"
]
] |
WeilerP/cellrank | [
"c8c2b9f6bd2448861fb414435aee7620ca5a0bad"
] | [
"cellrank/pl/_circular_projection.py"
] | [
"from typing import Any, Tuple, Union, Mapping, Callable, Optional, Sequence\nfrom typing_extensions import Literal\n\nfrom enum import auto\nfrom types import MappingProxyType\nfrom pathlib import Path\n\nimport scvelo as scv\nfrom anndata import AnnData\nfrom cellrank import logging as logg\nfrom cellrank.tl import Lineage\nfrom cellrank._key import Key\nfrom scanpy._utils import deprecated_arg_names\nfrom cellrank.tl._enum import ModeEnum\nfrom cellrank.ul._docs import d\nfrom cellrank.pl._utils import _held_karp\nfrom cellrank.tl._utils import save_fig, _unique_order_preserving\nfrom cellrank.ul._utils import _check_collection\nfrom cellrank.tl._lineage import PrimingDegree\n\nimport numpy as np\nimport pandas as pd\nfrom sklearn.metrics import pairwise_distances\n\nimport matplotlib.pyplot as plt\nfrom matplotlib.colors import LogNorm, LinearSegmentedColormap\nfrom matplotlib.collections import LineCollection\n\n\nclass LineageOrder(ModeEnum): # noqa: D101\n DEFAULT = auto()\n OPTIMAL = auto()\n\n\nclass LabelRot(ModeEnum): # noqa: D101\n DEFAULT = auto()\n BEST = auto()\n\n\nMetric_T = Union[str, Callable, np.ndarray, pd.DataFrame]\n_N = 200\n\n\ndef _get_distances(data: Union[np.ndarray, Lineage], metric: Metric_T) -> np.ndarray:\n if isinstance(data, Lineage):\n data = data.X\n\n if isinstance(metric, str) or callable(metric):\n metric = pairwise_distances(data.T, metric=metric)\n elif isinstance(metric, (pd.DataFrame, np.ndarray)):\n shape = (data.shape[1], data.shape[1])\n if metric.shape != shape:\n raise ValueError(\n f\"Expected an `numpy.array` or `pandas.DataFrame` of shape `{shape}`, found `{metric.shape}`.\"\n )\n else:\n raise TypeError(\n f\"Expected either metric defined by `str`, `callable` or a pairwise distance matrix of type\"\n f\" `numpy.ndarray` or `pandas.DataFrame`, found `{type(metric).__name__}`.\"\n )\n\n return np.asarray(metric, dtype=np.float64)\n\n\ndef _get_optimal_order(data: Lineage, metric: Metric_T) -> Tuple[float, np.ndarray]:\n \"\"\"Solve the TSP using dynamic programming.\"\"\"\n return _held_karp(_get_distances(data, metric))\n\n\[email protected]\n@deprecated_arg_names({\"labeldistance\": \"label_distance\", \"labelrot\": \"label_rot\"})\ndef circular_projection(\n adata: AnnData,\n keys: Union[str, Sequence[str]],\n backward: bool = False,\n lineages: Optional[Union[str, Sequence[str]]] = None,\n early_cells: Optional[Union[Mapping[str, Sequence[str]], Sequence[str]]] = None,\n lineage_order: Optional[Literal[\"default\", \"optimal\"]] = None,\n metric: Union[str, Callable, np.ndarray, pd.DataFrame] = \"correlation\",\n normalize_by_mean: bool = True,\n ncols: int = 4,\n space: float = 0.25,\n use_raw: bool = False,\n text_kwargs: Mapping[str, Any] = MappingProxyType({}),\n label_distance: float = 1.25,\n label_rot: Union[Literal[\"default\", \"best\"], float] = \"best\",\n show_edges: bool = True,\n key_added: Optional[str] = None,\n figsize: Optional[Tuple[float, float]] = None,\n dpi: Optional[int] = None,\n save: Optional[Union[str, Path]] = None,\n **kwargs: Any,\n):\n r\"\"\"\n Plot absorption probabilities on a circular embedding as in :cite:`velten:17`.\n\n Parameters\n ----------\n %(adata)s\n keys\n Keys in :attr:`anndata.AnnData.obs` or :attr:`anndata.AnnData.var_names`. Additional keys are:\n\n - `'kl_divergence'` - as in :cite:`velten:17`, computes KL-divergence between the fate probabilities\n of a cell and the average fate probabilities. See ``early_cells`` for more information.\n - `'entropy'` - as in :cite:`setty:19`, computes entropy over a cells fate probabilities.\n\n %(backward)s\n lineages\n Lineages to plot. If `None`, plot all lineages.\n early_cells\n Cell ids or a mask marking early cells used to define the average fate probabilities. If `None`, use all cells.\n Only used when `'kl_divergence'` is in ``keys``. If a :class:`dict`, key specifies a cluster key in\n :attr:`anndata.AnnData.obs` and the values specify cluster labels containing early cells.\n lineage_order\n Can be one of the following:\n\n - `None` - it will determined automatically, based on the number of lineages.\n - `'optimal'` - order lineages optimally by solving the Travelling salesman problem (TSP).\n Recommended for <= `20` lineages.\n - `'default'` - use the order as specified by ``lineages``.\n\n metric\n Metric to use when constructing pairwise distance matrix when ``lineage_order = 'optimal'``. For available\n options, see :func:`sklearn.metrics.pairwise_distances`.\n normalize_by_mean\n If `True`, normalize each lineage by its mean probability, as done in :cite:`velten:17`.\n ncols\n Number of columns when plotting multiple ``keys``.\n space\n Horizontal and vertical space between for :func:`matplotlib.pyplot.subplots_adjust`.\n use_raw\n Whether to access :attr:`anndata.AnnData.raw` when there are ``keys`` in :attr:`anndata.AnnData.var_names`.\n text_kwargs\n Keyword arguments for :func:`matplotlib.pyplot.text`.\n label_distance\n Distance at which the lineage labels will be drawn.\n label_rot\n How to rotate the labels. Valid options are:\n\n - `'best'` - rotate labels so that they are easily readable.\n - `'default'` - use :mod:`matplotlib`'s default.\n - `None` - same as `'default'`.\n\n If a :class:`float`, all labels will be rotated by this many degrees.\n show_edges\n Whether to show the edges surrounding the simplex.\n key_added\n Key in :attr:`anndata.AnnData.obsm` where to add the circular embedding. If `None`, it will be set to\n `'X_fate_simplex_{fwd,bwd}'`, based on ``backward``.\n %(plotting)s\n kwargs\n Keyword arguments for :func:`scvelo.pl.scatter`.\n\n Returns\n -------\n %(just_plots)s\n Also updates ``adata`` with the following fields:\n\n - :attr:`anndata.AnnData.obsm` ``['{key_added}']`` - the circular projection.\n - :attr:`anndata.AnnData.obs` ``['to_{initial,terminal}_states_{method}']`` - the priming degree,\n if a method is present in ``keys``.\n \"\"\"\n if label_distance is not None and label_distance < 0:\n raise ValueError(\n f\"Expected `label_distance` to be positive, found `{label_distance}`.\"\n )\n\n if label_rot is None:\n label_rot = LabelRot.DEFAULT\n label_rot = LabelRot(label_rot)\n\n suffix = \"bwd\" if backward else \"fwd\"\n if key_added is None:\n key_added = \"X_fate_simplex_\" + suffix\n\n if isinstance(keys, str):\n keys = (keys,)\n\n keys = _unique_order_preserving(keys)\n keys_ = _check_collection(\n adata, keys, \"obs\", key_name=\"Observation\", raise_exc=False\n ) + _check_collection(\n adata, keys, \"var_names\", key_name=\"Gene\", raise_exc=False, use_raw=use_raw\n )\n haystack = set(PrimingDegree)\n keys = keys_ + [k for k in keys if k in haystack]\n keys = _unique_order_preserving(keys)\n\n if not len(keys):\n raise ValueError(\"No valid keys have been selected.\")\n\n lineage_key = Key.obsm.abs_probs(backward)\n if lineage_key not in adata.obsm:\n raise KeyError(f\"Lineages key `{lineage_key!r}` not found in `adata.obsm`.\")\n\n probs: Lineage = adata.obsm[lineage_key]\n\n if isinstance(lineages, str):\n lineages = (lineages,)\n elif lineages is None:\n lineages = probs.names\n\n probs = adata.obsm[lineage_key][lineages]\n n_lin = probs.shape[1]\n if n_lin < 3:\n raise ValueError(f\"Expected at least `3` lineages, found `{n_lin}`.\")\n\n X = probs.X.copy()\n if normalize_by_mean:\n X /= np.mean(X, axis=0)[None, :]\n X /= X.sum(1)[:, None]\n # this happens when cells for sel. lineages sum to 1 (or when the lineage average is 0, which is unlikely)\n X = np.nan_to_num(X, nan=1.0 / n_lin, copy=False)\n\n if lineage_order is None:\n lineage_order = (\n LineageOrder.OPTIMAL if 3 < n_lin <= 20 else LineageOrder.DEFAULT\n )\n logg.debug(f\"Set ordering to `{lineage_order}`\")\n lineage_order = LineageOrder(lineage_order)\n\n if lineage_order == LineageOrder.OPTIMAL:\n logg.info(f\"Solving TSP for `{n_lin}` states\")\n _, order = _get_optimal_order(X, metric=metric)\n else:\n order = np.arange(n_lin)\n\n probs = probs[:, order]\n X = X[:, order]\n\n angle_vec = np.linspace(0, 2 * np.pi, n_lin, endpoint=False)\n angle_vec_sin = np.cos(angle_vec)\n angle_vec_cos = np.sin(angle_vec)\n\n x = np.sum(X * angle_vec_sin, axis=1)\n y = np.sum(X * angle_vec_cos, axis=1)\n adata.obsm[key_added] = np.c_[x, y]\n\n nrows = int(np.ceil(len(keys) / ncols))\n fig, ax = plt.subplots(\n nrows=nrows,\n ncols=ncols,\n figsize=(ncols * 5, nrows * 5) if figsize is None else figsize,\n dpi=dpi,\n )\n\n fig.subplots_adjust(wspace=space, hspace=space)\n axes = np.ravel([ax])\n\n text_kwargs = dict(text_kwargs)\n text_kwargs[\"ha\"] = \"center\"\n text_kwargs[\"va\"] = \"center\"\n\n _i = 0\n for _i, (k, ax) in enumerate(zip(keys, axes)):\n\n set_lognorm, colorbar = False, kwargs.pop(\"colorbar\", True)\n try:\n _ = PrimingDegree(k)\n logg.debug(f\"Calculating priming degree using `method={k}`\")\n val = probs.priming_degree(method=k, early_cells=early_cells)\n k = f\"{lineage_key}_{k}\"\n adata.obs[k] = val\n except ValueError:\n pass\n\n scv.pl.scatter(\n adata,\n basis=key_added,\n color=k,\n show=False,\n ax=ax,\n use_raw=use_raw,\n norm=LogNorm() if set_lognorm else None,\n colorbar=colorbar,\n **kwargs,\n )\n if colorbar and set_lognorm:\n cbar = ax.collections[0].colorbar\n cax = cbar.locator.axis\n ticks = cax.minor.locator.tick_values(cbar.vmin, cbar.vmax)\n ticks = [ticks[0], ticks[len(ticks) // 2 + 1], ticks[-1]]\n cbar.set_ticks(ticks)\n cbar.set_ticklabels([f\"{t:.2f}\" for t in ticks])\n cbar.update_ticks()\n\n patches, texts = ax.pie(\n np.ones_like(angle_vec),\n labeldistance=label_distance,\n rotatelabels=True,\n labels=probs.names[::-1],\n startangle=-360 / len(angle_vec) / 2,\n counterclock=False,\n textprops=text_kwargs,\n )\n\n for patch in patches:\n patch.set_visible(False)\n\n # clockwise\n for color, text in zip(probs.colors[::-1], texts):\n if isinstance(label_rot, (int, float)):\n text.set_rotation(label_rot)\n elif label_rot == LabelRot.BEST:\n rot = text.get_rotation()\n text.set_rotation(rot + 90 + (1 - rot // 180) * 180)\n elif label_rot != LabelRot.DEFAULT:\n raise NotImplementedError(\n f\"Label rotation `{label_rot}` is not yet implemented.\"\n )\n text.set_color(color)\n\n if not show_edges:\n continue\n\n for i, color in enumerate(probs.colors):\n next = (i + 1) % n_lin\n x = 1.04 * np.linspace(angle_vec_sin[i], angle_vec_sin[next], _N)\n y = 1.04 * np.linspace(angle_vec_cos[i], angle_vec_cos[next], _N)\n points = np.array([x, y]).T.reshape(-1, 1, 2)\n segments = np.concatenate([points[:-1], points[1:]], axis=1)\n\n cmap = LinearSegmentedColormap.from_list(\n \"abs_prob_cmap\", [color, probs.colors[next]], N=_N\n )\n lc = LineCollection(segments, cmap=cmap, zorder=-1)\n lc.set_array(np.linspace(0, 1, _N))\n lc.set_linewidth(2)\n ax.add_collection(lc)\n\n for j in range(_i + 1, len(axes)):\n axes[j].remove()\n\n if save is not None:\n save_fig(fig, save)\n"
] | [
[
"numpy.concatenate",
"numpy.sin",
"numpy.ones_like",
"numpy.nan_to_num",
"numpy.asarray",
"numpy.array",
"numpy.sum",
"matplotlib.pyplot.subplots",
"numpy.mean",
"sklearn.metrics.pairwise_distances",
"matplotlib.collections.LineCollection",
"numpy.ravel",
"numpy.arange",
"numpy.cos",
"numpy.linspace",
"matplotlib.colors.LogNorm",
"matplotlib.colors.LinearSegmentedColormap.from_list"
]
] |
blnm/RSE | [
"6a3f0dd858ea4b6dafcfb1d97bb979e101d9911c"
] | [
"RAdam.py"
] | [
"import tensorflow as tf\r\nfrom tensorflow.python.eager import context\r\nfrom tensorflow.python.framework import ops\r\nfrom tensorflow.python.ops import clip_ops\r\nfrom tensorflow.python.ops import control_flow_ops\r\nfrom tensorflow.python.ops import math_ops\r\nfrom tensorflow.python.ops import resource_variable_ops\r\nfrom tensorflow.python.ops import state_ops\r\nfrom tensorflow.python.training import optimizer\r\n\r\n__all__ = ['RAdamOptimizer']\r\n\r\n\r\nclass RAdamOptimizer(optimizer.Optimizer):\r\n \"\"\"RAdam optimizer.\r\n\r\n According to the paper\r\n [On The Variance Of The Adaptive Learning Rate And Beyond](https://arxiv.org/pdf/1908.03265v1.pdf).\r\n \"\"\"\r\n\r\n def __init__(self,\r\n learning_rate=0.001,\r\n beta1=0.9,\r\n beta2=0.999,\r\n epsilon=1e-7,\r\n L2_decay=0.,\r\n amsgrad=False,\r\n total_steps=0,\r\n warmup_proportion=0.1,\r\n min_lr=0.,\r\n use_locking=False,\r\n name=\"RAdam\",\r\n decay_vars=None,\r\n L1_decay=0.0,\r\n clip_gradients=False, clip_multiplier=3.0, clip_epsilon=1e-2):\r\n r\"\"\"Construct a new Adam optimizer.\r\n\r\n Args:\r\n learning_rate: A Tensor or a floating point value. The learning rate.\r\n beta1: A float value or a constant float tensor. The exponential decay\r\n rate for the 1st moment estimates.\r\n beta2: A float value or a constant float tensor. The exponential decay\r\n rate for the 2nd moment estimates.\r\n epsilon: A small constant for numerical stability. This epsilon is\r\n \"epsilon hat\" in the Kingma and Ba paper (in the formula just before\r\n Section 2.1), not the epsilon in Algorithm 1 of the paper.\r\n L2_decay: A floating point value. Weight decay for each param.\r\n amsgrad: boolean. Whether to apply AMSGrad variant of this algorithm from\r\n the paper \"On the Convergence of Adam and beyond\".\r\n total_steps: An integer. Total number of training steps.\r\n Enable warmup by setting a positive value.\r\n warmup_proportion: A floating point value. The proportion of increasing steps.\r\n min_lr: A floating point value. Minimum learning rate after warmup.\r\n name: Optional name for the operations created when applying gradients.\r\n Defaults to \"Adam\". @compatibility(eager) When eager execution is\r\n enabled, `learning_rate`, `beta_1`, `beta_2`, and `epsilon` can each be\r\n a callable that takes no arguments and returns the actual value to use.\r\n This can be useful for changing these values across different\r\n invocations of optimizer functions. @end_compatibility\r\n **kwargs: keyword arguments. Allowed to be {`clipnorm`, `clipvalue`, `lr`,\r\n `decay`}. `clipnorm` is clip gradients by norm; `clipvalue` is clip\r\n gradients by value, `decay` is included for backward compatibility to\r\n allow time inverse decay of learning rate. `lr` is included for backward\r\n compatibility, recommended to use `learning_rate` instead.\r\n \"\"\"\r\n super(RAdamOptimizer, self).__init__(use_locking, name)\r\n self._lr = learning_rate\r\n self._beta1 = beta1\r\n self._beta2 = beta2\r\n self._epsilon = epsilon\r\n self._weight_decay = L2_decay\r\n self._L1_decay = L1_decay\r\n self._amsgrad = amsgrad\r\n self._total_steps = float(total_steps)\r\n self._warmup_proportion = warmup_proportion\r\n self._min_lr = min_lr\r\n self._initial_weight_decay = L2_decay\r\n self._initial_total_steps = total_steps\r\n self.clip_multiplier = clip_multiplier\r\n self.clip_epsilon = clip_epsilon\r\n self.clip_gradients = clip_gradients\r\n self.clip_multiplier_t = ops.convert_to_tensor(self.clip_multiplier, name=\"clip_multiplier\")\r\n self.clip_epsilon_t = ops.convert_to_tensor(self.clip_epsilon, name=\"clip_epsilon\")\r\n\r\n self._lr_t = None\r\n self._step_t = None\r\n self._beta1_t = None\r\n self._beta2_t = None\r\n self._epsilon_t = None\r\n self._weight_decay_t = None\r\n self._total_steps_t = None\r\n self._warmup_proportion_t = None\r\n self._min_lr_t = None\r\n self.reg_vars = set(decay_vars) if decay_vars is not None else set()\r\n\r\n def _get_beta_accumulators(self):\r\n with ops.init_scope():\r\n if context.executing_eagerly():\r\n graph = None\r\n else:\r\n graph = ops.get_default_graph()\r\n return (self._get_non_slot_variable(\"step\", graph=graph),\r\n self._get_non_slot_variable(\"beta1_power\", graph=graph),\r\n self._get_non_slot_variable(\"beta2_power\", graph=graph))\r\n\r\n def _create_slots_internal(self, var_list):\r\n first_var = min(var_list, key=lambda x: x.name)\r\n self._create_non_slot_variable(initial_value=1.0, name=\"step\", colocate_with=first_var)\r\n self._create_non_slot_variable(initial_value=self._beta1, name=\"beta1_power\", colocate_with=first_var)\r\n self._create_non_slot_variable(initial_value=self._beta2, name=\"beta2_power\", colocate_with=first_var)\r\n for v in var_list:\r\n self._zeros_slot(v, \"m\", self._name)\r\n self._zeros_slot(v, \"v\", self._name)\r\n if self._amsgrad:\r\n self._zeros_slot(v, \"vhat\", self._name)\r\n\r\n def _prepare(self):\r\n lr = self._call_if_callable(self._lr)\r\n beta1 = self._call_if_callable(self._beta1)\r\n beta2 = self._call_if_callable(self._beta2)\r\n epsilon = self._call_if_callable(self._epsilon)\r\n weight_decay = self._call_if_callable(self._weight_decay)\r\n total_steps = self._call_if_callable(self._total_steps)\r\n warmup_proportion = self._call_if_callable(self._warmup_proportion)\r\n min_lr = self._call_if_callable(self._min_lr)\r\n\r\n self._lr_t = ops.convert_to_tensor(lr, name=\"learning_rate\")\r\n self._beta1_t = ops.convert_to_tensor(beta1, name=\"beta1\")\r\n self._beta2_t = ops.convert_to_tensor(beta2, name=\"beta2\")\r\n self._epsilon_t = ops.convert_to_tensor(epsilon, name=\"epsilon\")\r\n self._weight_decay_t = ops.convert_to_tensor(weight_decay, name=\"weight_decay\")\r\n self._total_steps_t = ops.convert_to_tensor(total_steps, name=\"total_steps\")\r\n self._warmup_proportion_t = ops.convert_to_tensor(warmup_proportion, name=\"warmup_proportion\")\r\n self._min_lr_t = ops.convert_to_tensor(min_lr, name=\"min_lr\")\r\n\r\n def apply_gradients(self, grads_and_vars, global_step=None, name=None):\r\n tvars = list(zip(*grads_and_vars))[1]\r\n self._create_slots_internal(tvars)\r\n\r\n return super().apply_gradients(grads_and_vars, global_step, name)\r\n\r\n def _apply_dense(self, grad, var):\r\n return self._resource_apply_dense(grad, var)\r\n\r\n def _resource_apply_dense(self, grad, var):\r\n step, beta1_power, beta2_power = self._get_beta_accumulators()\r\n beta1_power = math_ops.cast(beta1_power, var.dtype.base_dtype)\r\n beta2_power = math_ops.cast(beta2_power, var.dtype.base_dtype)\r\n lr_t = math_ops.cast(self._lr_t, var.dtype.base_dtype)\r\n\r\n if self._initial_total_steps > 0:\r\n total_steps = math_ops.cast(self._total_steps_t, var.dtype.base_dtype)\r\n warmup_proportion = math_ops.cast(self._warmup_proportion_t, var.dtype.base_dtype)\r\n min_lr = math_ops.cast(self._min_lr_t, var.dtype.base_dtype)\r\n warmup_steps = total_steps * warmup_proportion\r\n decay_steps = math_ops.maximum(total_steps - warmup_steps, 1)\r\n decay_rate = (min_lr - lr_t) / decay_steps\r\n lr_t = tf.where(\r\n step <= warmup_steps,\r\n lr_t * (step / warmup_steps),\r\n lr_t + decay_rate * math_ops.minimum(step - warmup_steps, decay_steps),\r\n )\r\n\r\n beta1_t = math_ops.cast(self._beta1_t, var.dtype.base_dtype)\r\n beta2_t = math_ops.cast(self._beta2_t, var.dtype.base_dtype)\r\n epsilon_t = math_ops.cast(self._epsilon_t, var.dtype.base_dtype)\r\n\r\n v = self.get_slot(var, \"v\")\r\n\r\n if self.clip_gradients:\r\n clipVal = math_ops.sqrt(\r\n tf.reduce_sum(v) / (1.0 - beta2_power)) * self.clip_multiplier_t + self.clip_epsilon_t\r\n grad = clip_ops.clip_by_norm(grad, clipVal)\r\n\r\n sma_inf = 2.0 / (1.0 - beta2_t) - 1.0\r\n sma_t = sma_inf - 2.0 * step * beta2_power / (1.0 - beta2_power)\r\n\r\n m = self.get_slot(var, \"m\")\r\n\r\n v_t = state_ops.assign(v, beta2_t * v + (1.0 - beta2_t) * math_ops.square(grad), use_locking=self._use_locking)\r\n v_corr_t = math_ops.sqrt(v_t / (1.0 - beta2_power)) + epsilon_t\r\n grad_corr = grad / v_corr_t\r\n\r\n m_t = state_ops.assign(m, beta1_t * m + (1.0 - beta1_t) * grad_corr, use_locking=self._use_locking)\r\n m_corr_t = m_t / (1.0 - beta1_power)\r\n\r\n r_t = math_ops.sqrt((sma_t - 4.0) / (sma_inf - 4.0) *\r\n (sma_t - 2.0) / (sma_inf - 2.0) *\r\n sma_inf / sma_t)\r\n\r\n var_t = tf.where(sma_t >= 5.0, r_t * m_corr_t, m_corr_t)\r\n\r\n if var in self.reg_vars:\r\n if self._initial_weight_decay > 0.0:\r\n var_t += math_ops.cast(self._weight_decay_t, var.dtype.base_dtype) * var\r\n if self._L1_decay > 0.0:\r\n var_t += math_ops.cast(self._L1_decay, var.dtype.base_dtype) * math_ops.sign(var)\r\n\r\n with tf.control_dependencies([var_t]):\r\n var_update = state_ops.assign_sub(var, lr_t * var_t, use_locking=self._use_locking)\r\n\r\n updates = [var_update, m_t, v_t]\r\n return control_flow_ops.group(*updates)\r\n\r\n def _apply_sparse_shared(self, grad, var, indices, scatter_add):\r\n step, beta1_power, beta2_power = self._get_beta_accumulators()\r\n beta1_power = math_ops.cast(beta1_power, var.dtype.base_dtype)\r\n beta2_power = math_ops.cast(beta2_power, var.dtype.base_dtype)\r\n lr_t = math_ops.cast(self._lr_t, var.dtype.base_dtype)\r\n\r\n if self._initial_total_steps > 0:\r\n total_steps = math_ops.cast(self._total_steps_t, var.dtype.base_dtype)\r\n warmup_proportion = math_ops.cast(self._warmup_proportion_t, var.dtype.base_dtype)\r\n min_lr = math_ops.cast(self._min_lr_t, var.dtype.base_dtype)\r\n warmup_steps = total_steps * warmup_proportion\r\n decay_steps = math_ops.maximum(total_steps - warmup_steps, 1)\r\n decay_rate = (min_lr - lr_t) / decay_steps\r\n lr_t = tf.where(\r\n step <= warmup_steps,\r\n lr_t * (step / warmup_steps),\r\n lr_t + decay_rate * math_ops.minimum(step - warmup_steps, decay_steps),\r\n )\r\n\r\n beta1_t = math_ops.cast(self._beta1_t, var.dtype.base_dtype)\r\n beta2_t = math_ops.cast(self._beta2_t, var.dtype.base_dtype)\r\n epsilon_t = math_ops.cast(self._epsilon_t, var.dtype.base_dtype)\r\n v = self.get_slot(var, \"v\")\r\n\r\n if self.clip_gradients:\r\n clipVal = math_ops.sqrt(\r\n tf.reduce_sum(v) / (1.0 - beta2_power)) * self.clip_multiplier_t + self.clip_epsilon_t\r\n grad = clip_ops.clip_by_norm(grad, clipVal)\r\n\r\n sma_inf = 2.0 / (1.0 - beta2_t) - 1.0\r\n sma_t = sma_inf - 2.0 * step * beta2_power / (1.0 - beta2_power)\r\n\r\n m = self.get_slot(var, \"m\")\r\n m_scaled_g_values = grad * (1 - beta1_t)\r\n m_t = state_ops.assign(m, m * beta1_t, use_locking=self._use_locking)\r\n with ops.control_dependencies([m_t]):\r\n m_t = scatter_add(m, indices, m_scaled_g_values)\r\n m_corr_t = m_t / (1.0 - beta1_power)\r\n\r\n v_scaled_g_values = (grad * grad) * (1 - beta2_t)\r\n v_t = state_ops.assign(v, v * beta2_t, use_locking=self._use_locking)\r\n with ops.control_dependencies([v_t]):\r\n v_t = scatter_add(v, indices, v_scaled_g_values)\r\n if self._amsgrad:\r\n vhat = self.get_slot(var, 'vhat')\r\n vhat_t = state_ops.assign(vhat, math_ops.maximum(vhat, v_t), use_locking=self._use_locking)\r\n v_corr_t = math_ops.sqrt(vhat_t / (1.0 - beta2_power)) + epsilon_t\r\n else:\r\n v_corr_t = math_ops.sqrt(v_t / (1.0 - beta2_power)) + epsilon_t\r\n\r\n r_t = math_ops.sqrt((sma_t - 4.0) / (sma_inf - 4.0) *\r\n (sma_t - 2.0) / (sma_inf - 2.0) *\r\n sma_inf / sma_t)\r\n\r\n var_t = tf.where(sma_t >= 5.0, r_t * m_corr_t / v_corr_t, m_corr_t)\r\n\r\n if var in self.reg_vars:\r\n if self._initial_weight_decay > 0.0:\r\n var_t += math_ops.cast(self._weight_decay_t, var.dtype.base_dtype) * var\r\n if self._L1_decay > 0.0:\r\n var_t += math_ops.cast(self._L1_decay, var.dtype.base_dtype) * math_ops.sign(var)\r\n\r\n var_update = state_ops.assign_sub(var, lr_t * var_t, use_locking=self._use_locking)\r\n\r\n updates = [var_update, m_t, v_t]\r\n if self._amsgrad:\r\n updates.append(vhat_t)\r\n return control_flow_ops.group(*updates)\r\n\r\n def _apply_sparse(self, grad, var):\r\n return self._apply_sparse_shared(\r\n grad.values,\r\n var,\r\n grad.indices,\r\n lambda x, i, v: state_ops.scatter_add(x, i, v, use_locking=self._use_locking))\r\n\r\n def _resource_scatter_add(self, x, i, v):\r\n with ops.control_dependencies([resource_variable_ops.resource_scatter_add(x.handle, i, v)]):\r\n return x.value()\r\n\r\n def _resource_apply_sparse(self, grad, var, indices):\r\n return self._apply_sparse_shared(grad, var, indices, self._resource_scatter_add)\r\n\r\n def _finish(self, update_ops, name_scope):\r\n with ops.control_dependencies(update_ops):\r\n step, beta1_power, beta2_power = self._get_beta_accumulators()\r\n with ops.colocate_with(beta1_power):\r\n update_step = step.assign(step + 1.0, use_locking=self._use_locking)\r\n update_beta1 = beta1_power.assign(beta1_power * self._beta1_t, use_locking=self._use_locking)\r\n update_beta2 = beta2_power.assign(beta2_power * self._beta2_t, use_locking=self._use_locking)\r\n return control_flow_ops.group(*update_ops + [update_step, update_beta1, update_beta2], name=name_scope)\r\n"
] | [
[
"tensorflow.python.ops.state_ops.assign",
"tensorflow.python.ops.math_ops.minimum",
"tensorflow.python.framework.ops.init_scope",
"tensorflow.python.eager.context.executing_eagerly",
"tensorflow.control_dependencies",
"tensorflow.python.ops.state_ops.assign_sub",
"tensorflow.python.framework.ops.control_dependencies",
"tensorflow.python.ops.math_ops.cast",
"tensorflow.python.framework.ops.colocate_with",
"tensorflow.python.ops.math_ops.sqrt",
"tensorflow.python.ops.state_ops.scatter_add",
"tensorflow.python.ops.math_ops.maximum",
"tensorflow.python.ops.math_ops.sign",
"tensorflow.where",
"tensorflow.python.ops.clip_ops.clip_by_norm",
"tensorflow.python.ops.math_ops.square",
"tensorflow.python.ops.resource_variable_ops.resource_scatter_add",
"tensorflow.reduce_sum",
"tensorflow.python.ops.control_flow_ops.group",
"tensorflow.python.framework.ops.convert_to_tensor",
"tensorflow.python.framework.ops.get_default_graph"
]
] |
rhshadrach/pandas | [
"777c0f90c6067c636fcd76ce003a8fbfcc311d7b"
] | [
"pandas/core/generic.py"
] | [
"import collections\nfrom datetime import timedelta\nimport functools\nimport gc\nimport json\nimport operator\nimport pickle\nimport re\nfrom textwrap import dedent\nfrom typing import (\n TYPE_CHECKING,\n Any,\n Callable,\n Dict,\n FrozenSet,\n Hashable,\n List,\n Mapping,\n Optional,\n Sequence,\n Set,\n Tuple,\n Type,\n Union,\n)\nimport warnings\nimport weakref\n\nimport numpy as np\n\nfrom pandas._config import config\n\nfrom pandas._libs import Timestamp, iNaT, lib\nfrom pandas._typing import (\n Axis,\n FilePathOrBuffer,\n FrameOrSeries,\n JSONSerializable,\n Label,\n Level,\n Renamer,\n)\nfrom pandas.compat import set_function_name\nfrom pandas.compat._optional import import_optional_dependency\nfrom pandas.compat.numpy import function as nv\nfrom pandas.errors import AbstractMethodError\nfrom pandas.util._decorators import (\n Appender,\n Substitution,\n doc,\n rewrite_axis_style_signature,\n)\nfrom pandas.util._validators import (\n validate_bool_kwarg,\n validate_fillna_kwargs,\n validate_percentile,\n)\n\nfrom pandas.core.dtypes.common import (\n ensure_int64,\n ensure_object,\n ensure_str,\n is_bool,\n is_bool_dtype,\n is_datetime64_any_dtype,\n is_datetime64tz_dtype,\n is_dict_like,\n is_extension_array_dtype,\n is_float,\n is_integer,\n is_list_like,\n is_number,\n is_numeric_dtype,\n is_object_dtype,\n is_re_compilable,\n is_scalar,\n is_timedelta64_dtype,\n pandas_dtype,\n)\nfrom pandas.core.dtypes.generic import ABCDataFrame, ABCSeries\nfrom pandas.core.dtypes.inference import is_hashable\nfrom pandas.core.dtypes.missing import isna, notna\n\nimport pandas as pd\nfrom pandas.core import missing, nanops\nimport pandas.core.algorithms as algos\nfrom pandas.core.base import PandasObject, SelectionMixin\nimport pandas.core.common as com\nfrom pandas.core.construction import create_series_with_explicit_dtype\nfrom pandas.core.indexes.api import (\n Index,\n InvalidIndexError,\n MultiIndex,\n RangeIndex,\n ensure_index,\n)\nfrom pandas.core.indexes.datetimes import DatetimeIndex\nfrom pandas.core.indexes.period import Period, PeriodIndex\nimport pandas.core.indexing as indexing\nfrom pandas.core.internals import BlockManager\nfrom pandas.core.missing import find_valid_index\nfrom pandas.core.ops import _align_method_FRAME\n\nfrom pandas.io.formats import format as fmt\nfrom pandas.io.formats.format import DataFrameFormatter, format_percentiles\nfrom pandas.io.formats.printing import pprint_thing\nfrom pandas.tseries.frequencies import to_offset\n\nif TYPE_CHECKING:\n from pandas.core.resample import Resampler\n\n# goal is to be able to define the docs close to function, while still being\n# able to share\n_shared_docs: Dict[str, str] = dict()\n_shared_doc_kwargs = dict(\n axes=\"keywords for axes\",\n klass=\"Series/DataFrame\",\n axes_single_arg=\"int or labels for object\",\n args_transpose=\"axes to permute (int or label for object)\",\n optional_by=\"\"\"\n by : str or list of str\n Name or list of names to sort by\"\"\",\n)\n\n\ndef _single_replace(self, to_replace, method, inplace, limit):\n \"\"\"\n Replaces values in a Series using the fill method specified when no\n replacement value is given in the replace method\n \"\"\"\n if self.ndim != 1:\n raise TypeError(\n f\"cannot replace {to_replace} with method {method} on a \"\n f\"{type(self).__name__}\"\n )\n\n orig_dtype = self.dtype\n result = self if inplace else self.copy()\n fill_f = missing.get_fill_func(method)\n\n mask = missing.mask_missing(result.values, to_replace)\n values = fill_f(result.values, limit=limit, mask=mask)\n\n if values.dtype == orig_dtype and inplace:\n return\n\n result = pd.Series(values, index=self.index, dtype=self.dtype).__finalize__(self)\n\n if inplace:\n self._update_inplace(result._data)\n return\n\n return result\n\n\nbool_t = bool # Need alias because NDFrame has def bool:\n\n\nclass NDFrame(PandasObject, SelectionMixin, indexing.IndexingMixin):\n \"\"\"\n N-dimensional analogue of DataFrame. Store multi-dimensional in a\n size-mutable, labeled data structure\n\n Parameters\n ----------\n data : BlockManager\n axes : list\n copy : bool, default False\n \"\"\"\n\n _internal_names: List[str] = [\n \"_data\",\n \"_cacher\",\n \"_item_cache\",\n \"_cache\",\n \"_is_copy\",\n \"_subtyp\",\n \"_name\",\n \"_index\",\n \"_default_kind\",\n \"_default_fill_value\",\n \"_metadata\",\n \"__array_struct__\",\n \"__array_interface__\",\n ]\n _internal_names_set: Set[str] = set(_internal_names)\n _accessors: Set[str] = set()\n _deprecations: FrozenSet[str] = frozenset([\"get_values\"])\n _metadata: List[str] = []\n _is_copy = None\n _data: BlockManager\n _attrs: Dict[Optional[Hashable], Any]\n _typ: str\n\n # ----------------------------------------------------------------------\n # Constructors\n\n def __init__(\n self,\n data: BlockManager,\n copy: bool = False,\n attrs: Optional[Mapping[Optional[Hashable], Any]] = None,\n ):\n # copy kwarg is retained for mypy compat, is not used\n\n object.__setattr__(self, \"_is_copy\", None)\n object.__setattr__(self, \"_data\", data)\n object.__setattr__(self, \"_item_cache\", {})\n if attrs is None:\n attrs = {}\n else:\n attrs = dict(attrs)\n object.__setattr__(self, \"_attrs\", attrs)\n\n @classmethod\n def _init_mgr(cls, mgr, axes=None, dtype=None, copy=False):\n \"\"\" passed a manager and a axes dict \"\"\"\n for a, axe in axes.items():\n if axe is not None:\n mgr = mgr.reindex_axis(\n axe, axis=cls._get_block_manager_axis(a), copy=False\n )\n\n # make a copy if explicitly requested\n if copy:\n mgr = mgr.copy()\n if dtype is not None:\n # avoid further copies if we can\n if len(mgr.blocks) > 1 or mgr.blocks[0].values.dtype != dtype:\n mgr = mgr.astype(dtype=dtype)\n return mgr\n\n # ----------------------------------------------------------------------\n\n @property\n def attrs(self) -> Dict[Optional[Hashable], Any]:\n \"\"\"\n Dictionary of global attributes on this object.\n\n .. warning::\n\n attrs is experimental and may change without warning.\n \"\"\"\n if self._attrs is None:\n self._attrs = {}\n return self._attrs\n\n @attrs.setter\n def attrs(self, value: Mapping[Optional[Hashable], Any]) -> None:\n self._attrs = dict(value)\n\n @classmethod\n def _validate_dtype(cls, dtype):\n \"\"\" validate the passed dtype \"\"\"\n if dtype is not None:\n dtype = pandas_dtype(dtype)\n\n # a compound dtype\n if dtype.kind == \"V\":\n raise NotImplementedError(\n \"compound dtypes are not implemented \"\n f\"in the {cls.__name__} constructor\"\n )\n\n return dtype\n\n # ----------------------------------------------------------------------\n # Construction\n\n @property\n def _constructor(self: FrameOrSeries) -> Type[FrameOrSeries]:\n \"\"\"\n Used when a manipulation result has the same dimensions as the\n original.\n \"\"\"\n raise AbstractMethodError(self)\n\n @property\n def _constructor_sliced(self):\n \"\"\"\n Used when a manipulation result has one lower dimension(s) as the\n original, such as DataFrame single columns slicing.\n \"\"\"\n raise AbstractMethodError(self)\n\n @property\n def _constructor_expanddim(self):\n \"\"\"\n Used when a manipulation result has one higher dimension as the\n original, such as Series.to_frame()\n \"\"\"\n raise NotImplementedError\n\n # ----------------------------------------------------------------------\n # Axis\n _AXIS_ALIASES = {\"rows\": 0}\n _AXIS_IALIASES = {0: \"rows\"}\n _stat_axis_number = 0\n _stat_axis_name = \"index\"\n _ix = None\n _AXIS_ORDERS: List[str]\n _AXIS_NUMBERS: Dict[str, int]\n _AXIS_NAMES: Dict[int, str]\n _AXIS_REVERSED: bool\n _info_axis_number: int\n _info_axis_name: str\n _AXIS_LEN: int\n\n def _construct_axes_dict(self, axes=None, **kwargs):\n \"\"\"Return an axes dictionary for myself.\"\"\"\n d = {a: self._get_axis(a) for a in (axes or self._AXIS_ORDERS)}\n d.update(kwargs)\n return d\n\n @classmethod\n def _construct_axes_from_arguments(\n cls, args, kwargs, require_all: bool = False, sentinel=None\n ):\n \"\"\"\n Construct and returns axes if supplied in args/kwargs.\n\n If require_all, raise if all axis arguments are not supplied\n return a tuple of (axes, kwargs).\n\n sentinel specifies the default parameter when an axis is not\n supplied; useful to distinguish when a user explicitly passes None\n in scenarios where None has special meaning.\n \"\"\"\n # construct the args\n args = list(args)\n for a in cls._AXIS_ORDERS:\n\n # look for a argument by position\n if a not in kwargs:\n try:\n kwargs[a] = args.pop(0)\n except IndexError as err:\n if require_all:\n raise TypeError(\n \"not enough/duplicate arguments specified!\"\n ) from err\n\n axes = {a: kwargs.pop(a, sentinel) for a in cls._AXIS_ORDERS}\n return axes, kwargs\n\n @classmethod\n def _get_axis_number(cls, axis):\n axis = cls._AXIS_ALIASES.get(axis, axis)\n if is_integer(axis):\n if axis in cls._AXIS_NAMES:\n return axis\n else:\n try:\n return cls._AXIS_NUMBERS[axis]\n except KeyError:\n pass\n raise ValueError(f\"No axis named {axis} for object type {cls}\")\n\n @classmethod\n def _get_axis_name(cls, axis):\n axis = cls._AXIS_ALIASES.get(axis, axis)\n if isinstance(axis, str):\n if axis in cls._AXIS_NUMBERS:\n return axis\n else:\n try:\n return cls._AXIS_NAMES[axis]\n except KeyError:\n pass\n raise ValueError(f\"No axis named {axis} for object type {cls}\")\n\n def _get_axis(self, axis):\n name = self._get_axis_name(axis)\n return getattr(self, name)\n\n @classmethod\n def _get_block_manager_axis(cls, axis):\n \"\"\"Map the axis to the block_manager axis.\"\"\"\n axis = cls._get_axis_number(axis)\n if cls._AXIS_REVERSED:\n m = cls._AXIS_LEN - 1\n return m - axis\n return axis\n\n def _get_axis_resolvers(self, axis: str) -> Dict[str, ABCSeries]:\n # index or columns\n axis_index = getattr(self, axis)\n d = dict()\n prefix = axis[0]\n\n for i, name in enumerate(axis_index.names):\n if name is not None:\n key = level = name\n else:\n # prefix with 'i' or 'c' depending on the input axis\n # e.g., you must do ilevel_0 for the 0th level of an unnamed\n # multiiindex\n key = f\"{prefix}level_{i}\"\n level = i\n\n level_values = axis_index.get_level_values(level)\n s = level_values.to_series()\n s.index = axis_index\n d[key] = s\n\n # put the index/columns itself in the dict\n if isinstance(axis_index, MultiIndex):\n dindex = axis_index\n else:\n dindex = axis_index.to_series()\n\n d[axis] = dindex\n return d\n\n def _get_index_resolvers(self) -> Dict[str, ABCSeries]:\n from pandas.core.computation.parsing import clean_column_name\n\n d: Dict[str, ABCSeries] = {}\n for axis_name in self._AXIS_ORDERS:\n d.update(self._get_axis_resolvers(axis_name))\n\n return {clean_column_name(k): v for k, v in d.items() if not isinstance(k, int)}\n\n def _get_cleaned_column_resolvers(self) -> Dict[str, ABCSeries]:\n \"\"\"\n Return the special character free column resolvers of a dataframe.\n\n Column names with special characters are 'cleaned up' so that they can\n be referred to by backtick quoting.\n Used in :meth:`DataFrame.eval`.\n \"\"\"\n from pandas.core.computation.parsing import clean_column_name\n\n if isinstance(self, ABCSeries):\n return {clean_column_name(self.name): self}\n\n return {\n clean_column_name(k): v for k, v in self.items() if not isinstance(k, int)\n }\n\n @property\n def _info_axis(self):\n return getattr(self, self._info_axis_name)\n\n @property\n def _stat_axis(self):\n return getattr(self, self._stat_axis_name)\n\n @property\n def shape(self) -> Tuple[int, ...]:\n \"\"\"\n Return a tuple of axis dimensions\n \"\"\"\n return tuple(len(self._get_axis(a)) for a in self._AXIS_ORDERS)\n\n @property\n def axes(self) -> List[Index]:\n \"\"\"\n Return index label(s) of the internal NDFrame\n \"\"\"\n # we do it this way because if we have reversed axes, then\n # the block manager shows then reversed\n return [self._get_axis(a) for a in self._AXIS_ORDERS]\n\n @property\n def ndim(self) -> int:\n \"\"\"\n Return an int representing the number of axes / array dimensions.\n\n Return 1 if Series. Otherwise return 2 if DataFrame.\n\n See Also\n --------\n ndarray.ndim : Number of array dimensions.\n\n Examples\n --------\n >>> s = pd.Series({'a': 1, 'b': 2, 'c': 3})\n >>> s.ndim\n 1\n\n >>> df = pd.DataFrame({'col1': [1, 2], 'col2': [3, 4]})\n >>> df.ndim\n 2\n \"\"\"\n return self._data.ndim\n\n @property\n def size(self) -> int:\n \"\"\"\n Return an int representing the number of elements in this object.\n\n Return the number of rows if Series. Otherwise return the number of\n rows times number of columns if DataFrame.\n\n See Also\n --------\n ndarray.size : Number of elements in the array.\n\n Examples\n --------\n >>> s = pd.Series({'a': 1, 'b': 2, 'c': 3})\n >>> s.size\n 3\n\n >>> df = pd.DataFrame({'col1': [1, 2], 'col2': [3, 4]})\n >>> df.size\n 4\n \"\"\"\n return np.prod(self.shape)\n\n @property\n def _selected_obj(self: FrameOrSeries) -> FrameOrSeries:\n \"\"\" internal compat with SelectionMixin \"\"\"\n return self\n\n @property\n def _obj_with_exclusions(self: FrameOrSeries) -> FrameOrSeries:\n \"\"\" internal compat with SelectionMixin \"\"\"\n return self\n\n def set_axis(self, labels, axis: Axis = 0, inplace: bool = False):\n \"\"\"\n Assign desired index to given axis.\n\n Indexes for%(extended_summary_sub)s row labels can be changed by assigning\n a list-like or Index.\n\n .. versionchanged:: 0.21.0\n\n The signature is now `labels` and `axis`, consistent with\n the rest of pandas API. Previously, the `axis` and `labels`\n arguments were respectively the first and second positional\n arguments.\n\n Parameters\n ----------\n labels : list-like, Index\n The values for the new index.\n\n axis : %(axes_single_arg)s, default 0\n The axis to update. The value 0 identifies the rows%(axis_description_sub)s.\n\n inplace : bool, default False\n Whether to return a new %(klass)s instance.\n\n Returns\n -------\n renamed : %(klass)s or None\n An object of type %(klass)s if inplace=False, None otherwise.\n\n See Also\n --------\n %(klass)s.rename_axis : Alter the name of the index%(see_also_sub)s.\n \"\"\"\n if inplace:\n setattr(self, self._get_axis_name(axis), labels)\n else:\n obj = self.copy()\n obj.set_axis(labels, axis=axis, inplace=True)\n return obj\n\n def _set_axis(self, axis: int, labels: Index) -> None:\n labels = ensure_index(labels)\n self._data.set_axis(axis, labels)\n self._clear_item_cache()\n\n def swapaxes(self: FrameOrSeries, axis1, axis2, copy=True) -> FrameOrSeries:\n \"\"\"\n Interchange axes and swap values axes appropriately.\n\n Returns\n -------\n y : same as input\n \"\"\"\n i = self._get_axis_number(axis1)\n j = self._get_axis_number(axis2)\n\n if i == j:\n if copy:\n return self.copy()\n return self\n\n mapping = {i: j, j: i}\n\n new_axes = (self._get_axis(mapping.get(k, k)) for k in range(self._AXIS_LEN))\n new_values = self.values.swapaxes(i, j)\n if copy:\n new_values = new_values.copy()\n\n return self._constructor(new_values, *new_axes).__finalize__(self)\n\n def droplevel(self: FrameOrSeries, level, axis=0) -> FrameOrSeries:\n \"\"\"\n Return DataFrame with requested index / column level(s) removed.\n\n .. versionadded:: 0.24.0\n\n Parameters\n ----------\n level : int, str, or list-like\n If a string is given, must be the name of a level\n If list-like, elements must be names or positional indexes\n of levels.\n\n axis : {0 or 'index', 1 or 'columns'}, default 0\n Axis along which the level(s) is removed:\n\n * 0 or 'index': remove level(s) in column.\n * 1 or 'columns': remove level(s) in row.\n\n Returns\n -------\n DataFrame\n DataFrame with requested index / column level(s) removed.\n\n Examples\n --------\n >>> df = pd.DataFrame([\n ... [1, 2, 3, 4],\n ... [5, 6, 7, 8],\n ... [9, 10, 11, 12]\n ... ]).set_index([0, 1]).rename_axis(['a', 'b'])\n\n >>> df.columns = pd.MultiIndex.from_tuples([\n ... ('c', 'e'), ('d', 'f')\n ... ], names=['level_1', 'level_2'])\n\n >>> df\n level_1 c d\n level_2 e f\n a b\n 1 2 3 4\n 5 6 7 8\n 9 10 11 12\n\n >>> df.droplevel('a')\n level_1 c d\n level_2 e f\n b\n 2 3 4\n 6 7 8\n 10 11 12\n\n >>> df.droplevel('level_2', axis=1)\n level_1 c d\n a b\n 1 2 3 4\n 5 6 7 8\n 9 10 11 12\n \"\"\"\n labels = self._get_axis(axis)\n new_labels = labels.droplevel(level)\n result = self.set_axis(new_labels, axis=axis, inplace=False)\n return result\n\n def pop(self: FrameOrSeries, item) -> FrameOrSeries:\n \"\"\"\n Return item and drop from frame. Raise KeyError if not found.\n\n Parameters\n ----------\n item : str\n Label of column to be popped.\n\n Returns\n -------\n Series\n\n Examples\n --------\n >>> df = pd.DataFrame([('falcon', 'bird', 389.0),\n ... ('parrot', 'bird', 24.0),\n ... ('lion', 'mammal', 80.5),\n ... ('monkey', 'mammal', np.nan)],\n ... columns=('name', 'class', 'max_speed'))\n >>> df\n name class max_speed\n 0 falcon bird 389.0\n 1 parrot bird 24.0\n 2 lion mammal 80.5\n 3 monkey mammal NaN\n\n >>> df.pop('class')\n 0 bird\n 1 bird\n 2 mammal\n 3 mammal\n Name: class, dtype: object\n\n >>> df\n name max_speed\n 0 falcon 389.0\n 1 parrot 24.0\n 2 lion 80.5\n 3 monkey NaN\n \"\"\"\n result = self[item]\n del self[item]\n try:\n result._reset_cacher()\n except AttributeError:\n pass\n\n return result\n\n def squeeze(self, axis=None):\n \"\"\"\n Squeeze 1 dimensional axis objects into scalars.\n\n Series or DataFrames with a single element are squeezed to a scalar.\n DataFrames with a single column or a single row are squeezed to a\n Series. Otherwise the object is unchanged.\n\n This method is most useful when you don't know if your\n object is a Series or DataFrame, but you do know it has just a single\n column. In that case you can safely call `squeeze` to ensure you have a\n Series.\n\n Parameters\n ----------\n axis : {0 or 'index', 1 or 'columns', None}, default None\n A specific axis to squeeze. By default, all length-1 axes are\n squeezed.\n\n Returns\n -------\n DataFrame, Series, or scalar\n The projection after squeezing `axis` or all the axes.\n\n See Also\n --------\n Series.iloc : Integer-location based indexing for selecting scalars.\n DataFrame.iloc : Integer-location based indexing for selecting Series.\n Series.to_frame : Inverse of DataFrame.squeeze for a\n single-column DataFrame.\n\n Examples\n --------\n >>> primes = pd.Series([2, 3, 5, 7])\n\n Slicing might produce a Series with a single value:\n\n >>> even_primes = primes[primes % 2 == 0]\n >>> even_primes\n 0 2\n dtype: int64\n\n >>> even_primes.squeeze()\n 2\n\n Squeezing objects with more than one value in every axis does nothing:\n\n >>> odd_primes = primes[primes % 2 == 1]\n >>> odd_primes\n 1 3\n 2 5\n 3 7\n dtype: int64\n\n >>> odd_primes.squeeze()\n 1 3\n 2 5\n 3 7\n dtype: int64\n\n Squeezing is even more effective when used with DataFrames.\n\n >>> df = pd.DataFrame([[1, 2], [3, 4]], columns=['a', 'b'])\n >>> df\n a b\n 0 1 2\n 1 3 4\n\n Slicing a single column will produce a DataFrame with the columns\n having only one value:\n\n >>> df_a = df[['a']]\n >>> df_a\n a\n 0 1\n 1 3\n\n So the columns can be squeezed down, resulting in a Series:\n\n >>> df_a.squeeze('columns')\n 0 1\n 1 3\n Name: a, dtype: int64\n\n Slicing a single row from a single column will produce a single\n scalar DataFrame:\n\n >>> df_0a = df.loc[df.index < 1, ['a']]\n >>> df_0a\n a\n 0 1\n\n Squeezing the rows produces a single scalar Series:\n\n >>> df_0a.squeeze('rows')\n a 1\n Name: 0, dtype: int64\n\n Squeezing all axes will project directly into a scalar:\n\n >>> df_0a.squeeze()\n 1\n \"\"\"\n axis = self._AXIS_NAMES if axis is None else (self._get_axis_number(axis),)\n return self.iloc[\n tuple(\n 0 if i in axis and len(a) == 1 else slice(None)\n for i, a in enumerate(self.axes)\n )\n ]\n\n # ----------------------------------------------------------------------\n # Rename\n\n def rename(\n self: FrameOrSeries,\n mapper: Optional[Renamer] = None,\n *,\n index: Optional[Renamer] = None,\n columns: Optional[Renamer] = None,\n axis: Optional[Axis] = None,\n copy: bool = True,\n inplace: bool = False,\n level: Optional[Level] = None,\n errors: str = \"ignore\",\n ) -> Optional[FrameOrSeries]:\n \"\"\"\n Alter axes input function or functions. Function / dict values must be\n unique (1-to-1). Labels not contained in a dict / Series will be left\n as-is. Extra labels listed don't throw an error. Alternatively, change\n ``Series.name`` with a scalar value (Series only).\n\n Parameters\n ----------\n %(axes)s : scalar, list-like, dict-like or function, optional\n Scalar or list-like will alter the ``Series.name`` attribute,\n and raise on DataFrame.\n dict-like or functions are transformations to apply to\n that axis' values\n copy : bool, default True\n Also copy underlying data.\n inplace : bool, default False\n Whether to return a new %(klass)s. If True then value of copy is\n ignored.\n level : int or level name, default None\n In case of a MultiIndex, only rename labels in the specified\n level.\n errors : {'ignore', 'raise'}, default 'ignore'\n If 'raise', raise a `KeyError` when a dict-like `mapper`, `index`,\n or `columns` contains labels that are not present in the Index\n being transformed.\n If 'ignore', existing keys will be renamed and extra keys will be\n ignored.\n\n Returns\n -------\n renamed : %(klass)s (new object)\n\n Raises\n ------\n KeyError\n If any of the labels is not found in the selected axis and\n \"errors='raise'\".\n\n See Also\n --------\n NDFrame.rename_axis\n\n Examples\n --------\n >>> s = pd.Series([1, 2, 3])\n >>> s\n 0 1\n 1 2\n 2 3\n dtype: int64\n >>> s.rename(\"my_name\") # scalar, changes Series.name\n 0 1\n 1 2\n 2 3\n Name: my_name, dtype: int64\n >>> s.rename(lambda x: x ** 2) # function, changes labels\n 0 1\n 1 2\n 4 3\n dtype: int64\n >>> s.rename({1: 3, 2: 5}) # mapping, changes labels\n 0 1\n 3 2\n 5 3\n dtype: int64\n\n Since ``DataFrame`` doesn't have a ``.name`` attribute,\n only mapping-type arguments are allowed.\n\n >>> df = pd.DataFrame({\"A\": [1, 2, 3], \"B\": [4, 5, 6]})\n >>> df.rename(2)\n Traceback (most recent call last):\n ...\n TypeError: 'int' object is not callable\n\n ``DataFrame.rename`` supports two calling conventions\n\n * ``(index=index_mapper, columns=columns_mapper, ...)``\n * ``(mapper, axis={'index', 'columns'}, ...)``\n\n We *highly* recommend using keyword arguments to clarify your\n intent.\n\n >>> df.rename(index=str, columns={\"A\": \"a\", \"B\": \"c\"})\n a c\n 0 1 4\n 1 2 5\n 2 3 6\n\n >>> df.rename(index=str, columns={\"A\": \"a\", \"C\": \"c\"})\n a B\n 0 1 4\n 1 2 5\n 2 3 6\n\n Using axis-style parameters\n\n >>> df.rename(str.lower, axis='columns')\n a b\n 0 1 4\n 1 2 5\n 2 3 6\n\n >>> df.rename({1: 2, 2: 4}, axis='index')\n A B\n 0 1 4\n 2 2 5\n 4 3 6\n\n See the :ref:`user guide <basics.rename>` for more.\n \"\"\"\n if mapper is None and index is None and columns is None:\n raise TypeError(\"must pass an index to rename\")\n\n if index is not None or columns is not None:\n if axis is not None:\n raise TypeError(\n \"Cannot specify both 'axis' and any of 'index' or 'columns'\"\n )\n elif mapper is not None:\n raise TypeError(\n \"Cannot specify both 'mapper' and any of 'index' or 'columns'\"\n )\n else:\n # use the mapper argument\n if axis and self._get_axis_number(axis) == 1:\n columns = mapper\n else:\n index = mapper\n\n result = self if inplace else self.copy(deep=copy)\n\n for axis_no, replacements in enumerate((index, columns)):\n if replacements is None:\n continue\n\n ax = self._get_axis(axis_no)\n baxis = self._get_block_manager_axis(axis_no)\n f = com.get_rename_function(replacements)\n\n if level is not None:\n level = ax._get_level_number(level)\n\n # GH 13473\n if not callable(replacements):\n indexer = ax.get_indexer_for(replacements)\n if errors == \"raise\" and len(indexer[indexer == -1]):\n missing_labels = [\n label\n for index, label in enumerate(replacements)\n if indexer[index] == -1\n ]\n raise KeyError(f\"{missing_labels} not found in axis\")\n\n result._data = result._data.rename_axis(\n f, axis=baxis, copy=copy, level=level\n )\n result._clear_item_cache()\n\n if inplace:\n self._update_inplace(result._data)\n return None\n else:\n return result.__finalize__(self)\n\n @rewrite_axis_style_signature(\"mapper\", [(\"copy\", True), (\"inplace\", False)])\n def rename_axis(self, mapper=lib.no_default, **kwargs):\n \"\"\"\n Set the name of the axis for the index or columns.\n\n Parameters\n ----------\n mapper : scalar, list-like, optional\n Value to set the axis name attribute.\n index, columns : scalar, list-like, dict-like or function, optional\n A scalar, list-like, dict-like or functions transformations to\n apply to that axis' values.\n\n Use either ``mapper`` and ``axis`` to\n specify the axis to target with ``mapper``, or ``index``\n and/or ``columns``.\n\n .. versionchanged:: 0.24.0\n\n axis : {0 or 'index', 1 or 'columns'}, default 0\n The axis to rename.\n copy : bool, default True\n Also copy underlying data.\n inplace : bool, default False\n Modifies the object directly, instead of creating a new Series\n or DataFrame.\n\n Returns\n -------\n Series, DataFrame, or None\n The same type as the caller or None if `inplace` is True.\n\n See Also\n --------\n Series.rename : Alter Series index labels or name.\n DataFrame.rename : Alter DataFrame index labels or name.\n Index.rename : Set new names on index.\n\n Notes\n -----\n ``DataFrame.rename_axis`` supports two calling conventions\n\n * ``(index=index_mapper, columns=columns_mapper, ...)``\n * ``(mapper, axis={'index', 'columns'}, ...)``\n\n The first calling convention will only modify the names of\n the index and/or the names of the Index object that is the columns.\n In this case, the parameter ``copy`` is ignored.\n\n The second calling convention will modify the names of the\n the corresponding index if mapper is a list or a scalar.\n However, if mapper is dict-like or a function, it will use the\n deprecated behavior of modifying the axis *labels*.\n\n We *highly* recommend using keyword arguments to clarify your\n intent.\n\n Examples\n --------\n **Series**\n\n >>> s = pd.Series([\"dog\", \"cat\", \"monkey\"])\n >>> s\n 0 dog\n 1 cat\n 2 monkey\n dtype: object\n >>> s.rename_axis(\"animal\")\n animal\n 0 dog\n 1 cat\n 2 monkey\n dtype: object\n\n **DataFrame**\n\n >>> df = pd.DataFrame({\"num_legs\": [4, 4, 2],\n ... \"num_arms\": [0, 0, 2]},\n ... [\"dog\", \"cat\", \"monkey\"])\n >>> df\n num_legs num_arms\n dog 4 0\n cat 4 0\n monkey 2 2\n >>> df = df.rename_axis(\"animal\")\n >>> df\n num_legs num_arms\n animal\n dog 4 0\n cat 4 0\n monkey 2 2\n >>> df = df.rename_axis(\"limbs\", axis=\"columns\")\n >>> df\n limbs num_legs num_arms\n animal\n dog 4 0\n cat 4 0\n monkey 2 2\n\n **MultiIndex**\n\n >>> df.index = pd.MultiIndex.from_product([['mammal'],\n ... ['dog', 'cat', 'monkey']],\n ... names=['type', 'name'])\n >>> df\n limbs num_legs num_arms\n type name\n mammal dog 4 0\n cat 4 0\n monkey 2 2\n\n >>> df.rename_axis(index={'type': 'class'})\n limbs num_legs num_arms\n class name\n mammal dog 4 0\n cat 4 0\n monkey 2 2\n\n >>> df.rename_axis(columns=str.upper)\n LIMBS num_legs num_arms\n type name\n mammal dog 4 0\n cat 4 0\n monkey 2 2\n \"\"\"\n axes, kwargs = self._construct_axes_from_arguments(\n (), kwargs, sentinel=lib.no_default\n )\n copy = kwargs.pop(\"copy\", True)\n inplace = kwargs.pop(\"inplace\", False)\n axis = kwargs.pop(\"axis\", 0)\n if axis is not None:\n axis = self._get_axis_number(axis)\n\n if kwargs:\n raise TypeError(\n \"rename_axis() got an unexpected keyword \"\n f'argument \"{list(kwargs.keys())[0]}\"'\n )\n\n inplace = validate_bool_kwarg(inplace, \"inplace\")\n\n if mapper is not lib.no_default:\n # Use v0.23 behavior if a scalar or list\n non_mapper = is_scalar(mapper) or (\n is_list_like(mapper) and not is_dict_like(mapper)\n )\n if non_mapper:\n return self._set_axis_name(mapper, axis=axis, inplace=inplace)\n else:\n raise ValueError(\"Use `.rename` to alter labels with a mapper.\")\n else:\n # Use new behavior. Means that index and/or columns\n # is specified\n result = self if inplace else self.copy(deep=copy)\n\n for axis in range(self._AXIS_LEN):\n v = axes.get(self._AXIS_NAMES[axis])\n if v is lib.no_default:\n continue\n non_mapper = is_scalar(v) or (is_list_like(v) and not is_dict_like(v))\n if non_mapper:\n newnames = v\n else:\n f = com.get_rename_function(v)\n curnames = self._get_axis(axis).names\n newnames = [f(name) for name in curnames]\n result._set_axis_name(newnames, axis=axis, inplace=True)\n if not inplace:\n return result\n\n def _set_axis_name(self, name, axis=0, inplace=False):\n \"\"\"\n Set the name(s) of the axis.\n\n Parameters\n ----------\n name : str or list of str\n Name(s) to set.\n axis : {0 or 'index', 1 or 'columns'}, default 0\n The axis to set the label. The value 0 or 'index' specifies index,\n and the value 1 or 'columns' specifies columns.\n inplace : bool, default False\n If `True`, do operation inplace and return None.\n\n .. versionadded:: 0.21.0\n\n Returns\n -------\n Series, DataFrame, or None\n The same type as the caller or `None` if `inplace` is `True`.\n\n See Also\n --------\n DataFrame.rename : Alter the axis labels of :class:`DataFrame`.\n Series.rename : Alter the index labels or set the index name\n of :class:`Series`.\n Index.rename : Set the name of :class:`Index` or :class:`MultiIndex`.\n\n Examples\n --------\n >>> df = pd.DataFrame({\"num_legs\": [4, 4, 2]},\n ... [\"dog\", \"cat\", \"monkey\"])\n >>> df\n num_legs\n dog 4\n cat 4\n monkey 2\n >>> df._set_axis_name(\"animal\")\n num_legs\n animal\n dog 4\n cat 4\n monkey 2\n >>> df.index = pd.MultiIndex.from_product(\n ... [[\"mammal\"], ['dog', 'cat', 'monkey']])\n >>> df._set_axis_name([\"type\", \"name\"])\n legs\n type name\n mammal dog 4\n cat 4\n monkey 2\n \"\"\"\n axis = self._get_axis_number(axis)\n idx = self._get_axis(axis).set_names(name)\n\n inplace = validate_bool_kwarg(inplace, \"inplace\")\n renamed = self if inplace else self.copy()\n renamed.set_axis(idx, axis=axis, inplace=True)\n if not inplace:\n return renamed\n\n # ----------------------------------------------------------------------\n # Comparison Methods\n\n def _indexed_same(self, other) -> bool:\n return all(\n self._get_axis(a).equals(other._get_axis(a)) for a in self._AXIS_ORDERS\n )\n\n def equals(self, other):\n \"\"\"\n Test whether two objects contain the same elements.\n\n This function allows two Series or DataFrames to be compared against\n each other to see if they have the same shape and elements. NaNs in\n the same location are considered equal. The column headers do not\n need to have the same type, but the elements within the columns must\n be the same dtype.\n\n Parameters\n ----------\n other : Series or DataFrame\n The other Series or DataFrame to be compared with the first.\n\n Returns\n -------\n bool\n True if all elements are the same in both objects, False\n otherwise.\n\n See Also\n --------\n Series.eq : Compare two Series objects of the same length\n and return a Series where each element is True if the element\n in each Series is equal, False otherwise.\n DataFrame.eq : Compare two DataFrame objects of the same shape and\n return a DataFrame where each element is True if the respective\n element in each DataFrame is equal, False otherwise.\n testing.assert_series_equal : Raises an AssertionError if left and\n right are not equal. Provides an easy interface to ignore\n inequality in dtypes, indexes and precision among others.\n testing.assert_frame_equal : Like assert_series_equal, but targets\n DataFrames.\n numpy.array_equal : Return True if two arrays have the same shape\n and elements, False otherwise.\n\n Notes\n -----\n This function requires that the elements have the same dtype as their\n respective elements in the other Series or DataFrame. However, the\n column labels do not need to have the same type, as long as they are\n still considered equal.\n\n Examples\n --------\n >>> df = pd.DataFrame({1: [10], 2: [20]})\n >>> df\n 1 2\n 0 10 20\n\n DataFrames df and exactly_equal have the same types and values for\n their elements and column labels, which will return True.\n\n >>> exactly_equal = pd.DataFrame({1: [10], 2: [20]})\n >>> exactly_equal\n 1 2\n 0 10 20\n >>> df.equals(exactly_equal)\n True\n\n DataFrames df and different_column_type have the same element\n types and values, but have different types for the column labels,\n which will still return True.\n\n >>> different_column_type = pd.DataFrame({1.0: [10], 2.0: [20]})\n >>> different_column_type\n 1.0 2.0\n 0 10 20\n >>> df.equals(different_column_type)\n True\n\n DataFrames df and different_data_type have different types for the\n same values for their elements, and will return False even though\n their column labels are the same values and types.\n\n >>> different_data_type = pd.DataFrame({1: [10.0], 2: [20.0]})\n >>> different_data_type\n 1 2\n 0 10.0 20.0\n >>> df.equals(different_data_type)\n False\n \"\"\"\n if not isinstance(other, self._constructor):\n return False\n return self._data.equals(other._data)\n\n # -------------------------------------------------------------------------\n # Unary Methods\n\n def __neg__(self):\n values = self._values\n if is_bool_dtype(values):\n arr = operator.inv(values)\n elif (\n is_numeric_dtype(values)\n or is_timedelta64_dtype(values)\n or is_object_dtype(values)\n ):\n arr = operator.neg(values)\n else:\n raise TypeError(f\"Unary negative expects numeric dtype, not {values.dtype}\")\n return self.__array_wrap__(arr)\n\n def __pos__(self):\n values = self._values\n if is_bool_dtype(values):\n arr = values\n elif (\n is_numeric_dtype(values)\n or is_timedelta64_dtype(values)\n or is_object_dtype(values)\n ):\n arr = operator.pos(values)\n else:\n raise TypeError(f\"Unary plus expects numeric dtype, not {values.dtype}\")\n return self.__array_wrap__(arr)\n\n def __invert__(self):\n if not self.size:\n # inv fails with 0 len\n return self\n\n new_data = self._data.apply(operator.invert)\n result = self._constructor(new_data).__finalize__(self)\n return result\n\n def __nonzero__(self):\n raise ValueError(\n f\"The truth value of a {type(self).__name__} is ambiguous. \"\n \"Use a.empty, a.bool(), a.item(), a.any() or a.all().\"\n )\n\n __bool__ = __nonzero__\n\n def bool(self):\n \"\"\"\n Return the bool of a single element PandasObject.\n\n This must be a boolean scalar value, either True or False. Raise a\n ValueError if the PandasObject does not have exactly 1 element, or that\n element is not boolean\n\n Returns\n -------\n bool\n Same single boolean value converted to bool type.\n \"\"\"\n v = self.squeeze()\n if isinstance(v, (bool, np.bool_)):\n return bool(v)\n elif is_scalar(v):\n raise ValueError(\n \"bool cannot act on a non-boolean single element \"\n f\"{type(self).__name__}\"\n )\n\n self.__nonzero__()\n\n def __abs__(self: FrameOrSeries) -> FrameOrSeries:\n return self.abs()\n\n def __round__(self: FrameOrSeries, decimals: int = 0) -> FrameOrSeries:\n return self.round(decimals)\n\n # -------------------------------------------------------------------------\n # Label or Level Combination Helpers\n #\n # A collection of helper methods for DataFrame/Series operations that\n # accept a combination of column/index labels and levels. All such\n # operations should utilize/extend these methods when possible so that we\n # have consistent precedence and validation logic throughout the library.\n\n def _is_level_reference(self, key, axis=0):\n \"\"\"\n Test whether a key is a level reference for a given axis.\n\n To be considered a level reference, `key` must be a string that:\n - (axis=0): Matches the name of an index level and does NOT match\n a column label.\n - (axis=1): Matches the name of a column level and does NOT match\n an index label.\n\n Parameters\n ----------\n key : str\n Potential level name for the given axis\n axis : int, default 0\n Axis that levels are associated with (0 for index, 1 for columns)\n\n Returns\n -------\n is_level : bool\n \"\"\"\n axis = self._get_axis_number(axis)\n\n return (\n key is not None\n and is_hashable(key)\n and key in self.axes[axis].names\n and not self._is_label_reference(key, axis=axis)\n )\n\n def _is_label_reference(self, key, axis=0) -> bool_t:\n \"\"\"\n Test whether a key is a label reference for a given axis.\n\n To be considered a label reference, `key` must be a string that:\n - (axis=0): Matches a column label\n - (axis=1): Matches an index label\n\n Parameters\n ----------\n key: str\n Potential label name\n axis: int, default 0\n Axis perpendicular to the axis that labels are associated with\n (0 means search for column labels, 1 means search for index labels)\n\n Returns\n -------\n is_label: bool\n \"\"\"\n axis = self._get_axis_number(axis)\n other_axes = (ax for ax in range(self._AXIS_LEN) if ax != axis)\n\n return (\n key is not None\n and is_hashable(key)\n and any(key in self.axes[ax] for ax in other_axes)\n )\n\n def _is_label_or_level_reference(self, key: str, axis: int = 0) -> bool_t:\n \"\"\"\n Test whether a key is a label or level reference for a given axis.\n\n To be considered either a label or a level reference, `key` must be a\n string that:\n - (axis=0): Matches a column label or an index level\n - (axis=1): Matches an index label or a column level\n\n Parameters\n ----------\n key: str\n Potential label or level name\n axis: int, default 0\n Axis that levels are associated with (0 for index, 1 for columns)\n\n Returns\n -------\n is_label_or_level: bool\n \"\"\"\n return self._is_level_reference(key, axis=axis) or self._is_label_reference(\n key, axis=axis\n )\n\n def _check_label_or_level_ambiguity(self, key, axis: int = 0) -> None:\n \"\"\"\n Check whether `key` is ambiguous.\n\n By ambiguous, we mean that it matches both a level of the input\n `axis` and a label of the other axis.\n\n Parameters\n ----------\n key: str or object\n Label or level name.\n axis: int, default 0\n Axis that levels are associated with (0 for index, 1 for columns).\n\n Raises\n ------\n ValueError: `key` is ambiguous\n \"\"\"\n axis = self._get_axis_number(axis)\n other_axes = (ax for ax in range(self._AXIS_LEN) if ax != axis)\n\n if (\n key is not None\n and is_hashable(key)\n and key in self.axes[axis].names\n and any(key in self.axes[ax] for ax in other_axes)\n ):\n\n # Build an informative and grammatical warning\n level_article, level_type = (\n (\"an\", \"index\") if axis == 0 else (\"a\", \"column\")\n )\n\n label_article, label_type = (\n (\"a\", \"column\") if axis == 0 else (\"an\", \"index\")\n )\n\n msg = (\n f\"'{key}' is both {level_article} {level_type} level and \"\n f\"{label_article} {label_type} label, which is ambiguous.\"\n )\n raise ValueError(msg)\n\n def _get_label_or_level_values(self, key: str, axis: int = 0) -> np.ndarray:\n \"\"\"\n Return a 1-D array of values associated with `key`, a label or level\n from the given `axis`.\n\n Retrieval logic:\n - (axis=0): Return column values if `key` matches a column label.\n Otherwise return index level values if `key` matches an index\n level.\n - (axis=1): Return row values if `key` matches an index label.\n Otherwise return column level values if 'key' matches a column\n level\n\n Parameters\n ----------\n key: str\n Label or level name.\n axis: int, default 0\n Axis that levels are associated with (0 for index, 1 for columns)\n\n Returns\n -------\n values: np.ndarray\n\n Raises\n ------\n KeyError\n if `key` matches neither a label nor a level\n ValueError\n if `key` matches multiple labels\n FutureWarning\n if `key` is ambiguous. This will become an ambiguity error in a\n future version\n \"\"\"\n axis = self._get_axis_number(axis)\n other_axes = [ax for ax in range(self._AXIS_LEN) if ax != axis]\n\n if self._is_label_reference(key, axis=axis):\n self._check_label_or_level_ambiguity(key, axis=axis)\n values = self.xs(key, axis=other_axes[0])._values\n elif self._is_level_reference(key, axis=axis):\n values = self.axes[axis].get_level_values(key)._values\n else:\n raise KeyError(key)\n\n # Check for duplicates\n if values.ndim > 1:\n\n if other_axes and isinstance(self._get_axis(other_axes[0]), MultiIndex):\n multi_message = (\n \"\\n\"\n \"For a multi-index, the label must be a \"\n \"tuple with elements corresponding to each level.\"\n )\n else:\n multi_message = \"\"\n\n label_axis_name = \"column\" if axis == 0 else \"index\"\n raise ValueError(\n (\n f\"The {label_axis_name} label '{key}' \"\n f\"is not unique.{multi_message}\"\n )\n )\n\n return values\n\n def _drop_labels_or_levels(self, keys, axis: int = 0):\n \"\"\"\n Drop labels and/or levels for the given `axis`.\n\n For each key in `keys`:\n - (axis=0): If key matches a column label then drop the column.\n Otherwise if key matches an index level then drop the level.\n - (axis=1): If key matches an index label then drop the row.\n Otherwise if key matches a column level then drop the level.\n\n Parameters\n ----------\n keys: str or list of str\n labels or levels to drop\n axis: int, default 0\n Axis that levels are associated with (0 for index, 1 for columns)\n\n Returns\n -------\n dropped: DataFrame\n\n Raises\n ------\n ValueError\n if any `keys` match neither a label nor a level\n \"\"\"\n axis = self._get_axis_number(axis)\n\n # Validate keys\n keys = com.maybe_make_list(keys)\n invalid_keys = [\n k for k in keys if not self._is_label_or_level_reference(k, axis=axis)\n ]\n\n if invalid_keys:\n raise ValueError(\n (\n \"The following keys are not valid labels or \"\n f\"levels for axis {axis}: {invalid_keys}\"\n )\n )\n\n # Compute levels and labels to drop\n levels_to_drop = [k for k in keys if self._is_level_reference(k, axis=axis)]\n\n labels_to_drop = [k for k in keys if not self._is_level_reference(k, axis=axis)]\n\n # Perform copy upfront and then use inplace operations below.\n # This ensures that we always perform exactly one copy.\n # ``copy`` and/or ``inplace`` options could be added in the future.\n dropped = self.copy()\n\n if axis == 0:\n # Handle dropping index levels\n if levels_to_drop:\n dropped.reset_index(levels_to_drop, drop=True, inplace=True)\n\n # Handle dropping columns labels\n if labels_to_drop:\n dropped.drop(labels_to_drop, axis=1, inplace=True)\n else:\n # Handle dropping column levels\n if levels_to_drop:\n if isinstance(dropped.columns, MultiIndex):\n # Drop the specified levels from the MultiIndex\n dropped.columns = dropped.columns.droplevel(levels_to_drop)\n else:\n # Drop the last level of Index by replacing with\n # a RangeIndex\n dropped.columns = RangeIndex(dropped.columns.size)\n\n # Handle dropping index labels\n if labels_to_drop:\n dropped.drop(labels_to_drop, axis=0, inplace=True)\n\n return dropped\n\n # ----------------------------------------------------------------------\n # Iteration\n\n def __hash__(self):\n raise TypeError(\n f\"{repr(type(self).__name__)} objects are mutable, \"\n f\"thus they cannot be hashed\"\n )\n\n def __iter__(self):\n \"\"\"\n Iterate over info axis.\n\n Returns\n -------\n iterator\n Info axis as iterator.\n \"\"\"\n return iter(self._info_axis)\n\n # can we get a better explanation of this?\n def keys(self):\n \"\"\"\n Get the 'info axis' (see Indexing for more).\n\n This is index for Series, columns for DataFrame.\n\n Returns\n -------\n Index\n Info axis.\n \"\"\"\n return self._info_axis\n\n def items(self):\n \"\"\"\n Iterate over (label, values) on info axis\n\n This is index for Series and columns for DataFrame.\n\n Returns\n -------\n Generator\n \"\"\"\n for h in self._info_axis:\n yield h, self[h]\n\n @Appender(items.__doc__)\n def iteritems(self):\n return self.items()\n\n def __len__(self) -> int:\n \"\"\"Returns length of info axis\"\"\"\n return len(self._info_axis)\n\n def __contains__(self, key) -> bool_t:\n \"\"\"True if the key is in the info axis\"\"\"\n return key in self._info_axis\n\n @property\n def empty(self) -> bool_t:\n \"\"\"\n Indicator whether DataFrame is empty.\n\n True if DataFrame is entirely empty (no items), meaning any of the\n axes are of length 0.\n\n Returns\n -------\n bool\n If DataFrame is empty, return True, if not return False.\n\n See Also\n --------\n Series.dropna : Return series without null values.\n DataFrame.dropna : Return DataFrame with labels on given axis omitted\n where (all or any) data are missing.\n\n Notes\n -----\n If DataFrame contains only NaNs, it is still not considered empty. See\n the example below.\n\n Examples\n --------\n An example of an actual empty DataFrame. Notice the index is empty:\n\n >>> df_empty = pd.DataFrame({'A' : []})\n >>> df_empty\n Empty DataFrame\n Columns: [A]\n Index: []\n >>> df_empty.empty\n True\n\n If we only have NaNs in our DataFrame, it is not considered empty! We\n will need to drop the NaNs to make the DataFrame empty:\n\n >>> df = pd.DataFrame({'A' : [np.nan]})\n >>> df\n A\n 0 NaN\n >>> df.empty\n False\n >>> df.dropna().empty\n True\n \"\"\"\n return any(len(self._get_axis(a)) == 0 for a in self._AXIS_ORDERS)\n\n # ----------------------------------------------------------------------\n # Array Interface\n\n # This is also set in IndexOpsMixin\n # GH#23114 Ensure ndarray.__op__(DataFrame) returns NotImplemented\n __array_priority__ = 1000\n\n def __array__(self, dtype=None) -> np.ndarray:\n return np.asarray(self._values, dtype=dtype)\n\n def __array_wrap__(self, result, context=None):\n result = lib.item_from_zerodim(result)\n if is_scalar(result):\n # e.g. we get here with np.ptp(series)\n # ptp also requires the item_from_zerodim\n return result\n d = self._construct_axes_dict(self._AXIS_ORDERS, copy=False)\n return self._constructor(result, **d).__finalize__(self)\n\n # ideally we would define this to avoid the getattr checks, but\n # is slower\n # @property\n # def __array_interface__(self):\n # \"\"\" provide numpy array interface method \"\"\"\n # values = self.values\n # return dict(typestr=values.dtype.str,shape=values.shape,data=values)\n\n # ----------------------------------------------------------------------\n # Picklability\n\n def __getstate__(self) -> Dict[str, Any]:\n meta = {k: getattr(self, k, None) for k in self._metadata}\n return dict(\n _data=self._data,\n _typ=self._typ,\n _metadata=self._metadata,\n attrs=self.attrs,\n **meta,\n )\n\n def __setstate__(self, state):\n\n if isinstance(state, BlockManager):\n self._data = state\n elif isinstance(state, dict):\n typ = state.get(\"_typ\")\n if typ is not None:\n attrs = state.get(\"_attrs\", {})\n object.__setattr__(self, \"_attrs\", attrs)\n\n # set in the order of internal names\n # to avoid definitional recursion\n # e.g. say fill_value needing _data to be\n # defined\n meta = set(self._internal_names + self._metadata)\n for k in list(meta):\n if k in state:\n v = state[k]\n object.__setattr__(self, k, v)\n\n for k, v in state.items():\n if k not in meta:\n object.__setattr__(self, k, v)\n\n else:\n raise NotImplementedError(\"Pre-0.12 pickles are no longer supported\")\n elif len(state) == 2:\n raise NotImplementedError(\"Pre-0.12 pickles are no longer supported\")\n\n self._item_cache = {}\n\n # ----------------------------------------------------------------------\n # Rendering Methods\n\n def __repr__(self) -> str:\n # string representation based upon iterating over self\n # (since, by definition, `PandasContainers` are iterable)\n prepr = f\"[{','.join(map(pprint_thing, self))}]\"\n return f\"{type(self).__name__}({prepr})\"\n\n def _repr_latex_(self):\n \"\"\"\n Returns a LaTeX representation for a particular object.\n Mainly for use with nbconvert (jupyter notebook conversion to pdf).\n \"\"\"\n if config.get_option(\"display.latex.repr\"):\n return self.to_latex()\n else:\n return None\n\n def _repr_data_resource_(self):\n \"\"\"\n Not a real Jupyter special repr method, but we use the same\n naming convention.\n \"\"\"\n if config.get_option(\"display.html.table_schema\"):\n data = self.head(config.get_option(\"display.max_rows\"))\n payload = json.loads(\n data.to_json(orient=\"table\"), object_pairs_hook=collections.OrderedDict\n )\n return payload\n\n # ----------------------------------------------------------------------\n # I/O Methods\n\n _shared_docs[\n \"to_markdown\"\n ] = \"\"\"\n Print %(klass)s in Markdown-friendly format.\n\n .. versionadded:: 1.0.0\n\n Parameters\n ----------\n buf : str, Path or StringIO-like, optional, default None\n Buffer to write to. If None, the output is returned as a string.\n mode : str, optional\n Mode in which file is opened.\n **kwargs\n These parameters will be passed to `tabulate`.\n\n Returns\n -------\n str\n %(klass)s in Markdown-friendly format.\n \"\"\"\n\n _shared_docs[\n \"to_excel\"\n ] = \"\"\"\n Write %(klass)s to an Excel sheet.\n\n To write a single %(klass)s to an Excel .xlsx file it is only necessary to\n specify a target file name. To write to multiple sheets it is necessary to\n create an `ExcelWriter` object with a target file name, and specify a sheet\n in the file to write to.\n\n Multiple sheets may be written to by specifying unique `sheet_name`.\n With all data written to the file it is necessary to save the changes.\n Note that creating an `ExcelWriter` object with a file name that already\n exists will result in the contents of the existing file being erased.\n\n Parameters\n ----------\n excel_writer : str or ExcelWriter object\n File path or existing ExcelWriter.\n sheet_name : str, default 'Sheet1'\n Name of sheet which will contain DataFrame.\n na_rep : str, default ''\n Missing data representation.\n float_format : str, optional\n Format string for floating point numbers. For example\n ``float_format=\"%%.2f\"`` will format 0.1234 to 0.12.\n columns : sequence or list of str, optional\n Columns to write.\n header : bool or list of str, default True\n Write out the column names. If a list of string is given it is\n assumed to be aliases for the column names.\n index : bool, default True\n Write row names (index).\n index_label : str or sequence, optional\n Column label for index column(s) if desired. If not specified, and\n `header` and `index` are True, then the index names are used. A\n sequence should be given if the DataFrame uses MultiIndex.\n startrow : int, default 0\n Upper left cell row to dump data frame.\n startcol : int, default 0\n Upper left cell column to dump data frame.\n engine : str, optional\n Write engine to use, 'openpyxl' or 'xlsxwriter'. You can also set this\n via the options ``io.excel.xlsx.writer``, ``io.excel.xls.writer``, and\n ``io.excel.xlsm.writer``.\n merge_cells : bool, default True\n Write MultiIndex and Hierarchical Rows as merged cells.\n encoding : str, optional\n Encoding of the resulting excel file. Only necessary for xlwt,\n other writers support unicode natively.\n inf_rep : str, default 'inf'\n Representation for infinity (there is no native representation for\n infinity in Excel).\n verbose : bool, default True\n Display more information in the error logs.\n freeze_panes : tuple of int (length 2), optional\n Specifies the one-based bottommost row and rightmost column that\n is to be frozen.\n\n See Also\n --------\n to_csv : Write DataFrame to a comma-separated values (csv) file.\n ExcelWriter : Class for writing DataFrame objects into excel sheets.\n read_excel : Read an Excel file into a pandas DataFrame.\n read_csv : Read a comma-separated values (csv) file into DataFrame.\n\n Notes\n -----\n For compatibility with :meth:`~DataFrame.to_csv`,\n to_excel serializes lists and dicts to strings before writing.\n\n Once a workbook has been saved it is not possible write further data\n without rewriting the whole workbook.\n\n Examples\n --------\n\n Create, write to and save a workbook:\n\n >>> df1 = pd.DataFrame([['a', 'b'], ['c', 'd']],\n ... index=['row 1', 'row 2'],\n ... columns=['col 1', 'col 2'])\n >>> df1.to_excel(\"output.xlsx\") # doctest: +SKIP\n\n To specify the sheet name:\n\n >>> df1.to_excel(\"output.xlsx\",\n ... sheet_name='Sheet_name_1') # doctest: +SKIP\n\n If you wish to write to more than one sheet in the workbook, it is\n necessary to specify an ExcelWriter object:\n\n >>> df2 = df1.copy()\n >>> with pd.ExcelWriter('output.xlsx') as writer: # doctest: +SKIP\n ... df1.to_excel(writer, sheet_name='Sheet_name_1')\n ... df2.to_excel(writer, sheet_name='Sheet_name_2')\n\n ExcelWriter can also be used to append to an existing Excel file:\n\n >>> with pd.ExcelWriter('output.xlsx',\n ... mode='a') as writer: # doctest: +SKIP\n ... df.to_excel(writer, sheet_name='Sheet_name_3')\n\n To set the library that is used to write the Excel file,\n you can pass the `engine` keyword (the default engine is\n automatically chosen depending on the file extension):\n\n >>> df1.to_excel('output1.xlsx', engine='xlsxwriter') # doctest: +SKIP\n \"\"\"\n\n @Appender(_shared_docs[\"to_excel\"] % dict(klass=\"object\"))\n def to_excel(\n self,\n excel_writer,\n sheet_name=\"Sheet1\",\n na_rep=\"\",\n float_format=None,\n columns=None,\n header=True,\n index=True,\n index_label=None,\n startrow=0,\n startcol=0,\n engine=None,\n merge_cells=True,\n encoding=None,\n inf_rep=\"inf\",\n verbose=True,\n freeze_panes=None,\n ) -> None:\n df = self if isinstance(self, ABCDataFrame) else self.to_frame()\n\n from pandas.io.formats.excel import ExcelFormatter\n\n formatter = ExcelFormatter(\n df,\n na_rep=na_rep,\n cols=columns,\n header=header,\n float_format=float_format,\n index=index,\n index_label=index_label,\n merge_cells=merge_cells,\n inf_rep=inf_rep,\n )\n formatter.write(\n excel_writer,\n sheet_name=sheet_name,\n startrow=startrow,\n startcol=startcol,\n freeze_panes=freeze_panes,\n engine=engine,\n )\n\n def to_json(\n self,\n path_or_buf: Optional[FilePathOrBuffer] = None,\n orient: Optional[str] = None,\n date_format: Optional[str] = None,\n double_precision: int = 10,\n force_ascii: bool_t = True,\n date_unit: str = \"ms\",\n default_handler: Optional[Callable[[Any], JSONSerializable]] = None,\n lines: bool_t = False,\n compression: Optional[str] = \"infer\",\n index: bool_t = True,\n indent: Optional[int] = None,\n ) -> Optional[str]:\n \"\"\"\n Convert the object to a JSON string.\n\n Note NaN's and None will be converted to null and datetime objects\n will be converted to UNIX timestamps.\n\n Parameters\n ----------\n path_or_buf : str or file handle, optional\n File path or object. If not specified, the result is returned as\n a string.\n orient : str\n Indication of expected JSON string format.\n\n * Series:\n\n - default is 'index'\n - allowed values are: {'split','records','index','table'}.\n\n * DataFrame:\n\n - default is 'columns'\n - allowed values are: {'split', 'records', 'index', 'columns',\n 'values', 'table'}.\n\n * The format of the JSON string:\n\n - 'split' : dict like {'index' -> [index], 'columns' -> [columns],\n 'data' -> [values]}\n - 'records' : list like [{column -> value}, ... , {column -> value}]\n - 'index' : dict like {index -> {column -> value}}\n - 'columns' : dict like {column -> {index -> value}}\n - 'values' : just the values array\n - 'table' : dict like {'schema': {schema}, 'data': {data}}\n\n Describing the data, where data component is like ``orient='records'``.\n\n .. versionchanged:: 0.20.0\n\n date_format : {None, 'epoch', 'iso'}\n Type of date conversion. 'epoch' = epoch milliseconds,\n 'iso' = ISO8601. The default depends on the `orient`. For\n ``orient='table'``, the default is 'iso'. For all other orients,\n the default is 'epoch'.\n double_precision : int, default 10\n The number of decimal places to use when encoding\n floating point values.\n force_ascii : bool, default True\n Force encoded string to be ASCII.\n date_unit : str, default 'ms' (milliseconds)\n The time unit to encode to, governs timestamp and ISO8601\n precision. One of 's', 'ms', 'us', 'ns' for second, millisecond,\n microsecond, and nanosecond respectively.\n default_handler : callable, default None\n Handler to call if object cannot otherwise be converted to a\n suitable format for JSON. Should receive a single argument which is\n the object to convert and return a serialisable object.\n lines : bool, default False\n If 'orient' is 'records' write out line delimited json format. Will\n throw ValueError if incorrect 'orient' since others are not list\n like.\n\n compression : {'infer', 'gzip', 'bz2', 'zip', 'xz', None}\n\n A string representing the compression to use in the output file,\n only used when the first argument is a filename. By default, the\n compression is inferred from the filename.\n\n .. versionadded:: 0.21.0\n .. versionchanged:: 0.24.0\n 'infer' option added and set to default\n index : bool, default True\n Whether to include the index values in the JSON string. Not\n including the index (``index=False``) is only supported when\n orient is 'split' or 'table'.\n\n .. versionadded:: 0.23.0\n\n indent : int, optional\n Length of whitespace used to indent each record.\n\n .. versionadded:: 1.0.0\n\n Returns\n -------\n None or str\n If path_or_buf is None, returns the resulting json format as a\n string. Otherwise returns None.\n\n See Also\n --------\n read_json : Convert a JSON string to pandas object.\n\n Notes\n -----\n The behavior of ``indent=0`` varies from the stdlib, which does not\n indent the output but does insert newlines. Currently, ``indent=0``\n and the default ``indent=None`` are equivalent in pandas, though this\n may change in a future release.\n\n Examples\n --------\n >>> df = pd.DataFrame([['a', 'b'], ['c', 'd']],\n ... index=['row 1', 'row 2'],\n ... columns=['col 1', 'col 2'])\n >>> df.to_json(orient='split')\n '{\"columns\":[\"col 1\",\"col 2\"],\n \"index\":[\"row 1\",\"row 2\"],\n \"data\":[[\"a\",\"b\"],[\"c\",\"d\"]]}'\n\n Encoding/decoding a Dataframe using ``'records'`` formatted JSON.\n Note that index labels are not preserved with this encoding.\n\n >>> df.to_json(orient='records')\n '[{\"col 1\":\"a\",\"col 2\":\"b\"},{\"col 1\":\"c\",\"col 2\":\"d\"}]'\n\n Encoding/decoding a Dataframe using ``'index'`` formatted JSON:\n\n >>> df.to_json(orient='index')\n '{\"row 1\":{\"col 1\":\"a\",\"col 2\":\"b\"},\"row 2\":{\"col 1\":\"c\",\"col 2\":\"d\"}}'\n\n Encoding/decoding a Dataframe using ``'columns'`` formatted JSON:\n\n >>> df.to_json(orient='columns')\n '{\"col 1\":{\"row 1\":\"a\",\"row 2\":\"c\"},\"col 2\":{\"row 1\":\"b\",\"row 2\":\"d\"}}'\n\n Encoding/decoding a Dataframe using ``'values'`` formatted JSON:\n\n >>> df.to_json(orient='values')\n '[[\"a\",\"b\"],[\"c\",\"d\"]]'\n\n Encoding with Table Schema\n\n >>> df.to_json(orient='table')\n '{\"schema\": {\"fields\": [{\"name\": \"index\", \"type\": \"string\"},\n {\"name\": \"col 1\", \"type\": \"string\"},\n {\"name\": \"col 2\", \"type\": \"string\"}],\n \"primaryKey\": \"index\",\n \"pandas_version\": \"0.20.0\"},\n \"data\": [{\"index\": \"row 1\", \"col 1\": \"a\", \"col 2\": \"b\"},\n {\"index\": \"row 2\", \"col 1\": \"c\", \"col 2\": \"d\"}]}'\n \"\"\"\n from pandas.io import json\n\n if date_format is None and orient == \"table\":\n date_format = \"iso\"\n elif date_format is None:\n date_format = \"epoch\"\n\n config.is_nonnegative_int(indent)\n indent = indent or 0\n\n return json.to_json(\n path_or_buf=path_or_buf,\n obj=self,\n orient=orient,\n date_format=date_format,\n double_precision=double_precision,\n force_ascii=force_ascii,\n date_unit=date_unit,\n default_handler=default_handler,\n lines=lines,\n compression=compression,\n index=index,\n indent=indent,\n )\n\n def to_hdf(\n self,\n path_or_buf,\n key: str,\n mode: str = \"a\",\n complevel: Optional[int] = None,\n complib: Optional[str] = None,\n append: bool_t = False,\n format: Optional[str] = None,\n index: bool_t = True,\n min_itemsize: Optional[Union[int, Dict[str, int]]] = None,\n nan_rep=None,\n dropna: Optional[bool_t] = None,\n data_columns: Optional[List[str]] = None,\n errors: str = \"strict\",\n encoding: str = \"UTF-8\",\n ) -> None:\n \"\"\"\n Write the contained data to an HDF5 file using HDFStore.\n\n Hierarchical Data Format (HDF) is self-describing, allowing an\n application to interpret the structure and contents of a file with\n no outside information. One HDF file can hold a mix of related objects\n which can be accessed as a group or as individual objects.\n\n In order to add another DataFrame or Series to an existing HDF file\n please use append mode and a different a key.\n\n For more information see the :ref:`user guide <io.hdf5>`.\n\n Parameters\n ----------\n path_or_buf : str or pandas.HDFStore\n File path or HDFStore object.\n key : str\n Identifier for the group in the store.\n mode : {'a', 'w', 'r+'}, default 'a'\n Mode to open file:\n\n - 'w': write, a new file is created (an existing file with\n the same name would be deleted).\n - 'a': append, an existing file is opened for reading and\n writing, and if the file does not exist it is created.\n - 'r+': similar to 'a', but the file must already exist.\n complevel : {0-9}, optional\n Specifies a compression level for data.\n A value of 0 disables compression.\n complib : {'zlib', 'lzo', 'bzip2', 'blosc'}, default 'zlib'\n Specifies the compression library to be used.\n As of v0.20.2 these additional compressors for Blosc are supported\n (default if no compressor specified: 'blosc:blosclz'):\n {'blosc:blosclz', 'blosc:lz4', 'blosc:lz4hc', 'blosc:snappy',\n 'blosc:zlib', 'blosc:zstd'}.\n Specifying a compression library which is not available issues\n a ValueError.\n append : bool, default False\n For Table formats, append the input data to the existing.\n format : {'fixed', 'table', None}, default 'fixed'\n Possible values:\n\n - 'fixed': Fixed format. Fast writing/reading. Not-appendable,\n nor searchable.\n - 'table': Table format. Write as a PyTables Table structure\n which may perform worse but allow more flexible operations\n like searching / selecting subsets of the data.\n - If None, pd.get_option('io.hdf.default_format') is checked,\n followed by fallback to \"fixed\"\n errors : str, default 'strict'\n Specifies how encoding and decoding errors are to be handled.\n See the errors argument for :func:`open` for a full list\n of options.\n encoding : str, default \"UTF-8\"\n min_itemsize : dict or int, optional\n Map column names to minimum string sizes for columns.\n nan_rep : Any, optional\n How to represent null values as str.\n Not allowed with append=True.\n data_columns : list of columns or True, optional\n List of columns to create as indexed data columns for on-disk\n queries, or True to use all columns. By default only the axes\n of the object are indexed. See :ref:`io.hdf5-query-data-columns`.\n Applicable only to format='table'.\n\n See Also\n --------\n DataFrame.read_hdf : Read from HDF file.\n DataFrame.to_parquet : Write a DataFrame to the binary parquet format.\n DataFrame.to_sql : Write to a sql table.\n DataFrame.to_feather : Write out feather-format for DataFrames.\n DataFrame.to_csv : Write out to a csv file.\n\n Examples\n --------\n >>> df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]},\n ... index=['a', 'b', 'c'])\n >>> df.to_hdf('data.h5', key='df', mode='w')\n\n We can add another object to the same file:\n\n >>> s = pd.Series([1, 2, 3, 4])\n >>> s.to_hdf('data.h5', key='s')\n\n Reading from HDF file:\n\n >>> pd.read_hdf('data.h5', 'df')\n A B\n a 1 4\n b 2 5\n c 3 6\n >>> pd.read_hdf('data.h5', 's')\n 0 1\n 1 2\n 2 3\n 3 4\n dtype: int64\n\n Deleting file with data:\n\n >>> import os\n >>> os.remove('data.h5')\n \"\"\"\n from pandas.io import pytables\n\n pytables.to_hdf(\n path_or_buf,\n key,\n self,\n mode=mode,\n complevel=complevel,\n complib=complib,\n append=append,\n format=format,\n index=index,\n min_itemsize=min_itemsize,\n nan_rep=nan_rep,\n dropna=dropna,\n data_columns=data_columns,\n errors=errors,\n encoding=encoding,\n )\n\n def to_sql(\n self,\n name: str,\n con,\n schema=None,\n if_exists: str = \"fail\",\n index: bool_t = True,\n index_label=None,\n chunksize=None,\n dtype=None,\n method=None,\n ) -> None:\n \"\"\"\n Write records stored in a DataFrame to a SQL database.\n\n Databases supported by SQLAlchemy [1]_ are supported. Tables can be\n newly created, appended to, or overwritten.\n\n Parameters\n ----------\n name : str\n Name of SQL table.\n con : sqlalchemy.engine.Engine or sqlite3.Connection\n Using SQLAlchemy makes it possible to use any DB supported by that\n library. Legacy support is provided for sqlite3.Connection objects. The user\n is responsible for engine disposal and connection closure for the SQLAlchemy\n connectable See `here \\\n <https://docs.sqlalchemy.org/en/13/core/connections.html>`_.\n\n schema : str, optional\n Specify the schema (if database flavor supports this). If None, use\n default schema.\n if_exists : {'fail', 'replace', 'append'}, default 'fail'\n How to behave if the table already exists.\n\n * fail: Raise a ValueError.\n * replace: Drop the table before inserting new values.\n * append: Insert new values to the existing table.\n\n index : bool, default True\n Write DataFrame index as a column. Uses `index_label` as the column\n name in the table.\n index_label : str or sequence, default None\n Column label for index column(s). If None is given (default) and\n `index` is True, then the index names are used.\n A sequence should be given if the DataFrame uses MultiIndex.\n chunksize : int, optional\n Specify the number of rows in each batch to be written at a time.\n By default, all rows will be written at once.\n dtype : dict or scalar, optional\n Specifying the datatype for columns. If a dictionary is used, the\n keys should be the column names and the values should be the\n SQLAlchemy types or strings for the sqlite3 legacy mode. If a\n scalar is provided, it will be applied to all columns.\n method : {None, 'multi', callable}, optional\n Controls the SQL insertion clause used:\n\n * None : Uses standard SQL ``INSERT`` clause (one per row).\n * 'multi': Pass multiple values in a single ``INSERT`` clause.\n * callable with signature ``(pd_table, conn, keys, data_iter)``.\n\n Details and a sample callable implementation can be found in the\n section :ref:`insert method <io.sql.method>`.\n\n .. versionadded:: 0.24.0\n\n Raises\n ------\n ValueError\n When the table already exists and `if_exists` is 'fail' (the\n default).\n\n See Also\n --------\n read_sql : Read a DataFrame from a table.\n\n Notes\n -----\n Timezone aware datetime columns will be written as\n ``Timestamp with timezone`` type with SQLAlchemy if supported by the\n database. Otherwise, the datetimes will be stored as timezone unaware\n timestamps local to the original timezone.\n\n .. versionadded:: 0.24.0\n\n References\n ----------\n .. [1] https://docs.sqlalchemy.org\n .. [2] https://www.python.org/dev/peps/pep-0249/\n\n Examples\n --------\n Create an in-memory SQLite database.\n\n >>> from sqlalchemy import create_engine\n >>> engine = create_engine('sqlite://', echo=False)\n\n Create a table from scratch with 3 rows.\n\n >>> df = pd.DataFrame({'name' : ['User 1', 'User 2', 'User 3']})\n >>> df\n name\n 0 User 1\n 1 User 2\n 2 User 3\n\n >>> df.to_sql('users', con=engine)\n >>> engine.execute(\"SELECT * FROM users\").fetchall()\n [(0, 'User 1'), (1, 'User 2'), (2, 'User 3')]\n\n >>> df1 = pd.DataFrame({'name' : ['User 4', 'User 5']})\n >>> df1.to_sql('users', con=engine, if_exists='append')\n >>> engine.execute(\"SELECT * FROM users\").fetchall()\n [(0, 'User 1'), (1, 'User 2'), (2, 'User 3'),\n (0, 'User 4'), (1, 'User 5')]\n\n Overwrite the table with just ``df1``.\n\n >>> df1.to_sql('users', con=engine, if_exists='replace',\n ... index_label='id')\n >>> engine.execute(\"SELECT * FROM users\").fetchall()\n [(0, 'User 4'), (1, 'User 5')]\n\n Specify the dtype (especially useful for integers with missing values).\n Notice that while pandas is forced to store the data as floating point,\n the database supports nullable integers. When fetching the data with\n Python, we get back integer scalars.\n\n >>> df = pd.DataFrame({\"A\": [1, None, 2]})\n >>> df\n A\n 0 1.0\n 1 NaN\n 2 2.0\n\n >>> from sqlalchemy.types import Integer\n >>> df.to_sql('integers', con=engine, index=False,\n ... dtype={\"A\": Integer()})\n\n >>> engine.execute(\"SELECT * FROM integers\").fetchall()\n [(1,), (None,), (2,)]\n \"\"\"\n from pandas.io import sql\n\n sql.to_sql(\n self,\n name,\n con,\n schema=schema,\n if_exists=if_exists,\n index=index,\n index_label=index_label,\n chunksize=chunksize,\n dtype=dtype,\n method=method,\n )\n\n def to_pickle(\n self,\n path,\n compression: Optional[str] = \"infer\",\n protocol: int = pickle.HIGHEST_PROTOCOL,\n ) -> None:\n \"\"\"\n Pickle (serialize) object to file.\n\n Parameters\n ----------\n path : str\n File path where the pickled object will be stored.\n compression : {'infer', 'gzip', 'bz2', 'zip', 'xz', None}, \\\n default 'infer'\n A string representing the compression to use in the output file. By\n default, infers from the file extension in specified path.\n protocol : int\n Int which indicates which protocol should be used by the pickler,\n default HIGHEST_PROTOCOL (see [1]_ paragraph 12.1.2). The possible\n values are 0, 1, 2, 3, 4. A negative value for the protocol\n parameter is equivalent to setting its value to HIGHEST_PROTOCOL.\n\n .. [1] https://docs.python.org/3/library/pickle.html.\n .. versionadded:: 0.21.0.\n\n See Also\n --------\n read_pickle : Load pickled pandas object (or any object) from file.\n DataFrame.to_hdf : Write DataFrame to an HDF5 file.\n DataFrame.to_sql : Write DataFrame to a SQL database.\n DataFrame.to_parquet : Write a DataFrame to the binary parquet format.\n\n Examples\n --------\n >>> original_df = pd.DataFrame({\"foo\": range(5), \"bar\": range(5, 10)})\n >>> original_df\n foo bar\n 0 0 5\n 1 1 6\n 2 2 7\n 3 3 8\n 4 4 9\n >>> original_df.to_pickle(\"./dummy.pkl\")\n\n >>> unpickled_df = pd.read_pickle(\"./dummy.pkl\")\n >>> unpickled_df\n foo bar\n 0 0 5\n 1 1 6\n 2 2 7\n 3 3 8\n 4 4 9\n\n >>> import os\n >>> os.remove(\"./dummy.pkl\")\n \"\"\"\n from pandas.io.pickle import to_pickle\n\n to_pickle(self, path, compression=compression, protocol=protocol)\n\n def to_clipboard(\n self, excel: bool_t = True, sep: Optional[str] = None, **kwargs\n ) -> None:\n r\"\"\"\n Copy object to the system clipboard.\n\n Write a text representation of object to the system clipboard.\n This can be pasted into Excel, for example.\n\n Parameters\n ----------\n excel : bool, default True\n Produce output in a csv format for easy pasting into excel.\n\n - True, use the provided separator for csv pasting.\n - False, write a string representation of the object to the clipboard.\n\n sep : str, default ``'\\t'``\n Field delimiter.\n **kwargs\n These parameters will be passed to DataFrame.to_csv.\n\n See Also\n --------\n DataFrame.to_csv : Write a DataFrame to a comma-separated values\n (csv) file.\n read_clipboard : Read text from clipboard and pass to read_table.\n\n Notes\n -----\n Requirements for your platform.\n\n - Linux : `xclip`, or `xsel` (with `PyQt4` modules)\n - Windows : none\n - OS X : none\n\n Examples\n --------\n Copy the contents of a DataFrame to the clipboard.\n\n >>> df = pd.DataFrame([[1, 2, 3], [4, 5, 6]], columns=['A', 'B', 'C'])\n >>> df.to_clipboard(sep=',')\n ... # Wrote the following to the system clipboard:\n ... # ,A,B,C\n ... # 0,1,2,3\n ... # 1,4,5,6\n\n We can omit the index by passing the keyword `index` and setting\n it to false.\n\n >>> df.to_clipboard(sep=',', index=False)\n ... # Wrote the following to the system clipboard:\n ... # A,B,C\n ... # 1,2,3\n ... # 4,5,6\n \"\"\"\n from pandas.io import clipboards\n\n clipboards.to_clipboard(self, excel=excel, sep=sep, **kwargs)\n\n def to_xarray(self):\n \"\"\"\n Return an xarray object from the pandas object.\n\n Returns\n -------\n xarray.DataArray or xarray.Dataset\n Data in the pandas structure converted to Dataset if the object is\n a DataFrame, or a DataArray if the object is a Series.\n\n See Also\n --------\n DataFrame.to_hdf : Write DataFrame to an HDF5 file.\n DataFrame.to_parquet : Write a DataFrame to the binary parquet format.\n\n Notes\n -----\n See the `xarray docs <https://xarray.pydata.org/en/stable/>`__\n\n Examples\n --------\n >>> df = pd.DataFrame([('falcon', 'bird', 389.0, 2),\n ... ('parrot', 'bird', 24.0, 2),\n ... ('lion', 'mammal', 80.5, 4),\n ... ('monkey', 'mammal', np.nan, 4)],\n ... columns=['name', 'class', 'max_speed',\n ... 'num_legs'])\n >>> df\n name class max_speed num_legs\n 0 falcon bird 389.0 2\n 1 parrot bird 24.0 2\n 2 lion mammal 80.5 4\n 3 monkey mammal NaN 4\n\n >>> df.to_xarray()\n <xarray.Dataset>\n Dimensions: (index: 4)\n Coordinates:\n * index (index) int64 0 1 2 3\n Data variables:\n name (index) object 'falcon' 'parrot' 'lion' 'monkey'\n class (index) object 'bird' 'bird' 'mammal' 'mammal'\n max_speed (index) float64 389.0 24.0 80.5 nan\n num_legs (index) int64 2 2 4 4\n\n >>> df['max_speed'].to_xarray()\n <xarray.DataArray 'max_speed' (index: 4)>\n array([389. , 24. , 80.5, nan])\n Coordinates:\n * index (index) int64 0 1 2 3\n\n >>> dates = pd.to_datetime(['2018-01-01', '2018-01-01',\n ... '2018-01-02', '2018-01-02'])\n >>> df_multiindex = pd.DataFrame({'date': dates,\n ... 'animal': ['falcon', 'parrot',\n ... 'falcon', 'parrot'],\n ... 'speed': [350, 18, 361, 15]})\n >>> df_multiindex = df_multiindex.set_index(['date', 'animal'])\n\n >>> df_multiindex\n speed\n date animal\n 2018-01-01 falcon 350\n parrot 18\n 2018-01-02 falcon 361\n parrot 15\n\n >>> df_multiindex.to_xarray()\n <xarray.Dataset>\n Dimensions: (animal: 2, date: 2)\n Coordinates:\n * date (date) datetime64[ns] 2018-01-01 2018-01-02\n * animal (animal) object 'falcon' 'parrot'\n Data variables:\n speed (date, animal) int64 350 18 361 15\n \"\"\"\n xarray = import_optional_dependency(\"xarray\")\n\n if self.ndim == 1:\n return xarray.DataArray.from_series(self)\n else:\n return xarray.Dataset.from_dataframe(self)\n\n @Substitution(returns=fmt.return_docstring)\n def to_latex(\n self,\n buf=None,\n columns=None,\n col_space=None,\n header=True,\n index=True,\n na_rep=\"NaN\",\n formatters=None,\n float_format=None,\n sparsify=None,\n index_names=True,\n bold_rows=False,\n column_format=None,\n longtable=None,\n escape=None,\n encoding=None,\n decimal=\".\",\n multicolumn=None,\n multicolumn_format=None,\n multirow=None,\n caption=None,\n label=None,\n ):\n r\"\"\"\n Render object to a LaTeX tabular, longtable, or nested table/tabular.\n\n Requires ``\\usepackage{booktabs}``. The output can be copy/pasted\n into a main LaTeX document or read from an external file\n with ``\\input{table.tex}``.\n\n .. versionchanged:: 0.20.2\n Added to Series.\n\n .. versionchanged:: 1.0.0\n Added caption and label arguments.\n\n Parameters\n ----------\n buf : str, Path or StringIO-like, optional, default None\n Buffer to write to. If None, the output is returned as a string.\n columns : list of label, optional\n The subset of columns to write. Writes all columns by default.\n col_space : int, optional\n The minimum width of each column.\n header : bool or list of str, default True\n Write out the column names. If a list of strings is given,\n it is assumed to be aliases for the column names.\n index : bool, default True\n Write row names (index).\n na_rep : str, default 'NaN'\n Missing data representation.\n formatters : list of functions or dict of {str: function}, optional\n Formatter functions to apply to columns' elements by position or\n name. The result of each function must be a unicode string.\n List must be of length equal to the number of columns.\n float_format : one-parameter function or str, optional, default None\n Formatter for floating point numbers. For example\n ``float_format=\"%%.2f\"`` and ``float_format=\"{:0.2f}\".format`` will\n both result in 0.1234 being formatted as 0.12.\n sparsify : bool, optional\n Set to False for a DataFrame with a hierarchical index to print\n every multiindex key at each row. By default, the value will be\n read from the config module.\n index_names : bool, default True\n Prints the names of the indexes.\n bold_rows : bool, default False\n Make the row labels bold in the output.\n column_format : str, optional\n The columns format as specified in `LaTeX table format\n <https://en.wikibooks.org/wiki/LaTeX/Tables>`__ e.g. 'rcl' for 3\n columns. By default, 'l' will be used for all columns except\n columns of numbers, which default to 'r'.\n longtable : bool, optional\n By default, the value will be read from the pandas config\n module. Use a longtable environment instead of tabular. Requires\n adding a \\usepackage{longtable} to your LaTeX preamble.\n escape : bool, optional\n By default, the value will be read from the pandas config\n module. When set to False prevents from escaping latex special\n characters in column names.\n encoding : str, optional\n A string representing the encoding to use in the output file,\n defaults to 'utf-8'.\n decimal : str, default '.'\n Character recognized as decimal separator, e.g. ',' in Europe.\n multicolumn : bool, default True\n Use \\multicolumn to enhance MultiIndex columns.\n The default will be read from the config module.\n multicolumn_format : str, default 'l'\n The alignment for multicolumns, similar to `column_format`\n The default will be read from the config module.\n multirow : bool, default False\n Use \\multirow to enhance MultiIndex rows. Requires adding a\n \\usepackage{multirow} to your LaTeX preamble. Will print\n centered labels (instead of top-aligned) across the contained\n rows, separating groups via clines. The default will be read\n from the pandas config module.\n caption : str, optional\n The LaTeX caption to be placed inside ``\\caption{}`` in the output.\n\n .. versionadded:: 1.0.0\n\n label : str, optional\n The LaTeX label to be placed inside ``\\label{}`` in the output.\n This is used with ``\\ref{}`` in the main ``.tex`` file.\n\n .. versionadded:: 1.0.0\n %(returns)s\n See Also\n --------\n DataFrame.to_string : Render a DataFrame to a console-friendly\n tabular output.\n DataFrame.to_html : Render a DataFrame as an HTML table.\n\n Examples\n --------\n >>> df = pd.DataFrame({'name': ['Raphael', 'Donatello'],\n ... 'mask': ['red', 'purple'],\n ... 'weapon': ['sai', 'bo staff']})\n >>> print(df.to_latex(index=False)) # doctest: +NORMALIZE_WHITESPACE\n \\begin{tabular}{lll}\n \\toprule\n name & mask & weapon \\\\\n \\midrule\n Raphael & red & sai \\\\\n Donatello & purple & bo staff \\\\\n \\bottomrule\n \\end{tabular}\n \"\"\"\n # Get defaults from the pandas config\n if self.ndim == 1:\n self = self.to_frame()\n if longtable is None:\n longtable = config.get_option(\"display.latex.longtable\")\n if escape is None:\n escape = config.get_option(\"display.latex.escape\")\n if multicolumn is None:\n multicolumn = config.get_option(\"display.latex.multicolumn\")\n if multicolumn_format is None:\n multicolumn_format = config.get_option(\"display.latex.multicolumn_format\")\n if multirow is None:\n multirow = config.get_option(\"display.latex.multirow\")\n\n formatter = DataFrameFormatter(\n self,\n columns=columns,\n col_space=col_space,\n na_rep=na_rep,\n header=header,\n index=index,\n formatters=formatters,\n float_format=float_format,\n bold_rows=bold_rows,\n sparsify=sparsify,\n index_names=index_names,\n escape=escape,\n decimal=decimal,\n )\n return formatter.to_latex(\n buf=buf,\n column_format=column_format,\n longtable=longtable,\n encoding=encoding,\n multicolumn=multicolumn,\n multicolumn_format=multicolumn_format,\n multirow=multirow,\n caption=caption,\n label=label,\n )\n\n def to_csv(\n self,\n path_or_buf: Optional[FilePathOrBuffer] = None,\n sep: str = \",\",\n na_rep: str = \"\",\n float_format: Optional[str] = None,\n columns: Optional[Sequence[Label]] = None,\n header: Union[bool_t, List[str]] = True,\n index: bool_t = True,\n index_label: Optional[Union[bool_t, str, Sequence[Label]]] = None,\n mode: str = \"w\",\n encoding: Optional[str] = None,\n compression: Optional[Union[str, Mapping[str, str]]] = \"infer\",\n quoting: Optional[int] = None,\n quotechar: str = '\"',\n line_terminator: Optional[str] = None,\n chunksize: Optional[int] = None,\n date_format: Optional[str] = None,\n doublequote: bool_t = True,\n escapechar: Optional[str] = None,\n decimal: Optional[str] = \".\",\n ) -> Optional[str]:\n r\"\"\"\n Write object to a comma-separated values (csv) file.\n\n .. versionchanged:: 0.24.0\n The order of arguments for Series was changed.\n\n Parameters\n ----------\n path_or_buf : str or file handle, default None\n File path or object, if None is provided the result is returned as\n a string. If a file object is passed it should be opened with\n `newline=''`, disabling universal newlines.\n\n .. versionchanged:: 0.24.0\n\n Was previously named \"path\" for Series.\n\n sep : str, default ','\n String of length 1. Field delimiter for the output file.\n na_rep : str, default ''\n Missing data representation.\n float_format : str, default None\n Format string for floating point numbers.\n columns : sequence, optional\n Columns to write.\n header : bool or list of str, default True\n Write out the column names. If a list of strings is given it is\n assumed to be aliases for the column names.\n\n .. versionchanged:: 0.24.0\n\n Previously defaulted to False for Series.\n\n index : bool, default True\n Write row names (index).\n index_label : str or sequence, or False, default None\n Column label for index column(s) if desired. If None is given, and\n `header` and `index` are True, then the index names are used. A\n sequence should be given if the object uses MultiIndex. If\n False do not print fields for index names. Use index_label=False\n for easier importing in R.\n mode : str\n Python write mode, default 'w'.\n encoding : str, optional\n A string representing the encoding to use in the output file,\n defaults to 'utf-8'.\n compression : str or dict, default 'infer'\n If str, represents compression mode. If dict, value at 'method' is\n the compression mode. Compression mode may be any of the following\n possible values: {'infer', 'gzip', 'bz2', 'zip', 'xz', None}. If\n compression mode is 'infer' and `path_or_buf` is path-like, then\n detect compression mode from the following extensions: '.gz',\n '.bz2', '.zip' or '.xz'. (otherwise no compression). If dict given\n and mode is 'zip' or inferred as 'zip', other entries passed as\n additional compression options.\n\n .. versionchanged:: 1.0.0\n\n May now be a dict with key 'method' as compression mode\n and other entries as additional compression options if\n compression mode is 'zip'.\n\n quoting : optional constant from csv module\n Defaults to csv.QUOTE_MINIMAL. If you have set a `float_format`\n then floats are converted to strings and thus csv.QUOTE_NONNUMERIC\n will treat them as non-numeric.\n quotechar : str, default '\\\"'\n String of length 1. Character used to quote fields.\n line_terminator : str, optional\n The newline character or character sequence to use in the output\n file. Defaults to `os.linesep`, which depends on the OS in which\n this method is called ('\\n' for linux, '\\r\\n' for Windows, i.e.).\n\n .. versionchanged:: 0.24.0\n chunksize : int or None\n Rows to write at a time.\n date_format : str, default None\n Format string for datetime objects.\n doublequote : bool, default True\n Control quoting of `quotechar` inside a field.\n escapechar : str, default None\n String of length 1. Character used to escape `sep` and `quotechar`\n when appropriate.\n decimal : str, default '.'\n Character recognized as decimal separator. E.g. use ',' for\n European data.\n\n Returns\n -------\n None or str\n If path_or_buf is None, returns the resulting csv format as a\n string. Otherwise returns None.\n\n See Also\n --------\n read_csv : Load a CSV file into a DataFrame.\n to_excel : Write DataFrame to an Excel file.\n\n Examples\n --------\n >>> df = pd.DataFrame({'name': ['Raphael', 'Donatello'],\n ... 'mask': ['red', 'purple'],\n ... 'weapon': ['sai', 'bo staff']})\n >>> df.to_csv(index=False)\n 'name,mask,weapon\\nRaphael,red,sai\\nDonatello,purple,bo staff\\n'\n\n Create 'out.zip' containing 'out.csv'\n\n >>> compression_opts = dict(method='zip',\n ... archive_name='out.csv') # doctest: +SKIP\n >>> df.to_csv('out.zip', index=False,\n ... compression=compression_opts) # doctest: +SKIP\n \"\"\"\n df = self if isinstance(self, ABCDataFrame) else self.to_frame()\n\n from pandas.io.formats.csvs import CSVFormatter\n\n formatter = CSVFormatter(\n df,\n path_or_buf,\n line_terminator=line_terminator,\n sep=sep,\n encoding=encoding,\n compression=compression,\n quoting=quoting,\n na_rep=na_rep,\n float_format=float_format,\n cols=columns,\n header=header,\n index=index,\n index_label=index_label,\n mode=mode,\n chunksize=chunksize,\n quotechar=quotechar,\n date_format=date_format,\n doublequote=doublequote,\n escapechar=escapechar,\n decimal=decimal,\n )\n formatter.save()\n\n if path_or_buf is None:\n return formatter.path_or_buf.getvalue()\n\n return None\n\n # ----------------------------------------------------------------------\n # Lookup Caching\n\n def _set_as_cached(self, item, cacher) -> None:\n \"\"\"\n Set the _cacher attribute on the calling object with a weakref to\n cacher.\n \"\"\"\n self._cacher = (item, weakref.ref(cacher))\n\n def _reset_cacher(self) -> None:\n \"\"\"\n Reset the cacher.\n \"\"\"\n if hasattr(self, \"_cacher\"):\n del self._cacher\n\n def _maybe_cache_changed(self, item, value) -> None:\n \"\"\"\n The object has called back to us saying maybe it has changed.\n \"\"\"\n self._data.set(item, value)\n\n @property\n def _is_cached(self) -> bool_t:\n \"\"\"Return boolean indicating if self is cached or not.\"\"\"\n return getattr(self, \"_cacher\", None) is not None\n\n def _get_cacher(self):\n \"\"\"return my cacher or None\"\"\"\n cacher = getattr(self, \"_cacher\", None)\n if cacher is not None:\n cacher = cacher[1]()\n return cacher\n\n def _maybe_update_cacher(\n self, clear: bool_t = False, verify_is_copy: bool_t = True\n ) -> None:\n \"\"\"\n See if we need to update our parent cacher if clear, then clear our\n cache.\n\n Parameters\n ----------\n clear : bool, default False\n Clear the item cache.\n verify_is_copy : bool, default True\n Provide is_copy checks.\n \"\"\"\n cacher = getattr(self, \"_cacher\", None)\n if cacher is not None:\n ref = cacher[1]()\n\n # we are trying to reference a dead referant, hence\n # a copy\n if ref is None:\n del self._cacher\n else:\n # Note: we need to call ref._maybe_cache_changed even in the\n # case where it will raise. (Uh, not clear why)\n try:\n ref._maybe_cache_changed(cacher[0], self)\n except AssertionError:\n # ref._data.setitem can raise\n # AssertionError because of shape mismatch\n pass\n\n if verify_is_copy:\n self._check_setitem_copy(stacklevel=5, t=\"referant\")\n\n if clear:\n self._clear_item_cache()\n\n def _clear_item_cache(self) -> None:\n self._item_cache.clear()\n\n # ----------------------------------------------------------------------\n # Indexing Methods\n\n def take(\n self: FrameOrSeries, indices, axis=0, is_copy: Optional[bool_t] = None, **kwargs\n ) -> FrameOrSeries:\n \"\"\"\n Return the elements in the given *positional* indices along an axis.\n\n This means that we are not indexing according to actual values in\n the index attribute of the object. We are indexing according to the\n actual position of the element in the object.\n\n Parameters\n ----------\n indices : array-like\n An array of ints indicating which positions to take.\n axis : {0 or 'index', 1 or 'columns', None}, default 0\n The axis on which to select elements. ``0`` means that we are\n selecting rows, ``1`` means that we are selecting columns.\n is_copy : bool\n Before pandas 1.0, ``is_copy=False`` can be specified to ensure\n that the return value is an actual copy. Starting with pandas 1.0,\n ``take`` always returns a copy, and the keyword is therefore\n deprecated.\n\n .. deprecated:: 1.0.0\n **kwargs\n For compatibility with :meth:`numpy.take`. Has no effect on the\n output.\n\n Returns\n -------\n taken : same type as caller\n An array-like containing the elements taken from the object.\n\n See Also\n --------\n DataFrame.loc : Select a subset of a DataFrame by labels.\n DataFrame.iloc : Select a subset of a DataFrame by positions.\n numpy.take : Take elements from an array along an axis.\n\n Examples\n --------\n >>> df = pd.DataFrame([('falcon', 'bird', 389.0),\n ... ('parrot', 'bird', 24.0),\n ... ('lion', 'mammal', 80.5),\n ... ('monkey', 'mammal', np.nan)],\n ... columns=['name', 'class', 'max_speed'],\n ... index=[0, 2, 3, 1])\n >>> df\n name class max_speed\n 0 falcon bird 389.0\n 2 parrot bird 24.0\n 3 lion mammal 80.5\n 1 monkey mammal NaN\n\n Take elements at positions 0 and 3 along the axis 0 (default).\n\n Note how the actual indices selected (0 and 1) do not correspond to\n our selected indices 0 and 3. That's because we are selecting the 0th\n and 3rd rows, not rows whose indices equal 0 and 3.\n\n >>> df.take([0, 3])\n name class max_speed\n 0 falcon bird 389.0\n 1 monkey mammal NaN\n\n Take elements at indices 1 and 2 along the axis 1 (column selection).\n\n >>> df.take([1, 2], axis=1)\n class max_speed\n 0 bird 389.0\n 2 bird 24.0\n 3 mammal 80.5\n 1 mammal NaN\n\n We may take elements using negative integers for positive indices,\n starting from the end of the object, just like with Python lists.\n\n >>> df.take([-1, -2])\n name class max_speed\n 1 monkey mammal NaN\n 3 lion mammal 80.5\n \"\"\"\n if is_copy is not None:\n warnings.warn(\n \"is_copy is deprecated and will be removed in a future version. \"\n \"'take' always returns a copy, so there is no need to specify this.\",\n FutureWarning,\n stacklevel=2,\n )\n\n nv.validate_take(tuple(), kwargs)\n\n self._consolidate_inplace()\n\n new_data = self._data.take(\n indices, axis=self._get_block_manager_axis(axis), verify=True\n )\n return self._constructor(new_data).__finalize__(self)\n\n def _take_with_is_copy(self: FrameOrSeries, indices, axis=0) -> FrameOrSeries:\n \"\"\"\n Internal version of the `take` method that sets the `_is_copy`\n attribute to keep track of the parent dataframe (using in indexing\n for the SettingWithCopyWarning).\n\n See the docstring of `take` for full explanation of the parameters.\n \"\"\"\n result = self.take(indices=indices, axis=axis)\n # Maybe set copy if we didn't actually change the index.\n if not result._get_axis(axis).equals(self._get_axis(axis)):\n result._set_is_copy(self)\n return result\n\n def xs(self, key, axis=0, level=None, drop_level: bool_t = True):\n \"\"\"\n Return cross-section from the Series/DataFrame.\n\n This method takes a `key` argument to select data at a particular\n level of a MultiIndex.\n\n Parameters\n ----------\n key : label or tuple of label\n Label contained in the index, or partially in a MultiIndex.\n axis : {0 or 'index', 1 or 'columns'}, default 0\n Axis to retrieve cross-section on.\n level : object, defaults to first n levels (n=1 or len(key))\n In case of a key partially contained in a MultiIndex, indicate\n which levels are used. Levels can be referred by label or position.\n drop_level : bool, default True\n If False, returns object with same levels as self.\n\n Returns\n -------\n Series or DataFrame\n Cross-section from the original Series or DataFrame\n corresponding to the selected index levels.\n\n See Also\n --------\n DataFrame.loc : Access a group of rows and columns\n by label(s) or a boolean array.\n DataFrame.iloc : Purely integer-location based indexing\n for selection by position.\n\n Notes\n -----\n `xs` can not be used to set values.\n\n MultiIndex Slicers is a generic way to get/set values on\n any level or levels.\n It is a superset of `xs` functionality, see\n :ref:`MultiIndex Slicers <advanced.mi_slicers>`.\n\n Examples\n --------\n >>> d = {'num_legs': [4, 4, 2, 2],\n ... 'num_wings': [0, 0, 2, 2],\n ... 'class': ['mammal', 'mammal', 'mammal', 'bird'],\n ... 'animal': ['cat', 'dog', 'bat', 'penguin'],\n ... 'locomotion': ['walks', 'walks', 'flies', 'walks']}\n >>> df = pd.DataFrame(data=d)\n >>> df = df.set_index(['class', 'animal', 'locomotion'])\n >>> df\n num_legs num_wings\n class animal locomotion\n mammal cat walks 4 0\n dog walks 4 0\n bat flies 2 2\n bird penguin walks 2 2\n\n Get values at specified index\n\n >>> df.xs('mammal')\n num_legs num_wings\n animal locomotion\n cat walks 4 0\n dog walks 4 0\n bat flies 2 2\n\n Get values at several indexes\n\n >>> df.xs(('mammal', 'dog'))\n num_legs num_wings\n locomotion\n walks 4 0\n\n Get values at specified index and level\n\n >>> df.xs('cat', level=1)\n num_legs num_wings\n class locomotion\n mammal walks 4 0\n\n Get values at several indexes and levels\n\n >>> df.xs(('bird', 'walks'),\n ... level=[0, 'locomotion'])\n num_legs num_wings\n animal\n penguin 2 2\n\n Get values at specified column and axis\n\n >>> df.xs('num_wings', axis=1)\n class animal locomotion\n mammal cat walks 0\n dog walks 0\n bat flies 2\n bird penguin walks 2\n Name: num_wings, dtype: int64\n \"\"\"\n axis = self._get_axis_number(axis)\n labels = self._get_axis(axis)\n if level is not None:\n loc, new_ax = labels.get_loc_level(key, level=level, drop_level=drop_level)\n\n # create the tuple of the indexer\n _indexer = [slice(None)] * self.ndim\n _indexer[axis] = loc\n indexer = tuple(_indexer)\n\n result = self.iloc[indexer]\n setattr(result, result._get_axis_name(axis), new_ax)\n return result\n\n if axis == 1:\n return self[key]\n\n self._consolidate_inplace()\n\n index = self.index\n if isinstance(index, MultiIndex):\n loc, new_index = self.index.get_loc_level(key, drop_level=drop_level)\n else:\n loc = self.index.get_loc(key)\n\n if isinstance(loc, np.ndarray):\n if loc.dtype == np.bool_:\n (inds,) = loc.nonzero()\n return self._take_with_is_copy(inds, axis=axis)\n else:\n return self._take_with_is_copy(loc, axis=axis)\n\n if not is_scalar(loc):\n new_index = self.index[loc]\n\n if is_scalar(loc):\n # In this case loc should be an integer\n if self.ndim == 1:\n # if we encounter an array-like and we only have 1 dim\n # that means that their are list/ndarrays inside the Series!\n # so just return them (GH 6394)\n return self._values[loc]\n\n new_values = self._data.fast_xs(loc)\n\n result = self._constructor_sliced(\n new_values,\n index=self.columns,\n name=self.index[loc],\n dtype=new_values.dtype,\n )\n\n else:\n result = self.iloc[loc]\n result.index = new_index\n\n # this could be a view\n # but only in a single-dtyped view sliceable case\n result._set_is_copy(self, copy=not result._is_view)\n return result\n\n _xs: Callable = xs\n\n def __getitem__(self, item):\n raise AbstractMethodError(self)\n\n def _get_item_cache(self, item):\n \"\"\"Return the cached item, item represents a label indexer.\"\"\"\n cache = self._item_cache\n res = cache.get(item)\n if res is None:\n values = self._data.get(item)\n res = self._box_item_values(item, values)\n cache[item] = res\n res._set_as_cached(item, self)\n\n # for a chain\n res._is_copy = self._is_copy\n return res\n\n def _box_item_values(self, key, values):\n raise AbstractMethodError(self)\n\n def _slice(self: FrameOrSeries, slobj: slice, axis=0) -> FrameOrSeries:\n \"\"\"\n Construct a slice of this container.\n\n Slicing with this method is *always* positional.\n \"\"\"\n assert isinstance(slobj, slice), type(slobj)\n axis = self._get_block_manager_axis(axis)\n result = self._constructor(self._data.get_slice(slobj, axis=axis))\n result = result.__finalize__(self)\n\n # this could be a view\n # but only in a single-dtyped view sliceable case\n is_copy = axis != 0 or result._is_view\n result._set_is_copy(self, copy=is_copy)\n return result\n\n def _set_item(self, key, value) -> None:\n self._data.set(key, value)\n self._clear_item_cache()\n\n def _set_is_copy(self, ref, copy: bool_t = True) -> None:\n if not copy:\n self._is_copy = None\n else:\n assert ref is not None\n self._is_copy = weakref.ref(ref)\n\n def _check_is_chained_assignment_possible(self) -> bool_t:\n \"\"\"\n Check if we are a view, have a cacher, and are of mixed type.\n If so, then force a setitem_copy check.\n\n Should be called just near setting a value\n\n Will return a boolean if it we are a view and are cached, but a\n single-dtype meaning that the cacher should be updated following\n setting.\n \"\"\"\n if self._is_view and self._is_cached:\n ref = self._get_cacher()\n if ref is not None and ref._is_mixed_type:\n self._check_setitem_copy(stacklevel=4, t=\"referant\", force=True)\n return True\n elif self._is_copy:\n self._check_setitem_copy(stacklevel=4, t=\"referant\")\n return False\n\n def _check_setitem_copy(self, stacklevel=4, t=\"setting\", force=False):\n \"\"\"\n\n Parameters\n ----------\n stacklevel : int, default 4\n the level to show of the stack when the error is output\n t : str, the type of setting error\n force : bool, default False\n If True, then force showing an error.\n\n validate if we are doing a setitem on a chained copy.\n\n If you call this function, be sure to set the stacklevel such that the\n user will see the error *at the level of setting*\n\n It is technically possible to figure out that we are setting on\n a copy even WITH a multi-dtyped pandas object. In other words, some\n blocks may be views while other are not. Currently _is_view will ALWAYS\n return False for multi-blocks to avoid having to handle this case.\n\n df = DataFrame(np.arange(0,9), columns=['count'])\n df['group'] = 'b'\n\n # This technically need not raise SettingWithCopy if both are view\n # (which is not # generally guaranteed but is usually True. However,\n # this is in general not a good practice and we recommend using .loc.\n df.iloc[0:5]['group'] = 'a'\n\n \"\"\"\n # return early if the check is not needed\n if not (force or self._is_copy):\n return\n\n value = config.get_option(\"mode.chained_assignment\")\n if value is None:\n return\n\n # see if the copy is not actually referred; if so, then dissolve\n # the copy weakref\n if self._is_copy is not None and not isinstance(self._is_copy, str):\n r = self._is_copy()\n if not gc.get_referents(r) or r.shape == self.shape:\n self._is_copy = None\n return\n\n # a custom message\n if isinstance(self._is_copy, str):\n t = self._is_copy\n\n elif t == \"referant\":\n t = (\n \"\\n\"\n \"A value is trying to be set on a copy of a slice from a \"\n \"DataFrame\\n\\n\"\n \"See the caveats in the documentation: \"\n \"https://pandas.pydata.org/pandas-docs/stable/user_guide/\"\n \"indexing.html#returning-a-view-versus-a-copy\"\n )\n\n else:\n t = (\n \"\\n\"\n \"A value is trying to be set on a copy of a slice from a \"\n \"DataFrame.\\n\"\n \"Try using .loc[row_indexer,col_indexer] = value \"\n \"instead\\n\\nSee the caveats in the documentation: \"\n \"https://pandas.pydata.org/pandas-docs/stable/user_guide/\"\n \"indexing.html#returning-a-view-versus-a-copy\"\n )\n\n if value == \"raise\":\n raise com.SettingWithCopyError(t)\n elif value == \"warn\":\n warnings.warn(t, com.SettingWithCopyWarning, stacklevel=stacklevel)\n\n def __delitem__(self, key) -> None:\n \"\"\"\n Delete item\n \"\"\"\n deleted = False\n\n maybe_shortcut = False\n if self.ndim == 2 and isinstance(self.columns, MultiIndex):\n try:\n maybe_shortcut = key not in self.columns._engine\n except TypeError:\n pass\n\n if maybe_shortcut:\n # Allow shorthand to delete all columns whose first len(key)\n # elements match key:\n if not isinstance(key, tuple):\n key = (key,)\n for col in self.columns:\n if isinstance(col, tuple) and col[: len(key)] == key:\n del self[col]\n deleted = True\n if not deleted:\n # If the above loop ran and didn't delete anything because\n # there was no match, this call should raise the appropriate\n # exception:\n self._data.delete(key)\n\n # delete from the caches\n try:\n del self._item_cache[key]\n except KeyError:\n pass\n\n # ----------------------------------------------------------------------\n # Unsorted\n\n def get(self, key, default=None):\n \"\"\"\n Get item from object for given key (ex: DataFrame column).\n\n Returns default value if not found.\n\n Parameters\n ----------\n key : object\n\n Returns\n -------\n value : same type as items contained in object\n \"\"\"\n try:\n return self[key]\n except (KeyError, ValueError, IndexError):\n return default\n\n @property\n def _is_view(self) -> bool_t:\n \"\"\"Return boolean indicating if self is view of another array \"\"\"\n return self._data.is_view\n\n def reindex_like(\n self: FrameOrSeries,\n other,\n method: Optional[str] = None,\n copy: bool_t = True,\n limit=None,\n tolerance=None,\n ) -> FrameOrSeries:\n \"\"\"\n Return an object with matching indices as other object.\n\n Conform the object to the same index on all axes. Optional\n filling logic, placing NaN in locations having no value\n in the previous index. A new object is produced unless the\n new index is equivalent to the current one and copy=False.\n\n Parameters\n ----------\n other : Object of the same data type\n Its row and column indices are used to define the new indices\n of this object.\n method : {None, 'backfill'/'bfill', 'pad'/'ffill', 'nearest'}\n Method to use for filling holes in reindexed DataFrame.\n Please note: this is only applicable to DataFrames/Series with a\n monotonically increasing/decreasing index.\n\n * None (default): don't fill gaps\n * pad / ffill: propagate last valid observation forward to next\n valid\n * backfill / bfill: use next valid observation to fill gap\n * nearest: use nearest valid observations to fill gap.\n\n copy : bool, default True\n Return a new object, even if the passed indexes are the same.\n limit : int, default None\n Maximum number of consecutive labels to fill for inexact matches.\n tolerance : optional\n Maximum distance between original and new labels for inexact\n matches. The values of the index at the matching locations most\n satisfy the equation ``abs(index[indexer] - target) <= tolerance``.\n\n Tolerance may be a scalar value, which applies the same tolerance\n to all values, or list-like, which applies variable tolerance per\n element. List-like includes list, tuple, array, Series, and must be\n the same size as the index and its dtype must exactly match the\n index's type.\n\n .. versionadded:: 0.21.0 (list-like tolerance)\n\n Returns\n -------\n Series or DataFrame\n Same type as caller, but with changed indices on each axis.\n\n See Also\n --------\n DataFrame.set_index : Set row labels.\n DataFrame.reset_index : Remove row labels or move them to new columns.\n DataFrame.reindex : Change to new indices or expand indices.\n\n Notes\n -----\n Same as calling\n ``.reindex(index=other.index, columns=other.columns,...)``.\n\n Examples\n --------\n >>> df1 = pd.DataFrame([[24.3, 75.7, 'high'],\n ... [31, 87.8, 'high'],\n ... [22, 71.6, 'medium'],\n ... [35, 95, 'medium']],\n ... columns=['temp_celsius', 'temp_fahrenheit',\n ... 'windspeed'],\n ... index=pd.date_range(start='2014-02-12',\n ... end='2014-02-15', freq='D'))\n\n >>> df1\n temp_celsius temp_fahrenheit windspeed\n 2014-02-12 24.3 75.7 high\n 2014-02-13 31.0 87.8 high\n 2014-02-14 22.0 71.6 medium\n 2014-02-15 35.0 95.0 medium\n\n >>> df2 = pd.DataFrame([[28, 'low'],\n ... [30, 'low'],\n ... [35.1, 'medium']],\n ... columns=['temp_celsius', 'windspeed'],\n ... index=pd.DatetimeIndex(['2014-02-12', '2014-02-13',\n ... '2014-02-15']))\n\n >>> df2\n temp_celsius windspeed\n 2014-02-12 28.0 low\n 2014-02-13 30.0 low\n 2014-02-15 35.1 medium\n\n >>> df2.reindex_like(df1)\n temp_celsius temp_fahrenheit windspeed\n 2014-02-12 28.0 NaN low\n 2014-02-13 30.0 NaN low\n 2014-02-14 NaN NaN NaN\n 2014-02-15 35.1 NaN medium\n \"\"\"\n d = other._construct_axes_dict(\n axes=self._AXIS_ORDERS,\n method=method,\n copy=copy,\n limit=limit,\n tolerance=tolerance,\n )\n\n return self.reindex(**d)\n\n def drop(\n self,\n labels=None,\n axis=0,\n index=None,\n columns=None,\n level=None,\n inplace: bool_t = False,\n errors: str = \"raise\",\n ):\n\n inplace = validate_bool_kwarg(inplace, \"inplace\")\n\n if labels is not None:\n if index is not None or columns is not None:\n raise ValueError(\"Cannot specify both 'labels' and 'index'/'columns'\")\n axis_name = self._get_axis_name(axis)\n axes = {axis_name: labels}\n elif index is not None or columns is not None:\n axes, _ = self._construct_axes_from_arguments((index, columns), {})\n else:\n raise ValueError(\n \"Need to specify at least one of 'labels', 'index' or 'columns'\"\n )\n\n obj = self\n\n for axis, labels in axes.items():\n if labels is not None:\n obj = obj._drop_axis(labels, axis, level=level, errors=errors)\n\n if inplace:\n self._update_inplace(obj)\n else:\n return obj\n\n def _drop_axis(\n self: FrameOrSeries, labels, axis, level=None, errors: str = \"raise\"\n ) -> FrameOrSeries:\n \"\"\"\n Drop labels from specified axis. Used in the ``drop`` method\n internally.\n\n Parameters\n ----------\n labels : single label or list-like\n axis : int or axis name\n level : int or level name, default None\n For MultiIndex\n errors : {'ignore', 'raise'}, default 'raise'\n If 'ignore', suppress error and existing labels are dropped.\n\n \"\"\"\n axis = self._get_axis_number(axis)\n axis_name = self._get_axis_name(axis)\n axis = self._get_axis(axis)\n\n if axis.is_unique:\n if level is not None:\n if not isinstance(axis, MultiIndex):\n raise AssertionError(\"axis must be a MultiIndex\")\n new_axis = axis.drop(labels, level=level, errors=errors)\n else:\n new_axis = axis.drop(labels, errors=errors)\n result = self.reindex(**{axis_name: new_axis})\n\n # Case for non-unique axis\n else:\n labels = ensure_object(com.index_labels_to_array(labels))\n if level is not None:\n if not isinstance(axis, MultiIndex):\n raise AssertionError(\"axis must be a MultiIndex\")\n indexer = ~axis.get_level_values(level).isin(labels)\n\n # GH 18561 MultiIndex.drop should raise if label is absent\n if errors == \"raise\" and indexer.all():\n raise KeyError(f\"{labels} not found in axis\")\n else:\n indexer = ~axis.isin(labels)\n # Check if label doesn't exist along axis\n labels_missing = (axis.get_indexer_for(labels) == -1).any()\n if errors == \"raise\" and labels_missing:\n raise KeyError(f\"{labels} not found in axis\")\n\n slicer = [slice(None)] * self.ndim\n slicer[self._get_axis_number(axis_name)] = indexer\n\n result = self.loc[tuple(slicer)]\n\n return result\n\n def _update_inplace(self, result, verify_is_copy: bool_t = True) -> None:\n \"\"\"\n Replace self internals with result.\n\n Parameters\n ----------\n verify_is_copy : bool, default True\n Provide is_copy checks.\n \"\"\"\n # NOTE: This does *not* call __finalize__ and that's an explicit\n # decision that we may revisit in the future.\n\n self._reset_cache()\n self._clear_item_cache()\n self._data = getattr(result, \"_data\", result)\n self._maybe_update_cacher(verify_is_copy=verify_is_copy)\n\n def add_prefix(self: FrameOrSeries, prefix: str) -> FrameOrSeries:\n \"\"\"\n Prefix labels with string `prefix`.\n\n For Series, the row labels are prefixed.\n For DataFrame, the column labels are prefixed.\n\n Parameters\n ----------\n prefix : str\n The string to add before each label.\n\n Returns\n -------\n Series or DataFrame\n New Series or DataFrame with updated labels.\n\n See Also\n --------\n Series.add_suffix: Suffix row labels with string `suffix`.\n DataFrame.add_suffix: Suffix column labels with string `suffix`.\n\n Examples\n --------\n >>> s = pd.Series([1, 2, 3, 4])\n >>> s\n 0 1\n 1 2\n 2 3\n 3 4\n dtype: int64\n\n >>> s.add_prefix('item_')\n item_0 1\n item_1 2\n item_2 3\n item_3 4\n dtype: int64\n\n >>> df = pd.DataFrame({'A': [1, 2, 3, 4], 'B': [3, 4, 5, 6]})\n >>> df\n A B\n 0 1 3\n 1 2 4\n 2 3 5\n 3 4 6\n\n >>> df.add_prefix('col_')\n col_A col_B\n 0 1 3\n 1 2 4\n 2 3 5\n 3 4 6\n \"\"\"\n f = functools.partial(\"{prefix}{}\".format, prefix=prefix)\n\n mapper = {self._info_axis_name: f}\n return self.rename(**mapper) # type: ignore\n\n def add_suffix(self: FrameOrSeries, suffix: str) -> FrameOrSeries:\n \"\"\"\n Suffix labels with string `suffix`.\n\n For Series, the row labels are suffixed.\n For DataFrame, the column labels are suffixed.\n\n Parameters\n ----------\n suffix : str\n The string to add after each label.\n\n Returns\n -------\n Series or DataFrame\n New Series or DataFrame with updated labels.\n\n See Also\n --------\n Series.add_prefix: Prefix row labels with string `prefix`.\n DataFrame.add_prefix: Prefix column labels with string `prefix`.\n\n Examples\n --------\n >>> s = pd.Series([1, 2, 3, 4])\n >>> s\n 0 1\n 1 2\n 2 3\n 3 4\n dtype: int64\n\n >>> s.add_suffix('_item')\n 0_item 1\n 1_item 2\n 2_item 3\n 3_item 4\n dtype: int64\n\n >>> df = pd.DataFrame({'A': [1, 2, 3, 4], 'B': [3, 4, 5, 6]})\n >>> df\n A B\n 0 1 3\n 1 2 4\n 2 3 5\n 3 4 6\n\n >>> df.add_suffix('_col')\n A_col B_col\n 0 1 3\n 1 2 4\n 2 3 5\n 3 4 6\n \"\"\"\n f = functools.partial(\"{}{suffix}\".format, suffix=suffix)\n\n mapper = {self._info_axis_name: f}\n return self.rename(**mapper) # type: ignore\n\n def sort_values(\n self,\n axis=0,\n ascending=True,\n inplace: bool_t = False,\n kind: str = \"quicksort\",\n na_position: str = \"last\",\n ignore_index: bool_t = False,\n ):\n \"\"\"\n Sort by the values along either axis.\n\n Parameters\n ----------%(optional_by)s\n axis : %(axes_single_arg)s, default 0\n Axis to be sorted.\n ascending : bool or list of bool, default True\n Sort ascending vs. descending. Specify list for multiple sort\n orders. If this is a list of bools, must match the length of\n the by.\n inplace : bool, default False\n If True, perform operation in-place.\n kind : {'quicksort', 'mergesort', 'heapsort'}, default 'quicksort'\n Choice of sorting algorithm. See also ndarray.np.sort for more\n information. `mergesort` is the only stable algorithm. For\n DataFrames, this option is only applied when sorting on a single\n column or label.\n na_position : {'first', 'last'}, default 'last'\n Puts NaNs at the beginning if `first`; `last` puts NaNs at the\n end.\n ignore_index : bool, default False\n If True, the resulting axis will be labeled 0, 1, …, n - 1.\n\n .. versionadded:: 1.0.0\n\n Returns\n -------\n sorted_obj : DataFrame or None\n DataFrame with sorted values if inplace=False, None otherwise.\n\n Examples\n --------\n >>> df = pd.DataFrame({\n ... 'col1': ['A', 'A', 'B', np.nan, 'D', 'C'],\n ... 'col2': [2, 1, 9, 8, 7, 4],\n ... 'col3': [0, 1, 9, 4, 2, 3],\n ... })\n >>> df\n col1 col2 col3\n 0 A 2 0\n 1 A 1 1\n 2 B 9 9\n 3 NaN 8 4\n 4 D 7 2\n 5 C 4 3\n\n Sort by col1\n\n >>> df.sort_values(by=['col1'])\n col1 col2 col3\n 0 A 2 0\n 1 A 1 1\n 2 B 9 9\n 5 C 4 3\n 4 D 7 2\n 3 NaN 8 4\n\n Sort by multiple columns\n\n >>> df.sort_values(by=['col1', 'col2'])\n col1 col2 col3\n 1 A 1 1\n 0 A 2 0\n 2 B 9 9\n 5 C 4 3\n 4 D 7 2\n 3 NaN 8 4\n\n Sort Descending\n\n >>> df.sort_values(by='col1', ascending=False)\n col1 col2 col3\n 4 D 7 2\n 5 C 4 3\n 2 B 9 9\n 0 A 2 0\n 1 A 1 1\n 3 NaN 8 4\n\n Putting NAs first\n\n >>> df.sort_values(by='col1', ascending=False, na_position='first')\n col1 col2 col3\n 3 NaN 8 4\n 4 D 7 2\n 5 C 4 3\n 2 B 9 9\n 0 A 2 0\n 1 A 1 1\n \"\"\"\n raise AbstractMethodError(self)\n\n def reindex(self: FrameOrSeries, *args, **kwargs) -> FrameOrSeries:\n \"\"\"\n Conform %(klass)s to new index with optional filling logic.\n\n Places NA/NaN in locations having no value in the previous index. A new object\n is produced unless the new index is equivalent to the current one and\n ``copy=False``.\n\n Parameters\n ----------\n %(optional_labels)s\n %(axes)s : array-like, optional\n New labels / index to conform to, should be specified using\n keywords. Preferably an Index object to avoid duplicating data.\n %(optional_axis)s\n method : {None, 'backfill'/'bfill', 'pad'/'ffill', 'nearest'}\n Method to use for filling holes in reindexed DataFrame.\n Please note: this is only applicable to DataFrames/Series with a\n monotonically increasing/decreasing index.\n\n * None (default): don't fill gaps\n * pad / ffill: Propagate last valid observation forward to next\n valid.\n * backfill / bfill: Use next valid observation to fill gap.\n * nearest: Use nearest valid observations to fill gap.\n\n copy : bool, default True\n Return a new object, even if the passed indexes are the same.\n level : int or name\n Broadcast across a level, matching Index values on the\n passed MultiIndex level.\n fill_value : scalar, default np.NaN\n Value to use for missing values. Defaults to NaN, but can be any\n \"compatible\" value.\n limit : int, default None\n Maximum number of consecutive elements to forward or backward fill.\n tolerance : optional\n Maximum distance between original and new labels for inexact\n matches. The values of the index at the matching locations most\n satisfy the equation ``abs(index[indexer] - target) <= tolerance``.\n\n Tolerance may be a scalar value, which applies the same tolerance\n to all values, or list-like, which applies variable tolerance per\n element. List-like includes list, tuple, array, Series, and must be\n the same size as the index and its dtype must exactly match the\n index's type.\n\n .. versionadded:: 0.21.0 (list-like tolerance)\n\n Returns\n -------\n %(klass)s with changed index.\n\n See Also\n --------\n DataFrame.set_index : Set row labels.\n DataFrame.reset_index : Remove row labels or move them to new columns.\n DataFrame.reindex_like : Change to same indices as other DataFrame.\n\n Examples\n --------\n ``DataFrame.reindex`` supports two calling conventions\n\n * ``(index=index_labels, columns=column_labels, ...)``\n * ``(labels, axis={'index', 'columns'}, ...)``\n\n We *highly* recommend using keyword arguments to clarify your\n intent.\n\n Create a dataframe with some fictional data.\n\n >>> index = ['Firefox', 'Chrome', 'Safari', 'IE10', 'Konqueror']\n >>> df = pd.DataFrame({'http_status': [200, 200, 404, 404, 301],\n ... 'response_time': [0.04, 0.02, 0.07, 0.08, 1.0]},\n ... index=index)\n >>> df\n http_status response_time\n Firefox 200 0.04\n Chrome 200 0.02\n Safari 404 0.07\n IE10 404 0.08\n Konqueror 301 1.00\n\n Create a new index and reindex the dataframe. By default\n values in the new index that do not have corresponding\n records in the dataframe are assigned ``NaN``.\n\n >>> new_index = ['Safari', 'Iceweasel', 'Comodo Dragon', 'IE10',\n ... 'Chrome']\n >>> df.reindex(new_index)\n http_status response_time\n Safari 404.0 0.07\n Iceweasel NaN NaN\n Comodo Dragon NaN NaN\n IE10 404.0 0.08\n Chrome 200.0 0.02\n\n We can fill in the missing values by passing a value to\n the keyword ``fill_value``. Because the index is not monotonically\n increasing or decreasing, we cannot use arguments to the keyword\n ``method`` to fill the ``NaN`` values.\n\n >>> df.reindex(new_index, fill_value=0)\n http_status response_time\n Safari 404 0.07\n Iceweasel 0 0.00\n Comodo Dragon 0 0.00\n IE10 404 0.08\n Chrome 200 0.02\n\n >>> df.reindex(new_index, fill_value='missing')\n http_status response_time\n Safari 404 0.07\n Iceweasel missing missing\n Comodo Dragon missing missing\n IE10 404 0.08\n Chrome 200 0.02\n\n We can also reindex the columns.\n\n >>> df.reindex(columns=['http_status', 'user_agent'])\n http_status user_agent\n Firefox 200 NaN\n Chrome 200 NaN\n Safari 404 NaN\n IE10 404 NaN\n Konqueror 301 NaN\n\n Or we can use \"axis-style\" keyword arguments\n\n >>> df.reindex(['http_status', 'user_agent'], axis=\"columns\")\n http_status user_agent\n Firefox 200 NaN\n Chrome 200 NaN\n Safari 404 NaN\n IE10 404 NaN\n Konqueror 301 NaN\n\n To further illustrate the filling functionality in\n ``reindex``, we will create a dataframe with a\n monotonically increasing index (for example, a sequence\n of dates).\n\n >>> date_index = pd.date_range('1/1/2010', periods=6, freq='D')\n >>> df2 = pd.DataFrame({\"prices\": [100, 101, np.nan, 100, 89, 88]},\n ... index=date_index)\n >>> df2\n prices\n 2010-01-01 100.0\n 2010-01-02 101.0\n 2010-01-03 NaN\n 2010-01-04 100.0\n 2010-01-05 89.0\n 2010-01-06 88.0\n\n Suppose we decide to expand the dataframe to cover a wider\n date range.\n\n >>> date_index2 = pd.date_range('12/29/2009', periods=10, freq='D')\n >>> df2.reindex(date_index2)\n prices\n 2009-12-29 NaN\n 2009-12-30 NaN\n 2009-12-31 NaN\n 2010-01-01 100.0\n 2010-01-02 101.0\n 2010-01-03 NaN\n 2010-01-04 100.0\n 2010-01-05 89.0\n 2010-01-06 88.0\n 2010-01-07 NaN\n\n The index entries that did not have a value in the original data frame\n (for example, '2009-12-29') are by default filled with ``NaN``.\n If desired, we can fill in the missing values using one of several\n options.\n\n For example, to back-propagate the last valid value to fill the ``NaN``\n values, pass ``bfill`` as an argument to the ``method`` keyword.\n\n >>> df2.reindex(date_index2, method='bfill')\n prices\n 2009-12-29 100.0\n 2009-12-30 100.0\n 2009-12-31 100.0\n 2010-01-01 100.0\n 2010-01-02 101.0\n 2010-01-03 NaN\n 2010-01-04 100.0\n 2010-01-05 89.0\n 2010-01-06 88.0\n 2010-01-07 NaN\n\n Please note that the ``NaN`` value present in the original dataframe\n (at index value 2010-01-03) will not be filled by any of the\n value propagation schemes. This is because filling while reindexing\n does not look at dataframe values, but only compares the original and\n desired indexes. If you do want to fill in the ``NaN`` values present\n in the original dataframe, use the ``fillna()`` method.\n\n See the :ref:`user guide <basics.reindexing>` for more.\n \"\"\"\n # TODO: Decide if we care about having different examples for different\n # kinds\n\n # construct the args\n axes, kwargs = self._construct_axes_from_arguments(args, kwargs)\n method = missing.clean_reindex_fill_method(kwargs.pop(\"method\", None))\n level = kwargs.pop(\"level\", None)\n copy = kwargs.pop(\"copy\", True)\n limit = kwargs.pop(\"limit\", None)\n tolerance = kwargs.pop(\"tolerance\", None)\n fill_value = kwargs.pop(\"fill_value\", None)\n\n # Series.reindex doesn't use / need the axis kwarg\n # We pop and ignore it here, to make writing Series/Frame generic code\n # easier\n kwargs.pop(\"axis\", None)\n\n if kwargs:\n raise TypeError(\n \"reindex() got an unexpected keyword \"\n f'argument \"{list(kwargs.keys())[0]}\"'\n )\n\n self._consolidate_inplace()\n\n # if all axes that are requested to reindex are equal, then only copy\n # if indicated must have index names equal here as well as values\n if all(\n self._get_axis(axis).identical(ax)\n for axis, ax in axes.items()\n if ax is not None\n ):\n if copy:\n return self.copy()\n return self\n\n # check if we are a multi reindex\n if self._needs_reindex_multi(axes, method, level):\n return self._reindex_multi(axes, copy, fill_value)\n\n # perform the reindex on the axes\n return self._reindex_axes(\n axes, level, limit, tolerance, method, fill_value, copy\n ).__finalize__(self)\n\n def _reindex_axes(\n self: FrameOrSeries, axes, level, limit, tolerance, method, fill_value, copy\n ) -> FrameOrSeries:\n \"\"\"Perform the reindex for all the axes.\"\"\"\n obj = self\n for a in self._AXIS_ORDERS:\n labels = axes[a]\n if labels is None:\n continue\n\n ax = self._get_axis(a)\n new_index, indexer = ax.reindex(\n labels, level=level, limit=limit, tolerance=tolerance, method=method\n )\n\n axis = self._get_axis_number(a)\n obj = obj._reindex_with_indexers(\n {axis: [new_index, indexer]},\n fill_value=fill_value,\n copy=copy,\n allow_dups=False,\n )\n\n return obj\n\n def _needs_reindex_multi(self, axes, method, level) -> bool_t:\n \"\"\"Check if we do need a multi reindex.\"\"\"\n return (\n (com.count_not_none(*axes.values()) == self._AXIS_LEN)\n and method is None\n and level is None\n and not self._is_mixed_type\n )\n\n def _reindex_multi(self, axes, copy, fill_value):\n raise AbstractMethodError(self)\n\n def _reindex_with_indexers(\n self: FrameOrSeries,\n reindexers,\n fill_value=None,\n copy: bool_t = False,\n allow_dups: bool_t = False,\n ) -> FrameOrSeries:\n \"\"\"allow_dups indicates an internal call here \"\"\"\n # reindex doing multiple operations on different axes if indicated\n new_data = self._data\n for axis in sorted(reindexers.keys()):\n index, indexer = reindexers[axis]\n baxis = self._get_block_manager_axis(axis)\n\n if index is None:\n continue\n\n index = ensure_index(index)\n if indexer is not None:\n indexer = ensure_int64(indexer)\n\n # TODO: speed up on homogeneous DataFrame objects\n new_data = new_data.reindex_indexer(\n index,\n indexer,\n axis=baxis,\n fill_value=fill_value,\n allow_dups=allow_dups,\n copy=copy,\n )\n\n if copy and new_data is self._data:\n new_data = new_data.copy()\n\n return self._constructor(new_data).__finalize__(self)\n\n def filter(\n self: FrameOrSeries,\n items=None,\n like: Optional[str] = None,\n regex: Optional[str] = None,\n axis=None,\n ) -> FrameOrSeries:\n \"\"\"\n Subset the dataframe rows or columns according to the specified index labels.\n\n Note that this routine does not filter a dataframe on its\n contents. The filter is applied to the labels of the index.\n\n Parameters\n ----------\n items : list-like\n Keep labels from axis which are in items.\n like : str\n Keep labels from axis for which \"like in label == True\".\n regex : str (regular expression)\n Keep labels from axis for which re.search(regex, label) == True.\n axis : {0 or ‘index’, 1 or ‘columns’, None}, default None\n The axis to filter on, expressed either as an index (int)\n or axis name (str). By default this is the info axis,\n 'index' for Series, 'columns' for DataFrame.\n\n Returns\n -------\n same type as input object\n\n See Also\n --------\n DataFrame.loc : Access a group of rows and columns\n by label(s) or a boolean array.\n\n Notes\n -----\n The ``items``, ``like``, and ``regex`` parameters are\n enforced to be mutually exclusive.\n\n ``axis`` defaults to the info axis that is used when indexing\n with ``[]``.\n\n Examples\n --------\n >>> df = pd.DataFrame(np.array(([1, 2, 3], [4, 5, 6])),\n ... index=['mouse', 'rabbit'],\n ... columns=['one', 'two', 'three'])\n\n >>> # select columns by name\n >>> df.filter(items=['one', 'three'])\n one three\n mouse 1 3\n rabbit 4 6\n\n >>> # select columns by regular expression\n >>> df.filter(regex='e$', axis=1)\n one three\n mouse 1 3\n rabbit 4 6\n\n >>> # select rows containing 'bbi'\n >>> df.filter(like='bbi', axis=0)\n one two three\n rabbit 4 5 6\n \"\"\"\n nkw = com.count_not_none(items, like, regex)\n if nkw > 1:\n raise TypeError(\n \"Keyword arguments `items`, `like`, or `regex` \"\n \"are mutually exclusive\"\n )\n\n if axis is None:\n axis = self._info_axis_name\n labels = self._get_axis(axis)\n\n if items is not None:\n name = self._get_axis_name(axis)\n return self.reindex(**{name: [r for r in items if r in labels]})\n elif like:\n\n def f(x):\n return like in ensure_str(x)\n\n values = labels.map(f)\n return self.loc(axis=axis)[values]\n elif regex:\n\n def f(x):\n return matcher.search(ensure_str(x)) is not None\n\n matcher = re.compile(regex)\n values = labels.map(f)\n return self.loc(axis=axis)[values]\n else:\n raise TypeError(\"Must pass either `items`, `like`, or `regex`\")\n\n def head(self: FrameOrSeries, n: int = 5) -> FrameOrSeries:\n \"\"\"\n Return the first `n` rows.\n\n This function returns the first `n` rows for the object based\n on position. It is useful for quickly testing if your object\n has the right type of data in it.\n\n For negative values of `n`, this function returns all rows except\n the last `n` rows, equivalent to ``df[:-n]``.\n\n Parameters\n ----------\n n : int, default 5\n Number of rows to select.\n\n Returns\n -------\n same type as caller\n The first `n` rows of the caller object.\n\n See Also\n --------\n DataFrame.tail: Returns the last `n` rows.\n\n Examples\n --------\n >>> df = pd.DataFrame({'animal': ['alligator', 'bee', 'falcon', 'lion',\n ... 'monkey', 'parrot', 'shark', 'whale', 'zebra']})\n >>> df\n animal\n 0 alligator\n 1 bee\n 2 falcon\n 3 lion\n 4 monkey\n 5 parrot\n 6 shark\n 7 whale\n 8 zebra\n\n Viewing the first 5 lines\n\n >>> df.head()\n animal\n 0 alligator\n 1 bee\n 2 falcon\n 3 lion\n 4 monkey\n\n Viewing the first `n` lines (three in this case)\n\n >>> df.head(3)\n animal\n 0 alligator\n 1 bee\n 2 falcon\n\n For negative values of `n`\n\n >>> df.head(-3)\n animal\n 0 alligator\n 1 bee\n 2 falcon\n 3 lion\n 4 monkey\n 5 parrot\n \"\"\"\n return self.iloc[:n]\n\n def tail(self: FrameOrSeries, n: int = 5) -> FrameOrSeries:\n \"\"\"\n Return the last `n` rows.\n\n This function returns last `n` rows from the object based on\n position. It is useful for quickly verifying data, for example,\n after sorting or appending rows.\n\n For negative values of `n`, this function returns all rows except\n the first `n` rows, equivalent to ``df[n:]``.\n\n Parameters\n ----------\n n : int, default 5\n Number of rows to select.\n\n Returns\n -------\n type of caller\n The last `n` rows of the caller object.\n\n See Also\n --------\n DataFrame.head : The first `n` rows of the caller object.\n\n Examples\n --------\n >>> df = pd.DataFrame({'animal': ['alligator', 'bee', 'falcon', 'lion',\n ... 'monkey', 'parrot', 'shark', 'whale', 'zebra']})\n >>> df\n animal\n 0 alligator\n 1 bee\n 2 falcon\n 3 lion\n 4 monkey\n 5 parrot\n 6 shark\n 7 whale\n 8 zebra\n\n Viewing the last 5 lines\n\n >>> df.tail()\n animal\n 4 monkey\n 5 parrot\n 6 shark\n 7 whale\n 8 zebra\n\n Viewing the last `n` lines (three in this case)\n\n >>> df.tail(3)\n animal\n 6 shark\n 7 whale\n 8 zebra\n\n For negative values of `n`\n\n >>> df.tail(-3)\n animal\n 3 lion\n 4 monkey\n 5 parrot\n 6 shark\n 7 whale\n 8 zebra\n \"\"\"\n if n == 0:\n return self.iloc[0:0]\n return self.iloc[-n:]\n\n def sample(\n self: FrameOrSeries,\n n=None,\n frac=None,\n replace=False,\n weights=None,\n random_state=None,\n axis=None,\n ) -> FrameOrSeries:\n \"\"\"\n Return a random sample of items from an axis of object.\n\n You can use `random_state` for reproducibility.\n\n Parameters\n ----------\n n : int, optional\n Number of items from axis to return. Cannot be used with `frac`.\n Default = 1 if `frac` = None.\n frac : float, optional\n Fraction of axis items to return. Cannot be used with `n`.\n replace : bool, default False\n Allow or disallow sampling of the same row more than once.\n weights : str or ndarray-like, optional\n Default 'None' results in equal probability weighting.\n If passed a Series, will align with target object on index. Index\n values in weights not found in sampled object will be ignored and\n index values in sampled object not in weights will be assigned\n weights of zero.\n If called on a DataFrame, will accept the name of a column\n when axis = 0.\n Unless weights are a Series, weights must be same length as axis\n being sampled.\n If weights do not sum to 1, they will be normalized to sum to 1.\n Missing values in the weights column will be treated as zero.\n Infinite values not allowed.\n random_state : int or numpy.random.RandomState, optional\n Seed for the random number generator (if int), or numpy RandomState\n object.\n axis : {0 or ‘index’, 1 or ‘columns’, None}, default None\n Axis to sample. Accepts axis number or name. Default is stat axis\n for given data type (0 for Series and DataFrames).\n\n Returns\n -------\n Series or DataFrame\n A new object of same type as caller containing `n` items randomly\n sampled from the caller object.\n\n See Also\n --------\n numpy.random.choice: Generates a random sample from a given 1-D numpy\n array.\n\n Notes\n -----\n If `frac` > 1, `replacement` should be set to `True`.\n\n Examples\n --------\n >>> df = pd.DataFrame({'num_legs': [2, 4, 8, 0],\n ... 'num_wings': [2, 0, 0, 0],\n ... 'num_specimen_seen': [10, 2, 1, 8]},\n ... index=['falcon', 'dog', 'spider', 'fish'])\n >>> df\n num_legs num_wings num_specimen_seen\n falcon 2 2 10\n dog 4 0 2\n spider 8 0 1\n fish 0 0 8\n\n Extract 3 random elements from the ``Series`` ``df['num_legs']``:\n Note that we use `random_state` to ensure the reproducibility of\n the examples.\n\n >>> df['num_legs'].sample(n=3, random_state=1)\n fish 0\n spider 8\n falcon 2\n Name: num_legs, dtype: int64\n\n A random 50% sample of the ``DataFrame`` with replacement:\n\n >>> df.sample(frac=0.5, replace=True, random_state=1)\n num_legs num_wings num_specimen_seen\n dog 4 0 2\n fish 0 0 8\n\n An upsample sample of the ``DataFrame`` with replacement:\n Note that `replace` parameter has to be `True` for `frac` parameter > 1.\n\n >>> df.sample(frac=2, replace=True, random_state=1)\n num_legs num_wings num_specimen_seen\n dog 4 0 2\n fish 0 0 8\n falcon 2 2 10\n falcon 2 2 10\n fish 0 0 8\n dog 4 0 2\n fish 0 0 8\n dog 4 0 2\n\n Using a DataFrame column as weights. Rows with larger value in the\n `num_specimen_seen` column are more likely to be sampled.\n\n >>> df.sample(n=2, weights='num_specimen_seen', random_state=1)\n num_legs num_wings num_specimen_seen\n falcon 2 2 10\n fish 0 0 8\n \"\"\"\n if axis is None:\n axis = self._stat_axis_number\n\n axis = self._get_axis_number(axis)\n axis_length = self.shape[axis]\n\n # Process random_state argument\n rs = com.random_state(random_state)\n\n # Check weights for compliance\n if weights is not None:\n\n # If a series, align with frame\n if isinstance(weights, ABCSeries):\n weights = weights.reindex(self.axes[axis])\n\n # Strings acceptable if a dataframe and axis = 0\n if isinstance(weights, str):\n if isinstance(self, ABCDataFrame):\n if axis == 0:\n try:\n weights = self[weights]\n except KeyError as err:\n raise KeyError(\n \"String passed to weights not a valid column\"\n ) from err\n else:\n raise ValueError(\n \"Strings can only be passed to \"\n \"weights when sampling from rows on \"\n \"a DataFrame\"\n )\n else:\n raise ValueError(\n \"Strings cannot be passed as weights \"\n \"when sampling from a Series.\"\n )\n\n weights = pd.Series(weights, dtype=\"float64\")\n\n if len(weights) != axis_length:\n raise ValueError(\n \"Weights and axis to be sampled must be of same length\"\n )\n\n if (weights == np.inf).any() or (weights == -np.inf).any():\n raise ValueError(\"weight vector may not include `inf` values\")\n\n if (weights < 0).any():\n raise ValueError(\"weight vector many not include negative values\")\n\n # If has nan, set to zero.\n weights = weights.fillna(0)\n\n # Renormalize if don't sum to 1\n if weights.sum() != 1:\n if weights.sum() != 0:\n weights = weights / weights.sum()\n else:\n raise ValueError(\"Invalid weights: weights sum to zero\")\n\n weights = weights.values\n\n # If no frac or n, default to n=1.\n if n is None and frac is None:\n n = 1\n elif frac is not None and frac > 1 and not replace:\n raise ValueError(\n \"Replace has to be set to `True` when \"\n \"upsampling the population `frac` > 1.\"\n )\n elif n is not None and frac is None and n % 1 != 0:\n raise ValueError(\"Only integers accepted as `n` values\")\n elif n is None and frac is not None:\n n = int(round(frac * axis_length))\n elif n is not None and frac is not None:\n raise ValueError(\"Please enter a value for `frac` OR `n`, not both\")\n\n # Check for negative sizes\n if n < 0:\n raise ValueError(\n \"A negative number of rows requested. Please provide positive value.\"\n )\n\n locs = rs.choice(axis_length, size=n, replace=replace, p=weights)\n return self.take(locs, axis=axis)\n\n _shared_docs[\n \"pipe\"\n ] = r\"\"\"\n Apply func(self, \\*args, \\*\\*kwargs).\n\n Parameters\n ----------\n func : function\n Function to apply to the %(klass)s.\n ``args``, and ``kwargs`` are passed into ``func``.\n Alternatively a ``(callable, data_keyword)`` tuple where\n ``data_keyword`` is a string indicating the keyword of\n ``callable`` that expects the %(klass)s.\n args : iterable, optional\n Positional arguments passed into ``func``.\n kwargs : mapping, optional\n A dictionary of keyword arguments passed into ``func``.\n\n Returns\n -------\n object : the return type of ``func``.\n\n See Also\n --------\n DataFrame.apply : Apply a function along input axis of DataFrame.\n DataFrame.applymap : Apply a function elementwise on a whole DataFrame.\n Series.map : Apply a mapping correspondence on a\n :class:`~pandas.Series`.\n\n Notes\n -----\n\n Use ``.pipe`` when chaining together functions that expect\n Series, DataFrames or GroupBy objects. Instead of writing\n\n >>> f(g(h(df), arg1=a), arg2=b, arg3=c)\n\n You can write\n\n >>> (df.pipe(h)\n ... .pipe(g, arg1=a)\n ... .pipe(f, arg2=b, arg3=c)\n ... )\n\n If you have a function that takes the data as (say) the second\n argument, pass a tuple indicating which keyword expects the\n data. For example, suppose ``f`` takes its data as ``arg2``:\n\n >>> (df.pipe(h)\n ... .pipe(g, arg1=a)\n ... .pipe((f, 'arg2'), arg1=a, arg3=c)\n ... )\n \"\"\"\n\n @Appender(_shared_docs[\"pipe\"] % _shared_doc_kwargs)\n def pipe(self, func, *args, **kwargs):\n return com.pipe(self, func, *args, **kwargs)\n\n _shared_docs[\"aggregate\"] = dedent(\n \"\"\"\n Aggregate using one or more operations over the specified axis.\n %(versionadded)s\n Parameters\n ----------\n func : function, str, list or dict\n Function to use for aggregating the data. If a function, must either\n work when passed a %(klass)s or when passed to %(klass)s.apply.\n\n Accepted combinations are:\n\n - function\n - string function name\n - list of functions and/or function names, e.g. ``[np.sum, 'mean']``\n - dict of axis labels -> functions, function names or list of such.\n %(axis)s\n *args\n Positional arguments to pass to `func`.\n **kwargs\n Keyword arguments to pass to `func`.\n\n Returns\n -------\n scalar, Series or DataFrame\n\n The return can be:\n\n * scalar : when Series.agg is called with single function\n * Series : when DataFrame.agg is called with a single function\n * DataFrame : when DataFrame.agg is called with several functions\n\n Return scalar, Series or DataFrame.\n %(see_also)s\n Notes\n -----\n `agg` is an alias for `aggregate`. Use the alias.\n\n A passed user-defined-function will be passed a Series for evaluation.\n %(examples)s\"\"\"\n )\n\n _shared_docs[\n \"transform\"\n ] = \"\"\"\n Call ``func`` on self producing a %(klass)s with transformed values.\n\n Produced %(klass)s will have same axis length as self.\n\n Parameters\n ----------\n func : function, str, list or dict\n Function to use for transforming the data. If a function, must either\n work when passed a %(klass)s or when passed to %(klass)s.apply.\n\n Accepted combinations are:\n\n - function\n - string function name\n - list of functions and/or function names, e.g. ``[np.exp. 'sqrt']``\n - dict of axis labels -> functions, function names or list of such.\n %(axis)s\n *args\n Positional arguments to pass to `func`.\n **kwargs\n Keyword arguments to pass to `func`.\n\n Returns\n -------\n %(klass)s\n A %(klass)s that must have the same length as self.\n\n Raises\n ------\n ValueError : If the returned %(klass)s has a different length than self.\n\n See Also\n --------\n %(klass)s.agg : Only perform aggregating type operations.\n %(klass)s.apply : Invoke function on a %(klass)s.\n\n Examples\n --------\n >>> df = pd.DataFrame({'A': range(3), 'B': range(1, 4)})\n >>> df\n A B\n 0 0 1\n 1 1 2\n 2 2 3\n >>> df.transform(lambda x: x + 1)\n A B\n 0 1 2\n 1 2 3\n 2 3 4\n\n Even though the resulting %(klass)s must have the same length as the\n input %(klass)s, it is possible to provide several input functions:\n\n >>> s = pd.Series(range(3))\n >>> s\n 0 0\n 1 1\n 2 2\n dtype: int64\n >>> s.transform([np.sqrt, np.exp])\n sqrt exp\n 0 0.000000 1.000000\n 1 1.000000 2.718282\n 2 1.414214 7.389056\n \"\"\"\n\n # ----------------------------------------------------------------------\n # Attribute access\n\n def __finalize__(\n self: FrameOrSeries, other, method=None, **kwargs\n ) -> FrameOrSeries:\n \"\"\"\n Propagate metadata from other to self.\n\n Parameters\n ----------\n other : the object from which to get the attributes that we are going\n to propagate\n method : optional, a passed method name ; possibly to take different\n types of propagation actions based on this\n\n \"\"\"\n if isinstance(other, NDFrame):\n for name in other.attrs:\n self.attrs[name] = other.attrs[name]\n # For subclasses using _metadata.\n for name in self._metadata:\n assert isinstance(name, str)\n object.__setattr__(self, name, getattr(other, name, None))\n return self\n\n def __getattr__(self, name: str):\n \"\"\"\n After regular attribute access, try looking up the name\n This allows simpler access to columns for interactive use.\n \"\"\"\n # Note: obj.x will always call obj.__getattribute__('x') prior to\n # calling obj.__getattr__('x').\n\n if (\n name in self._internal_names_set\n or name in self._metadata\n or name in self._accessors\n ):\n return object.__getattribute__(self, name)\n else:\n if self._info_axis._can_hold_identifiers_and_holds_name(name):\n return self[name]\n return object.__getattribute__(self, name)\n\n def __setattr__(self, name: str, value) -> None:\n \"\"\"\n After regular attribute access, try setting the name\n This allows simpler access to columns for interactive use.\n \"\"\"\n # first try regular attribute access via __getattribute__, so that\n # e.g. ``obj.x`` and ``obj.x = 4`` will always reference/modify\n # the same attribute.\n\n try:\n object.__getattribute__(self, name)\n return object.__setattr__(self, name, value)\n except AttributeError:\n pass\n\n # if this fails, go on to more involved attribute setting\n # (note that this matches __getattr__, above).\n if name in self._internal_names_set:\n object.__setattr__(self, name, value)\n elif name in self._metadata:\n object.__setattr__(self, name, value)\n else:\n try:\n existing = getattr(self, name)\n if isinstance(existing, Index):\n object.__setattr__(self, name, value)\n elif name in self._info_axis:\n self[name] = value\n else:\n object.__setattr__(self, name, value)\n except (AttributeError, TypeError):\n if isinstance(self, ABCDataFrame) and (is_list_like(value)):\n warnings.warn(\n \"Pandas doesn't allow columns to be \"\n \"created via a new attribute name - see \"\n \"https://pandas.pydata.org/pandas-docs/\"\n \"stable/indexing.html#attribute-access\",\n stacklevel=2,\n )\n object.__setattr__(self, name, value)\n\n def _dir_additions(self):\n \"\"\"\n add the string-like attributes from the info_axis.\n If info_axis is a MultiIndex, it's first level values are used.\n \"\"\"\n additions = {\n c\n for c in self._info_axis.unique(level=0)[:100]\n if isinstance(c, str) and c.isidentifier()\n }\n return super()._dir_additions().union(additions)\n\n # ----------------------------------------------------------------------\n # Consolidation of internals\n\n def _protect_consolidate(self, f):\n \"\"\"\n Consolidate _data -- if the blocks have changed, then clear the\n cache\n \"\"\"\n blocks_before = len(self._data.blocks)\n result = f()\n if len(self._data.blocks) != blocks_before:\n self._clear_item_cache()\n return result\n\n def _consolidate_inplace(self) -> None:\n \"\"\"Consolidate data in place and return None\"\"\"\n\n def f():\n self._data = self._data.consolidate()\n\n self._protect_consolidate(f)\n\n def _consolidate(self, inplace: bool_t = False):\n \"\"\"\n Compute NDFrame with \"consolidated\" internals (data of each dtype\n grouped together in a single ndarray).\n\n Parameters\n ----------\n inplace : bool, default False\n If False return new object, otherwise modify existing object.\n\n Returns\n -------\n consolidated : same type as caller\n \"\"\"\n inplace = validate_bool_kwarg(inplace, \"inplace\")\n if inplace:\n self._consolidate_inplace()\n else:\n f = lambda: self._data.consolidate()\n cons_data = self._protect_consolidate(f)\n return self._constructor(cons_data).__finalize__(self)\n\n @property\n def _is_mixed_type(self) -> bool_t:\n f = lambda: self._data.is_mixed_type\n return self._protect_consolidate(f)\n\n @property\n def _is_numeric_mixed_type(self) -> bool_t:\n f = lambda: self._data.is_numeric_mixed_type\n return self._protect_consolidate(f)\n\n def _check_inplace_setting(self, value) -> bool_t:\n \"\"\" check whether we allow in-place setting with this type of value \"\"\"\n if self._is_mixed_type:\n if not self._is_numeric_mixed_type:\n\n # allow an actual np.nan thru\n if is_float(value) and np.isnan(value):\n return True\n\n raise TypeError(\n \"Cannot do inplace boolean setting on \"\n \"mixed-types with a non np.nan value\"\n )\n\n return True\n\n def _get_numeric_data(self):\n return self._constructor(self._data.get_numeric_data()).__finalize__(self)\n\n def _get_bool_data(self):\n return self._constructor(self._data.get_bool_data()).__finalize__(self)\n\n # ----------------------------------------------------------------------\n # Internal Interface Methods\n\n @property\n def values(self) -> np.ndarray:\n \"\"\"\n Return a Numpy representation of the DataFrame.\n\n .. warning::\n\n We recommend using :meth:`DataFrame.to_numpy` instead.\n\n Only the values in the DataFrame will be returned, the axes labels\n will be removed.\n\n Returns\n -------\n numpy.ndarray\n The values of the DataFrame.\n\n See Also\n --------\n DataFrame.to_numpy : Recommended alternative to this method.\n DataFrame.index : Retrieve the index labels.\n DataFrame.columns : Retrieving the column names.\n\n Notes\n -----\n The dtype will be a lower-common-denominator dtype (implicit\n upcasting); that is to say if the dtypes (even of numeric types)\n are mixed, the one that accommodates all will be chosen. Use this\n with care if you are not dealing with the blocks.\n\n e.g. If the dtypes are float16 and float32, dtype will be upcast to\n float32. If dtypes are int32 and uint8, dtype will be upcast to\n int32. By :func:`numpy.find_common_type` convention, mixing int64\n and uint64 will result in a float64 dtype.\n\n Examples\n --------\n A DataFrame where all columns are the same type (e.g., int64) results\n in an array of the same type.\n\n >>> df = pd.DataFrame({'age': [ 3, 29],\n ... 'height': [94, 170],\n ... 'weight': [31, 115]})\n >>> df\n age height weight\n 0 3 94 31\n 1 29 170 115\n >>> df.dtypes\n age int64\n height int64\n weight int64\n dtype: object\n >>> df.values\n array([[ 3, 94, 31],\n [ 29, 170, 115]], dtype=int64)\n\n A DataFrame with mixed type columns(e.g., str/object, int64, float32)\n results in an ndarray of the broadest type that accommodates these\n mixed types (e.g., object).\n\n >>> df2 = pd.DataFrame([('parrot', 24.0, 'second'),\n ... ('lion', 80.5, 1),\n ... ('monkey', np.nan, None)],\n ... columns=('name', 'max_speed', 'rank'))\n >>> df2.dtypes\n name object\n max_speed float64\n rank object\n dtype: object\n >>> df2.values\n array([['parrot', 24.0, 'second'],\n ['lion', 80.5, 1],\n ['monkey', nan, None]], dtype=object)\n \"\"\"\n self._consolidate_inplace()\n return self._data.as_array(transpose=self._AXIS_REVERSED)\n\n @property\n def _values(self) -> np.ndarray:\n \"\"\"internal implementation\"\"\"\n return self.values\n\n def _internal_get_values(self) -> np.ndarray:\n \"\"\"\n Return an ndarray after converting sparse values to dense.\n\n This is the same as ``.values`` for non-sparse data. For sparse\n data contained in a `SparseArray`, the data are first\n converted to a dense representation.\n\n Returns\n -------\n numpy.ndarray\n Numpy representation of DataFrame.\n\n See Also\n --------\n values : Numpy representation of DataFrame.\n SparseArray : Container for sparse data.\n \"\"\"\n return self.values\n\n @property\n def dtypes(self):\n \"\"\"\n Return the dtypes in the DataFrame.\n\n This returns a Series with the data type of each column.\n The result's index is the original DataFrame's columns. Columns\n with mixed types are stored with the ``object`` dtype. See\n :ref:`the User Guide <basics.dtypes>` for more.\n\n Returns\n -------\n pandas.Series\n The data type of each column.\n\n Examples\n --------\n >>> df = pd.DataFrame({'float': [1.0],\n ... 'int': [1],\n ... 'datetime': [pd.Timestamp('20180310')],\n ... 'string': ['foo']})\n >>> df.dtypes\n float float64\n int int64\n datetime datetime64[ns]\n string object\n dtype: object\n \"\"\"\n from pandas import Series\n\n return Series(self._data.get_dtypes(), index=self._info_axis, dtype=np.object_)\n\n def _to_dict_of_blocks(self, copy: bool_t = True):\n \"\"\"\n Return a dict of dtype -> Constructor Types that\n each is a homogeneous dtype.\n\n Internal ONLY\n \"\"\"\n return {\n k: self._constructor(v).__finalize__(self)\n for k, v, in self._data.to_dict(copy=copy).items()\n }\n\n def astype(\n self: FrameOrSeries, dtype, copy: bool_t = True, errors: str = \"raise\"\n ) -> FrameOrSeries:\n \"\"\"\n Cast a pandas object to a specified dtype ``dtype``.\n\n Parameters\n ----------\n dtype : data type, or dict of column name -> data type\n Use a numpy.dtype or Python type to cast entire pandas object to\n the same type. Alternatively, use {col: dtype, ...}, where col is a\n column label and dtype is a numpy.dtype or Python type to cast one\n or more of the DataFrame's columns to column-specific types.\n copy : bool, default True\n Return a copy when ``copy=True`` (be very careful setting\n ``copy=False`` as changes to values then may propagate to other\n pandas objects).\n errors : {'raise', 'ignore'}, default 'raise'\n Control raising of exceptions on invalid data for provided dtype.\n\n - ``raise`` : allow exceptions to be raised\n - ``ignore`` : suppress exceptions. On error return original object.\n\n Returns\n -------\n casted : same type as caller\n\n See Also\n --------\n to_datetime : Convert argument to datetime.\n to_timedelta : Convert argument to timedelta.\n to_numeric : Convert argument to a numeric type.\n numpy.ndarray.astype : Cast a numpy array to a specified type.\n\n Examples\n --------\n Create a DataFrame:\n\n >>> d = {'col1': [1, 2], 'col2': [3, 4]}\n >>> df = pd.DataFrame(data=d)\n >>> df.dtypes\n col1 int64\n col2 int64\n dtype: object\n\n Cast all columns to int32:\n\n >>> df.astype('int32').dtypes\n col1 int32\n col2 int32\n dtype: object\n\n Cast col1 to int32 using a dictionary:\n\n >>> df.astype({'col1': 'int32'}).dtypes\n col1 int32\n col2 int64\n dtype: object\n\n Create a series:\n\n >>> ser = pd.Series([1, 2], dtype='int32')\n >>> ser\n 0 1\n 1 2\n dtype: int32\n >>> ser.astype('int64')\n 0 1\n 1 2\n dtype: int64\n\n Convert to categorical type:\n\n >>> ser.astype('category')\n 0 1\n 1 2\n dtype: category\n Categories (2, int64): [1, 2]\n\n Convert to ordered categorical type with custom ordering:\n\n >>> cat_dtype = pd.api.types.CategoricalDtype(\n ... categories=[2, 1], ordered=True)\n >>> ser.astype(cat_dtype)\n 0 1\n 1 2\n dtype: category\n Categories (2, int64): [2 < 1]\n\n Note that using ``copy=False`` and changing data on a new\n pandas object may propagate changes:\n\n >>> s1 = pd.Series([1, 2])\n >>> s2 = s1.astype('int64', copy=False)\n >>> s2[0] = 10\n >>> s1 # note that s1[0] has changed too\n 0 10\n 1 2\n dtype: int64\n \"\"\"\n if is_dict_like(dtype):\n if self.ndim == 1: # i.e. Series\n if len(dtype) > 1 or self.name not in dtype:\n raise KeyError(\n \"Only the Series name can be used for \"\n \"the key in Series dtype mappings.\"\n )\n new_type = dtype[self.name]\n return self.astype(new_type, copy, errors)\n\n for col_name in dtype.keys():\n if col_name not in self:\n raise KeyError(\n \"Only a column name can be used for the \"\n \"key in a dtype mappings argument.\"\n )\n results = []\n for col_name, col in self.items():\n if col_name in dtype:\n results.append(\n col.astype(dtype=dtype[col_name], copy=copy, errors=errors)\n )\n else:\n results.append(col.copy() if copy else col)\n\n elif is_extension_array_dtype(dtype) and self.ndim > 1:\n # GH 18099/22869: columnwise conversion to extension dtype\n # GH 24704: use iloc to handle duplicate column names\n results = [\n self.iloc[:, i].astype(dtype, copy=copy)\n for i in range(len(self.columns))\n ]\n\n else:\n # else, only a single dtype is given\n new_data = self._data.astype(dtype=dtype, copy=copy, errors=errors)\n return self._constructor(new_data).__finalize__(self)\n\n # GH 19920: retain column metadata after concat\n result = pd.concat(results, axis=1, copy=False)\n result.columns = self.columns\n return result\n\n def copy(self: FrameOrSeries, deep: bool_t = True) -> FrameOrSeries:\n \"\"\"\n Make a copy of this object's indices and data.\n\n When ``deep=True`` (default), a new object will be created with a\n copy of the calling object's data and indices. Modifications to\n the data or indices of the copy will not be reflected in the\n original object (see notes below).\n\n When ``deep=False``, a new object will be created without copying\n the calling object's data or index (only references to the data\n and index are copied). Any changes to the data of the original\n will be reflected in the shallow copy (and vice versa).\n\n Parameters\n ----------\n deep : bool, default True\n Make a deep copy, including a copy of the data and the indices.\n With ``deep=False`` neither the indices nor the data are copied.\n\n Returns\n -------\n copy : Series or DataFrame\n Object type matches caller.\n\n Notes\n -----\n When ``deep=True``, data is copied but actual Python objects\n will not be copied recursively, only the reference to the object.\n This is in contrast to `copy.deepcopy` in the Standard Library,\n which recursively copies object data (see examples below).\n\n While ``Index`` objects are copied when ``deep=True``, the underlying\n numpy array is not copied for performance reasons. Since ``Index`` is\n immutable, the underlying data can be safely shared and a copy\n is not needed.\n\n Examples\n --------\n >>> s = pd.Series([1, 2], index=[\"a\", \"b\"])\n >>> s\n a 1\n b 2\n dtype: int64\n\n >>> s_copy = s.copy()\n >>> s_copy\n a 1\n b 2\n dtype: int64\n\n **Shallow copy versus default (deep) copy:**\n\n >>> s = pd.Series([1, 2], index=[\"a\", \"b\"])\n >>> deep = s.copy()\n >>> shallow = s.copy(deep=False)\n\n Shallow copy shares data and index with original.\n\n >>> s is shallow\n False\n >>> s.values is shallow.values and s.index is shallow.index\n True\n\n Deep copy has own copy of data and index.\n\n >>> s is deep\n False\n >>> s.values is deep.values or s.index is deep.index\n False\n\n Updates to the data shared by shallow copy and original is reflected\n in both; deep copy remains unchanged.\n\n >>> s[0] = 3\n >>> shallow[1] = 4\n >>> s\n a 3\n b 4\n dtype: int64\n >>> shallow\n a 3\n b 4\n dtype: int64\n >>> deep\n a 1\n b 2\n dtype: int64\n\n Note that when copying an object containing Python objects, a deep copy\n will copy the data, but will not do so recursively. Updating a nested\n data object will be reflected in the deep copy.\n\n >>> s = pd.Series([[1, 2], [3, 4]])\n >>> deep = s.copy()\n >>> s[0][0] = 10\n >>> s\n 0 [10, 2]\n 1 [3, 4]\n dtype: object\n >>> deep\n 0 [10, 2]\n 1 [3, 4]\n dtype: object\n \"\"\"\n data = self._data.copy(deep=deep)\n return self._constructor(data).__finalize__(self)\n\n def __copy__(self: FrameOrSeries, deep: bool_t = True) -> FrameOrSeries:\n return self.copy(deep=deep)\n\n def __deepcopy__(self: FrameOrSeries, memo=None) -> FrameOrSeries:\n \"\"\"\n Parameters\n ----------\n memo, default None\n Standard signature. Unused\n \"\"\"\n return self.copy(deep=True)\n\n def _convert(\n self: FrameOrSeries,\n datetime: bool_t = False,\n numeric: bool_t = False,\n timedelta: bool_t = False,\n coerce: bool_t = False,\n copy: bool_t = True,\n ) -> FrameOrSeries:\n \"\"\"\n Attempt to infer better dtype for object columns\n\n Parameters\n ----------\n datetime : bool, default False\n If True, convert to date where possible.\n numeric : bool, default False\n If True, attempt to convert to numbers (including strings), with\n unconvertible values becoming NaN.\n timedelta : bool, default False\n If True, convert to timedelta where possible.\n coerce : bool, default False\n If True, force conversion with unconvertible values converted to\n nulls (NaN or NaT).\n copy : bool, default True\n If True, return a copy even if no copy is necessary (e.g. no\n conversion was done). Note: This is meant for internal use, and\n should not be confused with inplace.\n\n Returns\n -------\n converted : same as input object\n \"\"\"\n validate_bool_kwarg(datetime, \"datetime\")\n validate_bool_kwarg(numeric, \"numeric\")\n validate_bool_kwarg(timedelta, \"timedelta\")\n validate_bool_kwarg(coerce, \"coerce\")\n validate_bool_kwarg(copy, \"copy\")\n return self._constructor(\n self._data.convert(\n datetime=datetime,\n numeric=numeric,\n timedelta=timedelta,\n coerce=coerce,\n copy=copy,\n )\n ).__finalize__(self)\n\n def infer_objects(self: FrameOrSeries) -> FrameOrSeries:\n \"\"\"\n Attempt to infer better dtypes for object columns.\n\n Attempts soft conversion of object-dtyped\n columns, leaving non-object and unconvertible\n columns unchanged. The inference rules are the\n same as during normal Series/DataFrame construction.\n\n .. versionadded:: 0.21.0\n\n Returns\n -------\n converted : same type as input object\n\n See Also\n --------\n to_datetime : Convert argument to datetime.\n to_timedelta : Convert argument to timedelta.\n to_numeric : Convert argument to numeric type.\n convert_dtypes : Convert argument to best possible dtype.\n\n Examples\n --------\n >>> df = pd.DataFrame({\"A\": [\"a\", 1, 2, 3]})\n >>> df = df.iloc[1:]\n >>> df\n A\n 1 1\n 2 2\n 3 3\n\n >>> df.dtypes\n A object\n dtype: object\n\n >>> df.infer_objects().dtypes\n A int64\n dtype: object\n \"\"\"\n # numeric=False necessary to only soft convert;\n # python objects will still be converted to\n # native numpy numeric types\n return self._constructor(\n self._data.convert(\n datetime=True, numeric=False, timedelta=True, coerce=False, copy=True\n )\n ).__finalize__(self)\n\n def convert_dtypes(\n self: FrameOrSeries,\n infer_objects: bool_t = True,\n convert_string: bool_t = True,\n convert_integer: bool_t = True,\n convert_boolean: bool_t = True,\n ) -> FrameOrSeries:\n \"\"\"\n Convert columns to best possible dtypes using dtypes supporting ``pd.NA``.\n\n .. versionadded:: 1.0.0\n\n Parameters\n ----------\n infer_objects : bool, default True\n Whether object dtypes should be converted to the best possible types.\n convert_string : bool, default True\n Whether object dtypes should be converted to ``StringDtype()``.\n convert_integer : bool, default True\n Whether, if possible, conversion can be done to integer extension types.\n convert_boolean : bool, defaults True\n Whether object dtypes should be converted to ``BooleanDtypes()``.\n\n Returns\n -------\n Series or DataFrame\n Copy of input object with new dtype.\n\n See Also\n --------\n infer_objects : Infer dtypes of objects.\n to_datetime : Convert argument to datetime.\n to_timedelta : Convert argument to timedelta.\n to_numeric : Convert argument to a numeric type.\n\n Notes\n -----\n By default, ``convert_dtypes`` will attempt to convert a Series (or each\n Series in a DataFrame) to dtypes that support ``pd.NA``. By using the options\n ``convert_string``, ``convert_integer``, and ``convert_boolean``, it is\n possible to turn off individual conversions to ``StringDtype``, the integer\n extension types or ``BooleanDtype``, respectively.\n\n For object-dtyped columns, if ``infer_objects`` is ``True``, use the inference\n rules as during normal Series/DataFrame construction. Then, if possible,\n convert to ``StringDtype``, ``BooleanDtype`` or an appropriate integer extension\n type, otherwise leave as ``object``.\n\n If the dtype is integer, convert to an appropriate integer extension type.\n\n If the dtype is numeric, and consists of all integers, convert to an\n appropriate integer extension type.\n\n In the future, as new dtypes are added that support ``pd.NA``, the results\n of this method will change to support those new dtypes.\n\n Examples\n --------\n >>> df = pd.DataFrame(\n ... {\n ... \"a\": pd.Series([1, 2, 3], dtype=np.dtype(\"int32\")),\n ... \"b\": pd.Series([\"x\", \"y\", \"z\"], dtype=np.dtype(\"O\")),\n ... \"c\": pd.Series([True, False, np.nan], dtype=np.dtype(\"O\")),\n ... \"d\": pd.Series([\"h\", \"i\", np.nan], dtype=np.dtype(\"O\")),\n ... \"e\": pd.Series([10, np.nan, 20], dtype=np.dtype(\"float\")),\n ... \"f\": pd.Series([np.nan, 100.5, 200], dtype=np.dtype(\"float\")),\n ... }\n ... )\n\n Start with a DataFrame with default dtypes.\n\n >>> df\n a b c d e f\n 0 1 x True h 10.0 NaN\n 1 2 y False i NaN 100.5\n 2 3 z NaN NaN 20.0 200.0\n\n >>> df.dtypes\n a int32\n b object\n c object\n d object\n e float64\n f float64\n dtype: object\n\n Convert the DataFrame to use best possible dtypes.\n\n >>> dfn = df.convert_dtypes()\n >>> dfn\n a b c d e f\n 0 1 x True h 10 NaN\n 1 2 y False i <NA> 100.5\n 2 3 z <NA> <NA> 20 200.0\n\n >>> dfn.dtypes\n a Int32\n b string\n c boolean\n d string\n e Int64\n f float64\n dtype: object\n\n Start with a Series of strings and missing data represented by ``np.nan``.\n\n >>> s = pd.Series([\"a\", \"b\", np.nan])\n >>> s\n 0 a\n 1 b\n 2 NaN\n dtype: object\n\n Obtain a Series with dtype ``StringDtype``.\n\n >>> s.convert_dtypes()\n 0 a\n 1 b\n 2 <NA>\n dtype: string\n \"\"\"\n if self.ndim == 1:\n return self._convert_dtypes(\n infer_objects, convert_string, convert_integer, convert_boolean\n )\n else:\n results = [\n col._convert_dtypes(\n infer_objects, convert_string, convert_integer, convert_boolean\n )\n for col_name, col in self.items()\n ]\n result = pd.concat(results, axis=1, copy=False)\n return result\n\n # ----------------------------------------------------------------------\n # Filling NA's\n\n @doc(**_shared_doc_kwargs)\n def fillna(\n self: FrameOrSeries,\n value=None,\n method=None,\n axis=None,\n inplace: bool_t = False,\n limit=None,\n downcast=None,\n ) -> Optional[FrameOrSeries]:\n \"\"\"\n Fill NA/NaN values using the specified method.\n\n Parameters\n ----------\n value : scalar, dict, Series, or DataFrame\n Value to use to fill holes (e.g. 0), alternately a\n dict/Series/DataFrame of values specifying which value to use for\n each index (for a Series) or column (for a DataFrame). Values not\n in the dict/Series/DataFrame will not be filled. This value cannot\n be a list.\n method : {{'backfill', 'bfill', 'pad', 'ffill', None}}, default None\n Method to use for filling holes in reindexed Series\n pad / ffill: propagate last valid observation forward to next valid\n backfill / bfill: use next valid observation to fill gap.\n axis : {axes_single_arg}\n Axis along which to fill missing values.\n inplace : bool, default False\n If True, fill in-place. Note: this will modify any\n other views on this object (e.g., a no-copy slice for a column in a\n DataFrame).\n limit : int, default None\n If method is specified, this is the maximum number of consecutive\n NaN values to forward/backward fill. In other words, if there is\n a gap with more than this number of consecutive NaNs, it will only\n be partially filled. If method is not specified, this is the\n maximum number of entries along the entire axis where NaNs will be\n filled. Must be greater than 0 if not None.\n downcast : dict, default is None\n A dict of item->dtype of what to downcast if possible,\n or the string 'infer' which will try to downcast to an appropriate\n equal type (e.g. float64 to int64 if possible).\n\n Returns\n -------\n {klass} or None\n Object with missing values filled or None if ``inplace=True``.\n\n See Also\n --------\n interpolate : Fill NaN values using interpolation.\n reindex : Conform object to new index.\n asfreq : Convert TimeSeries to specified frequency.\n\n Examples\n --------\n >>> df = pd.DataFrame([[np.nan, 2, np.nan, 0],\n ... [3, 4, np.nan, 1],\n ... [np.nan, np.nan, np.nan, 5],\n ... [np.nan, 3, np.nan, 4]],\n ... columns=list('ABCD'))\n >>> df\n A B C D\n 0 NaN 2.0 NaN 0\n 1 3.0 4.0 NaN 1\n 2 NaN NaN NaN 5\n 3 NaN 3.0 NaN 4\n\n Replace all NaN elements with 0s.\n\n >>> df.fillna(0)\n A B C D\n 0 0.0 2.0 0.0 0\n 1 3.0 4.0 0.0 1\n 2 0.0 0.0 0.0 5\n 3 0.0 3.0 0.0 4\n\n We can also propagate non-null values forward or backward.\n\n >>> df.fillna(method='ffill')\n A B C D\n 0 NaN 2.0 NaN 0\n 1 3.0 4.0 NaN 1\n 2 3.0 4.0 NaN 5\n 3 3.0 3.0 NaN 4\n\n Replace all NaN elements in column 'A', 'B', 'C', and 'D', with 0, 1,\n 2, and 3 respectively.\n\n >>> values = {{'A': 0, 'B': 1, 'C': 2, 'D': 3}}\n >>> df.fillna(value=values)\n A B C D\n 0 0.0 2.0 2.0 0\n 1 3.0 4.0 2.0 1\n 2 0.0 1.0 2.0 5\n 3 0.0 3.0 2.0 4\n\n Only replace the first NaN element.\n\n >>> df.fillna(value=values, limit=1)\n A B C D\n 0 0.0 2.0 2.0 0\n 1 3.0 4.0 NaN 1\n 2 NaN 1.0 NaN 5\n 3 NaN 3.0 NaN 4\n \"\"\"\n inplace = validate_bool_kwarg(inplace, \"inplace\")\n value, method = validate_fillna_kwargs(value, method)\n\n self._consolidate_inplace()\n\n # set the default here, so functions examining the signaure\n # can detect if something was set (e.g. in groupby) (GH9221)\n if axis is None:\n axis = 0\n axis = self._get_axis_number(axis)\n\n if value is None:\n\n if self._is_mixed_type and axis == 1:\n if inplace:\n raise NotImplementedError()\n result = self.T.fillna(method=method, limit=limit).T\n\n # need to downcast here because of all of the transposes\n result._data = result._data.downcast()\n\n return result\n\n new_data = self._data.interpolate(\n method=method,\n axis=axis,\n limit=limit,\n inplace=inplace,\n coerce=True,\n downcast=downcast,\n )\n else:\n if len(self._get_axis(axis)) == 0:\n return self\n\n if self.ndim == 1:\n if isinstance(value, (dict, ABCSeries)):\n value = create_series_with_explicit_dtype(\n value, dtype_if_empty=object\n )\n elif not is_list_like(value):\n pass\n else:\n raise TypeError(\n '\"value\" parameter must be a scalar, dict '\n \"or Series, but you passed a \"\n f'\"{type(value).__name__}\"'\n )\n\n new_data = self._data.fillna(\n value=value, limit=limit, inplace=inplace, downcast=downcast\n )\n\n elif isinstance(value, (dict, ABCSeries)):\n if axis == 1:\n raise NotImplementedError(\n \"Currently only can fill \"\n \"with dict/Series column \"\n \"by column\"\n )\n\n result = self if inplace else self.copy()\n for k, v in value.items():\n if k not in result:\n continue\n obj = result[k]\n obj.fillna(v, limit=limit, inplace=True, downcast=downcast)\n return result if not inplace else None\n\n elif not is_list_like(value):\n new_data = self._data.fillna(\n value=value, limit=limit, inplace=inplace, downcast=downcast\n )\n elif isinstance(value, ABCDataFrame) and self.ndim == 2:\n new_data = self.where(self.notna(), value)\n else:\n raise ValueError(f\"invalid fill value with a {type(value)}\")\n\n if inplace:\n self._update_inplace(new_data)\n return None\n else:\n return self._constructor(new_data).__finalize__(self)\n\n def ffill(\n self: FrameOrSeries,\n axis=None,\n inplace: bool_t = False,\n limit=None,\n downcast=None,\n ) -> Optional[FrameOrSeries]:\n \"\"\"\n Synonym for :meth:`DataFrame.fillna` with ``method='ffill'``.\n\n Returns\n -------\n %(klass)s or None\n Object with missing values filled or None if ``inplace=True``.\n \"\"\"\n return self.fillna(\n method=\"ffill\", axis=axis, inplace=inplace, limit=limit, downcast=downcast\n )\n\n def bfill(\n self: FrameOrSeries,\n axis=None,\n inplace: bool_t = False,\n limit=None,\n downcast=None,\n ) -> Optional[FrameOrSeries]:\n \"\"\"\n Synonym for :meth:`DataFrame.fillna` with ``method='bfill'``.\n\n Returns\n -------\n %(klass)s or None\n Object with missing values filled or None if ``inplace=True``.\n \"\"\"\n return self.fillna(\n method=\"bfill\", axis=axis, inplace=inplace, limit=limit, downcast=downcast\n )\n\n _shared_docs[\n \"replace\"\n ] = \"\"\"\n Replace values given in `to_replace` with `value`.\n\n Values of the %(klass)s are replaced with other values dynamically.\n This differs from updating with ``.loc`` or ``.iloc``, which require\n you to specify a location to update with some value.\n\n Parameters\n ----------\n to_replace : str, regex, list, dict, Series, int, float, or None\n How to find the values that will be replaced.\n\n * numeric, str or regex:\n\n - numeric: numeric values equal to `to_replace` will be\n replaced with `value`\n - str: string exactly matching `to_replace` will be replaced\n with `value`\n - regex: regexs matching `to_replace` will be replaced with\n `value`\n\n * list of str, regex, or numeric:\n\n - First, if `to_replace` and `value` are both lists, they\n **must** be the same length.\n - Second, if ``regex=True`` then all of the strings in **both**\n lists will be interpreted as regexs otherwise they will match\n directly. This doesn't matter much for `value` since there\n are only a few possible substitution regexes you can use.\n - str, regex and numeric rules apply as above.\n\n * dict:\n\n - Dicts can be used to specify different replacement values\n for different existing values. For example,\n ``{'a': 'b', 'y': 'z'}`` replaces the value 'a' with 'b' and\n 'y' with 'z'. To use a dict in this way the `value`\n parameter should be `None`.\n - For a DataFrame a dict can specify that different values\n should be replaced in different columns. For example,\n ``{'a': 1, 'b': 'z'}`` looks for the value 1 in column 'a'\n and the value 'z' in column 'b' and replaces these values\n with whatever is specified in `value`. The `value` parameter\n should not be ``None`` in this case. You can treat this as a\n special case of passing two lists except that you are\n specifying the column to search in.\n - For a DataFrame nested dictionaries, e.g.,\n ``{'a': {'b': np.nan}}``, are read as follows: look in column\n 'a' for the value 'b' and replace it with NaN. The `value`\n parameter should be ``None`` to use a nested dict in this\n way. You can nest regular expressions as well. Note that\n column names (the top-level dictionary keys in a nested\n dictionary) **cannot** be regular expressions.\n\n * None:\n\n - This means that the `regex` argument must be a string,\n compiled regular expression, or list, dict, ndarray or\n Series of such elements. If `value` is also ``None`` then\n this **must** be a nested dictionary or Series.\n\n See the examples section for examples of each of these.\n value : scalar, dict, list, str, regex, default None\n Value to replace any values matching `to_replace` with.\n For a DataFrame a dict of values can be used to specify which\n value to use for each column (columns not in the dict will not be\n filled). Regular expressions, strings and lists or dicts of such\n objects are also allowed.\n inplace : bool, default False\n If True, in place. Note: this will modify any\n other views on this object (e.g. a column from a DataFrame).\n Returns the caller if this is True.\n limit : int, default None\n Maximum size gap to forward or backward fill.\n regex : bool or same types as `to_replace`, default False\n Whether to interpret `to_replace` and/or `value` as regular\n expressions. If this is ``True`` then `to_replace` *must* be a\n string. Alternatively, this could be a regular expression or a\n list, dict, or array of regular expressions in which case\n `to_replace` must be ``None``.\n method : {'pad', 'ffill', 'bfill', `None`}\n The method to use when for replacement, when `to_replace` is a\n scalar, list or tuple and `value` is ``None``.\n\n .. versionchanged:: 0.23.0\n Added to DataFrame.\n\n Returns\n -------\n %(klass)s\n Object after replacement.\n\n Raises\n ------\n AssertionError\n * If `regex` is not a ``bool`` and `to_replace` is not\n ``None``.\n\n TypeError\n * If `to_replace` is not a scalar, array-like, ``dict``, or ``None``\n * If `to_replace` is a ``dict`` and `value` is not a ``list``,\n ``dict``, ``ndarray``, or ``Series``\n * If `to_replace` is ``None`` and `regex` is not compilable\n into a regular expression or is a list, dict, ndarray, or\n Series.\n * When replacing multiple ``bool`` or ``datetime64`` objects and\n the arguments to `to_replace` does not match the type of the\n value being replaced\n\n ValueError\n * If a ``list`` or an ``ndarray`` is passed to `to_replace` and\n `value` but they are not the same length.\n\n See Also\n --------\n %(klass)s.fillna : Fill NA values.\n %(klass)s.where : Replace values based on boolean condition.\n Series.str.replace : Simple string replacement.\n\n Notes\n -----\n * Regex substitution is performed under the hood with ``re.sub``. The\n rules for substitution for ``re.sub`` are the same.\n * Regular expressions will only substitute on strings, meaning you\n cannot provide, for example, a regular expression matching floating\n point numbers and expect the columns in your frame that have a\n numeric dtype to be matched. However, if those floating point\n numbers *are* strings, then you can do this.\n * This method has *a lot* of options. You are encouraged to experiment\n and play with this method to gain intuition about how it works.\n * When dict is used as the `to_replace` value, it is like\n key(s) in the dict are the to_replace part and\n value(s) in the dict are the value parameter.\n\n Examples\n --------\n\n **Scalar `to_replace` and `value`**\n\n >>> s = pd.Series([0, 1, 2, 3, 4])\n >>> s.replace(0, 5)\n 0 5\n 1 1\n 2 2\n 3 3\n 4 4\n dtype: int64\n\n >>> df = pd.DataFrame({'A': [0, 1, 2, 3, 4],\n ... 'B': [5, 6, 7, 8, 9],\n ... 'C': ['a', 'b', 'c', 'd', 'e']})\n >>> df.replace(0, 5)\n A B C\n 0 5 5 a\n 1 1 6 b\n 2 2 7 c\n 3 3 8 d\n 4 4 9 e\n\n **List-like `to_replace`**\n\n >>> df.replace([0, 1, 2, 3], 4)\n A B C\n 0 4 5 a\n 1 4 6 b\n 2 4 7 c\n 3 4 8 d\n 4 4 9 e\n\n >>> df.replace([0, 1, 2, 3], [4, 3, 2, 1])\n A B C\n 0 4 5 a\n 1 3 6 b\n 2 2 7 c\n 3 1 8 d\n 4 4 9 e\n\n >>> s.replace([1, 2], method='bfill')\n 0 0\n 1 3\n 2 3\n 3 3\n 4 4\n dtype: int64\n\n **dict-like `to_replace`**\n\n >>> df.replace({0: 10, 1: 100})\n A B C\n 0 10 5 a\n 1 100 6 b\n 2 2 7 c\n 3 3 8 d\n 4 4 9 e\n\n >>> df.replace({'A': 0, 'B': 5}, 100)\n A B C\n 0 100 100 a\n 1 1 6 b\n 2 2 7 c\n 3 3 8 d\n 4 4 9 e\n\n >>> df.replace({'A': {0: 100, 4: 400}})\n A B C\n 0 100 5 a\n 1 1 6 b\n 2 2 7 c\n 3 3 8 d\n 4 400 9 e\n\n **Regular expression `to_replace`**\n\n >>> df = pd.DataFrame({'A': ['bat', 'foo', 'bait'],\n ... 'B': ['abc', 'bar', 'xyz']})\n >>> df.replace(to_replace=r'^ba.$', value='new', regex=True)\n A B\n 0 new abc\n 1 foo new\n 2 bait xyz\n\n >>> df.replace({'A': r'^ba.$'}, {'A': 'new'}, regex=True)\n A B\n 0 new abc\n 1 foo bar\n 2 bait xyz\n\n >>> df.replace(regex=r'^ba.$', value='new')\n A B\n 0 new abc\n 1 foo new\n 2 bait xyz\n\n >>> df.replace(regex={r'^ba.$': 'new', 'foo': 'xyz'})\n A B\n 0 new abc\n 1 xyz new\n 2 bait xyz\n\n >>> df.replace(regex=[r'^ba.$', 'foo'], value='new')\n A B\n 0 new abc\n 1 new new\n 2 bait xyz\n\n Note that when replacing multiple ``bool`` or ``datetime64`` objects,\n the data types in the `to_replace` parameter must match the data\n type of the value being replaced:\n\n >>> df = pd.DataFrame({'A': [True, False, True],\n ... 'B': [False, True, False]})\n >>> df.replace({'a string': 'new value', True: False}) # raises\n Traceback (most recent call last):\n ...\n TypeError: Cannot compare types 'ndarray(dtype=bool)' and 'str'\n\n This raises a ``TypeError`` because one of the ``dict`` keys is not of\n the correct type for replacement.\n\n Compare the behavior of ``s.replace({'a': None})`` and\n ``s.replace('a', None)`` to understand the peculiarities\n of the `to_replace` parameter:\n\n >>> s = pd.Series([10, 'a', 'a', 'b', 'a'])\n\n When one uses a dict as the `to_replace` value, it is like the\n value(s) in the dict are equal to the `value` parameter.\n ``s.replace({'a': None})`` is equivalent to\n ``s.replace(to_replace={'a': None}, value=None, method=None)``:\n\n >>> s.replace({'a': None})\n 0 10\n 1 None\n 2 None\n 3 b\n 4 None\n dtype: object\n\n When ``value=None`` and `to_replace` is a scalar, list or\n tuple, `replace` uses the method parameter (default 'pad') to do the\n replacement. So this is why the 'a' values are being replaced by 10\n in rows 1 and 2 and 'b' in row 4 in this case.\n The command ``s.replace('a', None)`` is actually equivalent to\n ``s.replace(to_replace='a', value=None, method='pad')``:\n\n >>> s.replace('a', None)\n 0 10\n 1 10\n 2 10\n 3 b\n 4 b\n dtype: object\n \"\"\"\n\n @Appender(_shared_docs[\"replace\"] % _shared_doc_kwargs)\n def replace(\n self,\n to_replace=None,\n value=None,\n inplace=False,\n limit=None,\n regex=False,\n method=\"pad\",\n ):\n if not (\n is_scalar(to_replace)\n or isinstance(to_replace, pd.Series)\n or is_re_compilable(to_replace)\n or is_list_like(to_replace)\n ):\n raise TypeError(\n \"Expecting 'to_replace' to be either a scalar, array-like, \"\n \"dict or None, got invalid type \"\n f\"{repr(type(to_replace).__name__)}\"\n )\n\n inplace = validate_bool_kwarg(inplace, \"inplace\")\n if not is_bool(regex) and to_replace is not None:\n raise AssertionError(\"'to_replace' must be 'None' if 'regex' is not a bool\")\n\n self._consolidate_inplace()\n\n if value is None:\n # passing a single value that is scalar like\n # when value is None (GH5319), for compat\n if not is_dict_like(to_replace) and not is_dict_like(regex):\n to_replace = [to_replace]\n\n if isinstance(to_replace, (tuple, list)):\n if isinstance(self, ABCDataFrame):\n return self.apply(\n _single_replace, args=(to_replace, method, inplace, limit)\n )\n return _single_replace(self, to_replace, method, inplace, limit)\n\n if not is_dict_like(to_replace):\n if not is_dict_like(regex):\n raise TypeError(\n 'If \"to_replace\" and \"value\" are both None '\n 'and \"to_replace\" is not a list, then '\n \"regex must be a mapping\"\n )\n to_replace = regex\n regex = True\n\n items = list(to_replace.items())\n keys, values = zip(*items) if items else ([], [])\n\n are_mappings = [is_dict_like(v) for v in values]\n\n if any(are_mappings):\n if not all(are_mappings):\n raise TypeError(\n \"If a nested mapping is passed, all values \"\n \"of the top level mapping must be mappings\"\n )\n # passed a nested dict/Series\n to_rep_dict = {}\n value_dict = {}\n\n for k, v in items:\n keys, values = list(zip(*v.items())) or ([], [])\n\n to_rep_dict[k] = list(keys)\n value_dict[k] = list(values)\n\n to_replace, value = to_rep_dict, value_dict\n else:\n to_replace, value = keys, values\n\n return self.replace(\n to_replace, value, inplace=inplace, limit=limit, regex=regex\n )\n else:\n\n # need a non-zero len on all axes\n if not self.size:\n return self\n\n new_data = self._data\n if is_dict_like(to_replace):\n if is_dict_like(value): # {'A' : NA} -> {'A' : 0}\n res = self if inplace else self.copy()\n for c, src in to_replace.items():\n if c in value and c in self:\n # object conversion is handled in\n # series.replace which is called recursively\n res[c] = res[c].replace(\n to_replace=src,\n value=value[c],\n inplace=False,\n regex=regex,\n )\n return None if inplace else res\n\n # {'A': NA} -> 0\n elif not is_list_like(value):\n keys = [(k, src) for k, src in to_replace.items() if k in self]\n keys_len = len(keys) - 1\n for i, (k, src) in enumerate(keys):\n convert = i == keys_len\n new_data = new_data.replace(\n to_replace=src,\n value=value,\n filter=[k],\n inplace=inplace,\n regex=regex,\n convert=convert,\n )\n else:\n raise TypeError(\"value argument must be scalar, dict, or Series\")\n\n elif is_list_like(to_replace): # [NA, ''] -> [0, 'missing']\n if is_list_like(value):\n if len(to_replace) != len(value):\n raise ValueError(\n f\"Replacement lists must match in length. \"\n f\"Expecting {len(to_replace)} got {len(value)} \"\n )\n\n new_data = self._data.replace_list(\n src_list=to_replace,\n dest_list=value,\n inplace=inplace,\n regex=regex,\n )\n\n else: # [NA, ''] -> 0\n new_data = self._data.replace(\n to_replace=to_replace, value=value, inplace=inplace, regex=regex\n )\n elif to_replace is None:\n if not (\n is_re_compilable(regex)\n or is_list_like(regex)\n or is_dict_like(regex)\n ):\n raise TypeError(\n f\"'regex' must be a string or a compiled regular expression \"\n f\"or a list or dict of strings or regular expressions, \"\n f\"you passed a {repr(type(regex).__name__)}\"\n )\n return self.replace(\n regex, value, inplace=inplace, limit=limit, regex=True\n )\n else:\n\n # dest iterable dict-like\n if is_dict_like(value): # NA -> {'A' : 0, 'B' : -1}\n new_data = self._data\n\n for k, v in value.items():\n if k in self:\n new_data = new_data.replace(\n to_replace=to_replace,\n value=v,\n filter=[k],\n inplace=inplace,\n regex=regex,\n )\n\n elif not is_list_like(value): # NA -> 0\n new_data = self._data.replace(\n to_replace=to_replace, value=value, inplace=inplace, regex=regex\n )\n else:\n raise TypeError(\n f'Invalid \"to_replace\" type: {repr(type(to_replace).__name__)}'\n )\n\n if inplace:\n self._update_inplace(new_data)\n else:\n return self._constructor(new_data).__finalize__(self)\n\n _shared_docs[\n \"interpolate\"\n ] = \"\"\"\n Please note that only ``method='linear'`` is supported for\n DataFrame/Series with a MultiIndex.\n\n Parameters\n ----------\n method : str, default 'linear'\n Interpolation technique to use. One of:\n\n * 'linear': Ignore the index and treat the values as equally\n spaced. This is the only method supported on MultiIndexes.\n * 'time': Works on daily and higher resolution data to interpolate\n given length of interval.\n * 'index', 'values': use the actual numerical values of the index.\n * 'pad': Fill in NaNs using existing values.\n * 'nearest', 'zero', 'slinear', 'quadratic', 'cubic', 'spline',\n 'barycentric', 'polynomial': Passed to\n `scipy.interpolate.interp1d`. These methods use the numerical\n values of the index. Both 'polynomial' and 'spline' require that\n you also specify an `order` (int), e.g.\n ``df.interpolate(method='polynomial', order=5)``.\n * 'krogh', 'piecewise_polynomial', 'spline', 'pchip', 'akima':\n Wrappers around the SciPy interpolation methods of similar\n names. See `Notes`.\n * 'from_derivatives': Refers to\n `scipy.interpolate.BPoly.from_derivatives` which\n replaces 'piecewise_polynomial' interpolation method in\n scipy 0.18.\n axis : {0 or 'index', 1 or 'columns', None}, default None\n Axis to interpolate along.\n limit : int, optional\n Maximum number of consecutive NaNs to fill. Must be greater than\n 0.\n inplace : bool, default False\n Update the data in place if possible.\n limit_direction : {'forward', 'backward', 'both'}, default 'forward'\n If limit is specified, consecutive NaNs will be filled in this\n direction.\n limit_area : {`None`, 'inside', 'outside'}, default None\n If limit is specified, consecutive NaNs will be filled with this\n restriction.\n\n * ``None``: No fill restriction.\n * 'inside': Only fill NaNs surrounded by valid values\n (interpolate).\n * 'outside': Only fill NaNs outside valid values (extrapolate).\n\n .. versionadded:: 0.23.0\n\n downcast : optional, 'infer' or None, defaults to None\n Downcast dtypes if possible.\n **kwargs\n Keyword arguments to pass on to the interpolating function.\n\n Returns\n -------\n Series or DataFrame\n Returns the same object type as the caller, interpolated at\n some or all ``NaN`` values.\n\n See Also\n --------\n fillna : Fill missing values using different methods.\n scipy.interpolate.Akima1DInterpolator : Piecewise cubic polynomials\n (Akima interpolator).\n scipy.interpolate.BPoly.from_derivatives : Piecewise polynomial in the\n Bernstein basis.\n scipy.interpolate.interp1d : Interpolate a 1-D function.\n scipy.interpolate.KroghInterpolator : Interpolate polynomial (Krogh\n interpolator).\n scipy.interpolate.PchipInterpolator : PCHIP 1-d monotonic cubic\n interpolation.\n scipy.interpolate.CubicSpline : Cubic spline data interpolator.\n\n Notes\n -----\n The 'krogh', 'piecewise_polynomial', 'spline', 'pchip' and 'akima'\n methods are wrappers around the respective SciPy implementations of\n similar names. These use the actual numerical values of the index.\n For more information on their behavior, see the\n `SciPy documentation\n <https://docs.scipy.org/doc/scipy/reference/interpolate.html#univariate-interpolation>`__\n and `SciPy tutorial\n <https://docs.scipy.org/doc/scipy/reference/tutorial/interpolate.html>`__.\n\n Examples\n --------\n Filling in ``NaN`` in a :class:`~pandas.Series` via linear\n interpolation.\n\n >>> s = pd.Series([0, 1, np.nan, 3])\n >>> s\n 0 0.0\n 1 1.0\n 2 NaN\n 3 3.0\n dtype: float64\n >>> s.interpolate()\n 0 0.0\n 1 1.0\n 2 2.0\n 3 3.0\n dtype: float64\n\n Filling in ``NaN`` in a Series by padding, but filling at most two\n consecutive ``NaN`` at a time.\n\n >>> s = pd.Series([np.nan, \"single_one\", np.nan,\n ... \"fill_two_more\", np.nan, np.nan, np.nan,\n ... 4.71, np.nan])\n >>> s\n 0 NaN\n 1 single_one\n 2 NaN\n 3 fill_two_more\n 4 NaN\n 5 NaN\n 6 NaN\n 7 4.71\n 8 NaN\n dtype: object\n >>> s.interpolate(method='pad', limit=2)\n 0 NaN\n 1 single_one\n 2 single_one\n 3 fill_two_more\n 4 fill_two_more\n 5 fill_two_more\n 6 NaN\n 7 4.71\n 8 4.71\n dtype: object\n\n Filling in ``NaN`` in a Series via polynomial interpolation or splines:\n Both 'polynomial' and 'spline' methods require that you also specify\n an ``order`` (int).\n\n >>> s = pd.Series([0, 2, np.nan, 8])\n >>> s.interpolate(method='polynomial', order=2)\n 0 0.000000\n 1 2.000000\n 2 4.666667\n 3 8.000000\n dtype: float64\n\n Fill the DataFrame forward (that is, going down) along each column\n using linear interpolation.\n\n Note how the last entry in column 'a' is interpolated differently,\n because there is no entry after it to use for interpolation.\n Note how the first entry in column 'b' remains ``NaN``, because there\n is no entry before it to use for interpolation.\n\n >>> df = pd.DataFrame([(0.0, np.nan, -1.0, 1.0),\n ... (np.nan, 2.0, np.nan, np.nan),\n ... (2.0, 3.0, np.nan, 9.0),\n ... (np.nan, 4.0, -4.0, 16.0)],\n ... columns=list('abcd'))\n >>> df\n a b c d\n 0 0.0 NaN -1.0 1.0\n 1 NaN 2.0 NaN NaN\n 2 2.0 3.0 NaN 9.0\n 3 NaN 4.0 -4.0 16.0\n >>> df.interpolate(method='linear', limit_direction='forward', axis=0)\n a b c d\n 0 0.0 NaN -1.0 1.0\n 1 1.0 2.0 -2.0 5.0\n 2 2.0 3.0 -3.0 9.0\n 3 2.0 4.0 -4.0 16.0\n\n Using polynomial interpolation.\n\n >>> df['d'].interpolate(method='polynomial', order=2)\n 0 1.0\n 1 4.0\n 2 9.0\n 3 16.0\n Name: d, dtype: float64\n \"\"\"\n\n @Appender(_shared_docs[\"interpolate\"] % _shared_doc_kwargs)\n def interpolate(\n self,\n method=\"linear\",\n axis=0,\n limit=None,\n inplace=False,\n limit_direction=\"forward\",\n limit_area=None,\n downcast=None,\n **kwargs,\n ):\n \"\"\"\n Interpolate values according to different methods.\n \"\"\"\n inplace = validate_bool_kwarg(inplace, \"inplace\")\n\n axis = self._get_axis_number(axis)\n\n if axis == 0:\n ax = self._info_axis_name\n _maybe_transposed_self = self\n elif axis == 1:\n _maybe_transposed_self = self.T\n ax = 1\n\n ax = _maybe_transposed_self._get_axis_number(ax)\n\n if _maybe_transposed_self.ndim == 2:\n alt_ax = 1 - ax\n else:\n alt_ax = ax\n\n if isinstance(_maybe_transposed_self.index, MultiIndex) and method != \"linear\":\n raise ValueError(\n \"Only `method=linear` interpolation is supported on MultiIndexes.\"\n )\n\n if _maybe_transposed_self._data.get_dtype_counts().get(\"object\") == len(\n _maybe_transposed_self.T\n ):\n raise TypeError(\n \"Cannot interpolate with all object-dtype columns \"\n \"in the DataFrame. Try setting at least one \"\n \"column to a numeric dtype.\"\n )\n\n # create/use the index\n if method == \"linear\":\n # prior default\n index = np.arange(len(_maybe_transposed_self._get_axis(alt_ax)))\n else:\n index = _maybe_transposed_self._get_axis(alt_ax)\n methods = {\"index\", \"values\", \"nearest\", \"time\"}\n is_numeric_or_datetime = (\n is_numeric_dtype(index)\n or is_datetime64_any_dtype(index)\n or is_timedelta64_dtype(index)\n )\n if method not in methods and not is_numeric_or_datetime:\n raise ValueError(\n \"Index column must be numeric or datetime type when \"\n f\"using {method} method other than linear. \"\n \"Try setting a numeric or datetime index column before \"\n \"interpolating.\"\n )\n\n if isna(index).any():\n raise NotImplementedError(\n \"Interpolation with NaNs in the index \"\n \"has not been implemented. Try filling \"\n \"those NaNs before interpolating.\"\n )\n data = _maybe_transposed_self._data\n new_data = data.interpolate(\n method=method,\n axis=ax,\n index=index,\n limit=limit,\n limit_direction=limit_direction,\n limit_area=limit_area,\n inplace=inplace,\n downcast=downcast,\n **kwargs,\n )\n\n if inplace:\n if axis == 1:\n new_data = self._constructor(new_data).T._data\n self._update_inplace(new_data)\n else:\n res = self._constructor(new_data).__finalize__(self)\n if axis == 1:\n res = res.T\n return res\n\n # ----------------------------------------------------------------------\n # Timeseries methods Methods\n\n def asof(self, where, subset=None):\n \"\"\"\n Return the last row(s) without any NaNs before `where`.\n\n The last row (for each element in `where`, if list) without any\n NaN is taken.\n In case of a :class:`~pandas.DataFrame`, the last row without NaN\n considering only the subset of columns (if not `None`)\n\n If there is no good value, NaN is returned for a Series or\n a Series of NaN values for a DataFrame\n\n Parameters\n ----------\n where : date or array-like of dates\n Date(s) before which the last row(s) are returned.\n subset : str or array-like of str, default `None`\n For DataFrame, if not `None`, only use these columns to\n check for NaNs.\n\n Returns\n -------\n scalar, Series, or DataFrame\n\n The return can be:\n\n * scalar : when `self` is a Series and `where` is a scalar\n * Series: when `self` is a Series and `where` is an array-like,\n or when `self` is a DataFrame and `where` is a scalar\n * DataFrame : when `self` is a DataFrame and `where` is an\n array-like\n\n Return scalar, Series, or DataFrame.\n\n See Also\n --------\n merge_asof : Perform an asof merge. Similar to left join.\n\n Notes\n -----\n Dates are assumed to be sorted. Raises if this is not the case.\n\n Examples\n --------\n A Series and a scalar `where`.\n\n >>> s = pd.Series([1, 2, np.nan, 4], index=[10, 20, 30, 40])\n >>> s\n 10 1.0\n 20 2.0\n 30 NaN\n 40 4.0\n dtype: float64\n\n >>> s.asof(20)\n 2.0\n\n For a sequence `where`, a Series is returned. The first value is\n NaN, because the first element of `where` is before the first\n index value.\n\n >>> s.asof([5, 20])\n 5 NaN\n 20 2.0\n dtype: float64\n\n Missing values are not considered. The following is ``2.0``, not\n NaN, even though NaN is at the index location for ``30``.\n\n >>> s.asof(30)\n 2.0\n\n Take all columns into consideration\n\n >>> df = pd.DataFrame({'a': [10, 20, 30, 40, 50],\n ... 'b': [None, None, None, None, 500]},\n ... index=pd.DatetimeIndex(['2018-02-27 09:01:00',\n ... '2018-02-27 09:02:00',\n ... '2018-02-27 09:03:00',\n ... '2018-02-27 09:04:00',\n ... '2018-02-27 09:05:00']))\n >>> df.asof(pd.DatetimeIndex(['2018-02-27 09:03:30',\n ... '2018-02-27 09:04:30']))\n a b\n 2018-02-27 09:03:30 NaN NaN\n 2018-02-27 09:04:30 NaN NaN\n\n Take a single column into consideration\n\n >>> df.asof(pd.DatetimeIndex(['2018-02-27 09:03:30',\n ... '2018-02-27 09:04:30']),\n ... subset=['a'])\n a b\n 2018-02-27 09:03:30 30.0 NaN\n 2018-02-27 09:04:30 40.0 NaN\n \"\"\"\n if isinstance(where, str):\n where = Timestamp(where)\n\n if not self.index.is_monotonic:\n raise ValueError(\"asof requires a sorted index\")\n\n is_series = isinstance(self, ABCSeries)\n if is_series:\n if subset is not None:\n raise ValueError(\"subset is not valid for Series\")\n else:\n if subset is None:\n subset = self.columns\n if not is_list_like(subset):\n subset = [subset]\n\n is_list = is_list_like(where)\n if not is_list:\n start = self.index[0]\n if isinstance(self.index, PeriodIndex):\n where = Period(where, freq=self.index.freq)\n\n if where < start:\n if not is_series:\n from pandas import Series\n\n return Series(index=self.columns, name=where, dtype=np.float64)\n return np.nan\n\n # It's always much faster to use a *while* loop here for\n # Series than pre-computing all the NAs. However a\n # *while* loop is extremely expensive for DataFrame\n # so we later pre-compute all the NAs and use the same\n # code path whether *where* is a scalar or list.\n # See PR: https://github.com/pandas-dev/pandas/pull/14476\n if is_series:\n loc = self.index.searchsorted(where, side=\"right\")\n if loc > 0:\n loc -= 1\n\n values = self._values\n while loc > 0 and isna(values[loc]):\n loc -= 1\n return values[loc]\n\n if not isinstance(where, Index):\n where = Index(where) if is_list else Index([where])\n\n nulls = self.isna() if is_series else self[subset].isna().any(1)\n if nulls.all():\n if is_series:\n return self._constructor(np.nan, index=where, name=self.name)\n elif is_list:\n from pandas import DataFrame\n\n return DataFrame(np.nan, index=where, columns=self.columns)\n else:\n from pandas import Series\n\n return Series(np.nan, index=self.columns, name=where[0])\n\n locs = self.index.asof_locs(where, ~(nulls.values))\n\n # mask the missing\n missing = locs == -1\n data = self.take(locs)\n data.index = where\n data.loc[missing] = np.nan\n return data if is_list else data.iloc[-1]\n\n # ----------------------------------------------------------------------\n # Action Methods\n\n _shared_docs[\n \"isna\"\n ] = \"\"\"\n Detect missing values.\n\n Return a boolean same-sized object indicating if the values are NA.\n NA values, such as None or :attr:`numpy.NaN`, gets mapped to True\n values.\n Everything else gets mapped to False values. Characters such as empty\n strings ``''`` or :attr:`numpy.inf` are not considered NA values\n (unless you set ``pandas.options.mode.use_inf_as_na = True``).\n\n Returns\n -------\n %(klass)s\n Mask of bool values for each element in %(klass)s that\n indicates whether an element is not an NA value.\n\n See Also\n --------\n %(klass)s.isnull : Alias of isna.\n %(klass)s.notna : Boolean inverse of isna.\n %(klass)s.dropna : Omit axes labels with missing values.\n isna : Top-level isna.\n\n Examples\n --------\n Show which entries in a DataFrame are NA.\n\n >>> df = pd.DataFrame({'age': [5, 6, np.NaN],\n ... 'born': [pd.NaT, pd.Timestamp('1939-05-27'),\n ... pd.Timestamp('1940-04-25')],\n ... 'name': ['Alfred', 'Batman', ''],\n ... 'toy': [None, 'Batmobile', 'Joker']})\n >>> df\n age born name toy\n 0 5.0 NaT Alfred None\n 1 6.0 1939-05-27 Batman Batmobile\n 2 NaN 1940-04-25 Joker\n\n >>> df.isna()\n age born name toy\n 0 False True False True\n 1 False False False False\n 2 True False False False\n\n Show which entries in a Series are NA.\n\n >>> ser = pd.Series([5, 6, np.NaN])\n >>> ser\n 0 5.0\n 1 6.0\n 2 NaN\n dtype: float64\n\n >>> ser.isna()\n 0 False\n 1 False\n 2 True\n dtype: bool\n \"\"\"\n\n @Appender(_shared_docs[\"isna\"] % _shared_doc_kwargs)\n def isna(self: FrameOrSeries) -> FrameOrSeries:\n return isna(self).__finalize__(self)\n\n @Appender(_shared_docs[\"isna\"] % _shared_doc_kwargs)\n def isnull(self: FrameOrSeries) -> FrameOrSeries:\n return isna(self).__finalize__(self)\n\n _shared_docs[\n \"notna\"\n ] = \"\"\"\n Detect existing (non-missing) values.\n\n Return a boolean same-sized object indicating if the values are not NA.\n Non-missing values get mapped to True. Characters such as empty\n strings ``''`` or :attr:`numpy.inf` are not considered NA values\n (unless you set ``pandas.options.mode.use_inf_as_na = True``).\n NA values, such as None or :attr:`numpy.NaN`, get mapped to False\n values.\n\n Returns\n -------\n %(klass)s\n Mask of bool values for each element in %(klass)s that\n indicates whether an element is not an NA value.\n\n See Also\n --------\n %(klass)s.notnull : Alias of notna.\n %(klass)s.isna : Boolean inverse of notna.\n %(klass)s.dropna : Omit axes labels with missing values.\n notna : Top-level notna.\n\n Examples\n --------\n Show which entries in a DataFrame are not NA.\n\n >>> df = pd.DataFrame({'age': [5, 6, np.NaN],\n ... 'born': [pd.NaT, pd.Timestamp('1939-05-27'),\n ... pd.Timestamp('1940-04-25')],\n ... 'name': ['Alfred', 'Batman', ''],\n ... 'toy': [None, 'Batmobile', 'Joker']})\n >>> df\n age born name toy\n 0 5.0 NaT Alfred None\n 1 6.0 1939-05-27 Batman Batmobile\n 2 NaN 1940-04-25 Joker\n\n >>> df.notna()\n age born name toy\n 0 True False True False\n 1 True True True True\n 2 False True True True\n\n Show which entries in a Series are not NA.\n\n >>> ser = pd.Series([5, 6, np.NaN])\n >>> ser\n 0 5.0\n 1 6.0\n 2 NaN\n dtype: float64\n\n >>> ser.notna()\n 0 True\n 1 True\n 2 False\n dtype: bool\n \"\"\"\n\n @Appender(_shared_docs[\"notna\"] % _shared_doc_kwargs)\n def notna(self: FrameOrSeries) -> FrameOrSeries:\n return notna(self).__finalize__(self)\n\n @Appender(_shared_docs[\"notna\"] % _shared_doc_kwargs)\n def notnull(self: FrameOrSeries) -> FrameOrSeries:\n return notna(self).__finalize__(self)\n\n def _clip_with_scalar(self, lower, upper, inplace: bool_t = False):\n if (lower is not None and np.any(isna(lower))) or (\n upper is not None and np.any(isna(upper))\n ):\n raise ValueError(\"Cannot use an NA value as a clip threshold\")\n\n result = self\n mask = isna(self.values)\n\n with np.errstate(all=\"ignore\"):\n if upper is not None:\n subset = self.to_numpy() <= upper\n result = result.where(subset, upper, axis=None, inplace=False)\n if lower is not None:\n subset = self.to_numpy() >= lower\n result = result.where(subset, lower, axis=None, inplace=False)\n\n if np.any(mask):\n result[mask] = np.nan\n\n if inplace:\n self._update_inplace(result)\n else:\n return result\n\n def _clip_with_one_bound(self, threshold, method, axis, inplace):\n\n if axis is not None:\n axis = self._get_axis_number(axis)\n\n # method is self.le for upper bound and self.ge for lower bound\n if is_scalar(threshold) and is_number(threshold):\n if method.__name__ == \"le\":\n return self._clip_with_scalar(None, threshold, inplace=inplace)\n return self._clip_with_scalar(threshold, None, inplace=inplace)\n\n subset = method(threshold, axis=axis) | isna(self)\n\n # GH #15390\n # In order for where method to work, the threshold must\n # be transformed to NDFrame from other array like structure.\n if (not isinstance(threshold, ABCSeries)) and is_list_like(threshold):\n if isinstance(self, ABCSeries):\n threshold = self._constructor(threshold, index=self.index)\n else:\n threshold = _align_method_FRAME(self, threshold, axis, flex=None)[1]\n return self.where(subset, threshold, axis=axis, inplace=inplace)\n\n def clip(\n self: FrameOrSeries,\n lower=None,\n upper=None,\n axis=None,\n inplace: bool_t = False,\n *args,\n **kwargs,\n ) -> FrameOrSeries:\n \"\"\"\n Trim values at input threshold(s).\n\n Assigns values outside boundary to boundary values. Thresholds\n can be singular values or array like, and in the latter case\n the clipping is performed element-wise in the specified axis.\n\n Parameters\n ----------\n lower : float or array_like, default None\n Minimum threshold value. All values below this\n threshold will be set to it.\n upper : float or array_like, default None\n Maximum threshold value. All values above this\n threshold will be set to it.\n axis : int or str axis name, optional\n Align object with lower and upper along the given axis.\n inplace : bool, default False\n Whether to perform the operation in place on the data.\n\n .. versionadded:: 0.21.0\n *args, **kwargs\n Additional keywords have no effect but might be accepted\n for compatibility with numpy.\n\n Returns\n -------\n Series or DataFrame\n Same type as calling object with the values outside the\n clip boundaries replaced.\n\n Examples\n --------\n >>> data = {'col_0': [9, -3, 0, -1, 5], 'col_1': [-2, -7, 6, 8, -5]}\n >>> df = pd.DataFrame(data)\n >>> df\n col_0 col_1\n 0 9 -2\n 1 -3 -7\n 2 0 6\n 3 -1 8\n 4 5 -5\n\n Clips per column using lower and upper thresholds:\n\n >>> df.clip(-4, 6)\n col_0 col_1\n 0 6 -2\n 1 -3 -4\n 2 0 6\n 3 -1 6\n 4 5 -4\n\n Clips using specific lower and upper thresholds per column element:\n\n >>> t = pd.Series([2, -4, -1, 6, 3])\n >>> t\n 0 2\n 1 -4\n 2 -1\n 3 6\n 4 3\n dtype: int64\n\n >>> df.clip(t, t + 4, axis=0)\n col_0 col_1\n 0 6 2\n 1 -3 -4\n 2 0 3\n 3 6 8\n 4 5 3\n \"\"\"\n inplace = validate_bool_kwarg(inplace, \"inplace\")\n\n axis = nv.validate_clip_with_axis(axis, args, kwargs)\n if axis is not None:\n axis = self._get_axis_number(axis)\n\n # GH 17276\n # numpy doesn't like NaN as a clip value\n # so ignore\n # GH 19992\n # numpy doesn't drop a list-like bound containing NaN\n if not is_list_like(lower) and np.any(isna(lower)):\n lower = None\n if not is_list_like(upper) and np.any(isna(upper)):\n upper = None\n\n # GH 2747 (arguments were reversed)\n if lower is not None and upper is not None:\n if is_scalar(lower) and is_scalar(upper):\n lower, upper = min(lower, upper), max(lower, upper)\n\n # fast-path for scalars\n if (lower is None or (is_scalar(lower) and is_number(lower))) and (\n upper is None or (is_scalar(upper) and is_number(upper))\n ):\n return self._clip_with_scalar(lower, upper, inplace=inplace)\n\n result = self\n if lower is not None:\n result = result._clip_with_one_bound(\n lower, method=self.ge, axis=axis, inplace=inplace\n )\n if upper is not None:\n if inplace:\n result = self\n result = result._clip_with_one_bound(\n upper, method=self.le, axis=axis, inplace=inplace\n )\n\n return result\n\n _shared_docs[\n \"groupby\"\n ] = \"\"\"\n Group %(klass)s using a mapper or by a Series of columns.\n\n A groupby operation involves some combination of splitting the\n object, applying a function, and combining the results. This can be\n used to group large amounts of data and compute operations on these\n groups.\n\n Parameters\n ----------\n by : mapping, function, label, or list of labels\n Used to determine the groups for the groupby.\n If ``by`` is a function, it's called on each value of the object's\n index. If a dict or Series is passed, the Series or dict VALUES\n will be used to determine the groups (the Series' values are first\n aligned; see ``.align()`` method). If an ndarray is passed, the\n values are used as-is determine the groups. A label or list of\n labels may be passed to group by the columns in ``self``. Notice\n that a tuple is interpreted as a (single) key.\n axis : {0 or 'index', 1 or 'columns'}, default 0\n Split along rows (0) or columns (1).\n level : int, level name, or sequence of such, default None\n If the axis is a MultiIndex (hierarchical), group by a particular\n level or levels.\n as_index : bool, default True\n For aggregated output, return object with group labels as the\n index. Only relevant for DataFrame input. as_index=False is\n effectively \"SQL-style\" grouped output.\n sort : bool, default True\n Sort group keys. Get better performance by turning this off.\n Note this does not influence the order of observations within each\n group. Groupby preserves the order of rows within each group.\n group_keys : bool, default True\n When calling apply, add group keys to index to identify pieces.\n squeeze : bool, default False\n Reduce the dimensionality of the return type if possible,\n otherwise return a consistent type.\n observed : bool, default False\n This only applies if any of the groupers are Categoricals.\n If True: only show observed values for categorical groupers.\n If False: show all values for categorical groupers.\n\n .. versionadded:: 0.23.0\n\n Returns\n -------\n %(klass)sGroupBy\n Returns a groupby object that contains information about the groups.\n\n See Also\n --------\n resample : Convenience method for frequency conversion and resampling\n of time series.\n\n Notes\n -----\n See the `user guide\n <https://pandas.pydata.org/pandas-docs/stable/groupby.html>`_ for more.\n \"\"\"\n\n def asfreq(\n self: FrameOrSeries,\n freq,\n method=None,\n how: Optional[str] = None,\n normalize: bool_t = False,\n fill_value=None,\n ) -> FrameOrSeries:\n \"\"\"\n Convert TimeSeries to specified frequency.\n\n Optionally provide filling method to pad/backfill missing values.\n\n Returns the original data conformed to a new index with the specified\n frequency. ``resample`` is more appropriate if an operation, such as\n summarization, is necessary to represent the data at the new frequency.\n\n Parameters\n ----------\n freq : DateOffset or str\n method : {'backfill'/'bfill', 'pad'/'ffill'}, default None\n Method to use for filling holes in reindexed Series (note this\n does not fill NaNs that already were present):\n\n * 'pad' / 'ffill': propagate last valid observation forward to next\n valid\n * 'backfill' / 'bfill': use NEXT valid observation to fill.\n how : {'start', 'end'}, default end\n For PeriodIndex only (see PeriodIndex.asfreq).\n normalize : bool, default False\n Whether to reset output index to midnight.\n fill_value : scalar, optional\n Value to use for missing values, applied during upsampling (note\n this does not fill NaNs that already were present).\n\n Returns\n -------\n converted : same type as caller\n\n See Also\n --------\n reindex\n\n Notes\n -----\n To learn more about the frequency strings, please see `this link\n <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`__.\n\n Examples\n --------\n Start by creating a series with 4 one minute timestamps.\n\n >>> index = pd.date_range('1/1/2000', periods=4, freq='T')\n >>> series = pd.Series([0.0, None, 2.0, 3.0], index=index)\n >>> df = pd.DataFrame({'s':series})\n >>> df\n s\n 2000-01-01 00:00:00 0.0\n 2000-01-01 00:01:00 NaN\n 2000-01-01 00:02:00 2.0\n 2000-01-01 00:03:00 3.0\n\n Upsample the series into 30 second bins.\n\n >>> df.asfreq(freq='30S')\n s\n 2000-01-01 00:00:00 0.0\n 2000-01-01 00:00:30 NaN\n 2000-01-01 00:01:00 NaN\n 2000-01-01 00:01:30 NaN\n 2000-01-01 00:02:00 2.0\n 2000-01-01 00:02:30 NaN\n 2000-01-01 00:03:00 3.0\n\n Upsample again, providing a ``fill value``.\n\n >>> df.asfreq(freq='30S', fill_value=9.0)\n s\n 2000-01-01 00:00:00 0.0\n 2000-01-01 00:00:30 9.0\n 2000-01-01 00:01:00 NaN\n 2000-01-01 00:01:30 9.0\n 2000-01-01 00:02:00 2.0\n 2000-01-01 00:02:30 9.0\n 2000-01-01 00:03:00 3.0\n\n Upsample again, providing a ``method``.\n\n >>> df.asfreq(freq='30S', method='bfill')\n s\n 2000-01-01 00:00:00 0.0\n 2000-01-01 00:00:30 NaN\n 2000-01-01 00:01:00 NaN\n 2000-01-01 00:01:30 2.0\n 2000-01-01 00:02:00 2.0\n 2000-01-01 00:02:30 3.0\n 2000-01-01 00:03:00 3.0\n \"\"\"\n from pandas.core.resample import asfreq\n\n return asfreq(\n self,\n freq,\n method=method,\n how=how,\n normalize=normalize,\n fill_value=fill_value,\n )\n\n def at_time(\n self: FrameOrSeries, time, asof: bool_t = False, axis=None\n ) -> FrameOrSeries:\n \"\"\"\n Select values at particular time of day (e.g., 9:30AM).\n\n Parameters\n ----------\n time : datetime.time or str\n axis : {0 or 'index', 1 or 'columns'}, default 0\n\n .. versionadded:: 0.24.0\n\n Returns\n -------\n Series or DataFrame\n\n Raises\n ------\n TypeError\n If the index is not a :class:`DatetimeIndex`\n\n See Also\n --------\n between_time : Select values between particular times of the day.\n first : Select initial periods of time series based on a date offset.\n last : Select final periods of time series based on a date offset.\n DatetimeIndex.indexer_at_time : Get just the index locations for\n values at particular time of the day.\n\n Examples\n --------\n >>> i = pd.date_range('2018-04-09', periods=4, freq='12H')\n >>> ts = pd.DataFrame({'A': [1, 2, 3, 4]}, index=i)\n >>> ts\n A\n 2018-04-09 00:00:00 1\n 2018-04-09 12:00:00 2\n 2018-04-10 00:00:00 3\n 2018-04-10 12:00:00 4\n\n >>> ts.at_time('12:00')\n A\n 2018-04-09 12:00:00 2\n 2018-04-10 12:00:00 4\n \"\"\"\n if axis is None:\n axis = self._stat_axis_number\n axis = self._get_axis_number(axis)\n\n index = self._get_axis(axis)\n try:\n indexer = index.indexer_at_time(time, asof=asof)\n except AttributeError as err:\n raise TypeError(\"Index must be DatetimeIndex\") from err\n\n return self._take_with_is_copy(indexer, axis=axis)\n\n def between_time(\n self: FrameOrSeries,\n start_time,\n end_time,\n include_start: bool_t = True,\n include_end: bool_t = True,\n axis=None,\n ) -> FrameOrSeries:\n \"\"\"\n Select values between particular times of the day (e.g., 9:00-9:30 AM).\n\n By setting ``start_time`` to be later than ``end_time``,\n you can get the times that are *not* between the two times.\n\n Parameters\n ----------\n start_time : datetime.time or str\n Initial time as a time filter limit.\n end_time : datetime.time or str\n End time as a time filter limit.\n include_start : bool, default True\n Whether the start time needs to be included in the result.\n include_end : bool, default True\n Whether the end time needs to be included in the result.\n axis : {0 or 'index', 1 or 'columns'}, default 0\n Determine range time on index or columns value.\n\n .. versionadded:: 0.24.0\n\n Returns\n -------\n Series or DataFrame\n Data from the original object filtered to the specified dates range.\n\n Raises\n ------\n TypeError\n If the index is not a :class:`DatetimeIndex`\n\n See Also\n --------\n at_time : Select values at a particular time of the day.\n first : Select initial periods of time series based on a date offset.\n last : Select final periods of time series based on a date offset.\n DatetimeIndex.indexer_between_time : Get just the index locations for\n values between particular times of the day.\n\n Examples\n --------\n >>> i = pd.date_range('2018-04-09', periods=4, freq='1D20min')\n >>> ts = pd.DataFrame({'A': [1, 2, 3, 4]}, index=i)\n >>> ts\n A\n 2018-04-09 00:00:00 1\n 2018-04-10 00:20:00 2\n 2018-04-11 00:40:00 3\n 2018-04-12 01:00:00 4\n\n >>> ts.between_time('0:15', '0:45')\n A\n 2018-04-10 00:20:00 2\n 2018-04-11 00:40:00 3\n\n You get the times that are *not* between two times by setting\n ``start_time`` later than ``end_time``:\n\n >>> ts.between_time('0:45', '0:15')\n A\n 2018-04-09 00:00:00 1\n 2018-04-12 01:00:00 4\n \"\"\"\n if axis is None:\n axis = self._stat_axis_number\n axis = self._get_axis_number(axis)\n\n index = self._get_axis(axis)\n try:\n indexer = index.indexer_between_time(\n start_time,\n end_time,\n include_start=include_start,\n include_end=include_end,\n )\n except AttributeError as err:\n raise TypeError(\"Index must be DatetimeIndex\") from err\n\n return self._take_with_is_copy(indexer, axis=axis)\n\n def resample(\n self,\n rule,\n axis=0,\n closed: Optional[str] = None,\n label: Optional[str] = None,\n convention: str = \"start\",\n kind: Optional[str] = None,\n loffset=None,\n base: int = 0,\n on=None,\n level=None,\n ) -> \"Resampler\":\n \"\"\"\n Resample time-series data.\n\n Convenience method for frequency conversion and resampling of time\n series. Object must have a datetime-like index (`DatetimeIndex`,\n `PeriodIndex`, or `TimedeltaIndex`), or pass datetime-like values\n to the `on` or `level` keyword.\n\n Parameters\n ----------\n rule : DateOffset, Timedelta or str\n The offset string or object representing target conversion.\n axis : {0 or 'index', 1 or 'columns'}, default 0\n Which axis to use for up- or down-sampling. For `Series` this\n will default to 0, i.e. along the rows. Must be\n `DatetimeIndex`, `TimedeltaIndex` or `PeriodIndex`.\n closed : {'right', 'left'}, default None\n Which side of bin interval is closed. The default is 'left'\n for all frequency offsets except for 'M', 'A', 'Q', 'BM',\n 'BA', 'BQ', and 'W' which all have a default of 'right'.\n label : {'right', 'left'}, default None\n Which bin edge label to label bucket with. The default is 'left'\n for all frequency offsets except for 'M', 'A', 'Q', 'BM',\n 'BA', 'BQ', and 'W' which all have a default of 'right'.\n convention : {'start', 'end', 's', 'e'}, default 'start'\n For `PeriodIndex` only, controls whether to use the start or\n end of `rule`.\n kind : {'timestamp', 'period'}, optional, default None\n Pass 'timestamp' to convert the resulting index to a\n `DateTimeIndex` or 'period' to convert it to a `PeriodIndex`.\n By default the input representation is retained.\n loffset : timedelta, default None\n Adjust the resampled time labels.\n base : int, default 0\n For frequencies that evenly subdivide 1 day, the \"origin\" of the\n aggregated intervals. For example, for '5min' frequency, base could\n range from 0 through 4. Defaults to 0.\n on : str, optional\n For a DataFrame, column to use instead of index for resampling.\n Column must be datetime-like.\n\n level : str or int, optional\n For a MultiIndex, level (name or number) to use for\n resampling. `level` must be datetime-like.\n\n Returns\n -------\n Resampler object\n\n See Also\n --------\n groupby : Group by mapping, function, label, or list of labels.\n Series.resample : Resample a Series.\n DataFrame.resample: Resample a DataFrame.\n\n Notes\n -----\n See the `user guide\n <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#resampling>`_\n for more.\n\n To learn more about the offset strings, please see `this link\n <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#dateoffset-objects>`__.\n\n Examples\n --------\n Start by creating a series with 9 one minute timestamps.\n\n >>> index = pd.date_range('1/1/2000', periods=9, freq='T')\n >>> series = pd.Series(range(9), index=index)\n >>> series\n 2000-01-01 00:00:00 0\n 2000-01-01 00:01:00 1\n 2000-01-01 00:02:00 2\n 2000-01-01 00:03:00 3\n 2000-01-01 00:04:00 4\n 2000-01-01 00:05:00 5\n 2000-01-01 00:06:00 6\n 2000-01-01 00:07:00 7\n 2000-01-01 00:08:00 8\n Freq: T, dtype: int64\n\n Downsample the series into 3 minute bins and sum the values\n of the timestamps falling into a bin.\n\n >>> series.resample('3T').sum()\n 2000-01-01 00:00:00 3\n 2000-01-01 00:03:00 12\n 2000-01-01 00:06:00 21\n Freq: 3T, dtype: int64\n\n Downsample the series into 3 minute bins as above, but label each\n bin using the right edge instead of the left. Please note that the\n value in the bucket used as the label is not included in the bucket,\n which it labels. For example, in the original series the\n bucket ``2000-01-01 00:03:00`` contains the value 3, but the summed\n value in the resampled bucket with the label ``2000-01-01 00:03:00``\n does not include 3 (if it did, the summed value would be 6, not 3).\n To include this value close the right side of the bin interval as\n illustrated in the example below this one.\n\n >>> series.resample('3T', label='right').sum()\n 2000-01-01 00:03:00 3\n 2000-01-01 00:06:00 12\n 2000-01-01 00:09:00 21\n Freq: 3T, dtype: int64\n\n Downsample the series into 3 minute bins as above, but close the right\n side of the bin interval.\n\n >>> series.resample('3T', label='right', closed='right').sum()\n 2000-01-01 00:00:00 0\n 2000-01-01 00:03:00 6\n 2000-01-01 00:06:00 15\n 2000-01-01 00:09:00 15\n Freq: 3T, dtype: int64\n\n Upsample the series into 30 second bins.\n\n >>> series.resample('30S').asfreq()[0:5] # Select first 5 rows\n 2000-01-01 00:00:00 0.0\n 2000-01-01 00:00:30 NaN\n 2000-01-01 00:01:00 1.0\n 2000-01-01 00:01:30 NaN\n 2000-01-01 00:02:00 2.0\n Freq: 30S, dtype: float64\n\n Upsample the series into 30 second bins and fill the ``NaN``\n values using the ``pad`` method.\n\n >>> series.resample('30S').pad()[0:5]\n 2000-01-01 00:00:00 0\n 2000-01-01 00:00:30 0\n 2000-01-01 00:01:00 1\n 2000-01-01 00:01:30 1\n 2000-01-01 00:02:00 2\n Freq: 30S, dtype: int64\n\n Upsample the series into 30 second bins and fill the\n ``NaN`` values using the ``bfill`` method.\n\n >>> series.resample('30S').bfill()[0:5]\n 2000-01-01 00:00:00 0\n 2000-01-01 00:00:30 1\n 2000-01-01 00:01:00 1\n 2000-01-01 00:01:30 2\n 2000-01-01 00:02:00 2\n Freq: 30S, dtype: int64\n\n Pass a custom function via ``apply``\n\n >>> def custom_resampler(array_like):\n ... return np.sum(array_like) + 5\n ...\n >>> series.resample('3T').apply(custom_resampler)\n 2000-01-01 00:00:00 8\n 2000-01-01 00:03:00 17\n 2000-01-01 00:06:00 26\n Freq: 3T, dtype: int64\n\n For a Series with a PeriodIndex, the keyword `convention` can be\n used to control whether to use the start or end of `rule`.\n\n Resample a year by quarter using 'start' `convention`. Values are\n assigned to the first quarter of the period.\n\n >>> s = pd.Series([1, 2], index=pd.period_range('2012-01-01',\n ... freq='A',\n ... periods=2))\n >>> s\n 2012 1\n 2013 2\n Freq: A-DEC, dtype: int64\n >>> s.resample('Q', convention='start').asfreq()\n 2012Q1 1.0\n 2012Q2 NaN\n 2012Q3 NaN\n 2012Q4 NaN\n 2013Q1 2.0\n 2013Q2 NaN\n 2013Q3 NaN\n 2013Q4 NaN\n Freq: Q-DEC, dtype: float64\n\n Resample quarters by month using 'end' `convention`. Values are\n assigned to the last month of the period.\n\n >>> q = pd.Series([1, 2, 3, 4], index=pd.period_range('2018-01-01',\n ... freq='Q',\n ... periods=4))\n >>> q\n 2018Q1 1\n 2018Q2 2\n 2018Q3 3\n 2018Q4 4\n Freq: Q-DEC, dtype: int64\n >>> q.resample('M', convention='end').asfreq()\n 2018-03 1.0\n 2018-04 NaN\n 2018-05 NaN\n 2018-06 2.0\n 2018-07 NaN\n 2018-08 NaN\n 2018-09 3.0\n 2018-10 NaN\n 2018-11 NaN\n 2018-12 4.0\n Freq: M, dtype: float64\n\n For DataFrame objects, the keyword `on` can be used to specify the\n column instead of the index for resampling.\n\n >>> d = dict({'price': [10, 11, 9, 13, 14, 18, 17, 19],\n ... 'volume': [50, 60, 40, 100, 50, 100, 40, 50]})\n >>> df = pd.DataFrame(d)\n >>> df['week_starting'] = pd.date_range('01/01/2018',\n ... periods=8,\n ... freq='W')\n >>> df\n price volume week_starting\n 0 10 50 2018-01-07\n 1 11 60 2018-01-14\n 2 9 40 2018-01-21\n 3 13 100 2018-01-28\n 4 14 50 2018-02-04\n 5 18 100 2018-02-11\n 6 17 40 2018-02-18\n 7 19 50 2018-02-25\n >>> df.resample('M', on='week_starting').mean()\n price volume\n week_starting\n 2018-01-31 10.75 62.5\n 2018-02-28 17.00 60.0\n\n For a DataFrame with MultiIndex, the keyword `level` can be used to\n specify on which level the resampling needs to take place.\n\n >>> days = pd.date_range('1/1/2000', periods=4, freq='D')\n >>> d2 = dict({'price': [10, 11, 9, 13, 14, 18, 17, 19],\n ... 'volume': [50, 60, 40, 100, 50, 100, 40, 50]})\n >>> df2 = pd.DataFrame(d2,\n ... index=pd.MultiIndex.from_product([days,\n ... ['morning',\n ... 'afternoon']]\n ... ))\n >>> df2\n price volume\n 2000-01-01 morning 10 50\n afternoon 11 60\n 2000-01-02 morning 9 40\n afternoon 13 100\n 2000-01-03 morning 14 50\n afternoon 18 100\n 2000-01-04 morning 17 40\n afternoon 19 50\n >>> df2.resample('D', level=0).sum()\n price volume\n 2000-01-01 21 110\n 2000-01-02 22 140\n 2000-01-03 32 150\n 2000-01-04 36 90\n \"\"\"\n from pandas.core.resample import get_resampler\n\n axis = self._get_axis_number(axis)\n return get_resampler(\n self,\n freq=rule,\n label=label,\n closed=closed,\n axis=axis,\n kind=kind,\n loffset=loffset,\n convention=convention,\n base=base,\n key=on,\n level=level,\n )\n\n def first(self: FrameOrSeries, offset) -> FrameOrSeries:\n \"\"\"\n Method to subset initial periods of time series data based on a date offset.\n\n Parameters\n ----------\n offset : str, DateOffset, dateutil.relativedelta\n\n Returns\n -------\n subset : same type as caller\n\n Raises\n ------\n TypeError\n If the index is not a :class:`DatetimeIndex`\n\n See Also\n --------\n last : Select final periods of time series based on a date offset.\n at_time : Select values at a particular time of the day.\n between_time : Select values between particular times of the day.\n\n Examples\n --------\n >>> i = pd.date_range('2018-04-09', periods=4, freq='2D')\n >>> ts = pd.DataFrame({'A': [1,2,3,4]}, index=i)\n >>> ts\n A\n 2018-04-09 1\n 2018-04-11 2\n 2018-04-13 3\n 2018-04-15 4\n\n Get the rows for the first 3 days:\n\n >>> ts.first('3D')\n A\n 2018-04-09 1\n 2018-04-11 2\n\n Notice the data for 3 first calender days were returned, not the first\n 3 days observed in the dataset, and therefore data for 2018-04-13 was\n not returned.\n \"\"\"\n if not isinstance(self.index, DatetimeIndex):\n raise TypeError(\"'first' only supports a DatetimeIndex index\")\n\n if len(self.index) == 0:\n return self\n\n offset = to_offset(offset)\n end_date = end = self.index[0] + offset\n\n # Tick-like, e.g. 3 weeks\n if not offset.is_anchored() and hasattr(offset, \"_inc\"):\n if end_date in self.index:\n end = self.index.searchsorted(end_date, side=\"left\")\n return self.iloc[:end]\n\n return self.loc[:end]\n\n def last(self: FrameOrSeries, offset) -> FrameOrSeries:\n \"\"\"\n Method to subset final periods of time series data based on a date offset.\n\n Parameters\n ----------\n offset : str, DateOffset, dateutil.relativedelta\n\n Returns\n -------\n subset : same type as caller\n\n Raises\n ------\n TypeError\n If the index is not a :class:`DatetimeIndex`\n\n See Also\n --------\n first : Select initial periods of time series based on a date offset.\n at_time : Select values at a particular time of the day.\n between_time : Select values between particular times of the day.\n\n Examples\n --------\n >>> i = pd.date_range('2018-04-09', periods=4, freq='2D')\n >>> ts = pd.DataFrame({'A': [1, 2, 3, 4]}, index=i)\n >>> ts\n A\n 2018-04-09 1\n 2018-04-11 2\n 2018-04-13 3\n 2018-04-15 4\n\n Get the rows for the last 3 days:\n\n >>> ts.last('3D')\n A\n 2018-04-13 3\n 2018-04-15 4\n\n Notice the data for 3 last calender days were returned, not the last\n 3 observed days in the dataset, and therefore data for 2018-04-11 was\n not returned.\n \"\"\"\n if not isinstance(self.index, DatetimeIndex):\n raise TypeError(\"'last' only supports a DatetimeIndex index\")\n\n if len(self.index) == 0:\n return self\n\n offset = to_offset(offset)\n\n start_date = self.index[-1] - offset\n start = self.index.searchsorted(start_date, side=\"right\")\n return self.iloc[start:]\n\n def rank(\n self: FrameOrSeries,\n axis=0,\n method: str = \"average\",\n numeric_only: Optional[bool_t] = None,\n na_option: str = \"keep\",\n ascending: bool_t = True,\n pct: bool_t = False,\n ) -> FrameOrSeries:\n \"\"\"\n Compute numerical data ranks (1 through n) along axis.\n\n By default, equal values are assigned a rank that is the average of the\n ranks of those values.\n\n Parameters\n ----------\n axis : {0 or 'index', 1 or 'columns'}, default 0\n Index to direct ranking.\n method : {'average', 'min', 'max', 'first', 'dense'}, default 'average'\n How to rank the group of records that have the same value (i.e. ties):\n\n * average: average rank of the group\n * min: lowest rank in the group\n * max: highest rank in the group\n * first: ranks assigned in order they appear in the array\n * dense: like 'min', but rank always increases by 1 between groups.\n\n numeric_only : bool, optional\n For DataFrame objects, rank only numeric columns if set to True.\n na_option : {'keep', 'top', 'bottom'}, default 'keep'\n How to rank NaN values:\n\n * keep: assign NaN rank to NaN values\n * top: assign smallest rank to NaN values if ascending\n * bottom: assign highest rank to NaN values if ascending.\n\n ascending : bool, default True\n Whether or not the elements should be ranked in ascending order.\n pct : bool, default False\n Whether or not to display the returned rankings in percentile\n form.\n\n Returns\n -------\n same type as caller\n Return a Series or DataFrame with data ranks as values.\n\n See Also\n --------\n core.groupby.GroupBy.rank : Rank of values within each group.\n\n Examples\n --------\n >>> df = pd.DataFrame(data={'Animal': ['cat', 'penguin', 'dog',\n ... 'spider', 'snake'],\n ... 'Number_legs': [4, 2, 4, 8, np.nan]})\n >>> df\n Animal Number_legs\n 0 cat 4.0\n 1 penguin 2.0\n 2 dog 4.0\n 3 spider 8.0\n 4 snake NaN\n\n The following example shows how the method behaves with the above\n parameters:\n\n * default_rank: this is the default behaviour obtained without using\n any parameter.\n * max_rank: setting ``method = 'max'`` the records that have the\n same values are ranked using the highest rank (e.g.: since 'cat'\n and 'dog' are both in the 2nd and 3rd position, rank 3 is assigned.)\n * NA_bottom: choosing ``na_option = 'bottom'``, if there are records\n with NaN values they are placed at the bottom of the ranking.\n * pct_rank: when setting ``pct = True``, the ranking is expressed as\n percentile rank.\n\n >>> df['default_rank'] = df['Number_legs'].rank()\n >>> df['max_rank'] = df['Number_legs'].rank(method='max')\n >>> df['NA_bottom'] = df['Number_legs'].rank(na_option='bottom')\n >>> df['pct_rank'] = df['Number_legs'].rank(pct=True)\n >>> df\n Animal Number_legs default_rank max_rank NA_bottom pct_rank\n 0 cat 4.0 2.5 3.0 2.5 0.625\n 1 penguin 2.0 1.0 1.0 1.0 0.250\n 2 dog 4.0 2.5 3.0 2.5 0.625\n 3 spider 8.0 4.0 4.0 4.0 1.000\n 4 snake NaN NaN NaN 5.0 NaN\n \"\"\"\n axis = self._get_axis_number(axis)\n\n if na_option not in {\"keep\", \"top\", \"bottom\"}:\n msg = \"na_option must be one of 'keep', 'top', or 'bottom'\"\n raise ValueError(msg)\n\n def ranker(data):\n ranks = algos.rank(\n data.values,\n axis=axis,\n method=method,\n ascending=ascending,\n na_option=na_option,\n pct=pct,\n )\n ranks = self._constructor(ranks, **data._construct_axes_dict())\n return ranks.__finalize__(self)\n\n # if numeric_only is None, and we can't get anything, we try with\n # numeric_only=True\n if numeric_only is None:\n try:\n return ranker(self)\n except TypeError:\n numeric_only = True\n\n if numeric_only:\n data = self._get_numeric_data()\n else:\n data = self\n\n return ranker(data)\n\n _shared_docs[\n \"align\"\n ] = \"\"\"\n Align two objects on their axes with the specified join method.\n\n Join method is specified for each axis Index.\n\n Parameters\n ----------\n other : DataFrame or Series\n join : {'outer', 'inner', 'left', 'right'}, default 'outer'\n axis : allowed axis of the other object, default None\n Align on index (0), columns (1), or both (None).\n level : int or level name, default None\n Broadcast across a level, matching Index values on the\n passed MultiIndex level.\n copy : bool, default True\n Always returns new objects. If copy=False and no reindexing is\n required then original objects are returned.\n fill_value : scalar, default np.NaN\n Value to use for missing values. Defaults to NaN, but can be any\n \"compatible\" value.\n method : {'backfill', 'bfill', 'pad', 'ffill', None}, default None\n Method to use for filling holes in reindexed Series:\n\n - pad / ffill: propagate last valid observation forward to next valid.\n - backfill / bfill: use NEXT valid observation to fill gap.\n\n limit : int, default None\n If method is specified, this is the maximum number of consecutive\n NaN values to forward/backward fill. In other words, if there is\n a gap with more than this number of consecutive NaNs, it will only\n be partially filled. If method is not specified, this is the\n maximum number of entries along the entire axis where NaNs will be\n filled. Must be greater than 0 if not None.\n fill_axis : %(axes_single_arg)s, default 0\n Filling axis, method and limit.\n broadcast_axis : %(axes_single_arg)s, default None\n Broadcast values along this axis, if aligning two objects of\n different dimensions.\n\n Returns\n -------\n (left, right) : (%(klass)s, type of other)\n Aligned objects.\n \"\"\"\n\n @Appender(_shared_docs[\"align\"] % _shared_doc_kwargs)\n def align(\n self,\n other,\n join=\"outer\",\n axis=None,\n level=None,\n copy=True,\n fill_value=None,\n method=None,\n limit=None,\n fill_axis=0,\n broadcast_axis=None,\n ):\n method = missing.clean_fill_method(method)\n\n if broadcast_axis == 1 and self.ndim != other.ndim:\n if isinstance(self, ABCSeries):\n # this means other is a DataFrame, and we need to broadcast\n # self\n cons = self._constructor_expanddim\n df = cons(\n {c: self for c in other.columns}, **other._construct_axes_dict()\n )\n return df._align_frame(\n other,\n join=join,\n axis=axis,\n level=level,\n copy=copy,\n fill_value=fill_value,\n method=method,\n limit=limit,\n fill_axis=fill_axis,\n )\n elif isinstance(other, ABCSeries):\n # this means self is a DataFrame, and we need to broadcast\n # other\n cons = other._constructor_expanddim\n df = cons(\n {c: other for c in self.columns}, **self._construct_axes_dict()\n )\n return self._align_frame(\n df,\n join=join,\n axis=axis,\n level=level,\n copy=copy,\n fill_value=fill_value,\n method=method,\n limit=limit,\n fill_axis=fill_axis,\n )\n\n if axis is not None:\n axis = self._get_axis_number(axis)\n if isinstance(other, ABCDataFrame):\n return self._align_frame(\n other,\n join=join,\n axis=axis,\n level=level,\n copy=copy,\n fill_value=fill_value,\n method=method,\n limit=limit,\n fill_axis=fill_axis,\n )\n elif isinstance(other, ABCSeries):\n return self._align_series(\n other,\n join=join,\n axis=axis,\n level=level,\n copy=copy,\n fill_value=fill_value,\n method=method,\n limit=limit,\n fill_axis=fill_axis,\n )\n else: # pragma: no cover\n raise TypeError(f\"unsupported type: {type(other)}\")\n\n def _align_frame(\n self,\n other,\n join=\"outer\",\n axis=None,\n level=None,\n copy: bool_t = True,\n fill_value=None,\n method=None,\n limit=None,\n fill_axis=0,\n ):\n # defaults\n join_index, join_columns = None, None\n ilidx, iridx = None, None\n clidx, cridx = None, None\n\n is_series = isinstance(self, ABCSeries)\n\n if axis is None or axis == 0:\n if not self.index.equals(other.index):\n join_index, ilidx, iridx = self.index.join(\n other.index, how=join, level=level, return_indexers=True\n )\n\n if axis is None or axis == 1:\n if not is_series and not self.columns.equals(other.columns):\n join_columns, clidx, cridx = self.columns.join(\n other.columns, how=join, level=level, return_indexers=True\n )\n\n if is_series:\n reindexers = {0: [join_index, ilidx]}\n else:\n reindexers = {0: [join_index, ilidx], 1: [join_columns, clidx]}\n\n left = self._reindex_with_indexers(\n reindexers, copy=copy, fill_value=fill_value, allow_dups=True\n )\n # other must be always DataFrame\n right = other._reindex_with_indexers(\n {0: [join_index, iridx], 1: [join_columns, cridx]},\n copy=copy,\n fill_value=fill_value,\n allow_dups=True,\n )\n\n if method is not None:\n left = self._ensure_type(\n left.fillna(method=method, axis=fill_axis, limit=limit)\n )\n right = right.fillna(method=method, axis=fill_axis, limit=limit)\n\n # if DatetimeIndex have different tz, convert to UTC\n if is_datetime64tz_dtype(left.index):\n if left.index.tz != right.index.tz:\n if join_index is not None:\n left.index = join_index\n right.index = join_index\n\n return left.__finalize__(self), right.__finalize__(other)\n\n def _align_series(\n self,\n other,\n join=\"outer\",\n axis=None,\n level=None,\n copy: bool_t = True,\n fill_value=None,\n method=None,\n limit=None,\n fill_axis=0,\n ):\n\n is_series = isinstance(self, ABCSeries)\n\n # series/series compat, other must always be a Series\n if is_series:\n if axis:\n raise ValueError(\"cannot align series to a series other than axis 0\")\n\n # equal\n if self.index.equals(other.index):\n join_index, lidx, ridx = None, None, None\n else:\n join_index, lidx, ridx = self.index.join(\n other.index, how=join, level=level, return_indexers=True\n )\n\n left = self._reindex_indexer(join_index, lidx, copy)\n right = other._reindex_indexer(join_index, ridx, copy)\n\n else:\n # one has > 1 ndim\n fdata = self._data\n if axis == 0:\n join_index = self.index\n lidx, ridx = None, None\n if not self.index.equals(other.index):\n join_index, lidx, ridx = self.index.join(\n other.index, how=join, level=level, return_indexers=True\n )\n\n if lidx is not None:\n fdata = fdata.reindex_indexer(join_index, lidx, axis=1)\n\n elif axis == 1:\n join_index = self.columns\n lidx, ridx = None, None\n if not self.columns.equals(other.index):\n join_index, lidx, ridx = self.columns.join(\n other.index, how=join, level=level, return_indexers=True\n )\n\n if lidx is not None:\n fdata = fdata.reindex_indexer(join_index, lidx, axis=0)\n else:\n raise ValueError(\"Must specify axis=0 or 1\")\n\n if copy and fdata is self._data:\n fdata = fdata.copy()\n\n left = self._constructor(fdata)\n\n if ridx is None:\n right = other\n else:\n right = other.reindex(join_index, level=level)\n\n # fill\n fill_na = notna(fill_value) or (method is not None)\n if fill_na:\n left = left.fillna(fill_value, method=method, limit=limit, axis=fill_axis)\n right = right.fillna(fill_value, method=method, limit=limit)\n\n # if DatetimeIndex have different tz, convert to UTC\n if is_series or (not is_series and axis == 0):\n if is_datetime64tz_dtype(left.index):\n if left.index.tz != right.index.tz:\n if join_index is not None:\n left.index = join_index\n right.index = join_index\n\n return left.__finalize__(self), right.__finalize__(other)\n\n def _where(\n self,\n cond,\n other=np.nan,\n inplace=False,\n axis=None,\n level=None,\n errors=\"raise\",\n try_cast=False,\n ):\n \"\"\"\n Equivalent to public method `where`, except that `other` is not\n applied as a function even if callable. Used in __setitem__.\n \"\"\"\n inplace = validate_bool_kwarg(inplace, \"inplace\")\n\n # align the cond to same shape as myself\n cond = com.apply_if_callable(cond, self)\n if isinstance(cond, NDFrame):\n cond, _ = cond.align(self, join=\"right\", broadcast_axis=1)\n else:\n if not hasattr(cond, \"shape\"):\n cond = np.asanyarray(cond)\n if cond.shape != self.shape:\n raise ValueError(\"Array conditional must be same shape as self\")\n cond = self._constructor(cond, **self._construct_axes_dict())\n\n # make sure we are boolean\n fill_value = bool(inplace)\n cond = cond.fillna(fill_value)\n\n msg = \"Boolean array expected for the condition, not {dtype}\"\n\n if not isinstance(cond, ABCDataFrame):\n # This is a single-dimensional object.\n if not is_bool_dtype(cond):\n raise ValueError(msg.format(dtype=cond.dtype))\n elif not cond.empty:\n for dt in cond.dtypes:\n if not is_bool_dtype(dt):\n raise ValueError(msg.format(dtype=dt))\n\n cond = -cond if inplace else cond\n\n # try to align with other\n try_quick = True\n if hasattr(other, \"align\"):\n\n # align with me\n if other.ndim <= self.ndim:\n\n _, other = self.align(\n other, join=\"left\", axis=axis, level=level, fill_value=np.nan\n )\n\n # if we are NOT aligned, raise as we cannot where index\n if axis is None and not all(\n other._get_axis(i).equals(ax) for i, ax in enumerate(self.axes)\n ):\n raise InvalidIndexError\n\n # slice me out of the other\n else:\n raise NotImplementedError(\n \"cannot align with a higher dimensional NDFrame\"\n )\n\n if isinstance(other, np.ndarray):\n\n if other.shape != self.shape:\n\n if self.ndim == 1:\n\n icond = cond.values\n\n # GH 2745 / GH 4192\n # treat like a scalar\n if len(other) == 1:\n other = np.array(other[0])\n\n # GH 3235\n # match True cond to other\n elif len(cond[icond]) == len(other):\n\n # try to not change dtype at first (if try_quick)\n if try_quick:\n new_other = np.asarray(self)\n new_other = new_other.copy()\n new_other[icond] = other\n other = new_other\n\n else:\n raise ValueError(\n \"Length of replacements must equal series length\"\n )\n\n else:\n raise ValueError(\n \"other must be the same shape as self when an ndarray\"\n )\n\n # we are the same shape, so create an actual object for alignment\n else:\n other = self._constructor(other, **self._construct_axes_dict())\n\n if axis is None:\n axis = 0\n\n if self.ndim == getattr(other, \"ndim\", 0):\n align = True\n else:\n align = self._get_axis_number(axis) == 1\n\n block_axis = self._get_block_manager_axis(axis)\n\n if inplace:\n # we may have different type blocks come out of putmask, so\n # reconstruct the block manager\n\n self._check_inplace_setting(other)\n new_data = self._data.putmask(\n mask=cond,\n new=other,\n align=align,\n inplace=True,\n axis=block_axis,\n transpose=self._AXIS_REVERSED,\n )\n self._update_inplace(new_data)\n\n else:\n new_data = self._data.where(\n other=other,\n cond=cond,\n align=align,\n errors=errors,\n try_cast=try_cast,\n axis=block_axis,\n )\n\n return self._constructor(new_data).__finalize__(self)\n\n _shared_docs[\n \"where\"\n ] = \"\"\"\n Replace values where the condition is %(cond_rev)s.\n\n Parameters\n ----------\n cond : bool %(klass)s, array-like, or callable\n Where `cond` is %(cond)s, keep the original value. Where\n %(cond_rev)s, replace with corresponding value from `other`.\n If `cond` is callable, it is computed on the %(klass)s and\n should return boolean %(klass)s or array. The callable must\n not change input %(klass)s (though pandas doesn't check it).\n other : scalar, %(klass)s, or callable\n Entries where `cond` is %(cond_rev)s are replaced with\n corresponding value from `other`.\n If other is callable, it is computed on the %(klass)s and\n should return scalar or %(klass)s. The callable must not\n change input %(klass)s (though pandas doesn't check it).\n inplace : bool, default False\n Whether to perform the operation in place on the data.\n axis : int, default None\n Alignment axis if needed.\n level : int, default None\n Alignment level if needed.\n errors : str, {'raise', 'ignore'}, default 'raise'\n Note that currently this parameter won't affect\n the results and will always coerce to a suitable dtype.\n\n - 'raise' : allow exceptions to be raised.\n - 'ignore' : suppress exceptions. On error return original object.\n\n try_cast : bool, default False\n Try to cast the result back to the input type (if possible).\n\n Returns\n -------\n Same type as caller\n\n See Also\n --------\n :func:`DataFrame.%(name_other)s` : Return an object of same shape as\n self.\n\n Notes\n -----\n The %(name)s method is an application of the if-then idiom. For each\n element in the calling DataFrame, if ``cond`` is ``%(cond)s`` the\n element is used; otherwise the corresponding element from the DataFrame\n ``other`` is used.\n\n The signature for :func:`DataFrame.where` differs from\n :func:`numpy.where`. Roughly ``df1.where(m, df2)`` is equivalent to\n ``np.where(m, df1, df2)``.\n\n For further details and examples see the ``%(name)s`` documentation in\n :ref:`indexing <indexing.where_mask>`.\n\n Examples\n --------\n >>> s = pd.Series(range(5))\n >>> s.where(s > 0)\n 0 NaN\n 1 1.0\n 2 2.0\n 3 3.0\n 4 4.0\n dtype: float64\n\n >>> s.mask(s > 0)\n 0 0.0\n 1 NaN\n 2 NaN\n 3 NaN\n 4 NaN\n dtype: float64\n\n >>> s.where(s > 1, 10)\n 0 10\n 1 10\n 2 2\n 3 3\n 4 4\n dtype: int64\n\n >>> df = pd.DataFrame(np.arange(10).reshape(-1, 2), columns=['A', 'B'])\n >>> df\n A B\n 0 0 1\n 1 2 3\n 2 4 5\n 3 6 7\n 4 8 9\n >>> m = df %% 3 == 0\n >>> df.where(m, -df)\n A B\n 0 0 -1\n 1 -2 3\n 2 -4 -5\n 3 6 -7\n 4 -8 9\n >>> df.where(m, -df) == np.where(m, df, -df)\n A B\n 0 True True\n 1 True True\n 2 True True\n 3 True True\n 4 True True\n >>> df.where(m, -df) == df.mask(~m, -df)\n A B\n 0 True True\n 1 True True\n 2 True True\n 3 True True\n 4 True True\n \"\"\"\n\n @Appender(\n _shared_docs[\"where\"]\n % dict(\n _shared_doc_kwargs,\n cond=\"True\",\n cond_rev=\"False\",\n name=\"where\",\n name_other=\"mask\",\n )\n )\n def where(\n self,\n cond,\n other=np.nan,\n inplace=False,\n axis=None,\n level=None,\n errors=\"raise\",\n try_cast=False,\n ):\n\n other = com.apply_if_callable(other, self)\n return self._where(\n cond, other, inplace, axis, level, errors=errors, try_cast=try_cast\n )\n\n @Appender(\n _shared_docs[\"where\"]\n % dict(\n _shared_doc_kwargs,\n cond=\"False\",\n cond_rev=\"True\",\n name=\"mask\",\n name_other=\"where\",\n )\n )\n def mask(\n self,\n cond,\n other=np.nan,\n inplace=False,\n axis=None,\n level=None,\n errors=\"raise\",\n try_cast=False,\n ):\n\n inplace = validate_bool_kwarg(inplace, \"inplace\")\n cond = com.apply_if_callable(cond, self)\n\n # see gh-21891\n if not hasattr(cond, \"__invert__\"):\n cond = np.array(cond)\n\n return self.where(\n ~cond,\n other=other,\n inplace=inplace,\n axis=axis,\n level=level,\n try_cast=try_cast,\n errors=errors,\n )\n\n _shared_docs[\n \"shift\"\n ] = \"\"\"\n Shift index by desired number of periods with an optional time `freq`.\n\n When `freq` is not passed, shift the index without realigning the data.\n If `freq` is passed (in this case, the index must be date or datetime,\n or it will raise a `NotImplementedError`), the index will be\n increased using the periods and the `freq`.\n\n Parameters\n ----------\n periods : int\n Number of periods to shift. Can be positive or negative.\n freq : DateOffset, tseries.offsets, timedelta, or str, optional\n Offset to use from the tseries module or time rule (e.g. 'EOM').\n If `freq` is specified then the index values are shifted but the\n data is not realigned. That is, use `freq` if you would like to\n extend the index when shifting and preserve the original data.\n axis : {0 or 'index', 1 or 'columns', None}, default None\n Shift direction.\n fill_value : object, optional\n The scalar value to use for newly introduced missing values.\n the default depends on the dtype of `self`.\n For numeric data, ``np.nan`` is used.\n For datetime, timedelta, or period data, etc. :attr:`NaT` is used.\n For extension dtypes, ``self.dtype.na_value`` is used.\n\n .. versionchanged:: 0.24.0\n\n Returns\n -------\n %(klass)s\n Copy of input object, shifted.\n\n See Also\n --------\n Index.shift : Shift values of Index.\n DatetimeIndex.shift : Shift values of DatetimeIndex.\n PeriodIndex.shift : Shift values of PeriodIndex.\n tshift : Shift the time index, using the index's frequency if\n available.\n\n Examples\n --------\n >>> df = pd.DataFrame({'Col1': [10, 20, 15, 30, 45],\n ... 'Col2': [13, 23, 18, 33, 48],\n ... 'Col3': [17, 27, 22, 37, 52]})\n\n >>> df.shift(periods=3)\n Col1 Col2 Col3\n 0 NaN NaN NaN\n 1 NaN NaN NaN\n 2 NaN NaN NaN\n 3 10.0 13.0 17.0\n 4 20.0 23.0 27.0\n\n >>> df.shift(periods=1, axis='columns')\n Col1 Col2 Col3\n 0 NaN 10.0 13.0\n 1 NaN 20.0 23.0\n 2 NaN 15.0 18.0\n 3 NaN 30.0 33.0\n 4 NaN 45.0 48.0\n\n >>> df.shift(periods=3, fill_value=0)\n Col1 Col2 Col3\n 0 0 0 0\n 1 0 0 0\n 2 0 0 0\n 3 10 13 17\n 4 20 23 27\n \"\"\"\n\n @Appender(_shared_docs[\"shift\"] % _shared_doc_kwargs)\n def shift(\n self: FrameOrSeries, periods=1, freq=None, axis=0, fill_value=None\n ) -> FrameOrSeries:\n if periods == 0:\n return self.copy()\n\n block_axis = self._get_block_manager_axis(axis)\n if freq is None:\n new_data = self._data.shift(\n periods=periods, axis=block_axis, fill_value=fill_value\n )\n else:\n return self.tshift(periods, freq)\n\n return self._constructor(new_data).__finalize__(self)\n\n def slice_shift(self: FrameOrSeries, periods: int = 1, axis=0) -> FrameOrSeries:\n \"\"\"\n Equivalent to `shift` without copying data.\n\n The shifted data will not include the dropped periods and the\n shifted axis will be smaller than the original.\n\n Parameters\n ----------\n periods : int\n Number of periods to move, can be positive or negative.\n\n Returns\n -------\n shifted : same type as caller\n\n Notes\n -----\n While the `slice_shift` is faster than `shift`, you may pay for it\n later during alignment.\n \"\"\"\n if periods == 0:\n return self\n\n if periods > 0:\n vslicer = slice(None, -periods)\n islicer = slice(periods, None)\n else:\n vslicer = slice(-periods, None)\n islicer = slice(None, periods)\n\n new_obj = self._slice(vslicer, axis=axis)\n shifted_axis = self._get_axis(axis)[islicer]\n new_obj.set_axis(shifted_axis, axis=axis, inplace=True)\n\n return new_obj.__finalize__(self)\n\n def tshift(\n self: FrameOrSeries, periods: int = 1, freq=None, axis=0\n ) -> FrameOrSeries:\n \"\"\"\n Shift the time index, using the index's frequency if available.\n\n Parameters\n ----------\n periods : int\n Number of periods to move, can be positive or negative.\n freq : DateOffset, timedelta, or str, default None\n Increment to use from the tseries module\n or time rule expressed as a string (e.g. 'EOM').\n axis : {0 or ‘index’, 1 or ‘columns’, None}, default 0\n Corresponds to the axis that contains the Index.\n\n Returns\n -------\n shifted : Series/DataFrame\n\n Notes\n -----\n If freq is not specified then tries to use the freq or inferred_freq\n attributes of the index. If neither of those attributes exist, a\n ValueError is thrown\n \"\"\"\n index = self._get_axis(axis)\n if freq is None:\n freq = getattr(index, \"freq\", None)\n\n if freq is None:\n freq = getattr(index, \"inferred_freq\", None)\n\n if freq is None:\n msg = \"Freq was not given and was not set in the index\"\n raise ValueError(msg)\n\n if periods == 0:\n return self\n\n if isinstance(freq, str):\n freq = to_offset(freq)\n\n block_axis = self._get_block_manager_axis(axis)\n if isinstance(index, PeriodIndex):\n orig_freq = to_offset(index.freq)\n if freq == orig_freq:\n new_data = self._data.copy()\n new_data.axes[block_axis] = index.shift(periods)\n elif orig_freq is not None:\n raise ValueError(\n f\"Given freq {freq.rule_code} does not match \"\n f\"PeriodIndex freq {orig_freq.rule_code}\"\n )\n else:\n new_data = self._data.copy()\n new_data.axes[block_axis] = index.shift(periods, freq)\n\n return self._constructor(new_data).__finalize__(self)\n\n def truncate(\n self: FrameOrSeries, before=None, after=None, axis=None, copy: bool_t = True\n ) -> FrameOrSeries:\n \"\"\"\n Truncate a Series or DataFrame before and after some index value.\n\n This is a useful shorthand for boolean indexing based on index\n values above or below certain thresholds.\n\n Parameters\n ----------\n before : date, str, int\n Truncate all rows before this index value.\n after : date, str, int\n Truncate all rows after this index value.\n axis : {0 or 'index', 1 or 'columns'}, optional\n Axis to truncate. Truncates the index (rows) by default.\n copy : bool, default is True,\n Return a copy of the truncated section.\n\n Returns\n -------\n type of caller\n The truncated Series or DataFrame.\n\n See Also\n --------\n DataFrame.loc : Select a subset of a DataFrame by label.\n DataFrame.iloc : Select a subset of a DataFrame by position.\n\n Notes\n -----\n If the index being truncated contains only datetime values,\n `before` and `after` may be specified as strings instead of\n Timestamps.\n\n Examples\n --------\n >>> df = pd.DataFrame({'A': ['a', 'b', 'c', 'd', 'e'],\n ... 'B': ['f', 'g', 'h', 'i', 'j'],\n ... 'C': ['k', 'l', 'm', 'n', 'o']},\n ... index=[1, 2, 3, 4, 5])\n >>> df\n A B C\n 1 a f k\n 2 b g l\n 3 c h m\n 4 d i n\n 5 e j o\n\n >>> df.truncate(before=2, after=4)\n A B C\n 2 b g l\n 3 c h m\n 4 d i n\n\n The columns of a DataFrame can be truncated.\n\n >>> df.truncate(before=\"A\", after=\"B\", axis=\"columns\")\n A B\n 1 a f\n 2 b g\n 3 c h\n 4 d i\n 5 e j\n\n For Series, only rows can be truncated.\n\n >>> df['A'].truncate(before=2, after=4)\n 2 b\n 3 c\n 4 d\n Name: A, dtype: object\n\n The index values in ``truncate`` can be datetimes or string\n dates.\n\n >>> dates = pd.date_range('2016-01-01', '2016-02-01', freq='s')\n >>> df = pd.DataFrame(index=dates, data={'A': 1})\n >>> df.tail()\n A\n 2016-01-31 23:59:56 1\n 2016-01-31 23:59:57 1\n 2016-01-31 23:59:58 1\n 2016-01-31 23:59:59 1\n 2016-02-01 00:00:00 1\n\n >>> df.truncate(before=pd.Timestamp('2016-01-05'),\n ... after=pd.Timestamp('2016-01-10')).tail()\n A\n 2016-01-09 23:59:56 1\n 2016-01-09 23:59:57 1\n 2016-01-09 23:59:58 1\n 2016-01-09 23:59:59 1\n 2016-01-10 00:00:00 1\n\n Because the index is a DatetimeIndex containing only dates, we can\n specify `before` and `after` as strings. They will be coerced to\n Timestamps before truncation.\n\n >>> df.truncate('2016-01-05', '2016-01-10').tail()\n A\n 2016-01-09 23:59:56 1\n 2016-01-09 23:59:57 1\n 2016-01-09 23:59:58 1\n 2016-01-09 23:59:59 1\n 2016-01-10 00:00:00 1\n\n Note that ``truncate`` assumes a 0 value for any unspecified time\n component (midnight). This differs from partial string slicing, which\n returns any partially matching dates.\n\n >>> df.loc['2016-01-05':'2016-01-10', :].tail()\n A\n 2016-01-10 23:59:55 1\n 2016-01-10 23:59:56 1\n 2016-01-10 23:59:57 1\n 2016-01-10 23:59:58 1\n 2016-01-10 23:59:59 1\n \"\"\"\n if axis is None:\n axis = self._stat_axis_number\n axis = self._get_axis_number(axis)\n ax = self._get_axis(axis)\n\n # GH 17935\n # Check that index is sorted\n if not ax.is_monotonic_increasing and not ax.is_monotonic_decreasing:\n raise ValueError(\"truncate requires a sorted index\")\n\n # if we have a date index, convert to dates, otherwise\n # treat like a slice\n if ax.is_all_dates:\n from pandas.core.tools.datetimes import to_datetime\n\n before = to_datetime(before)\n after = to_datetime(after)\n\n if before is not None and after is not None:\n if before > after:\n raise ValueError(f\"Truncate: {after} must be after {before}\")\n\n slicer = [slice(None, None)] * self._AXIS_LEN\n slicer[axis] = slice(before, after)\n result = self.loc[tuple(slicer)]\n\n if isinstance(ax, MultiIndex):\n setattr(result, self._get_axis_name(axis), ax.truncate(before, after))\n\n if copy:\n result = result.copy()\n\n return result\n\n def tz_convert(\n self: FrameOrSeries, tz, axis=0, level=None, copy: bool_t = True\n ) -> FrameOrSeries:\n \"\"\"\n Convert tz-aware axis to target time zone.\n\n Parameters\n ----------\n tz : str or tzinfo object\n axis : the axis to convert\n level : int, str, default None\n If axis is a MultiIndex, convert a specific level. Otherwise\n must be None.\n copy : bool, default True\n Also make a copy of the underlying data.\n\n Returns\n -------\n %(klass)s\n Object with time zone converted axis.\n\n Raises\n ------\n TypeError\n If the axis is tz-naive.\n \"\"\"\n axis = self._get_axis_number(axis)\n ax = self._get_axis(axis)\n\n def _tz_convert(ax, tz):\n if not hasattr(ax, \"tz_convert\"):\n if len(ax) > 0:\n ax_name = self._get_axis_name(axis)\n raise TypeError(\n f\"{ax_name} is not a valid DatetimeIndex or PeriodIndex\"\n )\n else:\n ax = DatetimeIndex([], tz=tz)\n else:\n ax = ax.tz_convert(tz)\n return ax\n\n # if a level is given it must be a MultiIndex level or\n # equivalent to the axis name\n if isinstance(ax, MultiIndex):\n level = ax._get_level_number(level)\n new_level = _tz_convert(ax.levels[level], tz)\n ax = ax.set_levels(new_level, level=level)\n else:\n if level not in (None, 0, ax.name):\n raise ValueError(f\"The level {level} is not valid\")\n ax = _tz_convert(ax, tz)\n\n result = self._constructor(self._data, copy=copy)\n result = result.set_axis(ax, axis=axis, inplace=False)\n return result.__finalize__(self)\n\n def tz_localize(\n self: FrameOrSeries,\n tz,\n axis=0,\n level=None,\n copy: bool_t = True,\n ambiguous=\"raise\",\n nonexistent: str = \"raise\",\n ) -> FrameOrSeries:\n \"\"\"\n Localize tz-naive index of a Series or DataFrame to target time zone.\n\n This operation localizes the Index. To localize the values in a\n timezone-naive Series, use :meth:`Series.dt.tz_localize`.\n\n Parameters\n ----------\n tz : str or tzinfo\n axis : the axis to localize\n level : int, str, default None\n If axis ia a MultiIndex, localize a specific level. Otherwise\n must be None.\n copy : bool, default True\n Also make a copy of the underlying data.\n ambiguous : 'infer', bool-ndarray, 'NaT', default 'raise'\n When clocks moved backward due to DST, ambiguous times may arise.\n For example in Central European Time (UTC+01), when going from\n 03:00 DST to 02:00 non-DST, 02:30:00 local time occurs both at\n 00:30:00 UTC and at 01:30:00 UTC. In such a situation, the\n `ambiguous` parameter dictates how ambiguous times should be\n handled.\n\n - 'infer' will attempt to infer fall dst-transition hours based on\n order\n - bool-ndarray where True signifies a DST time, False designates\n a non-DST time (note that this flag is only applicable for\n ambiguous times)\n - 'NaT' will return NaT where there are ambiguous times\n - 'raise' will raise an AmbiguousTimeError if there are ambiguous\n times.\n nonexistent : str, default 'raise'\n A nonexistent time does not exist in a particular timezone\n where clocks moved forward due to DST. Valid values are:\n\n - 'shift_forward' will shift the nonexistent time forward to the\n closest existing time\n - 'shift_backward' will shift the nonexistent time backward to the\n closest existing time\n - 'NaT' will return NaT where there are nonexistent times\n - timedelta objects will shift nonexistent times by the timedelta\n - 'raise' will raise an NonExistentTimeError if there are\n nonexistent times.\n\n .. versionadded:: 0.24.0\n\n Returns\n -------\n Series or DataFrame\n Same type as the input.\n\n Raises\n ------\n TypeError\n If the TimeSeries is tz-aware and tz is not None.\n\n Examples\n --------\n Localize local times:\n\n >>> s = pd.Series([1],\n ... index=pd.DatetimeIndex(['2018-09-15 01:30:00']))\n >>> s.tz_localize('CET')\n 2018-09-15 01:30:00+02:00 1\n dtype: int64\n\n Be careful with DST changes. When there is sequential data, pandas\n can infer the DST time:\n\n >>> s = pd.Series(range(7),\n ... index=pd.DatetimeIndex(['2018-10-28 01:30:00',\n ... '2018-10-28 02:00:00',\n ... '2018-10-28 02:30:00',\n ... '2018-10-28 02:00:00',\n ... '2018-10-28 02:30:00',\n ... '2018-10-28 03:00:00',\n ... '2018-10-28 03:30:00']))\n >>> s.tz_localize('CET', ambiguous='infer')\n 2018-10-28 01:30:00+02:00 0\n 2018-10-28 02:00:00+02:00 1\n 2018-10-28 02:30:00+02:00 2\n 2018-10-28 02:00:00+01:00 3\n 2018-10-28 02:30:00+01:00 4\n 2018-10-28 03:00:00+01:00 5\n 2018-10-28 03:30:00+01:00 6\n dtype: int64\n\n In some cases, inferring the DST is impossible. In such cases, you can\n pass an ndarray to the ambiguous parameter to set the DST explicitly\n\n >>> s = pd.Series(range(3),\n ... index=pd.DatetimeIndex(['2018-10-28 01:20:00',\n ... '2018-10-28 02:36:00',\n ... '2018-10-28 03:46:00']))\n >>> s.tz_localize('CET', ambiguous=np.array([True, True, False]))\n 2018-10-28 01:20:00+02:00 0\n 2018-10-28 02:36:00+02:00 1\n 2018-10-28 03:46:00+01:00 2\n dtype: int64\n\n If the DST transition causes nonexistent times, you can shift these\n dates forward or backwards with a timedelta object or `'shift_forward'`\n or `'shift_backwards'`.\n >>> s = pd.Series(range(2),\n ... index=pd.DatetimeIndex(['2015-03-29 02:30:00',\n ... '2015-03-29 03:30:00']))\n >>> s.tz_localize('Europe/Warsaw', nonexistent='shift_forward')\n 2015-03-29 03:00:00+02:00 0\n 2015-03-29 03:30:00+02:00 1\n dtype: int64\n >>> s.tz_localize('Europe/Warsaw', nonexistent='shift_backward')\n 2015-03-29 01:59:59.999999999+01:00 0\n 2015-03-29 03:30:00+02:00 1\n dtype: int64\n >>> s.tz_localize('Europe/Warsaw', nonexistent=pd.Timedelta('1H'))\n 2015-03-29 03:30:00+02:00 0\n 2015-03-29 03:30:00+02:00 1\n dtype: int64\n \"\"\"\n nonexistent_options = (\"raise\", \"NaT\", \"shift_forward\", \"shift_backward\")\n if nonexistent not in nonexistent_options and not isinstance(\n nonexistent, timedelta\n ):\n raise ValueError(\n \"The nonexistent argument must be one of 'raise', \"\n \"'NaT', 'shift_forward', 'shift_backward' or \"\n \"a timedelta object\"\n )\n\n axis = self._get_axis_number(axis)\n ax = self._get_axis(axis)\n\n def _tz_localize(ax, tz, ambiguous, nonexistent):\n if not hasattr(ax, \"tz_localize\"):\n if len(ax) > 0:\n ax_name = self._get_axis_name(axis)\n raise TypeError(\n f\"{ax_name} is not a valid DatetimeIndex or PeriodIndex\"\n )\n else:\n ax = DatetimeIndex([], tz=tz)\n else:\n ax = ax.tz_localize(tz, ambiguous=ambiguous, nonexistent=nonexistent)\n return ax\n\n # if a level is given it must be a MultiIndex level or\n # equivalent to the axis name\n if isinstance(ax, MultiIndex):\n level = ax._get_level_number(level)\n new_level = _tz_localize(ax.levels[level], tz, ambiguous, nonexistent)\n ax = ax.set_levels(new_level, level=level)\n else:\n if level not in (None, 0, ax.name):\n raise ValueError(f\"The level {level} is not valid\")\n ax = _tz_localize(ax, tz, ambiguous, nonexistent)\n\n result = self._constructor(self._data, copy=copy)\n result = result.set_axis(ax, axis=axis, inplace=False)\n return result.__finalize__(self)\n\n # ----------------------------------------------------------------------\n # Numeric Methods\n def abs(self: FrameOrSeries) -> FrameOrSeries:\n \"\"\"\n Return a Series/DataFrame with absolute numeric value of each element.\n\n This function only applies to elements that are all numeric.\n\n Returns\n -------\n abs\n Series/DataFrame containing the absolute value of each element.\n\n See Also\n --------\n numpy.absolute : Calculate the absolute value element-wise.\n\n Notes\n -----\n For ``complex`` inputs, ``1.2 + 1j``, the absolute value is\n :math:`\\\\sqrt{ a^2 + b^2 }`.\n\n Examples\n --------\n Absolute numeric values in a Series.\n\n >>> s = pd.Series([-1.10, 2, -3.33, 4])\n >>> s.abs()\n 0 1.10\n 1 2.00\n 2 3.33\n 3 4.00\n dtype: float64\n\n Absolute numeric values in a Series with complex numbers.\n\n >>> s = pd.Series([1.2 + 1j])\n >>> s.abs()\n 0 1.56205\n dtype: float64\n\n Absolute numeric values in a Series with a Timedelta element.\n\n >>> s = pd.Series([pd.Timedelta('1 days')])\n >>> s.abs()\n 0 1 days\n dtype: timedelta64[ns]\n\n Select rows with data closest to certain value using argsort (from\n `StackOverflow <https://stackoverflow.com/a/17758115>`__).\n\n >>> df = pd.DataFrame({\n ... 'a': [4, 5, 6, 7],\n ... 'b': [10, 20, 30, 40],\n ... 'c': [100, 50, -30, -50]\n ... })\n >>> df\n a b c\n 0 4 10 100\n 1 5 20 50\n 2 6 30 -30\n 3 7 40 -50\n >>> df.loc[(df.c - 43).abs().argsort()]\n a b c\n 1 5 20 50\n 0 4 10 100\n 2 6 30 -30\n 3 7 40 -50\n \"\"\"\n return np.abs(self)\n\n def describe(\n self: FrameOrSeries, percentiles=None, include=None, exclude=None\n ) -> FrameOrSeries:\n \"\"\"\n Generate descriptive statistics.\n\n Descriptive statistics include those that summarize the central\n tendency, dispersion and shape of a\n dataset's distribution, excluding ``NaN`` values.\n\n Analyzes both numeric and object series, as well\n as ``DataFrame`` column sets of mixed data types. The output\n will vary depending on what is provided. Refer to the notes\n below for more detail.\n\n Parameters\n ----------\n percentiles : list-like of numbers, optional\n The percentiles to include in the output. All should\n fall between 0 and 1. The default is\n ``[.25, .5, .75]``, which returns the 25th, 50th, and\n 75th percentiles.\n include : 'all', list-like of dtypes or None (default), optional\n A white list of data types to include in the result. Ignored\n for ``Series``. Here are the options:\n\n - 'all' : All columns of the input will be included in the output.\n - A list-like of dtypes : Limits the results to the\n provided data types.\n To limit the result to numeric types submit\n ``numpy.number``. To limit it instead to object columns submit\n the ``numpy.object`` data type. Strings\n can also be used in the style of\n ``select_dtypes`` (e.g. ``df.describe(include=['O'])``). To\n select pandas categorical columns, use ``'category'``\n - None (default) : The result will include all numeric columns.\n exclude : list-like of dtypes or None (default), optional,\n A black list of data types to omit from the result. Ignored\n for ``Series``. Here are the options:\n\n - A list-like of dtypes : Excludes the provided data types\n from the result. To exclude numeric types submit\n ``numpy.number``. To exclude object columns submit the data\n type ``numpy.object``. Strings can also be used in the style of\n ``select_dtypes`` (e.g. ``df.describe(include=['O'])``). To\n exclude pandas categorical columns, use ``'category'``\n - None (default) : The result will exclude nothing.\n\n Returns\n -------\n Series or DataFrame\n Summary statistics of the Series or Dataframe provided.\n\n See Also\n --------\n DataFrame.count: Count number of non-NA/null observations.\n DataFrame.max: Maximum of the values in the object.\n DataFrame.min: Minimum of the values in the object.\n DataFrame.mean: Mean of the values.\n DataFrame.std: Standard deviation of the observations.\n DataFrame.select_dtypes: Subset of a DataFrame including/excluding\n columns based on their dtype.\n\n Notes\n -----\n For numeric data, the result's index will include ``count``,\n ``mean``, ``std``, ``min``, ``max`` as well as lower, ``50`` and\n upper percentiles. By default the lower percentile is ``25`` and the\n upper percentile is ``75``. The ``50`` percentile is the\n same as the median.\n\n For object data (e.g. strings or timestamps), the result's index\n will include ``count``, ``unique``, ``top``, and ``freq``. The ``top``\n is the most common value. The ``freq`` is the most common value's\n frequency. Timestamps also include the ``first`` and ``last`` items.\n\n If multiple object values have the highest count, then the\n ``count`` and ``top`` results will be arbitrarily chosen from\n among those with the highest count.\n\n For mixed data types provided via a ``DataFrame``, the default is to\n return only an analysis of numeric columns. If the dataframe consists\n only of object and categorical data without any numeric columns, the\n default is to return an analysis of both the object and categorical\n columns. If ``include='all'`` is provided as an option, the result\n will include a union of attributes of each type.\n\n The `include` and `exclude` parameters can be used to limit\n which columns in a ``DataFrame`` are analyzed for the output.\n The parameters are ignored when analyzing a ``Series``.\n\n Examples\n --------\n Describing a numeric ``Series``.\n\n >>> s = pd.Series([1, 2, 3])\n >>> s.describe()\n count 3.0\n mean 2.0\n std 1.0\n min 1.0\n 25% 1.5\n 50% 2.0\n 75% 2.5\n max 3.0\n dtype: float64\n\n Describing a categorical ``Series``.\n\n >>> s = pd.Series(['a', 'a', 'b', 'c'])\n >>> s.describe()\n count 4\n unique 3\n top a\n freq 2\n dtype: object\n\n Describing a timestamp ``Series``.\n\n >>> s = pd.Series([\n ... np.datetime64(\"2000-01-01\"),\n ... np.datetime64(\"2010-01-01\"),\n ... np.datetime64(\"2010-01-01\")\n ... ])\n >>> s.describe()\n count 3\n unique 2\n top 2010-01-01 00:00:00\n freq 2\n first 2000-01-01 00:00:00\n last 2010-01-01 00:00:00\n dtype: object\n\n Describing a ``DataFrame``. By default only numeric fields\n are returned.\n\n >>> df = pd.DataFrame({'categorical': pd.Categorical(['d','e','f']),\n ... 'numeric': [1, 2, 3],\n ... 'object': ['a', 'b', 'c']\n ... })\n >>> df.describe()\n numeric\n count 3.0\n mean 2.0\n std 1.0\n min 1.0\n 25% 1.5\n 50% 2.0\n 75% 2.5\n max 3.0\n\n Describing all columns of a ``DataFrame`` regardless of data type.\n\n >>> df.describe(include='all')\n categorical numeric object\n count 3 3.0 3\n unique 3 NaN 3\n top f NaN c\n freq 1 NaN 1\n mean NaN 2.0 NaN\n std NaN 1.0 NaN\n min NaN 1.0 NaN\n 25% NaN 1.5 NaN\n 50% NaN 2.0 NaN\n 75% NaN 2.5 NaN\n max NaN 3.0 NaN\n\n Describing a column from a ``DataFrame`` by accessing it as\n an attribute.\n\n >>> df.numeric.describe()\n count 3.0\n mean 2.0\n std 1.0\n min 1.0\n 25% 1.5\n 50% 2.0\n 75% 2.5\n max 3.0\n Name: numeric, dtype: float64\n\n Including only numeric columns in a ``DataFrame`` description.\n\n >>> df.describe(include=[np.number])\n numeric\n count 3.0\n mean 2.0\n std 1.0\n min 1.0\n 25% 1.5\n 50% 2.0\n 75% 2.5\n max 3.0\n\n Including only string columns in a ``DataFrame`` description.\n\n >>> df.describe(include=[np.object])\n object\n count 3\n unique 3\n top c\n freq 1\n\n Including only categorical columns from a ``DataFrame`` description.\n\n >>> df.describe(include=['category'])\n categorical\n count 3\n unique 3\n top f\n freq 1\n\n Excluding numeric columns from a ``DataFrame`` description.\n\n >>> df.describe(exclude=[np.number])\n categorical object\n count 3 3\n unique 3 3\n top f c\n freq 1 1\n\n Excluding object columns from a ``DataFrame`` description.\n\n >>> df.describe(exclude=[np.object])\n categorical numeric\n count 3 3.0\n unique 3 NaN\n top f NaN\n freq 1 NaN\n mean NaN 2.0\n std NaN 1.0\n min NaN 1.0\n 25% NaN 1.5\n 50% NaN 2.0\n 75% NaN 2.5\n max NaN 3.0\n \"\"\"\n if self.ndim == 2 and self.columns.size == 0:\n raise ValueError(\"Cannot describe a DataFrame without columns\")\n\n if percentiles is not None:\n # explicit conversion of `percentiles` to list\n percentiles = list(percentiles)\n\n # get them all to be in [0, 1]\n validate_percentile(percentiles)\n\n # median should always be included\n if 0.5 not in percentiles:\n percentiles.append(0.5)\n percentiles = np.asarray(percentiles)\n else:\n percentiles = np.array([0.25, 0.5, 0.75])\n\n # sort and check for duplicates\n unique_pcts = np.unique(percentiles)\n if len(unique_pcts) < len(percentiles):\n raise ValueError(\"percentiles cannot contain duplicates\")\n percentiles = unique_pcts\n\n formatted_percentiles = format_percentiles(percentiles)\n\n def describe_numeric_1d(series):\n stat_index = (\n [\"count\", \"mean\", \"std\", \"min\"] + formatted_percentiles + [\"max\"]\n )\n d = (\n [series.count(), series.mean(), series.std(), series.min()]\n + series.quantile(percentiles).tolist()\n + [series.max()]\n )\n return pd.Series(d, index=stat_index, name=series.name)\n\n def describe_categorical_1d(data):\n names = [\"count\", \"unique\"]\n objcounts = data.value_counts()\n count_unique = len(objcounts[objcounts != 0])\n result = [data.count(), count_unique]\n dtype = None\n if result[1] > 0:\n top, freq = objcounts.index[0], objcounts.iloc[0]\n names += [\"top\", \"freq\"]\n result += [top, freq]\n\n # If the DataFrame is empty, set 'top' and 'freq' to None\n # to maintain output shape consistency\n else:\n names += [\"top\", \"freq\"]\n result += [np.nan, np.nan]\n dtype = \"object\"\n\n return pd.Series(result, index=names, name=data.name, dtype=dtype)\n\n def describe_timestamp_1d(data):\n # GH-30164\n stat_index = [\"count\", \"mean\", \"min\"] + formatted_percentiles + [\"max\"]\n d = (\n [data.count(), data.mean(), data.min()]\n + data.quantile(percentiles).tolist()\n + [data.max()]\n )\n return pd.Series(d, index=stat_index, name=data.name)\n\n def describe_1d(data):\n if is_bool_dtype(data):\n return describe_categorical_1d(data)\n elif is_numeric_dtype(data):\n return describe_numeric_1d(data)\n elif is_datetime64_any_dtype(data):\n return describe_timestamp_1d(data)\n elif is_timedelta64_dtype(data):\n return describe_numeric_1d(data)\n else:\n return describe_categorical_1d(data)\n\n if self.ndim == 1:\n return describe_1d(self)\n elif (include is None) and (exclude is None):\n # when some numerics are found, keep only numerics\n data = self.select_dtypes(include=[np.number])\n if len(data.columns) == 0:\n data = self\n elif include == \"all\":\n if exclude is not None:\n msg = \"exclude must be None when include is 'all'\"\n raise ValueError(msg)\n data = self\n else:\n data = self.select_dtypes(include=include, exclude=exclude)\n\n ldesc = [describe_1d(s) for _, s in data.items()]\n # set a convenient order for rows\n names: List[Label] = []\n ldesc_indexes = sorted((x.index for x in ldesc), key=len)\n for idxnames in ldesc_indexes:\n for name in idxnames:\n if name not in names:\n names.append(name)\n\n d = pd.concat([x.reindex(names, copy=False) for x in ldesc], axis=1, sort=False)\n d.columns = data.columns.copy()\n return d\n\n _shared_docs[\n \"pct_change\"\n ] = \"\"\"\n Percentage change between the current and a prior element.\n\n Computes the percentage change from the immediately previous row by\n default. This is useful in comparing the percentage of change in a time\n series of elements.\n\n Parameters\n ----------\n periods : int, default 1\n Periods to shift for forming percent change.\n fill_method : str, default 'pad'\n How to handle NAs before computing percent changes.\n limit : int, default None\n The number of consecutive NAs to fill before stopping.\n freq : DateOffset, timedelta, or str, optional\n Increment to use from time series API (e.g. 'M' or BDay()).\n **kwargs\n Additional keyword arguments are passed into\n `DataFrame.shift` or `Series.shift`.\n\n Returns\n -------\n chg : Series or DataFrame\n The same type as the calling object.\n\n See Also\n --------\n Series.diff : Compute the difference of two elements in a Series.\n DataFrame.diff : Compute the difference of two elements in a DataFrame.\n Series.shift : Shift the index by some number of periods.\n DataFrame.shift : Shift the index by some number of periods.\n\n Examples\n --------\n **Series**\n\n >>> s = pd.Series([90, 91, 85])\n >>> s\n 0 90\n 1 91\n 2 85\n dtype: int64\n\n >>> s.pct_change()\n 0 NaN\n 1 0.011111\n 2 -0.065934\n dtype: float64\n\n >>> s.pct_change(periods=2)\n 0 NaN\n 1 NaN\n 2 -0.055556\n dtype: float64\n\n See the percentage change in a Series where filling NAs with last\n valid observation forward to next valid.\n\n >>> s = pd.Series([90, 91, None, 85])\n >>> s\n 0 90.0\n 1 91.0\n 2 NaN\n 3 85.0\n dtype: float64\n\n >>> s.pct_change(fill_method='ffill')\n 0 NaN\n 1 0.011111\n 2 0.000000\n 3 -0.065934\n dtype: float64\n\n **DataFrame**\n\n Percentage change in French franc, Deutsche Mark, and Italian lira from\n 1980-01-01 to 1980-03-01.\n\n >>> df = pd.DataFrame({\n ... 'FR': [4.0405, 4.0963, 4.3149],\n ... 'GR': [1.7246, 1.7482, 1.8519],\n ... 'IT': [804.74, 810.01, 860.13]},\n ... index=['1980-01-01', '1980-02-01', '1980-03-01'])\n >>> df\n FR GR IT\n 1980-01-01 4.0405 1.7246 804.74\n 1980-02-01 4.0963 1.7482 810.01\n 1980-03-01 4.3149 1.8519 860.13\n\n >>> df.pct_change()\n FR GR IT\n 1980-01-01 NaN NaN NaN\n 1980-02-01 0.013810 0.013684 0.006549\n 1980-03-01 0.053365 0.059318 0.061876\n\n Percentage of change in GOOG and APPL stock volume. Shows computing\n the percentage change between columns.\n\n >>> df = pd.DataFrame({\n ... '2016': [1769950, 30586265],\n ... '2015': [1500923, 40912316],\n ... '2014': [1371819, 41403351]},\n ... index=['GOOG', 'APPL'])\n >>> df\n 2016 2015 2014\n GOOG 1769950 1500923 1371819\n APPL 30586265 40912316 41403351\n\n >>> df.pct_change(axis='columns')\n 2016 2015 2014\n GOOG NaN -0.151997 -0.086016\n APPL NaN 0.337604 0.012002\n \"\"\"\n\n @Appender(_shared_docs[\"pct_change\"] % _shared_doc_kwargs)\n def pct_change(\n self: FrameOrSeries,\n periods=1,\n fill_method=\"pad\",\n limit=None,\n freq=None,\n **kwargs,\n ) -> FrameOrSeries:\n # TODO: Not sure if above is correct - need someone to confirm.\n axis = self._get_axis_number(kwargs.pop(\"axis\", self._stat_axis_name))\n if fill_method is None:\n data = self\n else:\n data = self._ensure_type(\n self.fillna(method=fill_method, axis=axis, limit=limit)\n )\n\n rs = data.div(data.shift(periods=periods, freq=freq, axis=axis, **kwargs)) - 1\n if freq is not None:\n # Shift method is implemented differently when freq is not None\n # We want to restore the original index\n rs = rs.loc[~rs.index.duplicated()]\n rs = rs.reindex_like(data)\n return rs\n\n def _agg_by_level(self, name, axis=0, level=0, skipna=True, **kwargs):\n if axis is None:\n raise ValueError(\"Must specify 'axis' when aggregating by level.\")\n grouped = self.groupby(level=level, axis=axis, sort=False)\n if hasattr(grouped, name) and skipna:\n return getattr(grouped, name)(**kwargs)\n axis = self._get_axis_number(axis)\n method = getattr(type(self), name)\n applyf = lambda x: method(x, axis=axis, skipna=skipna, **kwargs)\n return grouped.aggregate(applyf)\n\n @classmethod\n def _add_numeric_operations(cls):\n \"\"\"\n Add the operations to the cls; evaluate the doc strings again\n \"\"\"\n axis_descr, name1, name2 = _doc_parms(cls)\n\n cls.any = _make_logical_function(\n cls,\n \"any\",\n name1=name1,\n name2=name2,\n axis_descr=axis_descr,\n desc=_any_desc,\n func=nanops.nanany,\n see_also=_any_see_also,\n examples=_any_examples,\n empty_value=False,\n )\n cls.all = _make_logical_function(\n cls,\n \"all\",\n name1=name1,\n name2=name2,\n axis_descr=axis_descr,\n desc=_all_desc,\n func=nanops.nanall,\n see_also=_all_see_also,\n examples=_all_examples,\n empty_value=True,\n )\n\n @Substitution(\n desc=\"Return the mean absolute deviation of the values \"\n \"for the requested axis.\",\n name1=name1,\n name2=name2,\n axis_descr=axis_descr,\n min_count=\"\",\n see_also=\"\",\n examples=\"\",\n )\n @Appender(_num_doc_mad)\n def mad(self, axis=None, skipna=None, level=None):\n if skipna is None:\n skipna = True\n if axis is None:\n axis = self._stat_axis_number\n if level is not None:\n return self._agg_by_level(\"mad\", axis=axis, level=level, skipna=skipna)\n\n data = self._get_numeric_data()\n if axis == 0:\n demeaned = data - data.mean(axis=0)\n else:\n demeaned = data.sub(data.mean(axis=1), axis=0)\n return np.abs(demeaned).mean(axis=axis, skipna=skipna)\n\n cls.mad = mad\n\n cls.sem = _make_stat_function_ddof(\n cls,\n \"sem\",\n name1=name1,\n name2=name2,\n axis_descr=axis_descr,\n desc=\"Return unbiased standard error of the mean over requested \"\n \"axis.\\n\\nNormalized by N-1 by default. This can be changed \"\n \"using the ddof argument\",\n func=nanops.nansem,\n )\n cls.var = _make_stat_function_ddof(\n cls,\n \"var\",\n name1=name1,\n name2=name2,\n axis_descr=axis_descr,\n desc=\"Return unbiased variance over requested axis.\\n\\nNormalized by \"\n \"N-1 by default. This can be changed using the ddof argument\",\n func=nanops.nanvar,\n )\n cls.std = _make_stat_function_ddof(\n cls,\n \"std\",\n name1=name1,\n name2=name2,\n axis_descr=axis_descr,\n desc=\"Return sample standard deviation over requested axis.\"\n \"\\n\\nNormalized by N-1 by default. This can be changed using the \"\n \"ddof argument\",\n func=nanops.nanstd,\n )\n\n cls.cummin = _make_cum_function(\n cls,\n \"cummin\",\n name1=name1,\n name2=name2,\n axis_descr=axis_descr,\n desc=\"minimum\",\n accum_func=np.minimum.accumulate,\n accum_func_name=\"min\",\n mask_a=np.inf,\n mask_b=np.nan,\n examples=_cummin_examples,\n )\n cls.cumsum = _make_cum_function(\n cls,\n \"cumsum\",\n name1=name1,\n name2=name2,\n axis_descr=axis_descr,\n desc=\"sum\",\n accum_func=np.cumsum,\n accum_func_name=\"sum\",\n mask_a=0.0,\n mask_b=np.nan,\n examples=_cumsum_examples,\n )\n cls.cumprod = _make_cum_function(\n cls,\n \"cumprod\",\n name1=name1,\n name2=name2,\n axis_descr=axis_descr,\n desc=\"product\",\n accum_func=np.cumprod,\n accum_func_name=\"prod\",\n mask_a=1.0,\n mask_b=np.nan,\n examples=_cumprod_examples,\n )\n cls.cummax = _make_cum_function(\n cls,\n \"cummax\",\n name1=name1,\n name2=name2,\n axis_descr=axis_descr,\n desc=\"maximum\",\n accum_func=np.maximum.accumulate,\n accum_func_name=\"max\",\n mask_a=-np.inf,\n mask_b=np.nan,\n examples=_cummax_examples,\n )\n\n cls.sum = _make_min_count_stat_function(\n cls,\n \"sum\",\n name1=name1,\n name2=name2,\n axis_descr=axis_descr,\n desc=\"Return the sum of the values for the requested axis.\\n\\n\"\n \"This is equivalent to the method ``numpy.sum``.\",\n func=nanops.nansum,\n see_also=_stat_func_see_also,\n examples=_sum_examples,\n )\n cls.mean = _make_stat_function(\n cls,\n \"mean\",\n name1=name1,\n name2=name2,\n axis_descr=axis_descr,\n desc=\"Return the mean of the values for the requested axis.\",\n func=nanops.nanmean,\n )\n cls.skew = _make_stat_function(\n cls,\n \"skew\",\n name1=name1,\n name2=name2,\n axis_descr=axis_descr,\n desc=\"Return unbiased skew over requested axis.\\n\\nNormalized by N-1.\",\n func=nanops.nanskew,\n )\n cls.kurt = _make_stat_function(\n cls,\n \"kurt\",\n name1=name1,\n name2=name2,\n axis_descr=axis_descr,\n desc=\"Return unbiased kurtosis over requested axis.\\n\\n\"\n \"Kurtosis obtained using Fisher's definition of\\n\"\n \"kurtosis (kurtosis of normal == 0.0). Normalized \"\n \"by N-1.\",\n func=nanops.nankurt,\n )\n cls.kurtosis = cls.kurt\n cls.prod = _make_min_count_stat_function(\n cls,\n \"prod\",\n name1=name1,\n name2=name2,\n axis_descr=axis_descr,\n desc=\"Return the product of the values for the requested axis.\",\n func=nanops.nanprod,\n examples=_prod_examples,\n )\n cls.product = cls.prod\n cls.median = _make_stat_function(\n cls,\n \"median\",\n name1=name1,\n name2=name2,\n axis_descr=axis_descr,\n desc=\"Return the median of the values for the requested axis.\",\n func=nanops.nanmedian,\n )\n cls.max = _make_stat_function(\n cls,\n \"max\",\n name1=name1,\n name2=name2,\n axis_descr=axis_descr,\n desc=\"Return the maximum of the values for the requested axis.\\n\\n\"\n \"If you want the *index* of the maximum, use ``idxmax``. This is\"\n \"the equivalent of the ``numpy.ndarray`` method ``argmax``.\",\n func=nanops.nanmax,\n see_also=_stat_func_see_also,\n examples=_max_examples,\n )\n cls.min = _make_stat_function(\n cls,\n \"min\",\n name1=name1,\n name2=name2,\n axis_descr=axis_descr,\n desc=\"Return the minimum of the values for the requested axis.\\n\\n\"\n \"If you want the *index* of the minimum, use ``idxmin``. This is\"\n \"the equivalent of the ``numpy.ndarray`` method ``argmin``.\",\n func=nanops.nanmin,\n see_also=_stat_func_see_also,\n examples=_min_examples,\n )\n\n @classmethod\n def _add_series_or_dataframe_operations(cls):\n \"\"\"\n Add the series or dataframe only operations to the cls; evaluate\n the doc strings again.\n \"\"\"\n from pandas.core.window import EWM, Expanding, Rolling, Window\n\n @Appender(Rolling.__doc__)\n def rolling(\n self,\n window,\n min_periods=None,\n center=False,\n win_type=None,\n on=None,\n axis=0,\n closed=None,\n ):\n axis = self._get_axis_number(axis)\n\n if win_type is not None:\n return Window(\n self,\n window=window,\n min_periods=min_periods,\n center=center,\n win_type=win_type,\n on=on,\n axis=axis,\n closed=closed,\n )\n\n return Rolling(\n self,\n window=window,\n min_periods=min_periods,\n center=center,\n win_type=win_type,\n on=on,\n axis=axis,\n closed=closed,\n )\n\n cls.rolling = rolling\n\n @Appender(Expanding.__doc__)\n def expanding(self, min_periods=1, center=False, axis=0):\n axis = self._get_axis_number(axis)\n return Expanding(self, min_periods=min_periods, center=center, axis=axis)\n\n cls.expanding = expanding\n\n @Appender(EWM.__doc__)\n def ewm(\n self,\n com=None,\n span=None,\n halflife=None,\n alpha=None,\n min_periods=0,\n adjust=True,\n ignore_na=False,\n axis=0,\n ):\n axis = self._get_axis_number(axis)\n return EWM(\n self,\n com=com,\n span=span,\n halflife=halflife,\n alpha=alpha,\n min_periods=min_periods,\n adjust=adjust,\n ignore_na=ignore_na,\n axis=axis,\n )\n\n cls.ewm = ewm\n\n @Appender(_shared_docs[\"transform\"] % dict(axis=\"\", **_shared_doc_kwargs))\n def transform(self, func, *args, **kwargs):\n result = self.agg(func, *args, **kwargs)\n if is_scalar(result) or len(result) != len(self):\n raise ValueError(\"transforms cannot produce aggregated results\")\n\n return result\n\n # ----------------------------------------------------------------------\n # Misc methods\n\n _shared_docs[\n \"valid_index\"\n ] = \"\"\"\n Return index for %(position)s non-NA/null value.\n\n Returns\n -------\n scalar : type of index\n\n Notes\n -----\n If all elements are non-NA/null, returns None.\n Also returns None for empty %(klass)s.\n \"\"\"\n\n def _find_valid_index(self, how: str):\n \"\"\"\n Retrieves the index of the first valid value.\n\n Parameters\n ----------\n how : {'first', 'last'}\n Use this parameter to change between the first or last valid index.\n\n Returns\n -------\n idx_first_valid : type of index\n \"\"\"\n idxpos = find_valid_index(self._values, how)\n if idxpos is None:\n return None\n return self.index[idxpos]\n\n @Appender(\n _shared_docs[\"valid_index\"] % {\"position\": \"first\", \"klass\": \"Series/DataFrame\"}\n )\n def first_valid_index(self):\n return self._find_valid_index(\"first\")\n\n @Appender(\n _shared_docs[\"valid_index\"] % {\"position\": \"last\", \"klass\": \"Series/DataFrame\"}\n )\n def last_valid_index(self):\n return self._find_valid_index(\"last\")\n\n\ndef _doc_parms(cls):\n \"\"\"Return a tuple of the doc parms.\"\"\"\n axis_descr = (\n f\"{{{', '.join(f'{a} ({i})' for i, a in enumerate(cls._AXIS_ORDERS))}}}\"\n )\n name = cls._constructor_sliced.__name__ if cls._AXIS_LEN > 1 else \"scalar\"\n name2 = cls.__name__\n return axis_descr, name, name2\n\n\n_num_doc = \"\"\"\n%(desc)s\n\nParameters\n----------\naxis : %(axis_descr)s\n Axis for the function to be applied on.\nskipna : bool, default True\n Exclude NA/null values when computing the result.\nlevel : int or level name, default None\n If the axis is a MultiIndex (hierarchical), count along a\n particular level, collapsing into a %(name1)s.\nnumeric_only : bool, default None\n Include only float, int, boolean columns. If None, will attempt to use\n everything, then use only numeric data. Not implemented for Series.\n%(min_count)s\\\n**kwargs\n Additional keyword arguments to be passed to the function.\n\nReturns\n-------\n%(name1)s or %(name2)s (if level specified)\\\n%(see_also)s\\\n%(examples)s\n\"\"\"\n\n_num_doc_mad = \"\"\"\n%(desc)s\n\nParameters\n----------\naxis : %(axis_descr)s\n Axis for the function to be applied on.\nskipna : bool, default None\n Exclude NA/null values when computing the result.\nlevel : int or level name, default None\n If the axis is a MultiIndex (hierarchical), count along a\n particular level, collapsing into a %(name1)s.\n\nReturns\n-------\n%(name1)s or %(name2)s (if level specified)\\\n%(see_also)s\\\n%(examples)s\n\"\"\"\n\n_num_ddof_doc = \"\"\"\n%(desc)s\n\nParameters\n----------\naxis : %(axis_descr)s\nskipna : bool, default True\n Exclude NA/null values. If an entire row/column is NA, the result\n will be NA.\nlevel : int or level name, default None\n If the axis is a MultiIndex (hierarchical), count along a\n particular level, collapsing into a %(name1)s.\nddof : int, default 1\n Delta Degrees of Freedom. The divisor used in calculations is N - ddof,\n where N represents the number of elements.\nnumeric_only : bool, default None\n Include only float, int, boolean columns. If None, will attempt to use\n everything, then use only numeric data. Not implemented for Series.\n\nReturns\n-------\n%(name1)s or %(name2)s (if level specified)\\n\"\"\"\n\n_bool_doc = \"\"\"\n%(desc)s\n\nParameters\n----------\naxis : {0 or 'index', 1 or 'columns', None}, default 0\n Indicate which axis or axes should be reduced.\n\n * 0 / 'index' : reduce the index, return a Series whose index is the\n original column labels.\n * 1 / 'columns' : reduce the columns, return a Series whose index is the\n original index.\n * None : reduce all axes, return a scalar.\n\nbool_only : bool, default None\n Include only boolean columns. If None, will attempt to use everything,\n then use only boolean data. Not implemented for Series.\nskipna : bool, default True\n Exclude NA/null values. If the entire row/column is NA and skipna is\n True, then the result will be %(empty_value)s, as for an empty row/column.\n If skipna is False, then NA are treated as True, because these are not\n equal to zero.\nlevel : int or level name, default None\n If the axis is a MultiIndex (hierarchical), count along a\n particular level, collapsing into a %(name1)s.\n**kwargs : any, default None\n Additional keywords have no effect but might be accepted for\n compatibility with NumPy.\n\nReturns\n-------\n%(name1)s or %(name2)s\n If level is specified, then, %(name2)s is returned; otherwise, %(name1)s\n is returned.\n\n%(see_also)s\n%(examples)s\"\"\"\n\n_all_desc = \"\"\"\\\nReturn whether all elements are True, potentially over an axis.\n\nReturns True unless there at least one element within a series or\nalong a Dataframe axis that is False or equivalent (e.g. zero or\nempty).\"\"\"\n\n_all_examples = \"\"\"\\\nExamples\n--------\n**Series**\n\n>>> pd.Series([True, True]).all()\nTrue\n>>> pd.Series([True, False]).all()\nFalse\n>>> pd.Series([]).all()\nTrue\n>>> pd.Series([np.nan]).all()\nTrue\n>>> pd.Series([np.nan]).all(skipna=False)\nTrue\n\n**DataFrames**\n\nCreate a dataframe from a dictionary.\n\n>>> df = pd.DataFrame({'col1': [True, True], 'col2': [True, False]})\n>>> df\n col1 col2\n0 True True\n1 True False\n\nDefault behaviour checks if column-wise values all return True.\n\n>>> df.all()\ncol1 True\ncol2 False\ndtype: bool\n\nSpecify ``axis='columns'`` to check if row-wise values all return True.\n\n>>> df.all(axis='columns')\n0 True\n1 False\ndtype: bool\n\nOr ``axis=None`` for whether every value is True.\n\n>>> df.all(axis=None)\nFalse\n\"\"\"\n\n_all_see_also = \"\"\"\\\nSee Also\n--------\nSeries.all : Return True if all elements are True.\nDataFrame.any : Return True if one (or more) elements are True.\n\"\"\"\n\n_cnum_doc = \"\"\"\nReturn cumulative %(desc)s over a DataFrame or Series axis.\n\nReturns a DataFrame or Series of the same size containing the cumulative\n%(desc)s.\n\nParameters\n----------\naxis : {0 or 'index', 1 or 'columns'}, default 0\n The index or the name of the axis. 0 is equivalent to None or 'index'.\nskipna : bool, default True\n Exclude NA/null values. If an entire row/column is NA, the result\n will be NA.\n*args, **kwargs :\n Additional keywords have no effect but might be accepted for\n compatibility with NumPy.\n\nReturns\n-------\n%(name1)s or %(name2)s\n\nSee Also\n--------\ncore.window.Expanding.%(accum_func_name)s : Similar functionality\n but ignores ``NaN`` values.\n%(name2)s.%(accum_func_name)s : Return the %(desc)s over\n %(name2)s axis.\n%(name2)s.cummax : Return cumulative maximum over %(name2)s axis.\n%(name2)s.cummin : Return cumulative minimum over %(name2)s axis.\n%(name2)s.cumsum : Return cumulative sum over %(name2)s axis.\n%(name2)s.cumprod : Return cumulative product over %(name2)s axis.\n\n%(examples)s\"\"\"\n\n_cummin_examples = \"\"\"\\\nExamples\n--------\n**Series**\n\n>>> s = pd.Series([2, np.nan, 5, -1, 0])\n>>> s\n0 2.0\n1 NaN\n2 5.0\n3 -1.0\n4 0.0\ndtype: float64\n\nBy default, NA values are ignored.\n\n>>> s.cummin()\n0 2.0\n1 NaN\n2 2.0\n3 -1.0\n4 -1.0\ndtype: float64\n\nTo include NA values in the operation, use ``skipna=False``\n\n>>> s.cummin(skipna=False)\n0 2.0\n1 NaN\n2 NaN\n3 NaN\n4 NaN\ndtype: float64\n\n**DataFrame**\n\n>>> df = pd.DataFrame([[2.0, 1.0],\n... [3.0, np.nan],\n... [1.0, 0.0]],\n... columns=list('AB'))\n>>> df\n A B\n0 2.0 1.0\n1 3.0 NaN\n2 1.0 0.0\n\nBy default, iterates over rows and finds the minimum\nin each column. This is equivalent to ``axis=None`` or ``axis='index'``.\n\n>>> df.cummin()\n A B\n0 2.0 1.0\n1 2.0 NaN\n2 1.0 0.0\n\nTo iterate over columns and find the minimum in each row,\nuse ``axis=1``\n\n>>> df.cummin(axis=1)\n A B\n0 2.0 1.0\n1 3.0 NaN\n2 1.0 0.0\n\"\"\"\n\n_cumsum_examples = \"\"\"\\\nExamples\n--------\n**Series**\n\n>>> s = pd.Series([2, np.nan, 5, -1, 0])\n>>> s\n0 2.0\n1 NaN\n2 5.0\n3 -1.0\n4 0.0\ndtype: float64\n\nBy default, NA values are ignored.\n\n>>> s.cumsum()\n0 2.0\n1 NaN\n2 7.0\n3 6.0\n4 6.0\ndtype: float64\n\nTo include NA values in the operation, use ``skipna=False``\n\n>>> s.cumsum(skipna=False)\n0 2.0\n1 NaN\n2 NaN\n3 NaN\n4 NaN\ndtype: float64\n\n**DataFrame**\n\n>>> df = pd.DataFrame([[2.0, 1.0],\n... [3.0, np.nan],\n... [1.0, 0.0]],\n... columns=list('AB'))\n>>> df\n A B\n0 2.0 1.0\n1 3.0 NaN\n2 1.0 0.0\n\nBy default, iterates over rows and finds the sum\nin each column. This is equivalent to ``axis=None`` or ``axis='index'``.\n\n>>> df.cumsum()\n A B\n0 2.0 1.0\n1 5.0 NaN\n2 6.0 1.0\n\nTo iterate over columns and find the sum in each row,\nuse ``axis=1``\n\n>>> df.cumsum(axis=1)\n A B\n0 2.0 3.0\n1 3.0 NaN\n2 1.0 1.0\n\"\"\"\n\n_cumprod_examples = \"\"\"\\\nExamples\n--------\n**Series**\n\n>>> s = pd.Series([2, np.nan, 5, -1, 0])\n>>> s\n0 2.0\n1 NaN\n2 5.0\n3 -1.0\n4 0.0\ndtype: float64\n\nBy default, NA values are ignored.\n\n>>> s.cumprod()\n0 2.0\n1 NaN\n2 10.0\n3 -10.0\n4 -0.0\ndtype: float64\n\nTo include NA values in the operation, use ``skipna=False``\n\n>>> s.cumprod(skipna=False)\n0 2.0\n1 NaN\n2 NaN\n3 NaN\n4 NaN\ndtype: float64\n\n**DataFrame**\n\n>>> df = pd.DataFrame([[2.0, 1.0],\n... [3.0, np.nan],\n... [1.0, 0.0]],\n... columns=list('AB'))\n>>> df\n A B\n0 2.0 1.0\n1 3.0 NaN\n2 1.0 0.0\n\nBy default, iterates over rows and finds the product\nin each column. This is equivalent to ``axis=None`` or ``axis='index'``.\n\n>>> df.cumprod()\n A B\n0 2.0 1.0\n1 6.0 NaN\n2 6.0 0.0\n\nTo iterate over columns and find the product in each row,\nuse ``axis=1``\n\n>>> df.cumprod(axis=1)\n A B\n0 2.0 2.0\n1 3.0 NaN\n2 1.0 0.0\n\"\"\"\n\n_cummax_examples = \"\"\"\\\nExamples\n--------\n**Series**\n\n>>> s = pd.Series([2, np.nan, 5, -1, 0])\n>>> s\n0 2.0\n1 NaN\n2 5.0\n3 -1.0\n4 0.0\ndtype: float64\n\nBy default, NA values are ignored.\n\n>>> s.cummax()\n0 2.0\n1 NaN\n2 5.0\n3 5.0\n4 5.0\ndtype: float64\n\nTo include NA values in the operation, use ``skipna=False``\n\n>>> s.cummax(skipna=False)\n0 2.0\n1 NaN\n2 NaN\n3 NaN\n4 NaN\ndtype: float64\n\n**DataFrame**\n\n>>> df = pd.DataFrame([[2.0, 1.0],\n... [3.0, np.nan],\n... [1.0, 0.0]],\n... columns=list('AB'))\n>>> df\n A B\n0 2.0 1.0\n1 3.0 NaN\n2 1.0 0.0\n\nBy default, iterates over rows and finds the maximum\nin each column. This is equivalent to ``axis=None`` or ``axis='index'``.\n\n>>> df.cummax()\n A B\n0 2.0 1.0\n1 3.0 NaN\n2 3.0 1.0\n\nTo iterate over columns and find the maximum in each row,\nuse ``axis=1``\n\n>>> df.cummax(axis=1)\n A B\n0 2.0 2.0\n1 3.0 NaN\n2 1.0 1.0\n\"\"\"\n\n_any_see_also = \"\"\"\\\nSee Also\n--------\nnumpy.any : Numpy version of this method.\nSeries.any : Return whether any element is True.\nSeries.all : Return whether all elements are True.\nDataFrame.any : Return whether any element is True over requested axis.\nDataFrame.all : Return whether all elements are True over requested axis.\n\"\"\"\n\n_any_desc = \"\"\"\\\nReturn whether any element is True, potentially over an axis.\n\nReturns False unless there at least one element within a series or\nalong a Dataframe axis that is True or equivalent (e.g. non-zero or\nnon-empty).\"\"\"\n\n_any_examples = \"\"\"\\\nExamples\n--------\n**Series**\n\nFor Series input, the output is a scalar indicating whether any element\nis True.\n\n>>> pd.Series([False, False]).any()\nFalse\n>>> pd.Series([True, False]).any()\nTrue\n>>> pd.Series([]).any()\nFalse\n>>> pd.Series([np.nan]).any()\nFalse\n>>> pd.Series([np.nan]).any(skipna=False)\nTrue\n\n**DataFrame**\n\nWhether each column contains at least one True element (the default).\n\n>>> df = pd.DataFrame({\"A\": [1, 2], \"B\": [0, 2], \"C\": [0, 0]})\n>>> df\n A B C\n0 1 0 0\n1 2 2 0\n\n>>> df.any()\nA True\nB True\nC False\ndtype: bool\n\nAggregating over the columns.\n\n>>> df = pd.DataFrame({\"A\": [True, False], \"B\": [1, 2]})\n>>> df\n A B\n0 True 1\n1 False 2\n\n>>> df.any(axis='columns')\n0 True\n1 True\ndtype: bool\n\n>>> df = pd.DataFrame({\"A\": [True, False], \"B\": [1, 0]})\n>>> df\n A B\n0 True 1\n1 False 0\n\n>>> df.any(axis='columns')\n0 True\n1 False\ndtype: bool\n\nAggregating over the entire DataFrame with ``axis=None``.\n\n>>> df.any(axis=None)\nTrue\n\n`any` for an empty DataFrame is an empty Series.\n\n>>> pd.DataFrame([]).any()\nSeries([], dtype: bool)\n\"\"\"\n\n_shared_docs[\n \"stat_func_example\"\n] = \"\"\"\n\nExamples\n--------\n>>> idx = pd.MultiIndex.from_arrays([\n... ['warm', 'warm', 'cold', 'cold'],\n... ['dog', 'falcon', 'fish', 'spider']],\n... names=['blooded', 'animal'])\n>>> s = pd.Series([4, 2, 0, 8], name='legs', index=idx)\n>>> s\nblooded animal\nwarm dog 4\n falcon 2\ncold fish 0\n spider 8\nName: legs, dtype: int64\n\n>>> s.{stat_func}()\n{default_output}\n\n{verb} using level names, as well as indices.\n\n>>> s.{stat_func}(level='blooded')\nblooded\nwarm {level_output_0}\ncold {level_output_1}\nName: legs, dtype: int64\n\n>>> s.{stat_func}(level=0)\nblooded\nwarm {level_output_0}\ncold {level_output_1}\nName: legs, dtype: int64\"\"\"\n\n_sum_examples = _shared_docs[\"stat_func_example\"].format(\n stat_func=\"sum\", verb=\"Sum\", default_output=14, level_output_0=6, level_output_1=8\n)\n\n_sum_examples += \"\"\"\n\nBy default, the sum of an empty or all-NA Series is ``0``.\n\n>>> pd.Series([]).sum() # min_count=0 is the default\n0.0\n\nThis can be controlled with the ``min_count`` parameter. For example, if\nyou'd like the sum of an empty series to be NaN, pass ``min_count=1``.\n\n>>> pd.Series([]).sum(min_count=1)\nnan\n\nThanks to the ``skipna`` parameter, ``min_count`` handles all-NA and\nempty series identically.\n\n>>> pd.Series([np.nan]).sum()\n0.0\n\n>>> pd.Series([np.nan]).sum(min_count=1)\nnan\"\"\"\n\n_max_examples = _shared_docs[\"stat_func_example\"].format(\n stat_func=\"max\", verb=\"Max\", default_output=8, level_output_0=4, level_output_1=8\n)\n\n_min_examples = _shared_docs[\"stat_func_example\"].format(\n stat_func=\"min\", verb=\"Min\", default_output=0, level_output_0=2, level_output_1=0\n)\n\n_stat_func_see_also = \"\"\"\n\nSee Also\n--------\nSeries.sum : Return the sum.\nSeries.min : Return the minimum.\nSeries.max : Return the maximum.\nSeries.idxmin : Return the index of the minimum.\nSeries.idxmax : Return the index of the maximum.\nDataFrame.sum : Return the sum over the requested axis.\nDataFrame.min : Return the minimum over the requested axis.\nDataFrame.max : Return the maximum over the requested axis.\nDataFrame.idxmin : Return the index of the minimum over the requested axis.\nDataFrame.idxmax : Return the index of the maximum over the requested axis.\"\"\"\n\n_prod_examples = \"\"\"\n\nExamples\n--------\nBy default, the product of an empty or all-NA Series is ``1``\n\n>>> pd.Series([]).prod()\n1.0\n\nThis can be controlled with the ``min_count`` parameter\n\n>>> pd.Series([]).prod(min_count=1)\nnan\n\nThanks to the ``skipna`` parameter, ``min_count`` handles all-NA and\nempty series identically.\n\n>>> pd.Series([np.nan]).prod()\n1.0\n\n>>> pd.Series([np.nan]).prod(min_count=1)\nnan\"\"\"\n\n_min_count_stub = \"\"\"\\\nmin_count : int, default 0\n The required number of valid values to perform the operation. If fewer than\n ``min_count`` non-NA values are present the result will be NA.\n\n .. versionadded:: 0.22.0\n\n Added with the default being 0. This means the sum of an all-NA\n or empty Series is 0, and the product of an all-NA or empty\n Series is 1.\n\"\"\"\n\n\ndef _make_min_count_stat_function(\n cls,\n name: str,\n name1: str,\n name2: str,\n axis_descr: str,\n desc: str,\n func: Callable,\n see_also: str = \"\",\n examples: str = \"\",\n) -> Callable:\n @Substitution(\n desc=desc,\n name1=name1,\n name2=name2,\n axis_descr=axis_descr,\n min_count=_min_count_stub,\n see_also=see_also,\n examples=examples,\n )\n @Appender(_num_doc)\n def stat_func(\n self,\n axis=None,\n skipna=None,\n level=None,\n numeric_only=None,\n min_count=0,\n **kwargs,\n ):\n if name == \"sum\":\n nv.validate_sum(tuple(), kwargs)\n elif name == \"prod\":\n nv.validate_prod(tuple(), kwargs)\n else:\n nv.validate_stat_func(tuple(), kwargs, fname=name)\n if skipna is None:\n skipna = True\n if axis is None:\n axis = self._stat_axis_number\n if level is not None:\n return self._agg_by_level(\n name, axis=axis, level=level, skipna=skipna, min_count=min_count\n )\n return self._reduce(\n func,\n name=name,\n axis=axis,\n skipna=skipna,\n numeric_only=numeric_only,\n min_count=min_count,\n )\n\n return set_function_name(stat_func, name, cls)\n\n\ndef _make_stat_function(\n cls,\n name: str,\n name1: str,\n name2: str,\n axis_descr: str,\n desc: str,\n func: Callable,\n see_also: str = \"\",\n examples: str = \"\",\n) -> Callable:\n @Substitution(\n desc=desc,\n name1=name1,\n name2=name2,\n axis_descr=axis_descr,\n min_count=\"\",\n see_also=see_also,\n examples=examples,\n )\n @Appender(_num_doc)\n def stat_func(\n self, axis=None, skipna=None, level=None, numeric_only=None, **kwargs\n ):\n if name == \"median\":\n nv.validate_median(tuple(), kwargs)\n else:\n nv.validate_stat_func(tuple(), kwargs, fname=name)\n if skipna is None:\n skipna = True\n if axis is None:\n axis = self._stat_axis_number\n if level is not None:\n return self._agg_by_level(name, axis=axis, level=level, skipna=skipna)\n return self._reduce(\n func, name=name, axis=axis, skipna=skipna, numeric_only=numeric_only\n )\n\n return set_function_name(stat_func, name, cls)\n\n\ndef _make_stat_function_ddof(\n cls, name: str, name1: str, name2: str, axis_descr: str, desc: str, func: Callable\n) -> Callable:\n @Substitution(desc=desc, name1=name1, name2=name2, axis_descr=axis_descr)\n @Appender(_num_ddof_doc)\n def stat_func(\n self, axis=None, skipna=None, level=None, ddof=1, numeric_only=None, **kwargs\n ):\n nv.validate_stat_ddof_func(tuple(), kwargs, fname=name)\n if skipna is None:\n skipna = True\n if axis is None:\n axis = self._stat_axis_number\n if level is not None:\n return self._agg_by_level(\n name, axis=axis, level=level, skipna=skipna, ddof=ddof\n )\n return self._reduce(\n func, name, axis=axis, numeric_only=numeric_only, skipna=skipna, ddof=ddof\n )\n\n return set_function_name(stat_func, name, cls)\n\n\ndef _make_cum_function(\n cls,\n name: str,\n name1: str,\n name2: str,\n axis_descr: str,\n desc: str,\n accum_func: Callable,\n accum_func_name: str,\n mask_a: float,\n mask_b: float,\n examples: str,\n) -> Callable:\n @Substitution(\n desc=desc,\n name1=name1,\n name2=name2,\n axis_descr=axis_descr,\n accum_func_name=accum_func_name,\n examples=examples,\n )\n @Appender(_cnum_doc)\n def cum_func(self, axis=None, skipna=True, *args, **kwargs):\n skipna = nv.validate_cum_func_with_skipna(skipna, args, kwargs, name)\n if axis is None:\n axis = self._stat_axis_number\n else:\n axis = self._get_axis_number(axis)\n\n if axis == 1:\n return cum_func(self.T, axis=0, skipna=skipna, *args, **kwargs).T\n\n def na_accum_func(blk_values):\n # We will be applying this function to block values\n if blk_values.dtype.kind in [\"m\", \"M\"]:\n # GH#30460, GH#29058\n # numpy 1.18 started sorting NaTs at the end instead of beginning,\n # so we need to work around to maintain backwards-consistency.\n orig_dtype = blk_values.dtype\n\n # We need to define mask before masking NaTs\n mask = isna(blk_values)\n\n if accum_func == np.minimum.accumulate:\n # Note: the accum_func comparison fails as an \"is\" comparison\n y = blk_values.view(\"i8\")\n y[mask] = np.iinfo(np.int64).max\n changed = True\n else:\n y = blk_values\n changed = False\n\n result = accum_func(y.view(\"i8\"), axis)\n if skipna:\n np.putmask(result, mask, iNaT)\n elif accum_func == np.minimum.accumulate:\n # Restore NaTs that we masked previously\n nz = (~np.asarray(mask)).nonzero()[0]\n if len(nz):\n # everything up to the first non-na entry stays NaT\n result[: nz[0]] = iNaT\n\n if changed:\n # restore NaT elements\n y[mask] = iNaT # TODO: could try/finally for this?\n\n if isinstance(blk_values, np.ndarray):\n result = result.view(orig_dtype)\n else:\n # DatetimeArray\n result = type(blk_values)._from_sequence(result, dtype=orig_dtype)\n\n elif skipna and not issubclass(\n blk_values.dtype.type, (np.integer, np.bool_)\n ):\n vals = blk_values.copy().T\n mask = isna(vals)\n np.putmask(vals, mask, mask_a)\n result = accum_func(vals, axis)\n np.putmask(result, mask, mask_b)\n else:\n result = accum_func(blk_values.T, axis)\n\n # transpose back for ndarray, not for EA\n return result.T if hasattr(result, \"T\") else result\n\n result = self._data.apply(na_accum_func)\n\n d = self._construct_axes_dict()\n d[\"copy\"] = False\n return self._constructor(result, **d).__finalize__(self)\n\n return set_function_name(cum_func, name, cls)\n\n\ndef _make_logical_function(\n cls,\n name: str,\n name1: str,\n name2: str,\n axis_descr: str,\n desc: str,\n func: Callable,\n see_also: str,\n examples: str,\n empty_value: bool,\n) -> Callable:\n @Substitution(\n desc=desc,\n name1=name1,\n name2=name2,\n axis_descr=axis_descr,\n see_also=see_also,\n examples=examples,\n empty_value=empty_value,\n )\n @Appender(_bool_doc)\n def logical_func(self, axis=0, bool_only=None, skipna=True, level=None, **kwargs):\n nv.validate_logical_func(tuple(), kwargs, fname=name)\n if level is not None:\n if bool_only is not None:\n raise NotImplementedError(\n \"Option bool_only is not implemented with option level.\"\n )\n return self._agg_by_level(name, axis=axis, level=level, skipna=skipna)\n return self._reduce(\n func,\n name=name,\n axis=axis,\n skipna=skipna,\n numeric_only=bool_only,\n filter_type=\"bool\",\n )\n\n return set_function_name(logical_func, name, cls)\n"
] | [
[
"pandas.io.pickle.to_pickle",
"pandas.io.formats.excel.ExcelFormatter",
"pandas.core.dtypes.common.is_number",
"pandas.core.construction.create_series_with_explicit_dtype",
"pandas.DataFrame",
"pandas.compat.numpy.function.validate_clip_with_axis",
"pandas.core.resample.get_resampler",
"pandas.compat.numpy.function.validate_cum_func_with_skipna",
"pandas.core.common.SettingWithCopyError",
"pandas.core.dtypes.common.pandas_dtype",
"numpy.prod",
"pandas.core.dtypes.common.is_bool",
"pandas.core.dtypes.common.ensure_str",
"pandas.util._decorators.rewrite_axis_style_signature",
"pandas.util._decorators.doc",
"pandas.core.common.count_not_none",
"pandas.core.common.get_rename_function",
"numpy.iinfo",
"numpy.errstate",
"pandas.compat._optional.import_optional_dependency",
"numpy.any",
"pandas.core.resample.asfreq",
"pandas.io.formats.csvs.CSVFormatter",
"pandas.core.missing.find_valid_index",
"pandas.core.indexes.api.ensure_index",
"pandas.concat",
"pandas.core.dtypes.missing.isna",
"pandas.core.dtypes.common.is_re_compilable",
"pandas.core.dtypes.common.is_datetime64tz_dtype",
"pandas.core.indexes.api.Index",
"pandas.core.common.random_state",
"pandas.core.missing.clean_fill_method",
"pandas.core.indexes.api.RangeIndex",
"pandas.core.window.EWM",
"pandas._config.config.is_nonnegative_int",
"numpy.array",
"pandas.io.sql.to_sql",
"pandas.core.ops._align_method_FRAME",
"pandas.core.common.maybe_make_list",
"pandas.core.indexes.datetimes.DatetimeIndex",
"pandas._libs.Timestamp",
"pandas.Series",
"pandas.core.dtypes.common.is_timedelta64_dtype",
"pandas.core.dtypes.common.is_bool_dtype",
"pandas.core.dtypes.common.is_datetime64_any_dtype",
"pandas.core.common.pipe",
"pandas.core.window.Expanding",
"pandas.core.common.apply_if_callable",
"pandas.io.formats.format.format_percentiles",
"pandas.core.dtypes.common.is_dict_like",
"pandas.core.indexes.period.Period",
"pandas.core.dtypes.common.is_object_dtype",
"pandas._libs.lib.item_from_zerodim",
"pandas.util._validators.validate_fillna_kwargs",
"pandas.util._decorators.Substitution",
"pandas.errors.AbstractMethodError",
"pandas.core.common.index_labels_to_array",
"pandas.core.dtypes.common.is_scalar",
"pandas.core.dtypes.common.is_integer",
"pandas.core.algorithms.rank",
"pandas.io.json.to_json",
"pandas.io.formats.format.DataFrameFormatter",
"pandas.core.dtypes.common.ensure_int64",
"pandas.core.dtypes.common.is_list_like",
"numpy.asarray",
"pandas.core.missing.mask_missing",
"pandas.core.missing.get_fill_func",
"pandas._config.config.get_option",
"numpy.abs",
"pandas.core.dtypes.common.is_float",
"pandas.io.pytables.to_hdf",
"pandas.core.dtypes.inference.is_hashable",
"pandas.core.dtypes.missing.notna",
"numpy.putmask",
"pandas.core.dtypes.common.is_extension_array_dtype",
"pandas.util._validators.validate_bool_kwarg",
"pandas.core.window.Rolling",
"pandas.core.tools.datetimes.to_datetime",
"pandas.core.window.Window",
"pandas.util._decorators.Appender",
"pandas.core.computation.parsing.clean_column_name",
"pandas.tseries.frequencies.to_offset",
"numpy.isnan",
"pandas.io.clipboards.to_clipboard",
"pandas.util._validators.validate_percentile",
"pandas.core.dtypes.common.is_numeric_dtype",
"pandas.compat.set_function_name",
"numpy.asanyarray",
"numpy.unique"
]
] |
dajtmullaj/example_conda_pkg | [
"7c2bf657d14c714608e653d7218fa3cd658a6297"
] | [
"example_conda_pkg/descriptors.py"
] | [
"# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Sat Oct 3 21:21:19 2020\n\nProject: chemplot (Chemical Space Visualization)\nContent: Descriptor operation methods\n\n@author: murat cihan sorkun\n\"\"\"\n\nfrom rdkit import Chem\nfrom rdkit.Chem import AllChem\nimport pandas as pd\nimport math\nimport mordred\nfrom mordred import Calculator, descriptors #Dont remove these imports\nfrom sklearn.linear_model import Lasso, LogisticRegression\nfrom sklearn.feature_selection import SelectFromModel\nfrom sklearn.preprocessing import StandardScaler\n\ndef get_mordred_descriptors(smiles_list):\n \"\"\"\n Calculates the Mordred descriptors for given smiles list\n \n :param smiles_list: List of smiles\n :type smiles_list: list\n :returns: The calculated descriptors list for the given smiles\n :rtype: Dataframe\n \"\"\" \n \n return generate_mordred_descriptors(smiles_list, Chem.MolFromSmiles, 'SMILES')\n\n\ndef get_mordred_descriptors_from_inchi(inchi_list):\n \"\"\"\n Calculates the Mordred descriptors for given InChi list\n \n :param inchi_list: List of InChi\n :type inchi_list: list\n :returns: The calculated descriptors list for the given smiles\n :rtype: Dataframe\n \"\"\" \n \n return generate_mordred_descriptors(inchi_list, Chem.MolFromInchi, 'InChi')\n\n \ndef generate_mordred_descriptors(encoding_list, encoding_function, encoding_name):\n \"\"\"\n Calculates the Mordred descriptors for list of molecules encodings\n \n :param smiles_list: List of molecules encodings\n :type smiles_list: list\n :returns: The calculated descriptors list for the given molecules encodings\n :rtype: Dataframe\n \"\"\" \n \n calc = mordred.Calculator() \n \n calc.register(mordred.AtomCount) #16\n calc.register(mordred.RingCount) #139\n calc.register(mordred.BondCount) #9 \n calc.register(mordred.HydrogenBond) #2 \n calc.register(mordred.CarbonTypes) #10\n calc.register(mordred.SLogP) #2\n calc.register(mordred.Constitutional) #16 \n calc.register(mordred.TopoPSA) #2\n calc.register(mordred.Weight) #2\n calc.register(mordred.Polarizability) #2\n calc.register(mordred.McGowanVolume) #1\n \n name_list=[]\n for desc_name in calc.descriptors:\n name_list.append(str(desc_name))\n \n descriptors_list=[] \n erroneous_encodings=[]\n encodings_none_descriptors=[]\n for encoding in encoding_list:\n mol=encoding_function(encoding)\n if mol is None:\n descriptors_list.append([None]*len(name_list))\n erroneous_encodings.append(encoding)\n else:\n mol=Chem.AddHs(mol)\n calculated_descriptors = calc(mol)\n for i in range(len(calculated_descriptors._values)):\n if math.isnan(calculated_descriptors._values[i]):\n calculated_descriptors._values = [None]*len(name_list)\n encodings_none_descriptors.append(encoding)\n break\n descriptors_list.append(calculated_descriptors._values) \n \n if len(erroneous_encodings)>0:\n print(\"The following erroneous {} have been found in the data:\\n{}.\\nThe erroneous {} will be removed from the data.\".format(encoding_name, '\\n'.join(map(str, erroneous_encodings)), encoding_name))\n\n if len(encodings_none_descriptors)>0:\n print(\"For the following {} not all descriptors can be computed:\\n{}.\\nThese {} will be removed from the data.\".format(encoding_name, '\\n'.join(map(str, encodings_none_descriptors)), encoding_name))\n \n df_descriptors=pd.DataFrame(descriptors_list,columns=name_list)\n df_descriptors = df_descriptors.select_dtypes(exclude=['object']) \n return df_descriptors\n \ndef select_descriptors_lasso(df_descriptors,target_list, R_select=0.05, C_select=0.05, kind=\"R\"):\n \"\"\"\n Selects descriptors by LASSO \n \n :param df_descriptors: descriptors of molecules \n :type df_descriptors: Dataframe\n :param target_list: list of target values \n :type target_list: list\n :param R_select: alpha value for Lasso \n :type R_select: float\n :param C_select: C value for LogisticRegression \n :type C_select: float\n :param kind: kind of target R->Regression C->Classification \n :type kind: string\n :returns: The selected descriptors\n :rtype: Dataframe\n \"\"\" \n \n # Remove erroneous data\n df_descriptors = df_descriptors.assign(target=target_list.values)\n df_descriptors = df_descriptors.dropna(how='any')\n target_list = df_descriptors['target'].to_list()\n df_descriptors = df_descriptors.drop(columns=['target'])\n \n df_descriptors_scaled = StandardScaler().fit_transform(df_descriptors)\n \n if(kind==\"C\"): \n model = LogisticRegression(C=C_select,penalty='l1', solver='liblinear',random_state=1).fit(df_descriptors_scaled, target_list)\n else:\n model = Lasso(alpha=R_select,max_iter=10000,random_state=1).fit(df_descriptors_scaled, target_list)\n \n \n selected = SelectFromModel(model, prefit=True)\n X_new_lasso = selected.transform(df_descriptors)\n # Get back the kept features as a DataFrame with dropped columns as all 0s\n selected_features = pd.DataFrame(selected.inverse_transform(X_new_lasso), index=df_descriptors.index, columns=df_descriptors.columns)\n # Dropped columns have values of all 0s, keep other columns \n selected_columns_lasso = selected_features.columns[selected_features.var() != 0] \n selected_data = df_descriptors[selected_columns_lasso] \n \n return selected_data, target_list\n\n\ndef get_ecfp(smiles_list, target_list, radius=2, nBits=2048):\n \"\"\"\n Calculates the ECFP fingerprint for given SMILES list\n \n :param smiles_list: List of SMILES\n :type smiles_list: list\n :param radius: The ECPF fingerprints radius.\n :type radius: int\n :param nBits: The number of bits of the fingerprint vector.\n :type nBits: int\n :returns: The calculated ECPF fingerprints for the given SMILES\n :rtype: Dataframe\n \"\"\" \n \n return generate_ecfp(smiles_list, Chem.MolFromSmiles, 'SMILES', target_list, radius=2, nBits=2048)\n\n\ndef get_ecfp_from_inchi(inchi_list, target_list, radius=2, nBits=2048):\n \"\"\"\n Calculates the ECFP fingerprint for given InChi list\n \n :param inchi_list: List of InChi\n :type inchi_list: list\n :param radius: The ECPF fingerprints radius.\n :type radius: int\n :param nBits: The number of bits of the fingerprint vector.\n :type nBits: int\n :returns: The calculated ECPF fingerprints for the given InChi\n :rtype: Dataframe\n \"\"\" \n \n return generate_ecfp(inchi_list, Chem.MolFromInchi, 'InChi', target_list, radius=2, nBits=2048)\n\n\ndef generate_ecfp(encoding_list, encoding_function, encoding_name, target_list, radius=2, nBits=2048):\n \"\"\"\n Calculates the ECFP fingerprint for given list of molecules encodings\n \n :param encoding_list: List of molecules encodings\n :type encoding_list: list\n :param encoding_function: Function used to extract the molecules from the encodings\n :type encoding_function: fun\n :param radius: The ECPF fingerprints radius.\n :type radius: int\n :param nBits: The number of bits of the fingerprint vector.\n :type nBits: int\n :returns: The calculated ECPF fingerprints for the given molecules encodings\n :rtype: Dataframe\n \"\"\" \n \n # Generate ECFP fingerprints\n ecfp_fingerprints=[]\n erroneous_encodings=[]\n for encoding in encoding_list:\n mol=encoding_function(encoding)\n if mol is None:\n ecfp_fingerprints.append([None]*nBits)\n erroneous_encodings.append(encoding)\n else:\n mol=Chem.AddHs(mol)\n list_bits_fingerprint = []\n list_bits_fingerprint[:0] = AllChem.GetMorganFingerprintAsBitVect(mol, radius, nBits).ToBitString()\n ecfp_fingerprints.append(list_bits_fingerprint) \n \n # Create dataframe of fingerprints\n df_ecfp_fingerprints = pd.DataFrame(data = ecfp_fingerprints, index = encoding_list)\n # Remove erroneous data\n if len(erroneous_encodings)>0:\n print(\"The following erroneous {} have been found in the data:\\n{}.\\nThe erroneous {} will be removed from the data.\".format(encoding_name, '\\n'.join(map(str, erroneous_encodings)), encoding_name))\n \n if len(target_list)>0:\n df_ecfp_fingerprints = df_ecfp_fingerprints.assign(target=target_list.values)\n \n df_ecfp_fingerprints = df_ecfp_fingerprints.dropna(how='any')\n \n if len(target_list)>0:\n target_list = df_ecfp_fingerprints['target'].to_list()\n df_ecfp_fingerprints = df_ecfp_fingerprints.drop(columns=['target'])\n \n # Remove bit columns with no variablity (all \"0\" or all \"1\")\n df_ecfp_fingerprints = df_ecfp_fingerprints.loc[:, (df_ecfp_fingerprints != 0).any(axis=0)]\n df_ecfp_fingerprints = df_ecfp_fingerprints.loc[:, (df_ecfp_fingerprints != 1).any(axis=0)]\n \n return df_ecfp_fingerprints, target_list"
] | [
[
"sklearn.linear_model.Lasso",
"sklearn.preprocessing.StandardScaler",
"sklearn.feature_selection.SelectFromModel",
"pandas.DataFrame",
"sklearn.linear_model.LogisticRegression"
]
] |
pmarshwx/matplotlib | [
"12be528dbf2114f7c25abf60de8100cb2d4494af",
"12be528dbf2114f7c25abf60de8100cb2d4494af"
] | [
"lib/matplotlib/backends/qt_compat.py",
"lib/matplotlib/transforms.py"
] | [
"\"\"\" A Qt API selector that can be used to switch between PyQt and PySide.\n\"\"\"\nfrom __future__ import (absolute_import, division, print_function,\n unicode_literals)\n\nimport six\n\nimport os\nfrom matplotlib import rcParams, verbose\n\n# Available APIs.\nQT_API_PYQT = 'PyQt4' # API is not set here; Python 2.x default is V 1\nQT_API_PYQTv2 = 'PyQt4v2' # forced to Version 2 API\nQT_API_PYSIDE = 'PySide' # only supports Version 2 API\nQT_API_PYQT5 = 'PyQt5' # use PyQt5 API; Version 2 with module shim\n\nETS = dict(pyqt=(QT_API_PYQTv2, 4), pyside=(QT_API_PYSIDE, 4),\n pyqt5=(QT_API_PYQT5, 5))\n# ETS is a dict of env variable to (QT_API, QT_MAJOR_VERSION)\n# If the ETS QT_API environment variable is set, use it, but only\n# if the varible if of the same major QT version. Note that\n# ETS requires the version 2 of PyQt4, which is not the platform\n# default for Python 2.x.\n\nQT_API_ENV = os.environ.get('QT_API')\n\nif rcParams['backend'] == 'Qt5Agg':\n QT_RC_MAJOR_VERSION = 5\nelse:\n QT_RC_MAJOR_VERSION = 4\n\nQT_API = None\n\nif (QT_API_ENV is not None):\n try:\n QT_ENV_MAJOR_VERSION = ETS[QT_API_ENV][1]\n except KeyError:\n raise RuntimeError(\n ('Unrecognized environment variable %r, valid values are:'\n ' %r, %r or %r' % (QT_API_ENV, 'pyqt', 'pyside', 'pyqt5')))\n if QT_ENV_MAJOR_VERSION == QT_RC_MAJOR_VERSION:\n # Only if backend and env qt major version are\n # compatible use the env variable.\n QT_API = ETS[QT_API_ENV][0]\n\nif QT_API is None:\n # No ETS environment or incompatible so use rcParams.\n if rcParams['backend'] == 'Qt5Agg':\n QT_API = rcParams['backend.qt5']\n else:\n QT_API = rcParams['backend.qt4']\n\n# We will define an appropriate wrapper for the differing versions\n# of file dialog.\n_getSaveFileName = None\n\n# Flag to check if sip could be imported\n_sip_imported = False\n\n# Now perform the imports.\nif QT_API in (QT_API_PYQT, QT_API_PYQTv2, QT_API_PYQT5):\n try:\n import sip\n _sip_imported = True\n except ImportError:\n # Try using PySide\n QT_API = QT_API_PYSIDE\n cond = (\"Could not import sip; falling back on PySide\\n\"\n \"in place of PyQt4 or PyQt5.\\n\")\n verbose.report(cond, 'helpful')\n\nif _sip_imported:\n if QT_API == QT_API_PYQTv2:\n if QT_API_ENV == 'pyqt':\n cond = (\"Found 'QT_API=pyqt' environment variable. \"\n \"Setting PyQt4 API accordingly.\\n\")\n else:\n cond = \"PyQt API v2 specified.\"\n try:\n sip.setapi('QString', 2)\n except:\n res = 'QString API v2 specification failed. Defaulting to v1.'\n verbose.report(cond + res, 'helpful')\n # condition has now been reported, no need to repeat it:\n cond = \"\"\n try:\n sip.setapi('QVariant', 2)\n except:\n res = 'QVariant API v2 specification failed. Defaulting to v1.'\n verbose.report(cond + res, 'helpful')\n\n if QT_API in [QT_API_PYQT, QT_API_PYQTv2]: # PyQt4 API\n\n from PyQt4 import QtCore, QtGui\n\n try:\n if sip.getapi(\"QString\") > 1:\n # Use new getSaveFileNameAndFilter()\n _getSaveFileName = QtGui.QFileDialog.getSaveFileNameAndFilter\n else:\n\n # Use old getSaveFileName()\n def _getSaveFileName(*args, **kwargs):\n return (QtGui.QFileDialog.getSaveFileName(*args, **kwargs),\n None)\n\n except (AttributeError, KeyError):\n\n # call to getapi() can fail in older versions of sip\n def _getSaveFileName(*args, **kwargs):\n return QtGui.QFileDialog.getSaveFileName(*args, **kwargs), None\n\n else: # PyQt5 API\n from PyQt5 import QtCore, QtGui, QtWidgets\n _getSaveFileName = QtWidgets.QFileDialog.getSaveFileName\n\n # Alias PyQt-specific functions for PySide compatibility.\n QtCore.Signal = QtCore.pyqtSignal\n try:\n QtCore.Slot = QtCore.pyqtSlot\n except AttributeError:\n # Not a perfect match but works in simple cases\n QtCore.Slot = QtCore.pyqtSignature\n\n QtCore.Property = QtCore.pyqtProperty\n __version__ = QtCore.PYQT_VERSION_STR\n\nelse: # try importing pyside\n try:\n from PySide import QtCore, QtGui, __version__, __version_info__\n except ImportError:\n raise ImportError(\n \"Matplotlib qt-based backends require an external PyQt4, PyQt5,\\n\"\n \"or PySide package to be installed, but it was not found.\")\n\n if __version_info__ < (1, 0, 3):\n raise ImportError(\n \"Matplotlib backend_qt4 and backend_qt4agg require PySide >=1.0.3\")\n\n _getSaveFileName = QtGui.QFileDialog.getSaveFileName\n\n\n# Apply shim to Qt4 APIs to make them look like Qt5\nif QT_API in (QT_API_PYQT, QT_API_PYQTv2, QT_API_PYSIDE):\n '''Import all used QtGui objects into QtWidgets\n\n Here I've opted to simple copy QtGui into QtWidgets as that\n achieves the same result as copying over the objects, and will\n continue to work if other objects are used.\n\n '''\n QtWidgets = QtGui\n",
"\"\"\"\nmatplotlib includes a framework for arbitrary geometric\ntransformations that is used determine the final position of all\nelements drawn on the canvas.\n\nTransforms are composed into trees of :class:`TransformNode` objects\nwhose actual value depends on their children. When the contents of\nchildren change, their parents are automatically invalidated. The\nnext time an invalidated transform is accessed, it is recomputed to\nreflect those changes. This invalidation/caching approach prevents\nunnecessary recomputations of transforms, and contributes to better\ninteractive performance.\n\nFor example, here is a graph of the transform tree used to plot data\nto the graph:\n\n.. image:: ../_static/transforms.png\n\nThe framework can be used for both affine and non-affine\ntransformations. However, for speed, we want use the backend\nrenderers to perform affine transformations whenever possible.\nTherefore, it is possible to perform just the affine or non-affine\npart of a transformation on a set of data. The affine is always\nassumed to occur after the non-affine. For any transform::\n\n full transform == non-affine part + affine part\n\nThe backends are not expected to handle non-affine transformations\nthemselves.\n\"\"\"\n\nfrom __future__ import (absolute_import, division, print_function,\n unicode_literals)\n\nimport six\n\nimport numpy as np\nfrom numpy import ma\nfrom matplotlib._path import (affine_transform, count_bboxes_overlapping_bbox,\n update_path_extents)\nfrom numpy.linalg import inv\n\nfrom weakref import WeakValueDictionary\nimport warnings\ntry:\n set\nexcept NameError:\n from sets import Set as set\n\nfrom .path import Path\n\nDEBUG = False\n\nMaskedArray = ma.MaskedArray\n\n\nclass TransformNode(object):\n \"\"\"\n :class:`TransformNode` is the base class for anything that\n participates in the transform tree and needs to invalidate its\n parents or be invalidated. This includes classes that are not\n really transforms, such as bounding boxes, since some transforms\n depend on bounding boxes to compute their values.\n \"\"\"\n _gid = 0\n\n # Invalidation may affect only the affine part. If the\n # invalidation was \"affine-only\", the _invalid member is set to\n # INVALID_AFFINE_ONLY\n INVALID_NON_AFFINE = 1\n INVALID_AFFINE = 2\n INVALID = INVALID_NON_AFFINE | INVALID_AFFINE\n\n # Some metadata about the transform, used to determine whether an\n # invalidation is affine-only\n is_affine = False\n is_bbox = False\n\n pass_through = False\n \"\"\"\n If pass_through is True, all ancestors will always be\n invalidated, even if 'self' is already invalid.\n \"\"\"\n\n def __init__(self, shorthand_name=None):\n \"\"\"\n Creates a new :class:`TransformNode`.\n\n **shorthand_name** - a string representing the \"name\" of this\n transform. The name carries no significance\n other than to improve the readability of\n ``str(transform)`` when DEBUG=True.\n \"\"\"\n # Parents are stored in a WeakValueDictionary, so that if the\n # parents are deleted, references from the children won't keep\n # them alive.\n self._parents = WeakValueDictionary()\n\n # TransformNodes start out as invalid until their values are\n # computed for the first time.\n self._invalid = 1\n self._shorthand_name = shorthand_name or ''\n\n if DEBUG:\n def __str__(self):\n # either just return the name of this TransformNode, or it's repr\n return self._shorthand_name or repr(self)\n\n def __getstate__(self):\n d = self.__dict__.copy()\n # turn the weakkey dictionary into a normal dictionary\n d['_parents'] = dict(six.iteritems(self._parents))\n return d\n\n def __setstate__(self, data_dict):\n self.__dict__ = data_dict\n # turn the normal dictionary back into a WeakValueDictionary\n self._parents = WeakValueDictionary(self._parents)\n\n def __copy__(self, *args):\n raise NotImplementedError(\n \"TransformNode instances can not be copied. \" +\n \"Consider using frozen() instead.\")\n __deepcopy__ = __copy__\n\n def invalidate(self):\n \"\"\"\n Invalidate this :class:`TransformNode` and triggers an\n invalidation of its ancestors. Should be called any\n time the transform changes.\n \"\"\"\n value = self.INVALID\n if self.is_affine:\n value = self.INVALID_AFFINE\n return self._invalidate_internal(value, invalidating_node=self)\n\n def _invalidate_internal(self, value, invalidating_node):\n \"\"\"\n Called by :meth:`invalidate` and subsequently ascends the transform\n stack calling each TransformNode's _invalidate_internal method.\n \"\"\"\n # determine if this call will be an extension to the invalidation\n # status. If not, then a shortcut means that we needn't invoke an\n # invalidation up the transform stack as it will already have been\n # invalidated.\n\n # N.B This makes the invalidation sticky, once a transform has been\n # invalidated as NON_AFFINE, then it will always be invalidated as\n # NON_AFFINE even when triggered with a AFFINE_ONLY invalidation.\n # In most cases this is not a problem (i.e. for interactive panning and\n # zooming) and the only side effect will be on performance.\n status_changed = self._invalid < value\n\n if self.pass_through or status_changed:\n self._invalid = value\n\n for parent in list(six.itervalues(self._parents)):\n parent._invalidate_internal(value=value,\n invalidating_node=self)\n\n def set_children(self, *children):\n \"\"\"\n Set the children of the transform, to let the invalidation\n system know which transforms can invalidate this transform.\n Should be called from the constructor of any transforms that\n depend on other transforms.\n \"\"\"\n for child in children:\n child._parents[id(self)] = self\n\n if DEBUG:\n _set_children = set_children\n\n def set_children(self, *children):\n self._set_children(*children)\n self._children = children\n set_children.__doc__ = _set_children.__doc__\n\n def frozen(self):\n \"\"\"\n Returns a frozen copy of this transform node. The frozen copy\n will not update when its children change. Useful for storing\n a previously known state of a transform where\n ``copy.deepcopy()`` might normally be used.\n \"\"\"\n return self\n\n if DEBUG:\n def write_graphviz(self, fobj, highlight=[]):\n \"\"\"\n For debugging purposes.\n\n Writes the transform tree rooted at 'self' to a graphviz \"dot\"\n format file. This file can be run through the \"dot\" utility\n to produce a graph of the transform tree.\n\n Affine transforms are marked in blue. Bounding boxes are\n marked in yellow.\n\n *fobj*: A Python file-like object\n\n Once the \"dot\" file has been created, it can be turned into a\n png easily with::\n\n $> dot -Tpng -o $OUTPUT_FILE $DOT_FILE\n\n \"\"\"\n seen = set()\n\n def recurse(root):\n if root in seen:\n return\n seen.add(root)\n props = {}\n label = root.__class__.__name__\n if root._invalid:\n label = '[%s]' % label\n if root in highlight:\n props['style'] = 'bold'\n props['shape'] = 'box'\n props['label'] = '\"%s\"' % label\n props = ' '.join(['%s=%s' % (key, val)\n for key, val\n in six.iteritems(props)])\n\n fobj.write('%s [%s];\\n' %\n (hash(root), props))\n\n if hasattr(root, '_children'):\n for child in root._children:\n name = '?'\n for key, val in six.iteritems(root.__dict__):\n if val is child:\n name = key\n break\n fobj.write('\"%s\" -> \"%s\" [label=\"%s\", fontsize=10];\\n'\n % (hash(root),\n hash(child),\n name))\n recurse(child)\n\n fobj.write(\"digraph G {\\n\")\n recurse(self)\n fobj.write(\"}\\n\")\n\n\nclass BboxBase(TransformNode):\n \"\"\"\n This is the base class of all bounding boxes, and provides\n read-only access to its data. A mutable bounding box is provided\n by the :class:`Bbox` class.\n\n The canonical representation is as two points, with no\n restrictions on their ordering. Convenience properties are\n provided to get the left, bottom, right and top edges and width\n and height, but these are not stored explicitly.\n \"\"\"\n is_bbox = True\n is_affine = True\n\n #* Redundant: Removed for performance\n #\n # def __init__(self):\n # TransformNode.__init__(self)\n\n if DEBUG:\n def _check(points):\n if ma.isMaskedArray(points):\n warnings.warn(\"Bbox bounds are a masked array.\")\n points = np.asarray(points)\n if (points[1, 0] - points[0, 0] == 0 or\n points[1, 1] - points[0, 1] == 0):\n warnings.warn(\"Singular Bbox.\")\n _check = staticmethod(_check)\n\n def frozen(self):\n return Bbox(self.get_points().copy())\n frozen.__doc__ = TransformNode.__doc__\n\n def __array__(self, *args, **kwargs):\n return self.get_points()\n\n def is_unit(self):\n \"\"\"\n Returns True if the :class:`Bbox` is the unit bounding box\n from (0, 0) to (1, 1).\n \"\"\"\n return list(self.get_points().flatten()) == [0., 0., 1., 1.]\n\n def _get_x0(self):\n return self.get_points()[0, 0]\n x0 = property(_get_x0, None, None, \"\"\"\n (property) :attr:`x0` is the first of the pair of *x* coordinates that\n define the bounding box. :attr:`x0` is not guaranteed to be\n less than :attr:`x1`. If you require that, use :attr:`xmin`.\"\"\")\n\n def _get_y0(self):\n return self.get_points()[0, 1]\n y0 = property(_get_y0, None, None, \"\"\"\n (property) :attr:`y0` is the first of the pair of *y* coordinates that\n define the bounding box. :attr:`y0` is not guaranteed to be\n less than :attr:`y1`. If you require that, use :attr:`ymin`.\"\"\")\n\n def _get_x1(self):\n return self.get_points()[1, 0]\n x1 = property(_get_x1, None, None, \"\"\"\n (property) :attr:`x1` is the second of the pair of *x* coordinates\n that define the bounding box. :attr:`x1` is not guaranteed to be\n greater than :attr:`x0`. If you require that, use :attr:`xmax`.\"\"\")\n\n def _get_y1(self):\n return self.get_points()[1, 1]\n y1 = property(_get_y1, None, None, \"\"\"\n (property) :attr:`y1` is the second of the pair of *y* coordinates\n that define the bounding box. :attr:`y1` is not guaranteed to be\n greater than :attr:`y0`. If you require that, use :attr:`ymax`.\"\"\")\n\n def _get_p0(self):\n return self.get_points()[0]\n p0 = property(_get_p0, None, None, \"\"\"\n (property) :attr:`p0` is the first pair of (*x*, *y*) coordinates\n that define the bounding box. It is not guaranteed to be the\n bottom-left corner. For that, use :attr:`min`.\"\"\")\n\n def _get_p1(self):\n return self.get_points()[1]\n p1 = property(_get_p1, None, None, \"\"\"\n (property) :attr:`p1` is the second pair of (*x*, *y*) coordinates\n that define the bounding box. It is not guaranteed to be the\n top-right corner. For that, use :attr:`max`.\"\"\")\n\n def _get_xmin(self):\n return min(self.get_points()[:, 0])\n xmin = property(_get_xmin, None, None, \"\"\"\n (property) :attr:`xmin` is the left edge of the bounding box.\"\"\")\n\n def _get_ymin(self):\n return min(self.get_points()[:, 1])\n ymin = property(_get_ymin, None, None, \"\"\"\n (property) :attr:`ymin` is the bottom edge of the bounding box.\"\"\")\n\n def _get_xmax(self):\n return max(self.get_points()[:, 0])\n xmax = property(_get_xmax, None, None, \"\"\"\n (property) :attr:`xmax` is the right edge of the bounding box.\"\"\")\n\n def _get_ymax(self):\n return max(self.get_points()[:, 1])\n ymax = property(_get_ymax, None, None, \"\"\"\n (property) :attr:`ymax` is the top edge of the bounding box.\"\"\")\n\n def _get_min(self):\n return [min(self.get_points()[:, 0]),\n min(self.get_points()[:, 1])]\n min = property(_get_min, None, None, \"\"\"\n (property) :attr:`min` is the bottom-left corner of the bounding\n box.\"\"\")\n\n def _get_max(self):\n return [max(self.get_points()[:, 0]),\n max(self.get_points()[:, 1])]\n max = property(_get_max, None, None, \"\"\"\n (property) :attr:`max` is the top-right corner of the bounding box.\"\"\")\n\n def _get_intervalx(self):\n return self.get_points()[:, 0]\n intervalx = property(_get_intervalx, None, None, \"\"\"\n (property) :attr:`intervalx` is the pair of *x* coordinates that define\n the bounding box. It is not guaranteed to be sorted from left to\n right.\"\"\")\n\n def _get_intervaly(self):\n return self.get_points()[:, 1]\n intervaly = property(_get_intervaly, None, None, \"\"\"\n (property) :attr:`intervaly` is the pair of *y* coordinates that define\n the bounding box. It is not guaranteed to be sorted from bottom to\n top.\"\"\")\n\n def _get_width(self):\n points = self.get_points()\n return points[1, 0] - points[0, 0]\n width = property(_get_width, None, None, \"\"\"\n (property) The width of the bounding box. It may be negative if\n :attr:`x1` < :attr:`x0`.\"\"\")\n\n def _get_height(self):\n points = self.get_points()\n return points[1, 1] - points[0, 1]\n height = property(_get_height, None, None, \"\"\"\n (property) The height of the bounding box. It may be negative if\n :attr:`y1` < :attr:`y0`.\"\"\")\n\n def _get_size(self):\n points = self.get_points()\n return points[1] - points[0]\n size = property(_get_size, None, None, \"\"\"\n (property) The width and height of the bounding box. May be negative,\n in the same way as :attr:`width` and :attr:`height`.\"\"\")\n\n def _get_bounds(self):\n x0, y0, x1, y1 = self.get_points().flatten()\n return (x0, y0, x1 - x0, y1 - y0)\n bounds = property(_get_bounds, None, None, \"\"\"\n (property) Returns (:attr:`x0`, :attr:`y0`, :attr:`width`,\n :attr:`height`).\"\"\")\n\n def _get_extents(self):\n return self.get_points().flatten().copy()\n extents = property(_get_extents, None, None, \"\"\"\n (property) Returns (:attr:`x0`, :attr:`y0`, :attr:`x1`,\n :attr:`y1`).\"\"\")\n\n def get_points(self):\n return NotImplementedError()\n\n def containsx(self, x):\n \"\"\"\n Returns True if *x* is between or equal to :attr:`x0` and\n :attr:`x1`.\n \"\"\"\n x0, x1 = self.intervalx\n return ((x0 < x1\n and (x >= x0 and x <= x1))\n or (x >= x1 and x <= x0))\n\n def containsy(self, y):\n \"\"\"\n Returns True if *y* is between or equal to :attr:`y0` and\n :attr:`y1`.\n \"\"\"\n y0, y1 = self.intervaly\n return ((y0 < y1\n and (y >= y0 and y <= y1))\n or (y >= y1 and y <= y0))\n\n def contains(self, x, y):\n \"\"\"\n Returns *True* if (*x*, *y*) is a coordinate inside the\n bounding box or on its edge.\n \"\"\"\n return self.containsx(x) and self.containsy(y)\n\n def overlaps(self, other):\n \"\"\"\n Returns True if this bounding box overlaps with the given\n bounding box *other*.\n \"\"\"\n ax1, ay1, ax2, ay2 = self._get_extents()\n bx1, by1, bx2, by2 = other._get_extents()\n if any(np.isnan(v) for v in [ax1, ay1, ax2, ay2, bx1, by1, bx2, by2]):\n return False\n\n if ax2 < ax1:\n ax2, ax1 = ax1, ax2\n if ay2 < ay1:\n ay2, ay1 = ay1, ay2\n if bx2 < bx1:\n bx2, bx1 = bx1, bx2\n if by2 < by1:\n by2, by1 = by1, by2\n\n return not ((bx2 < ax1) or\n (by2 < ay1) or\n (bx1 > ax2) or\n (by1 > ay2))\n\n def fully_containsx(self, x):\n \"\"\"\n Returns True if *x* is between but not equal to :attr:`x0` and\n :attr:`x1`.\n \"\"\"\n x0, x1 = self.intervalx\n return ((x0 < x1\n and (x > x0 and x < x1))\n or (x > x1 and x < x0))\n\n def fully_containsy(self, y):\n \"\"\"\n Returns True if *y* is between but not equal to :attr:`y0` and\n :attr:`y1`.\n \"\"\"\n y0, y1 = self.intervaly\n return ((y0 < y1\n and (y > y0 and y < y1))\n or (y > y1 and y < y0))\n\n def fully_contains(self, x, y):\n \"\"\"\n Returns True if (*x*, *y*) is a coordinate inside the bounding\n box, but not on its edge.\n \"\"\"\n return self.fully_containsx(x) \\\n and self.fully_containsy(y)\n\n def fully_overlaps(self, other):\n \"\"\"\n Returns True if this bounding box overlaps with the given\n bounding box *other*, but not on its edge alone.\n \"\"\"\n ax1, ay1, ax2, ay2 = self._get_extents()\n bx1, by1, bx2, by2 = other._get_extents()\n\n if ax2 < ax1:\n ax2, ax1 = ax1, ax2\n if ay2 < ay1:\n ay2, ay1 = ay1, ay2\n if bx2 < bx1:\n bx2, bx1 = bx1, bx2\n if by2 < by1:\n by2, by1 = by1, by2\n\n return not ((bx2 <= ax1) or\n (by2 <= ay1) or\n (bx1 >= ax2) or\n (by1 >= ay2))\n\n def transformed(self, transform):\n \"\"\"\n Return a new :class:`Bbox` object, statically transformed by\n the given transform.\n \"\"\"\n pts = self.get_points()\n ll, ul, lr = transform.transform(np.array([pts[0],\n [pts[0, 0], pts[1, 1]], [pts[1, 0], pts[0, 1]]]))\n return Bbox([ll, [lr[0], ul[1]]])\n\n def inverse_transformed(self, transform):\n \"\"\"\n Return a new :class:`Bbox` object, statically transformed by\n the inverse of the given transform.\n \"\"\"\n return self.transformed(transform.inverted())\n\n coefs = {'C': (0.5, 0.5),\n 'SW': (0, 0),\n 'S': (0.5, 0),\n 'SE': (1.0, 0),\n 'E': (1.0, 0.5),\n 'NE': (1.0, 1.0),\n 'N': (0.5, 1.0),\n 'NW': (0, 1.0),\n 'W': (0, 0.5)}\n\n def anchored(self, c, container=None):\n \"\"\"\n Return a copy of the :class:`Bbox`, shifted to position *c*\n within a container.\n\n *c*: may be either:\n\n * a sequence (*cx*, *cy*) where *cx* and *cy* range from 0\n to 1, where 0 is left or bottom and 1 is right or top\n\n * a string:\n - 'C' for centered\n - 'S' for bottom-center\n - 'SE' for bottom-left\n - 'E' for left\n - etc.\n\n Optional argument *container* is the box within which the\n :class:`Bbox` is positioned; it defaults to the initial\n :class:`Bbox`.\n \"\"\"\n if container is None:\n container = self\n l, b, w, h = container.bounds\n if isinstance(c, six.string_types):\n cx, cy = self.coefs[c]\n else:\n cx, cy = c\n L, B, W, H = self.bounds\n return Bbox(self._points +\n [(l + cx * (w - W)) - L,\n (b + cy * (h - H)) - B])\n\n def shrunk(self, mx, my):\n \"\"\"\n Return a copy of the :class:`Bbox`, shrunk by the factor *mx*\n in the *x* direction and the factor *my* in the *y* direction.\n The lower left corner of the box remains unchanged. Normally\n *mx* and *my* will be less than 1, but this is not enforced.\n \"\"\"\n w, h = self.size\n return Bbox([self._points[0],\n self._points[0] + [mx * w, my * h]])\n\n def shrunk_to_aspect(self, box_aspect, container=None, fig_aspect=1.0):\n \"\"\"\n Return a copy of the :class:`Bbox`, shrunk so that it is as\n large as it can be while having the desired aspect ratio,\n *box_aspect*. If the box coordinates are relative---that\n is, fractions of a larger box such as a figure---then the\n physical aspect ratio of that figure is specified with\n *fig_aspect*, so that *box_aspect* can also be given as a\n ratio of the absolute dimensions, not the relative dimensions.\n \"\"\"\n if box_aspect <= 0 or fig_aspect <= 0:\n raise ValueError(\"'box_aspect' and 'fig_aspect' must be positive\")\n if container is None:\n container = self\n w, h = container.size\n H = w * box_aspect / fig_aspect\n if H <= h:\n W = w\n else:\n W = h * fig_aspect / box_aspect\n H = h\n return Bbox([self._points[0],\n self._points[0] + (W, H)])\n\n def splitx(self, *args):\n \"\"\"\n e.g., ``bbox.splitx(f1, f2, ...)``\n\n Returns a list of new :class:`Bbox` objects formed by\n splitting the original one with vertical lines at fractional\n positions *f1*, *f2*, ...\n \"\"\"\n boxes = []\n xf = [0] + list(args) + [1]\n x0, y0, x1, y1 = self._get_extents()\n w = x1 - x0\n for xf0, xf1 in zip(xf[:-1], xf[1:]):\n boxes.append(Bbox([[x0 + xf0 * w, y0], [x0 + xf1 * w, y1]]))\n return boxes\n\n def splity(self, *args):\n \"\"\"\n e.g., ``bbox.splitx(f1, f2, ...)``\n\n Returns a list of new :class:`Bbox` objects formed by\n splitting the original one with horizontal lines at fractional\n positions *f1*, *f2*, ...\n \"\"\"\n boxes = []\n yf = [0] + list(args) + [1]\n x0, y0, x1, y1 = self._get_extents()\n h = y1 - y0\n for yf0, yf1 in zip(yf[:-1], yf[1:]):\n boxes.append(Bbox([[x0, y0 + yf0 * h], [x1, y0 + yf1 * h]]))\n return boxes\n\n def count_contains(self, vertices):\n \"\"\"\n Count the number of vertices contained in the :class:`Bbox`.\n\n *vertices* is a Nx2 Numpy array.\n \"\"\"\n if len(vertices) == 0:\n return 0\n vertices = np.asarray(vertices)\n x0, y0, x1, y1 = self._get_extents()\n with np.errstate(invalid='ignore'):\n dx0 = np.sign(vertices[:, 0] - x0)\n dy0 = np.sign(vertices[:, 1] - y0)\n dx1 = np.sign(vertices[:, 0] - x1)\n dy1 = np.sign(vertices[:, 1] - y1)\n inside = ((abs(dx0 + dx1) + abs(dy0 + dy1)) == 0)\n return np.sum(inside)\n\n def count_overlaps(self, bboxes):\n \"\"\"\n Count the number of bounding boxes that overlap this one.\n\n bboxes is a sequence of :class:`BboxBase` objects\n \"\"\"\n return count_bboxes_overlapping_bbox(self, [np.array(x) for x in bboxes])\n\n def expanded(self, sw, sh):\n \"\"\"\n Return a new :class:`Bbox` which is this :class:`Bbox`\n expanded around its center by the given factors *sw* and\n *sh*.\n \"\"\"\n width = self.width\n height = self.height\n deltaw = (sw * width - width) / 2.0\n deltah = (sh * height - height) / 2.0\n a = np.array([[-deltaw, -deltah], [deltaw, deltah]])\n return Bbox(self._points + a)\n\n def padded(self, p):\n \"\"\"\n Return a new :class:`Bbox` that is padded on all four sides by\n the given value.\n \"\"\"\n points = self.get_points()\n return Bbox(points + [[-p, -p], [p, p]])\n\n def translated(self, tx, ty):\n \"\"\"\n Return a copy of the :class:`Bbox`, statically translated by\n *tx* and *ty*.\n \"\"\"\n return Bbox(self._points + (tx, ty))\n\n def corners(self):\n \"\"\"\n Return an array of points which are the four corners of this\n rectangle. For example, if this :class:`Bbox` is defined by\n the points (*a*, *b*) and (*c*, *d*), :meth:`corners` returns\n (*a*, *b*), (*a*, *d*), (*c*, *b*) and (*c*, *d*).\n \"\"\"\n l, b, r, t = self.get_points().flatten()\n return np.array([[l, b], [l, t], [r, b], [r, t]])\n\n def rotated(self, radians):\n \"\"\"\n Return a new bounding box that bounds a rotated version of\n this bounding box by the given radians. The new bounding box\n is still aligned with the axes, of course.\n \"\"\"\n corners = self.corners()\n corners_rotated = Affine2D().rotate(radians).transform(corners)\n bbox = Bbox.unit()\n bbox.update_from_data_xy(corners_rotated, ignore=True)\n return bbox\n\n @staticmethod\n def union(bboxes):\n \"\"\"\n Return a :class:`Bbox` that contains all of the given bboxes.\n \"\"\"\n if not len(bboxes):\n raise ValueError(\"'bboxes' cannot be empty\")\n\n if len(bboxes) == 1:\n return bboxes[0]\n\n x0 = np.inf\n y0 = np.inf\n x1 = -np.inf\n y1 = -np.inf\n\n for bbox in bboxes:\n points = bbox.get_points()\n xs = points[:, 0]\n ys = points[:, 1]\n x0 = min(x0, np.min(xs))\n y0 = min(y0, np.min(ys))\n x1 = max(x1, np.max(xs))\n y1 = max(y1, np.max(ys))\n\n return Bbox.from_extents(x0, y0, x1, y1)\n\n @staticmethod\n def intersection(bbox1, bbox2):\n \"\"\"\n Return the intersection of the two bboxes or None\n if they do not intersect.\n\n Implements the algorithm described at:\n\n http://www.tekpool.com/node/2687\n\n \"\"\"\n intersects = not (bbox2.xmin > bbox1.xmax or\n bbox2.xmax < bbox1.xmin or\n bbox2.ymin > bbox1.ymax or\n bbox2.ymax < bbox1.ymin)\n\n if intersects:\n x0 = max([bbox1.xmin, bbox2.xmin])\n x1 = min([bbox1.xmax, bbox2.xmax])\n y0 = max([bbox1.ymin, bbox2.ymin])\n y1 = min([bbox1.ymax, bbox2.ymax])\n return Bbox.from_extents(x0, y0, x1, y1)\n\n return None\n\n\nclass Bbox(BboxBase):\n \"\"\"\n A mutable bounding box.\n \"\"\"\n\n def __init__(self, points, **kwargs):\n \"\"\"\n *points*: a 2x2 numpy array of the form [[x0, y0], [x1, y1]]\n\n If you need to create a :class:`Bbox` object from another form\n of data, consider the static methods :meth:`unit`,\n :meth:`from_bounds` and :meth:`from_extents`.\n \"\"\"\n BboxBase.__init__(self, **kwargs)\n points = np.asarray(points, np.float_)\n if points.shape != (2, 2):\n raise ValueError('Bbox points must be of the form '\n '\"[[x0, y0], [x1, y1]]\".')\n self._points = points\n self._minpos = np.array([0.0000001, 0.0000001])\n self._ignore = True\n # it is helpful in some contexts to know if the bbox is a\n # default or has been mutated; we store the orig points to\n # support the mutated methods\n self._points_orig = self._points.copy()\n if DEBUG:\n ___init__ = __init__\n\n def __init__(self, points, **kwargs):\n self._check(points)\n self.___init__(points, **kwargs)\n\n def invalidate(self):\n self._check(self._points)\n TransformNode.invalidate(self)\n\n @staticmethod\n def unit():\n \"\"\"\n (staticmethod) Create a new unit :class:`Bbox` from (0, 0) to\n (1, 1).\n \"\"\"\n return Bbox(np.array([[0.0, 0.0], [1.0, 1.0]], np.float))\n\n @staticmethod\n def null():\n \"\"\"\n (staticmethod) Create a new null :class:`Bbox` from (inf, inf) to\n (-inf, -inf).\n \"\"\"\n return Bbox(np.array([[np.inf, np.inf], [-np.inf, -np.inf]], np.float))\n\n @staticmethod\n def from_bounds(x0, y0, width, height):\n \"\"\"\n (staticmethod) Create a new :class:`Bbox` from *x0*, *y0*,\n *width* and *height*.\n\n *width* and *height* may be negative.\n \"\"\"\n return Bbox.from_extents(x0, y0, x0 + width, y0 + height)\n\n @staticmethod\n def from_extents(*args):\n \"\"\"\n (staticmethod) Create a new Bbox from *left*, *bottom*,\n *right* and *top*.\n\n The *y*-axis increases upwards.\n \"\"\"\n points = np.array(args, dtype=np.float_).reshape(2, 2)\n return Bbox(points)\n\n def __format__(self, fmt):\n return (\n 'Bbox(x0={0.x0:{1}}, y0={0.y0:{1}}, x1={0.x1:{1}}, y1={0.y1:{1}})'.\n format(self, fmt))\n\n def __str__(self):\n return format(self, '')\n\n def __repr__(self):\n return 'Bbox([[{0.x0}, {0.y0}], [{0.x1}, {0.y1}]])'.format(self)\n\n def ignore(self, value):\n \"\"\"\n Set whether the existing bounds of the box should be ignored\n by subsequent calls to :meth:`update_from_data` or\n :meth:`update_from_data_xy`.\n\n *value*:\n\n - When True, subsequent calls to :meth:`update_from_data`\n will ignore the existing bounds of the :class:`Bbox`.\n\n - When False, subsequent calls to :meth:`update_from_data`\n will include the existing bounds of the :class:`Bbox`.\n \"\"\"\n self._ignore = value\n\n def update_from_data(self, x, y, ignore=None):\n \"\"\"\n Update the bounds of the :class:`Bbox` based on the passed in\n data. After updating, the bounds will have positive *width*\n and *height*; *x0* and *y0* will be the minimal values.\n\n *x*: a numpy array of *x*-values\n\n *y*: a numpy array of *y*-values\n\n *ignore*:\n - when True, ignore the existing bounds of the :class:`Bbox`.\n - when False, include the existing bounds of the :class:`Bbox`.\n - when None, use the last value passed to :meth:`ignore`.\n \"\"\"\n warnings.warn(\n \"update_from_data requires a memory copy -- please replace with \"\n \"update_from_data_xy\")\n\n xy = np.hstack((x.reshape((len(x), 1)), y.reshape((len(y), 1))))\n return self.update_from_data_xy(xy, ignore)\n\n def update_from_path(self, path, ignore=None, updatex=True, updatey=True):\n \"\"\"\n Update the bounds of the :class:`Bbox` based on the passed in\n data. After updating, the bounds will have positive *width*\n and *height*; *x0* and *y0* will be the minimal values.\n\n *path*: a :class:`~matplotlib.path.Path` instance\n\n *ignore*:\n - when True, ignore the existing bounds of the :class:`Bbox`.\n - when False, include the existing bounds of the :class:`Bbox`.\n - when None, use the last value passed to :meth:`ignore`.\n\n *updatex*: when True, update the x values\n\n *updatey*: when True, update the y values\n\n \"\"\"\n if ignore is None:\n ignore = self._ignore\n\n if path.vertices.size == 0:\n return\n\n points, minpos, changed = update_path_extents(\n path, None, self._points, self._minpos, ignore)\n\n if changed:\n self.invalidate()\n if updatex:\n self._points[:, 0] = points[:, 0]\n self._minpos[0] = minpos[0]\n if updatey:\n self._points[:, 1] = points[:, 1]\n self._minpos[1] = minpos[1]\n\n def update_from_data_xy(self, xy, ignore=None, updatex=True, updatey=True):\n \"\"\"\n Update the bounds of the :class:`Bbox` based on the passed in\n data. After updating, the bounds will have positive *width*\n and *height*; *x0* and *y0* will be the minimal values.\n\n *xy*: a numpy array of 2D points\n\n *ignore*:\n - when True, ignore the existing bounds of the :class:`Bbox`.\n - when False, include the existing bounds of the :class:`Bbox`.\n - when None, use the last value passed to :meth:`ignore`.\n\n *updatex*: when True, update the x values\n\n *updatey*: when True, update the y values\n \"\"\"\n if len(xy) == 0:\n return\n\n path = Path(xy)\n self.update_from_path(path, ignore=ignore,\n updatex=updatex, updatey=updatey)\n\n def _set_x0(self, val):\n self._points[0, 0] = val\n self.invalidate()\n x0 = property(BboxBase._get_x0, _set_x0)\n\n def _set_y0(self, val):\n self._points[0, 1] = val\n self.invalidate()\n y0 = property(BboxBase._get_y0, _set_y0)\n\n def _set_x1(self, val):\n self._points[1, 0] = val\n self.invalidate()\n x1 = property(BboxBase._get_x1, _set_x1)\n\n def _set_y1(self, val):\n self._points[1, 1] = val\n self.invalidate()\n y1 = property(BboxBase._get_y1, _set_y1)\n\n def _set_p0(self, val):\n self._points[0] = val\n self.invalidate()\n p0 = property(BboxBase._get_p0, _set_p0)\n\n def _set_p1(self, val):\n self._points[1] = val\n self.invalidate()\n p1 = property(BboxBase._get_p1, _set_p1)\n\n def _set_intervalx(self, interval):\n self._points[:, 0] = interval\n self.invalidate()\n intervalx = property(BboxBase._get_intervalx, _set_intervalx)\n\n def _set_intervaly(self, interval):\n self._points[:, 1] = interval\n self.invalidate()\n intervaly = property(BboxBase._get_intervaly, _set_intervaly)\n\n def _set_bounds(self, bounds):\n l, b, w, h = bounds\n points = np.array([[l, b], [l + w, b + h]], np.float_)\n if np.any(self._points != points):\n self._points = points\n self.invalidate()\n bounds = property(BboxBase._get_bounds, _set_bounds)\n\n def _get_minpos(self):\n return self._minpos\n minpos = property(_get_minpos)\n\n def _get_minposx(self):\n return self._minpos[0]\n minposx = property(_get_minposx)\n\n def _get_minposy(self):\n return self._minpos[1]\n minposy = property(_get_minposy)\n\n def get_points(self):\n \"\"\"\n Get the points of the bounding box directly as a numpy array\n of the form: [[x0, y0], [x1, y1]].\n \"\"\"\n self._invalid = 0\n return self._points\n\n def set_points(self, points):\n \"\"\"\n Set the points of the bounding box directly from a numpy array\n of the form: [[x0, y0], [x1, y1]]. No error checking is\n performed, as this method is mainly for internal use.\n \"\"\"\n if np.any(self._points != points):\n self._points = points\n self.invalidate()\n\n def set(self, other):\n \"\"\"\n Set this bounding box from the \"frozen\" bounds of another\n :class:`Bbox`.\n \"\"\"\n if np.any(self._points != other.get_points()):\n self._points = other.get_points()\n self.invalidate()\n\n def mutated(self):\n 'return whether the bbox has changed since init'\n return self.mutatedx() or self.mutatedy()\n\n def mutatedx(self):\n 'return whether the x-limits have changed since init'\n return (self._points[0, 0] != self._points_orig[0, 0] or\n self._points[1, 0] != self._points_orig[1, 0])\n\n def mutatedy(self):\n 'return whether the y-limits have changed since init'\n return (self._points[0, 1] != self._points_orig[0, 1] or\n self._points[1, 1] != self._points_orig[1, 1])\n\n\nclass TransformedBbox(BboxBase):\n \"\"\"\n A :class:`Bbox` that is automatically transformed by a given\n transform. When either the child bounding box or transform\n changes, the bounds of this bbox will update accordingly.\n \"\"\"\n def __init__(self, bbox, transform, **kwargs):\n \"\"\"\n *bbox*: a child :class:`Bbox`\n\n *transform*: a 2D :class:`Transform`\n \"\"\"\n if not bbox.is_bbox:\n raise ValueError(\"'bbox' is not a bbox\")\n if not isinstance(transform, Transform):\n msg = (\"'transform' must be an instance of\"\n \" 'matplotlib.transform.Transform'\")\n raise ValueError(msg)\n if transform.input_dims != 2 or transform.output_dims != 2:\n msg = \"The input and output dimensions of 'transform' must be 2\"\n raise ValueError(msg)\n\n BboxBase.__init__(self, **kwargs)\n self._bbox = bbox\n self._transform = transform\n self.set_children(bbox, transform)\n self._points = None\n\n def __repr__(self):\n return \"TransformedBbox(%r, %r)\" % (self._bbox, self._transform)\n\n def get_points(self):\n if self._invalid:\n points = self._transform.transform(self._bbox.get_points())\n points = np.ma.filled(points, 0.0)\n self._points = points\n self._invalid = 0\n return self._points\n get_points.__doc__ = Bbox.get_points.__doc__\n\n if DEBUG:\n _get_points = get_points\n\n def get_points(self):\n points = self._get_points()\n self._check(points)\n return points\n\n\nclass Transform(TransformNode):\n \"\"\"\n The base class of all :class:`TransformNode` instances that\n actually perform a transformation.\n\n All non-affine transformations should be subclasses of this class.\n New affine transformations should be subclasses of\n :class:`Affine2D`.\n\n Subclasses of this class should override the following members (at\n minimum):\n\n - :attr:`input_dims`\n - :attr:`output_dims`\n - :meth:`transform`\n - :attr:`is_separable`\n - :attr:`has_inverse`\n - :meth:`inverted` (if :attr:`has_inverse` is True)\n\n If the transform needs to do something non-standard with\n :class:`matplotlib.path.Path` objects, such as adding curves\n where there were once line segments, it should override:\n\n - :meth:`transform_path`\n \"\"\"\n input_dims = None\n \"\"\"\n The number of input dimensions of this transform.\n Must be overridden (with integers) in the subclass.\n \"\"\"\n\n output_dims = None\n \"\"\"\n The number of output dimensions of this transform.\n Must be overridden (with integers) in the subclass.\n \"\"\"\n\n has_inverse = False\n \"\"\"True if this transform has a corresponding inverse transform.\"\"\"\n\n is_separable = False\n \"\"\"True if this transform is separable in the x- and y- dimensions.\"\"\"\n\n def __add__(self, other):\n \"\"\"\n Composes two transforms together such that *self* is followed\n by *other*.\n \"\"\"\n if isinstance(other, Transform):\n return composite_transform_factory(self, other)\n raise TypeError(\n \"Can not add Transform to object of type '%s'\" % type(other))\n\n def __radd__(self, other):\n \"\"\"\n Composes two transforms together such that *self* is followed\n by *other*.\n \"\"\"\n if isinstance(other, Transform):\n return composite_transform_factory(other, self)\n raise TypeError(\n \"Can not add Transform to object of type '%s'\" % type(other))\n\n def __eq__(self, other):\n # equality is based on transform object id. Hence:\n # Transform() != Transform().\n # Some classes, such as TransformWrapper & AffineBase, will override.\n return self is other\n\n def _iter_break_from_left_to_right(self):\n \"\"\"\n Returns an iterator breaking down this transform stack from left to\n right recursively. If self == ((A, N), A) then the result will be an\n iterator which yields I : ((A, N), A), followed by A : (N, A),\n followed by (A, N) : (A), but not ((A, N), A) : I.\n\n This is equivalent to flattening the stack then yielding\n ``flat_stack[:i], flat_stack[i:]`` where i=0..(n-1).\n\n \"\"\"\n yield IdentityTransform(), self\n\n @property\n def depth(self):\n \"\"\"\n Returns the number of transforms which have been chained\n together to form this Transform instance.\n\n .. note::\n\n For the special case of a Composite transform, the maximum depth\n of the two is returned.\n\n \"\"\"\n return 1\n\n def contains_branch(self, other):\n \"\"\"\n Return whether the given transform is a sub-tree of this transform.\n\n This routine uses transform equality to identify sub-trees, therefore\n in many situations it is object id which will be used.\n\n For the case where the given transform represents the whole\n of this transform, returns True.\n\n \"\"\"\n if self.depth < other.depth:\n return False\n\n # check that a subtree is equal to other (starting from self)\n for _, sub_tree in self._iter_break_from_left_to_right():\n if sub_tree == other:\n return True\n return False\n\n def contains_branch_seperately(self, other_transform):\n \"\"\"\n Returns whether the given branch is a sub-tree of this transform on\n each seperate dimension.\n\n A common use for this method is to identify if a transform is a blended\n transform containing an axes' data transform. e.g.::\n\n x_isdata, y_isdata = trans.contains_branch_seperately(ax.transData)\n\n \"\"\"\n if self.output_dims != 2:\n raise ValueError('contains_branch_seperately only supports '\n 'transforms with 2 output dimensions')\n # for a non-blended transform each seperate dimension is the same, so\n # just return the appropriate shape.\n return [self.contains_branch(other_transform)] * 2\n\n def __sub__(self, other):\n \"\"\"\n Returns a transform stack which goes all the way down self's transform\n stack, and then ascends back up other's stack. If it can, this is\n optimised::\n\n # normally\n A - B == a + b.inverted()\n\n # sometimes, when A contains the tree B there is no need to\n # descend all the way down to the base of A (via B), instead we\n # can just stop at B.\n\n (A + B) - (B)^-1 == A\n\n # similarly, when B contains tree A, we can avoid decending A at\n # all, basically:\n A - (A + B) == ((B + A) - A).inverted() or B^-1\n\n For clarity, the result of ``(A + B) - B + B == (A + B)``.\n\n \"\"\"\n # we only know how to do this operation if other is a Transform.\n if not isinstance(other, Transform):\n return NotImplemented\n\n for remainder, sub_tree in self._iter_break_from_left_to_right():\n if sub_tree == other:\n return remainder\n\n for remainder, sub_tree in other._iter_break_from_left_to_right():\n if sub_tree == self:\n if not remainder.has_inverse:\n raise ValueError(\"The shortcut cannot be computed since \"\n \"other's transform includes a non-invertable component.\")\n return remainder.inverted()\n\n # if we have got this far, then there was no shortcut possible\n if other.has_inverse:\n return self + other.inverted()\n else:\n raise ValueError('It is not possible to compute transA - transB '\n 'since transB cannot be inverted and there is no '\n 'shortcut possible.')\n\n def __array__(self, *args, **kwargs):\n \"\"\"\n Array interface to get at this Transform's affine matrix.\n \"\"\"\n return self.get_affine().get_matrix()\n\n def transform(self, values):\n \"\"\"\n Performs the transformation on the given array of values.\n\n Accepts a numpy array of shape (N x :attr:`input_dims`) and\n returns a numpy array of shape (N x :attr:`output_dims`).\n\n Alternatively, accepts a numpy array of length :attr:`input_dims`\n and returns a numpy array of length :attr:`output_dims`.\n \"\"\"\n # Ensure that values is a 2d array (but remember whether\n # we started with a 1d or 2d array).\n values = np.asanyarray(values)\n ndim = values.ndim\n values = values.reshape((-1, self.input_dims))\n\n # Transform the values\n res = self.transform_affine(self.transform_non_affine(values))\n\n # Convert the result back to the shape of the input values.\n if ndim == 0:\n assert not np.ma.is_masked(res) # just to be on the safe side\n return res[0, 0]\n if ndim == 1:\n return res.reshape(-1)\n elif ndim == 2:\n return res\n else:\n raise ValueError(\n \"Input values must have shape (N x {dims}) \"\n \"or ({dims}).\".format(dims=self.input_dims))\n\n return res\n\n def transform_affine(self, values):\n \"\"\"\n Performs only the affine part of this transformation on the\n given array of values.\n\n ``transform(values)`` is always equivalent to\n ``transform_affine(transform_non_affine(values))``.\n\n In non-affine transformations, this is generally a no-op. In\n affine transformations, this is equivalent to\n ``transform(values)``.\n\n Accepts a numpy array of shape (N x :attr:`input_dims`) and\n returns a numpy array of shape (N x :attr:`output_dims`).\n\n Alternatively, accepts a numpy array of length :attr:`input_dims`\n and returns a numpy array of length :attr:`output_dims`.\n \"\"\"\n return self.get_affine().transform(values)\n\n def transform_non_affine(self, values):\n \"\"\"\n Performs only the non-affine part of the transformation.\n\n ``transform(values)`` is always equivalent to\n ``transform_affine(transform_non_affine(values))``.\n\n In non-affine transformations, this is generally equivalent to\n ``transform(values)``. In affine transformations, this is\n always a no-op.\n\n Accepts a numpy array of shape (N x :attr:`input_dims`) and\n returns a numpy array of shape (N x :attr:`output_dims`).\n\n Alternatively, accepts a numpy array of length :attr:`input_dims`\n and returns a numpy array of length :attr:`output_dims`.\n \"\"\"\n return values\n\n def transform_bbox(self, bbox):\n \"\"\"\n Transform the given bounding box.\n\n Note, for smarter transforms including caching (a common\n requirement for matplotlib figures), see :class:`TransformedBbox`.\n \"\"\"\n return Bbox(self.transform(bbox.get_points()))\n\n def get_affine(self):\n \"\"\"\n Get the affine part of this transform.\n \"\"\"\n return IdentityTransform()\n\n def get_matrix(self):\n \"\"\"\n Get the Affine transformation array for the affine part\n of this transform.\n\n \"\"\"\n return self.get_affine().get_matrix()\n\n def transform_point(self, point):\n \"\"\"\n A convenience function that returns the transformed copy of a\n single point.\n\n The point is given as a sequence of length :attr:`input_dims`.\n The transformed point is returned as a sequence of length\n :attr:`output_dims`.\n \"\"\"\n if len(point) != self.input_dims:\n msg = \"The length of 'point' must be 'self.input_dims'\"\n raise ValueError(msg)\n return self.transform(np.asarray([point]))[0]\n\n def transform_path(self, path):\n \"\"\"\n Returns a transformed path.\n\n *path*: a :class:`~matplotlib.path.Path` instance.\n\n In some cases, this transform may insert curves into the path\n that began as line segments.\n \"\"\"\n return self.transform_path_affine(self.transform_path_non_affine(path))\n\n def transform_path_affine(self, path):\n \"\"\"\n Returns a path, transformed only by the affine part of\n this transform.\n\n *path*: a :class:`~matplotlib.path.Path` instance.\n\n ``transform_path(path)`` is equivalent to\n ``transform_path_affine(transform_path_non_affine(values))``.\n \"\"\"\n return self.get_affine().transform_path_affine(path)\n\n def transform_path_non_affine(self, path):\n \"\"\"\n Returns a path, transformed only by the non-affine\n part of this transform.\n\n *path*: a :class:`~matplotlib.path.Path` instance.\n\n ``transform_path(path)`` is equivalent to\n ``transform_path_affine(transform_path_non_affine(values))``.\n \"\"\"\n x = self.transform_non_affine(path.vertices)\n return Path._fast_from_codes_and_verts(x, path.codes,\n {'interpolation_steps': path._interpolation_steps,\n 'should_simplify': path.should_simplify})\n\n def transform_angles(self, angles, pts, radians=False, pushoff=1e-5):\n \"\"\"\n Performs transformation on a set of angles anchored at\n specific locations.\n\n The *angles* must be a column vector (i.e., numpy array).\n\n The *pts* must be a two-column numpy array of x,y positions\n (angle transforms currently only work in 2D). This array must\n have the same number of rows as *angles*.\n\n *radians* indicates whether or not input angles are given in\n radians (True) or degrees (False; the default).\n\n *pushoff* is the distance to move away from *pts* for\n determining transformed angles (see discussion of method\n below).\n\n The transformed angles are returned in an array with the same\n size as *angles*.\n\n The generic version of this method uses a very generic\n algorithm that transforms *pts*, as well as locations very\n close to *pts*, to find the angle in the transformed system.\n \"\"\"\n # Must be 2D\n if self.input_dims != 2 or self.output_dims != 2:\n raise NotImplementedError('Only defined in 2D')\n\n if pts.shape[1] != 2:\n raise ValueError(\"'pts' must be array with 2 columns for x,y\")\n\n if angles.ndim != 1 or angles.shape[0] != pts.shape[0]:\n msg = \"'angles' must be a column vector and have same number of\"\n msg += \" rows as 'pts'\"\n raise ValueError(msg)\n\n # Convert to radians if desired\n if not radians:\n angles = angles / 180.0 * np.pi\n\n # Move a short distance away\n pts2 = pts + pushoff * np.c_[np.cos(angles), np.sin(angles)]\n\n # Transform both sets of points\n tpts = self.transform(pts)\n tpts2 = self.transform(pts2)\n\n # Calculate transformed angles\n d = tpts2 - tpts\n a = np.arctan2(d[:, 1], d[:, 0])\n\n # Convert back to degrees if desired\n if not radians:\n a = a * 180.0 / np.pi\n\n return a\n\n def inverted(self):\n \"\"\"\n Return the corresponding inverse transformation.\n\n The return value of this method should be treated as\n temporary. An update to *self* does not cause a corresponding\n update to its inverted copy.\n\n ``x === self.inverted().transform(self.transform(x))``\n \"\"\"\n raise NotImplementedError()\n\n\nclass TransformWrapper(Transform):\n \"\"\"\n A helper class that holds a single child transform and acts\n equivalently to it.\n\n This is useful if a node of the transform tree must be replaced at\n run time with a transform of a different type. This class allows\n that replacement to correctly trigger invalidation.\n\n Note that :class:`TransformWrapper` instances must have the same\n input and output dimensions during their entire lifetime, so the\n child transform may only be replaced with another child transform\n of the same dimensions.\n \"\"\"\n pass_through = True\n\n def __init__(self, child):\n \"\"\"\n *child*: A class:`Transform` instance. This child may later\n be replaced with :meth:`set`.\n \"\"\"\n if not isinstance(child, Transform):\n msg = (\"'child' must be an instance of\"\n \" 'matplotlib.transform.Transform'\")\n raise ValueError(msg)\n Transform.__init__(self)\n self.input_dims = child.input_dims\n self.output_dims = child.output_dims\n self._set(child)\n self._invalid = 0\n\n def __eq__(self, other):\n return self._child.__eq__(other)\n\n if DEBUG:\n\n def __str__(self):\n return str(self._child)\n\n def __getstate__(self):\n # only store the child\n return {'child': self._child}\n\n def __setstate__(self, state):\n # re-initialise the TransformWrapper with the state's child\n self.__init__(state['child'])\n\n def __repr__(self):\n return \"TransformWrapper(%r)\" % self._child\n\n def frozen(self):\n return self._child.frozen()\n frozen.__doc__ = Transform.frozen.__doc__\n\n def _set(self, child):\n self._child = child\n self.set_children(child)\n\n self.transform = child.transform\n self.transform_affine = child.transform_affine\n self.transform_non_affine = child.transform_non_affine\n self.transform_path = child.transform_path\n self.transform_path_affine = child.transform_path_affine\n self.transform_path_non_affine = child.transform_path_non_affine\n self.get_affine = child.get_affine\n self.inverted = child.inverted\n self.get_matrix = child.get_matrix\n\n # note we do not wrap other properties here since the transform's\n # child can be changed with WrappedTransform.set and so checking\n # is_affine and other such properties may be dangerous.\n\n def set(self, child):\n \"\"\"\n Replace the current child of this transform with another one.\n\n The new child must have the same number of input and output\n dimensions as the current child.\n \"\"\"\n if (child.input_dims != self.input_dims or\n child.output_dims != self.output_dims):\n msg = (\"The new child must have the same number of input and\"\n \" output dimensions as the current child.\")\n raise ValueError(msg)\n\n self._set(child)\n\n self._invalid = 0\n self.invalidate()\n self._invalid = 0\n\n def _get_is_affine(self):\n return self._child.is_affine\n is_affine = property(_get_is_affine)\n\n def _get_is_separable(self):\n return self._child.is_separable\n is_separable = property(_get_is_separable)\n\n def _get_has_inverse(self):\n return self._child.has_inverse\n has_inverse = property(_get_has_inverse)\n\n\nclass AffineBase(Transform):\n \"\"\"\n The base class of all affine transformations of any number of\n dimensions.\n \"\"\"\n is_affine = True\n\n def __init__(self, *args, **kwargs):\n Transform.__init__(self, *args, **kwargs)\n self._inverted = None\n\n def __array__(self, *args, **kwargs):\n # optimises the access of the transform matrix vs the superclass\n return self.get_matrix()\n\n @staticmethod\n def _concat(a, b):\n \"\"\"\n Concatenates two transformation matrices (represented as numpy\n arrays) together.\n \"\"\"\n return np.dot(b, a)\n\n def __eq__(self, other):\n if getattr(other, \"is_affine\", False):\n return np.all(self.get_matrix() == other.get_matrix())\n return NotImplemented\n\n def transform(self, values):\n return self.transform_affine(values)\n transform.__doc__ = Transform.transform.__doc__\n\n def transform_affine(self, values):\n raise NotImplementedError('Affine subclasses should override this '\n 'method.')\n transform_affine.__doc__ = Transform.transform_affine.__doc__\n\n def transform_non_affine(self, points):\n return points\n transform_non_affine.__doc__ = Transform.transform_non_affine.__doc__\n\n def transform_path(self, path):\n return self.transform_path_affine(path)\n transform_path.__doc__ = Transform.transform_path.__doc__\n\n def transform_path_affine(self, path):\n return Path(self.transform_affine(path.vertices),\n path.codes, path._interpolation_steps)\n transform_path_affine.__doc__ = Transform.transform_path_affine.__doc__\n\n def transform_path_non_affine(self, path):\n return path\n transform_path_non_affine.__doc__ = Transform.transform_path_non_affine.__doc__\n\n def get_affine(self):\n return self\n get_affine.__doc__ = Transform.get_affine.__doc__\n\n\nclass Affine2DBase(AffineBase):\n \"\"\"\n The base class of all 2D affine transformations.\n\n 2D affine transformations are performed using a 3x3 numpy array::\n\n a c e\n b d f\n 0 0 1\n\n This class provides the read-only interface. For a mutable 2D\n affine transformation, use :class:`Affine2D`.\n\n Subclasses of this class will generally only need to override a\n constructor and :meth:`get_matrix` that generates a custom 3x3 matrix.\n \"\"\"\n has_inverse = True\n\n input_dims = 2\n output_dims = 2\n\n def frozen(self):\n return Affine2D(self.get_matrix().copy())\n frozen.__doc__ = AffineBase.frozen.__doc__\n\n def _get_is_separable(self):\n mtx = self.get_matrix()\n return mtx[0, 1] == 0.0 and mtx[1, 0] == 0.0\n is_separable = property(_get_is_separable)\n\n def to_values(self):\n \"\"\"\n Return the values of the matrix as a sequence (a,b,c,d,e,f)\n \"\"\"\n mtx = self.get_matrix()\n return tuple(mtx[:2].swapaxes(0, 1).flatten())\n\n @staticmethod\n def matrix_from_values(a, b, c, d, e, f):\n \"\"\"\n (staticmethod) Create a new transformation matrix as a 3x3\n numpy array of the form::\n\n a c e\n b d f\n 0 0 1\n \"\"\"\n return np.array([[a, c, e], [b, d, f], [0.0, 0.0, 1.0]], np.float_)\n\n def transform_affine(self, points):\n mtx = self.get_matrix()\n if isinstance(points, MaskedArray):\n tpoints = affine_transform(points.data, mtx)\n return ma.MaskedArray(tpoints, mask=ma.getmask(points))\n return affine_transform(points, mtx)\n\n def transform_point(self, point):\n mtx = self.get_matrix()\n return affine_transform([point], mtx)[0]\n transform_point.__doc__ = AffineBase.transform_point.__doc__\n\n if DEBUG:\n _transform_affine = transform_affine\n\n def transform_affine(self, points):\n # The major speed trap here is just converting to the\n # points to an array in the first place. If we can use\n # more arrays upstream, that should help here.\n if (not ma.isMaskedArray(points) and\n not isinstance(points, np.ndarray)):\n warnings.warn(\n ('A non-numpy array of type %s was passed in for ' +\n 'transformation. Please correct this.')\n % type(points))\n return self._transform_affine(points)\n transform_affine.__doc__ = AffineBase.transform_affine.__doc__\n\n def inverted(self):\n if self._inverted is None or self._invalid:\n mtx = self.get_matrix()\n shorthand_name = None\n if self._shorthand_name:\n shorthand_name = '(%s)-1' % self._shorthand_name\n self._inverted = Affine2D(inv(mtx), shorthand_name=shorthand_name)\n self._invalid = 0\n return self._inverted\n inverted.__doc__ = AffineBase.inverted.__doc__\n\n\nclass Affine2D(Affine2DBase):\n \"\"\"\n A mutable 2D affine transformation.\n \"\"\"\n\n def __init__(self, matrix=None, **kwargs):\n \"\"\"\n Initialize an Affine transform from a 3x3 numpy float array::\n\n a c e\n b d f\n 0 0 1\n\n If *matrix* is None, initialize with the identity transform.\n \"\"\"\n Affine2DBase.__init__(self, **kwargs)\n if matrix is None:\n matrix = np.identity(3)\n elif DEBUG:\n matrix = np.asarray(matrix, np.float_)\n assert matrix.shape == (3, 3)\n self._mtx = matrix\n self._invalid = 0\n\n def __repr__(self):\n return \"Affine2D(%s)\" % repr(self._mtx)\n\n# def __cmp__(self, other):\n# # XXX redundant. this only tells us eq.\n# if (isinstance(other, Affine2D) and\n# (self.get_matrix() == other.get_matrix()).all()):\n# return 0\n# return -1\n\n @staticmethod\n def from_values(a, b, c, d, e, f):\n \"\"\"\n (staticmethod) Create a new Affine2D instance from the given\n values::\n\n a c e\n b d f\n 0 0 1\n\n .\n \"\"\"\n return Affine2D(\n np.array([a, c, e, b, d, f, 0.0, 0.0, 1.0], np.float_)\n .reshape((3, 3)))\n\n def get_matrix(self):\n \"\"\"\n Get the underlying transformation matrix as a 3x3 numpy array::\n\n a c e\n b d f\n 0 0 1\n\n .\n \"\"\"\n self._invalid = 0\n return self._mtx\n\n def set_matrix(self, mtx):\n \"\"\"\n Set the underlying transformation matrix from a 3x3 numpy array::\n\n a c e\n b d f\n 0 0 1\n\n .\n \"\"\"\n self._mtx = mtx\n self.invalidate()\n\n def set(self, other):\n \"\"\"\n Set this transformation from the frozen copy of another\n :class:`Affine2DBase` object.\n \"\"\"\n if not isinstance(other, Affine2DBase):\n msg = (\"'other' must be an instance of\"\n \" 'matplotlib.transform.Affine2DBase'\")\n raise ValueError(msg)\n self._mtx = other.get_matrix()\n self.invalidate()\n\n @staticmethod\n def identity():\n \"\"\"\n (staticmethod) Return a new :class:`Affine2D` object that is\n the identity transform.\n\n Unless this transform will be mutated later on, consider using\n the faster :class:`IdentityTransform` class instead.\n \"\"\"\n return Affine2D(np.identity(3))\n\n def clear(self):\n \"\"\"\n Reset the underlying matrix to the identity transform.\n \"\"\"\n self._mtx = np.identity(3)\n self.invalidate()\n return self\n\n def rotate(self, theta):\n \"\"\"\n Add a rotation (in radians) to this transform in place.\n\n Returns *self*, so this method can easily be chained with more\n calls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate`\n and :meth:`scale`.\n \"\"\"\n a = np.cos(theta)\n b = np.sin(theta)\n rotate_mtx = np.array(\n [[a, -b, 0.0], [b, a, 0.0], [0.0, 0.0, 1.0]],\n np.float_)\n self._mtx = np.dot(rotate_mtx, self._mtx)\n self.invalidate()\n return self\n\n def rotate_deg(self, degrees):\n \"\"\"\n Add a rotation (in degrees) to this transform in place.\n\n Returns *self*, so this method can easily be chained with more\n calls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate`\n and :meth:`scale`.\n \"\"\"\n return self.rotate(degrees * np.pi / 180.)\n\n def rotate_around(self, x, y, theta):\n \"\"\"\n Add a rotation (in radians) around the point (x, y) in place.\n\n Returns *self*, so this method can easily be chained with more\n calls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate`\n and :meth:`scale`.\n \"\"\"\n return self.translate(-x, -y).rotate(theta).translate(x, y)\n\n def rotate_deg_around(self, x, y, degrees):\n \"\"\"\n Add a rotation (in degrees) around the point (x, y) in place.\n\n Returns *self*, so this method can easily be chained with more\n calls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate`\n and :meth:`scale`.\n \"\"\"\n return self.translate(-x, -y).rotate_deg(degrees).translate(x, y)\n\n def translate(self, tx, ty):\n \"\"\"\n Adds a translation in place.\n\n Returns *self*, so this method can easily be chained with more\n calls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate`\n and :meth:`scale`.\n \"\"\"\n translate_mtx = np.array(\n [[1.0, 0.0, tx], [0.0, 1.0, ty], [0.0, 0.0, 1.0]],\n np.float_)\n self._mtx = np.dot(translate_mtx, self._mtx)\n self.invalidate()\n return self\n\n def scale(self, sx, sy=None):\n \"\"\"\n Adds a scale in place.\n\n If *sy* is None, the same scale is applied in both the *x*- and\n *y*-directions.\n\n Returns *self*, so this method can easily be chained with more\n calls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate`\n and :meth:`scale`.\n \"\"\"\n if sy is None:\n sy = sx\n scale_mtx = np.array(\n [[sx, 0.0, 0.0], [0.0, sy, 0.0], [0.0, 0.0, 1.0]],\n np.float_)\n self._mtx = np.dot(scale_mtx, self._mtx)\n self.invalidate()\n return self\n\n def skew(self, xShear, yShear):\n \"\"\"\n Adds a skew in place.\n\n *xShear* and *yShear* are the shear angles along the *x*- and\n *y*-axes, respectively, in radians.\n\n Returns *self*, so this method can easily be chained with more\n calls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate`\n and :meth:`scale`.\n \"\"\"\n rotX = np.tan(xShear)\n rotY = np.tan(yShear)\n skew_mtx = np.array(\n [[1.0, rotX, 0.0], [rotY, 1.0, 0.0], [0.0, 0.0, 1.0]],\n np.float_)\n self._mtx = np.dot(skew_mtx, self._mtx)\n self.invalidate()\n return self\n\n def skew_deg(self, xShear, yShear):\n \"\"\"\n Adds a skew in place.\n\n *xShear* and *yShear* are the shear angles along the *x*- and\n *y*-axes, respectively, in degrees.\n\n Returns *self*, so this method can easily be chained with more\n calls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate`\n and :meth:`scale`.\n \"\"\"\n return self.skew(np.deg2rad(xShear), np.deg2rad(yShear))\n\n def _get_is_separable(self):\n mtx = self.get_matrix()\n return mtx[0, 1] == 0.0 and mtx[1, 0] == 0.0\n is_separable = property(_get_is_separable)\n\n\nclass IdentityTransform(Affine2DBase):\n \"\"\"\n A special class that does on thing, the identity transform, in a\n fast way.\n \"\"\"\n _mtx = np.identity(3)\n\n def frozen(self):\n return self\n frozen.__doc__ = Affine2DBase.frozen.__doc__\n\n def __repr__(self):\n return \"IdentityTransform()\"\n\n def get_matrix(self):\n return self._mtx\n get_matrix.__doc__ = Affine2DBase.get_matrix.__doc__\n\n def transform(self, points):\n return np.asanyarray(points)\n transform.__doc__ = Affine2DBase.transform.__doc__\n\n transform_affine = transform\n transform_affine.__doc__ = Affine2DBase.transform_affine.__doc__\n\n transform_non_affine = transform\n transform_non_affine.__doc__ = Affine2DBase.transform_non_affine.__doc__\n\n def transform_path(self, path):\n return path\n transform_path.__doc__ = Affine2DBase.transform_path.__doc__\n\n transform_path_affine = transform_path\n transform_path_affine.__doc__ = Affine2DBase.transform_path_affine.__doc__\n\n transform_path_non_affine = transform_path\n transform_path_non_affine.__doc__ = Affine2DBase.transform_path_non_affine.__doc__\n\n def get_affine(self):\n return self\n get_affine.__doc__ = Affine2DBase.get_affine.__doc__\n\n inverted = get_affine\n inverted.__doc__ = Affine2DBase.inverted.__doc__\n\n\nclass BlendedGenericTransform(Transform):\n \"\"\"\n A \"blended\" transform uses one transform for the *x*-direction, and\n another transform for the *y*-direction.\n\n This \"generic\" version can handle any given child transform in the\n *x*- and *y*-directions.\n \"\"\"\n input_dims = 2\n output_dims = 2\n is_separable = True\n pass_through = True\n\n def __init__(self, x_transform, y_transform, **kwargs):\n \"\"\"\n Create a new \"blended\" transform using *x_transform* to\n transform the *x*-axis and *y_transform* to transform the\n *y*-axis.\n\n You will generally not call this constructor directly but use\n the :func:`blended_transform_factory` function instead, which\n can determine automatically which kind of blended transform to\n create.\n \"\"\"\n # Here we ask: \"Does it blend?\"\n\n Transform.__init__(self, **kwargs)\n self._x = x_transform\n self._y = y_transform\n self.set_children(x_transform, y_transform)\n self._affine = None\n\n def __eq__(self, other):\n # Note, this is an exact copy of BlendedAffine2D.__eq__\n if isinstance(other, (BlendedAffine2D, BlendedGenericTransform)):\n return (self._x == other._x) and (self._y == other._y)\n elif self._x == self._y:\n return self._x == other\n else:\n return NotImplemented\n\n def contains_branch_seperately(self, transform):\n # Note, this is an exact copy of BlendedAffine2D.contains_branch_seperately\n return self._x.contains_branch(transform), self._y.contains_branch(transform)\n\n @property\n def depth(self):\n return max([self._x.depth, self._y.depth])\n\n def contains_branch(self, other):\n # a blended transform cannot possibly contain a branch from two different transforms.\n return False\n\n def _get_is_affine(self):\n return self._x.is_affine and self._y.is_affine\n is_affine = property(_get_is_affine)\n\n def _get_has_inverse(self):\n return self._x.has_inverse and self._y.has_inverse\n has_inverse = property(_get_has_inverse)\n\n def frozen(self):\n return blended_transform_factory(self._x.frozen(), self._y.frozen())\n frozen.__doc__ = Transform.frozen.__doc__\n\n def __repr__(self):\n return \"BlendedGenericTransform(%s,%s)\" % (self._x, self._y)\n\n def transform_non_affine(self, points):\n if self._x.is_affine and self._y.is_affine:\n return points\n x = self._x\n y = self._y\n\n if x == y and x.input_dims == 2:\n return x.transform_non_affine(points)\n\n if x.input_dims == 2:\n x_points = x.transform_non_affine(points)[:, 0:1]\n else:\n x_points = x.transform_non_affine(points[:, 0])\n x_points = x_points.reshape((len(x_points), 1))\n\n if y.input_dims == 2:\n y_points = y.transform_non_affine(points)[:, 1:]\n else:\n y_points = y.transform_non_affine(points[:, 1])\n y_points = y_points.reshape((len(y_points), 1))\n\n if isinstance(x_points, MaskedArray) or isinstance(y_points, MaskedArray):\n return ma.concatenate((x_points, y_points), 1)\n else:\n return np.concatenate((x_points, y_points), 1)\n transform_non_affine.__doc__ = Transform.transform_non_affine.__doc__\n\n def inverted(self):\n return BlendedGenericTransform(self._x.inverted(), self._y.inverted())\n inverted.__doc__ = Transform.inverted.__doc__\n\n def get_affine(self):\n if self._invalid or self._affine is None:\n if self._x == self._y:\n self._affine = self._x.get_affine()\n else:\n x_mtx = self._x.get_affine().get_matrix()\n y_mtx = self._y.get_affine().get_matrix()\n # This works because we already know the transforms are\n # separable, though normally one would want to set b and\n # c to zero.\n mtx = np.vstack((x_mtx[0], y_mtx[1], [0.0, 0.0, 1.0]))\n self._affine = Affine2D(mtx)\n self._invalid = 0\n return self._affine\n get_affine.__doc__ = Transform.get_affine.__doc__\n\n\nclass BlendedAffine2D(Affine2DBase):\n \"\"\"\n A \"blended\" transform uses one transform for the *x*-direction, and\n another transform for the *y*-direction.\n\n This version is an optimization for the case where both child\n transforms are of type :class:`Affine2DBase`.\n \"\"\"\n is_separable = True\n\n def __init__(self, x_transform, y_transform, **kwargs):\n \"\"\"\n Create a new \"blended\" transform using *x_transform* to\n transform the *x*-axis and *y_transform* to transform the\n *y*-axis.\n\n Both *x_transform* and *y_transform* must be 2D affine\n transforms.\n\n You will generally not call this constructor directly but use\n the :func:`blended_transform_factory` function instead, which\n can determine automatically which kind of blended transform to\n create.\n \"\"\"\n is_affine = x_transform.is_affine and y_transform.is_affine\n is_separable = x_transform.is_separable and y_transform.is_separable\n is_correct = is_affine and is_separable\n if not is_correct:\n msg = (\"Both *x_transform* and *y_transform* must be 2D affine\"\n \" transforms.\")\n raise ValueError(msg)\n\n Transform.__init__(self, **kwargs)\n self._x = x_transform\n self._y = y_transform\n self.set_children(x_transform, y_transform)\n\n Affine2DBase.__init__(self)\n self._mtx = None\n\n def __eq__(self, other):\n # Note, this is an exact copy of BlendedGenericTransform.__eq__\n if isinstance(other, (BlendedAffine2D, BlendedGenericTransform)):\n return (self._x == other._x) and (self._y == other._y)\n elif self._x == self._y:\n return self._x == other\n else:\n return NotImplemented\n\n def contains_branch_seperately(self, transform):\n # Note, this is an exact copy of BlendedTransform.contains_branch_seperately\n return self._x.contains_branch(transform), self._y.contains_branch(transform)\n\n def __repr__(self):\n return \"BlendedAffine2D(%s,%s)\" % (self._x, self._y)\n\n def get_matrix(self):\n if self._invalid:\n if self._x == self._y:\n self._mtx = self._x.get_matrix()\n else:\n x_mtx = self._x.get_matrix()\n y_mtx = self._y.get_matrix()\n # This works because we already know the transforms are\n # separable, though normally one would want to set b and\n # c to zero.\n self._mtx = np.vstack((x_mtx[0], y_mtx[1], [0.0, 0.0, 1.0]))\n self._inverted = None\n self._invalid = 0\n return self._mtx\n get_matrix.__doc__ = Affine2DBase.get_matrix.__doc__\n\n\ndef blended_transform_factory(x_transform, y_transform):\n \"\"\"\n Create a new \"blended\" transform using *x_transform* to transform\n the *x*-axis and *y_transform* to transform the *y*-axis.\n\n A faster version of the blended transform is returned for the case\n where both child transforms are affine.\n \"\"\"\n if (isinstance(x_transform, Affine2DBase)\n and isinstance(y_transform, Affine2DBase)):\n return BlendedAffine2D(x_transform, y_transform)\n return BlendedGenericTransform(x_transform, y_transform)\n\n\nclass CompositeGenericTransform(Transform):\n \"\"\"\n A composite transform formed by applying transform *a* then\n transform *b*.\n\n This \"generic\" version can handle any two arbitrary\n transformations.\n \"\"\"\n pass_through = True\n\n def __init__(self, a, b, **kwargs):\n \"\"\"\n Create a new composite transform that is the result of\n applying transform *a* then transform *b*.\n\n You will generally not call this constructor directly but use\n the :func:`composite_transform_factory` function instead,\n which can automatically choose the best kind of composite\n transform instance to create.\n \"\"\"\n if a.output_dims != b.input_dims:\n msg = (\"The output dimension of 'a' must be equal to the input\"\n \" dimensions of 'b'\")\n raise ValueError(msg)\n self.input_dims = a.input_dims\n self.output_dims = b.output_dims\n\n Transform.__init__(self, **kwargs)\n self._a = a\n self._b = b\n self.set_children(a, b)\n\n is_affine = property(lambda self: self._a.is_affine and self._b.is_affine)\n\n def frozen(self):\n self._invalid = 0\n frozen = composite_transform_factory(self._a.frozen(), self._b.frozen())\n if not isinstance(frozen, CompositeGenericTransform):\n return frozen.frozen()\n return frozen\n frozen.__doc__ = Transform.frozen.__doc__\n\n def _invalidate_internal(self, value, invalidating_node):\n # In some cases for a composite transform, an invalidating call to AFFINE_ONLY needs\n # to be extended to invalidate the NON_AFFINE part too. These cases are when the right\n # hand transform is non-affine and either:\n # (a) the left hand transform is non affine\n # (b) it is the left hand node which has triggered the invalidation\n if value == Transform.INVALID_AFFINE \\\n and not self._b.is_affine \\\n and (not self._a.is_affine or invalidating_node is self._a):\n\n value = Transform.INVALID\n\n Transform._invalidate_internal(self, value=value,\n invalidating_node=invalidating_node)\n\n def __eq__(self, other):\n if isinstance(other, (CompositeGenericTransform, CompositeAffine2D)):\n return self is other or (self._a == other._a and self._b == other._b)\n else:\n return False\n\n def _iter_break_from_left_to_right(self):\n for lh_compliment, rh_compliment in self._a._iter_break_from_left_to_right():\n yield lh_compliment, rh_compliment + self._b\n for lh_compliment, rh_compliment in self._b._iter_break_from_left_to_right():\n yield self._a + lh_compliment, rh_compliment\n\n @property\n def depth(self):\n return self._a.depth + self._b.depth\n\n def _get_is_affine(self):\n return self._a.is_affine and self._b.is_affine\n is_affine = property(_get_is_affine)\n\n def _get_is_separable(self):\n return self._a.is_separable and self._b.is_separable\n is_separable = property(_get_is_separable)\n\n if DEBUG:\n def __str__(self):\n return '(%s, %s)' % (self._a, self._b)\n\n def __repr__(self):\n return \"CompositeGenericTransform(%r, %r)\" % (self._a, self._b)\n\n def transform_affine(self, points):\n return self.get_affine().transform(points)\n transform_affine.__doc__ = Transform.transform_affine.__doc__\n\n def transform_non_affine(self, points):\n if self._a.is_affine and self._b.is_affine:\n return points\n elif not self._a.is_affine and self._b.is_affine:\n return self._a.transform_non_affine(points)\n else:\n return self._b.transform_non_affine(\n self._a.transform(points))\n transform_non_affine.__doc__ = Transform.transform_non_affine.__doc__\n\n def transform_path_non_affine(self, path):\n if self._a.is_affine and self._b.is_affine:\n return path\n elif not self._a.is_affine and self._b.is_affine:\n return self._a.transform_path_non_affine(path)\n else:\n return self._b.transform_path_non_affine(\n self._a.transform_path(path))\n transform_path_non_affine.__doc__ = Transform.transform_path_non_affine.__doc__\n\n def get_affine(self):\n if not self._b.is_affine:\n return self._b.get_affine()\n else:\n return Affine2D(np.dot(self._b.get_affine().get_matrix(),\n self._a.get_affine().get_matrix()))\n get_affine.__doc__ = Transform.get_affine.__doc__\n\n def inverted(self):\n return CompositeGenericTransform(self._b.inverted(), self._a.inverted())\n inverted.__doc__ = Transform.inverted.__doc__\n\n def _get_has_inverse(self):\n return self._a.has_inverse and self._b.has_inverse\n has_inverse = property(_get_has_inverse)\n\n\nclass CompositeAffine2D(Affine2DBase):\n \"\"\"\n A composite transform formed by applying transform *a* then transform *b*.\n\n This version is an optimization that handles the case where both *a*\n and *b* are 2D affines.\n \"\"\"\n def __init__(self, a, b, **kwargs):\n \"\"\"\n Create a new composite transform that is the result of\n applying transform *a* then transform *b*.\n\n Both *a* and *b* must be instances of :class:`Affine2DBase`.\n\n You will generally not call this constructor directly but use\n the :func:`composite_transform_factory` function instead,\n which can automatically choose the best kind of composite\n transform instance to create.\n \"\"\"\n if not a.is_affine or not b.is_affine:\n raise ValueError(\"'a' and 'b' must be affine transforms\")\n if a.output_dims != b.input_dims:\n msg = (\"The output dimension of 'a' must be equal to the input\"\n \" dimensions of 'b'\")\n raise ValueError(msg)\n self.input_dims = a.input_dims\n self.output_dims = b.output_dims\n\n Affine2DBase.__init__(self, **kwargs)\n self._a = a\n self._b = b\n self.set_children(a, b)\n self._mtx = None\n\n if DEBUG:\n def __str__(self):\n return '(%s, %s)' % (self._a, self._b)\n\n @property\n def depth(self):\n return self._a.depth + self._b.depth\n\n def _iter_break_from_left_to_right(self):\n for lh_compliment, rh_compliment in self._a._iter_break_from_left_to_right():\n yield lh_compliment, rh_compliment + self._b\n for lh_compliment, rh_compliment in self._b._iter_break_from_left_to_right():\n yield self._a + lh_compliment, rh_compliment\n\n def __repr__(self):\n return \"CompositeAffine2D(%r, %r)\" % (self._a, self._b)\n\n def get_matrix(self):\n if self._invalid:\n self._mtx = np.dot(\n self._b.get_matrix(),\n self._a.get_matrix())\n self._inverted = None\n self._invalid = 0\n return self._mtx\n get_matrix.__doc__ = Affine2DBase.get_matrix.__doc__\n\n\ndef composite_transform_factory(a, b):\n \"\"\"\n Create a new composite transform that is the result of applying\n transform a then transform b.\n\n Shortcut versions of the blended transform are provided for the\n case where both child transforms are affine, or one or the other\n is the identity transform.\n\n Composite transforms may also be created using the '+' operator,\n e.g.::\n\n c = a + b\n \"\"\"\n # check to see if any of a or b are IdentityTransforms. We use\n # isinstance here to guarantee that the transforms will *always*\n # be IdentityTransforms. Since TransformWrappers are mutable,\n # use of equality here would be wrong.\n if isinstance(a, IdentityTransform):\n return b\n elif isinstance(b, IdentityTransform):\n return a\n elif isinstance(a, Affine2D) and isinstance(b, Affine2D):\n return CompositeAffine2D(a, b)\n return CompositeGenericTransform(a, b)\n\n\nclass BboxTransform(Affine2DBase):\n \"\"\"\n :class:`BboxTransform` linearly transforms points from one\n :class:`Bbox` to another :class:`Bbox`.\n \"\"\"\n is_separable = True\n\n def __init__(self, boxin, boxout, **kwargs):\n \"\"\"\n Create a new :class:`BboxTransform` that linearly transforms\n points from *boxin* to *boxout*.\n \"\"\"\n if not boxin.is_bbox or not boxout.is_bbox:\n msg = \"'boxin' and 'boxout' must be bbox\"\n raise ValueError(msg)\n\n Affine2DBase.__init__(self, **kwargs)\n self._boxin = boxin\n self._boxout = boxout\n self.set_children(boxin, boxout)\n self._mtx = None\n self._inverted = None\n\n def __repr__(self):\n return \"BboxTransform(%r, %r)\" % (self._boxin, self._boxout)\n\n def get_matrix(self):\n if self._invalid:\n inl, inb, inw, inh = self._boxin.bounds\n outl, outb, outw, outh = self._boxout.bounds\n x_scale = outw / inw\n y_scale = outh / inh\n if DEBUG and (x_scale == 0 or y_scale == 0):\n raise ValueError(\"Transforming from or to a singular bounding box.\")\n self._mtx = np.array([[x_scale, 0.0 , (-inl*x_scale+outl)],\n [0.0 , y_scale, (-inb*y_scale+outb)],\n [0.0 , 0.0 , 1.0 ]],\n np.float_)\n self._inverted = None\n self._invalid = 0\n return self._mtx\n get_matrix.__doc__ = Affine2DBase.get_matrix.__doc__\n\n\nclass BboxTransformTo(Affine2DBase):\n \"\"\"\n :class:`BboxTransformTo` is a transformation that linearly\n transforms points from the unit bounding box to a given\n :class:`Bbox`.\n \"\"\"\n is_separable = True\n\n def __init__(self, boxout, **kwargs):\n \"\"\"\n Create a new :class:`BboxTransformTo` that linearly transforms\n points from the unit bounding box to *boxout*.\n \"\"\"\n if not boxout.is_bbox:\n raise ValueError(\"'boxout' must be bbox\")\n\n Affine2DBase.__init__(self, **kwargs)\n self._boxout = boxout\n self.set_children(boxout)\n self._mtx = None\n self._inverted = None\n\n def __repr__(self):\n return \"BboxTransformTo(%r)\" % (self._boxout)\n\n def get_matrix(self):\n if self._invalid:\n outl, outb, outw, outh = self._boxout.bounds\n if DEBUG and (outw == 0 or outh == 0):\n raise ValueError(\"Transforming to a singular bounding box.\")\n self._mtx = np.array([[outw, 0.0, outl],\n [ 0.0, outh, outb],\n [ 0.0, 0.0, 1.0]],\n np.float_)\n self._inverted = None\n self._invalid = 0\n return self._mtx\n get_matrix.__doc__ = Affine2DBase.get_matrix.__doc__\n\n\nclass BboxTransformToMaxOnly(BboxTransformTo):\n \"\"\"\n :class:`BboxTransformTo` is a transformation that linearly\n transforms points from the unit bounding box to a given\n :class:`Bbox` with a fixed upper left of (0, 0).\n \"\"\"\n def __repr__(self):\n return \"BboxTransformToMaxOnly(%r)\" % (self._boxout)\n\n def get_matrix(self):\n if self._invalid:\n xmax, ymax = self._boxout.max\n if DEBUG and (xmax == 0 or ymax == 0):\n raise ValueError(\"Transforming to a singular bounding box.\")\n self._mtx = np.array([[xmax, 0.0, 0.0],\n [ 0.0, ymax, 0.0],\n [ 0.0, 0.0, 1.0]],\n np.float_)\n self._inverted = None\n self._invalid = 0\n return self._mtx\n get_matrix.__doc__ = Affine2DBase.get_matrix.__doc__\n\n\nclass BboxTransformFrom(Affine2DBase):\n \"\"\"\n :class:`BboxTransformFrom` linearly transforms points from a given\n :class:`Bbox` to the unit bounding box.\n \"\"\"\n is_separable = True\n\n def __init__(self, boxin, **kwargs):\n if not boxin.is_bbox:\n raise ValueError(\"'boxin' must be bbox\")\n\n Affine2DBase.__init__(self, **kwargs)\n self._boxin = boxin\n self.set_children(boxin)\n self._mtx = None\n self._inverted = None\n\n def __repr__(self):\n return \"BboxTransformFrom(%r)\" % (self._boxin)\n\n def get_matrix(self):\n if self._invalid:\n inl, inb, inw, inh = self._boxin.bounds\n if DEBUG and (inw == 0 or inh == 0):\n raise ValueError(\"Transforming from a singular bounding box.\")\n x_scale = 1.0 / inw\n y_scale = 1.0 / inh\n self._mtx = np.array([[x_scale, 0.0 , (-inl*x_scale)],\n [0.0 , y_scale, (-inb*y_scale)],\n [0.0 , 0.0 , 1.0 ]],\n np.float_)\n self._inverted = None\n self._invalid = 0\n return self._mtx\n get_matrix.__doc__ = Affine2DBase.get_matrix.__doc__\n\n\nclass ScaledTranslation(Affine2DBase):\n \"\"\"\n A transformation that translates by *xt* and *yt*, after *xt* and *yt*\n have been transformad by the given transform *scale_trans*.\n \"\"\"\n def __init__(self, xt, yt, scale_trans, **kwargs):\n Affine2DBase.__init__(self, **kwargs)\n self._t = (xt, yt)\n self._scale_trans = scale_trans\n self.set_children(scale_trans)\n self._mtx = None\n self._inverted = None\n\n def __repr__(self):\n return \"ScaledTranslation(%r)\" % (self._t,)\n\n def get_matrix(self):\n if self._invalid:\n xt, yt = self._scale_trans.transform_point(self._t)\n self._mtx = np.array([[1.0, 0.0, xt],\n [0.0, 1.0, yt],\n [0.0, 0.0, 1.0]],\n np.float_)\n self._invalid = 0\n self._inverted = None\n return self._mtx\n get_matrix.__doc__ = Affine2DBase.get_matrix.__doc__\n\n\nclass TransformedPath(TransformNode):\n \"\"\"\n A :class:`TransformedPath` caches a non-affine transformed copy of\n the :class:`~matplotlib.path.Path`. This cached copy is\n automatically updated when the non-affine part of the transform\n changes.\n\n .. note::\n\n Paths are considered immutable by this class. Any update to the\n path's vertices/codes will not trigger a transform recomputation.\n\n \"\"\"\n def __init__(self, path, transform):\n \"\"\"\n Create a new :class:`TransformedPath` from the given\n :class:`~matplotlib.path.Path` and :class:`Transform`.\n \"\"\"\n if not isinstance(transform, Transform):\n msg = (\"'transform' must be an instance of\"\n \" 'matplotlib.transform.Transform'\")\n raise ValueError(msg)\n TransformNode.__init__(self)\n\n self._path = path\n self._transform = transform\n self.set_children(transform)\n self._transformed_path = None\n self._transformed_points = None\n\n def _revalidate(self):\n # only recompute if the invalidation includes the non_affine part of the transform\n if ((self._invalid & self.INVALID_NON_AFFINE == self.INVALID_NON_AFFINE)\n or self._transformed_path is None):\n self._transformed_path = \\\n self._transform.transform_path_non_affine(self._path)\n self._transformed_points = \\\n Path._fast_from_codes_and_verts(\n self._transform.transform_non_affine(self._path.vertices),\n None,\n {'interpolation_steps': self._path._interpolation_steps,\n 'should_simplify': self._path.should_simplify})\n self._invalid = 0\n\n def get_transformed_points_and_affine(self):\n \"\"\"\n Return a copy of the child path, with the non-affine part of\n the transform already applied, along with the affine part of\n the path necessary to complete the transformation. Unlike\n :meth:`get_transformed_path_and_affine`, no interpolation will\n be performed.\n \"\"\"\n self._revalidate()\n return self._transformed_points, self.get_affine()\n\n def get_transformed_path_and_affine(self):\n \"\"\"\n Return a copy of the child path, with the non-affine part of\n the transform already applied, along with the affine part of\n the path necessary to complete the transformation.\n \"\"\"\n self._revalidate()\n return self._transformed_path, self.get_affine()\n\n def get_fully_transformed_path(self):\n \"\"\"\n Return a fully-transformed copy of the child path.\n \"\"\"\n self._revalidate()\n return self._transform.transform_path_affine(self._transformed_path)\n\n def get_affine(self):\n return self._transform.get_affine()\n\n\ndef nonsingular(vmin, vmax, expander=0.001, tiny=1e-15, increasing=True):\n '''\n Modify the endpoints of a range as needed to avoid singularities.\n\n *vmin*, *vmax*\n the initial endpoints.\n\n *tiny*\n threshold for the ratio of the interval to the maximum absolute\n value of its endpoints. If the interval is smaller than\n this, it will be expanded. This value should be around\n 1e-15 or larger; otherwise the interval will be approaching\n the double precision resolution limit.\n\n *expander*\n fractional amount by which *vmin* and *vmax* are expanded if\n the original interval is too small, based on *tiny*.\n\n *increasing*: [True | False]\n If True (default), swap *vmin*, *vmax* if *vmin* > *vmax*\n\n Returns *vmin*, *vmax*, expanded and/or swapped if necessary.\n\n If either input is inf or NaN, or if both inputs are 0,\n returns -*expander*, *expander*.\n '''\n if (not np.isfinite(vmin)) or (not np.isfinite(vmax)):\n return -expander, expander\n swapped = False\n if vmax < vmin:\n vmin, vmax = vmax, vmin\n swapped = True\n if vmax - vmin <= max(abs(vmin), abs(vmax)) * tiny:\n if vmax == 0 and vmin == 0:\n vmin = -expander\n vmax = expander\n else:\n vmin -= expander*abs(vmin)\n vmax += expander*abs(vmax)\n\n if swapped and not increasing:\n vmin, vmax = vmax, vmin\n return vmin, vmax\n\n\ndef interval_contains(interval, val):\n a, b = interval\n return (\n ((a < b) and (a <= val and b >= val))\n or (b <= val and a >= val))\n\ndef interval_contains_open(interval, val):\n a, b = interval\n return (\n ((a < b) and (a < val and b > val))\n or (b < val and a > val))\n\ndef offset_copy(trans, fig=None, x=0.0, y=0.0, units='inches'):\n '''\n Return a new transform with an added offset.\n args:\n trans is any transform\n kwargs:\n fig is the current figure; it can be None if units are 'dots'\n x, y give the offset\n units is 'inches', 'points' or 'dots'\n '''\n if units == 'dots':\n return trans + Affine2D().translate(x, y)\n if fig is None:\n raise ValueError('For units of inches or points a fig kwarg is needed')\n if units == 'points':\n x /= 72.0\n y /= 72.0\n elif not units == 'inches':\n raise ValueError('units must be dots, points, or inches')\n return trans + ScaledTranslation(x, y, fig.dpi_scale_trans)\n"
] | [
[
"matplotlib.verbose.report"
],
[
"numpy.dot",
"numpy.tan",
"numpy.min",
"numpy.sign",
"numpy.cos",
"numpy.ma.concatenate",
"numpy.deg2rad",
"numpy.concatenate",
"numpy.max",
"numpy.sin",
"matplotlib._path.affine_transform",
"numpy.isfinite",
"numpy.linalg.inv",
"numpy.vstack",
"numpy.array",
"numpy.identity",
"numpy.arctan2",
"matplotlib._path.update_path_extents",
"numpy.ma.getmask",
"numpy.isnan",
"numpy.asarray",
"numpy.errstate",
"numpy.sum",
"numpy.ma.isMaskedArray",
"numpy.any",
"numpy.ma.filled",
"numpy.ma.is_masked",
"numpy.asanyarray"
]
] |
DaulPavid/pyturbo | [
"878e0b1b514c043f1b4ea5cd5268b23c0df5192e"
] | [
"turbo/turbo_encoder.py"
] | [
"#\n# Turbo Encoder\n#\n\nimport numpy as np\n\nfrom .rsc import RSC\n\n\nclass TurboEncoder:\n def __init__(self, interleaver):\n self.interleaver = interleaver\n self.block_size = len(self.interleaver)\n self.encoders = 2 * [RSC()]\n\n def reset(self):\n for e in self.encoders:\n e.reset()\n\n def interleave(self, vector):\n interleaved = np.zeros(self.block_size, dtype=int)\n for i in range(0, self.block_size):\n interleaved[i] = vector[self.interleaver[i]]\n\n return interleaved\n\n def execute(self, vector):\n output_size = 3 * (len(vector) + len(self.encoders[0].registers))\n output = np.zeros(output_size, dtype=int)\n interleaved = self.interleave(vector)\n\n output[1::3], output[::3] = self.encoders[0].execute(vector)\n output[2::3], _ = self.encoders[1].execute(interleaved)\n\n return output\n"
] | [
[
"numpy.zeros"
]
] |
wmcnally/evopose2d | [
"ea05b818044d8d84e9cbbee778bc465be59ebd59"
] | [
"inference_speed.py"
] | [
"import os\nos.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'\nimport tensorflow as tf\nfrom dataset.dataloader import load_tfds\nfrom time import time\nimport argparse\nfrom nets.simple_basline import SimpleBaseline\nfrom nets.evopose2d import EvoPose\nfrom nets.hrnet import HRNet\nfrom utils import detect_hardware\n\n\ndef speed_test(strategy, cfg, split='val', n=1000):\n with strategy.scope():\n if cfg.MODEL.TYPE == 'simple_baseline':\n model = SimpleBaseline(cfg)\n elif cfg.MODEL.TYPE == 'hrnet':\n model = HRNet(cfg)\n elif cfg.MODEL.TYPE == 'evopose':\n model = EvoPose(cfg)\n\n cfg.DATASET.OUTPUT_SHAPE = model.output_shape[1:]\n\n ds = load_tfds(cfg, split, det=cfg.VAL.DET,\n predict_kp=True, drop_remainder=cfg.VAL.DROP_REMAINDER)\n ds = strategy.experimental_distribute_dataset(ds)\n\n @tf.function\n def predict(imgs, flip=False):\n if flip:\n imgs = imgs[:, :, ::-1, :]\n return model(imgs, training=False)\n\n for count, batch in enumerate(ds):\n if count == 1: # skip first pass\n ti = time()\n\n _, imgs, _, _, scores = batch\n\n hms = strategy.run(predict, args=(imgs,)).numpy()\n\n if cfg.VAL.FLIP:\n flip_hms = strategy.run(predict, args=(imgs, True,)).numpy()\n flip_hms = flip_hms[:, :, ::-1, :]\n tmp = flip_hms.copy()\n for i in range(len(cfg.DATASET.KP_FLIP)):\n flip_hms[:, :, :, i] = tmp[:, :, :, cfg.DATASET.KP_FLIP[i]]\n # shift to align features\n flip_hms[:, :, 1:, :] = flip_hms[:, :, 0:-1, :].copy()\n hms = (hms + flip_hms) / 2.\n\n if count == n:\n break\n\n print('FPS: {:.5f}'.format((n * cfg.VAL.BATCH_SIZE) / (time() - ti)))\n\n\nif __name__ == '__main__':\n parser = argparse.ArgumentParser()\n parser.add_argument('--cpu', action='store_true')\n parser.add_argument('--gpu', action='store_true')\n parser.add_argument('--tpu', default='')\n parser.add_argument('-c', '--cfg', required=True) # yaml\n parser.add_argument('-bs', '--batch-size', type=int, default=1)\n parser.add_argument('-n', type=int, default=1000)\n args = parser.parse_args()\n\n from dataset.coco import cn as cfg\n cfg.merge_from_file('configs/' + args.cfg)\n cfg.MODEL.NAME = args.cfg.split('.')[0]\n cfg.VAL.BATCH_SIZE = args.batch_size\n\n if args.cpu:\n strategy = tf.distribute.OneDeviceStrategy('/CPU:0')\n elif args.gpu:\n strategy = tf.distribute.OneDeviceStrategy('/GPU:0')\n else:\n tpu, strategy = detect_hardware(args.tpu)\n\n tf.config.optimizer.set_experimental_options({'disable_meta_optimizer': True})\n speed_test(strategy, cfg, split='val', n=args.n)\n\n\n\n"
] | [
[
"tensorflow.distribute.OneDeviceStrategy",
"tensorflow.config.optimizer.set_experimental_options"
]
] |
ourDirection/ourDirection | [
"b99ed67a8cc0fe5016e03fe3b5ad083b7f8bbdc0"
] | [
"momus/VHRED/split-examples-by-token.py"
] | [
"\"\"\"\nTakes as input a binarized dialogue corpus, splits the examples by a certain token and shuffles it\n\nExample run:\n\n python split-examples-by-token.py Training.dialogues.pkl 2 Training_SplitByDialogues.dialogues --join_last_two_examples\n\n@author Iulian Vlad Serban\n\"\"\"\n\nimport collections\nimport numpy\nimport math\nimport operator\nimport os\nimport sys\nimport logging\nimport cPickle\n\nfrom collections import Counter\n\nlogging.basicConfig(level=logging.INFO)\nlogger = logging.getLogger('text2dict')\n\ndef safe_pickle(obj, filename):\n if os.path.isfile(filename):\n logger.info(\"Overwriting %s.\" % filename)\n else:\n logger.info(\"Saving to %s.\" % filename)\n \n with open(filename, 'wb') as f:\n cPickle.dump(obj, f, protocol=cPickle.HIGHEST_PROTOCOL)\n\n# Thanks to Emile on Stackoverflow:\n# http://stackoverflow.com/questions/4322705/split-a-list-into-nested-lists-on-a-value\n\ndef _itersplit(l, splitters):\n current = []\n for item in l:\n if item in splitters:\n yield current\n current = []\n else:\n current.append(item)\n yield current\n\ndef magicsplit(l, *splitters):\n return [subl for subl in _itersplit(l, splitters) if subl]\n\nimport argparse\nparser = argparse.ArgumentParser()\nparser.add_argument(\"input\", type=str, help=\"Binarized dialogue corpus (pkl file)\")\nparser.add_argument(\"token_id\", type=int, help=\"Token index to split examples by (e.g. to split by end-of-dialogue set this to 2)\")\nparser.add_argument(\"consecutive_examples_to_merge\", type=int, default='1', help=\"After splitting these number of examples will be merged.\")\nparser.add_argument(\"--join_last_two_examples\",\n action=\"store_true\", default=False,\n help=\"If on, will join the last two splits generated from each example. This is useful to handle empty or very short last samples\")\n\n\nparser.add_argument(\"output\", type=str, help=\"Filename of processed binarized dialogue corpus (pkl file)\")\nargs = parser.parse_args()\n\nif not os.path.isfile(args.input):\n raise Exception(\"Input file not found!\")\n\nlogger.info(\"Loading dialogue corpus\")\ndata = cPickle.load(open(args.input, 'r'))\ndata_len = len(data)\n\nlogger.info('Corpus loaded... Data len is %d' % data_len)\n\n# Count number of tokens\ntokens_count = 0\nfor i in range(data_len):\n tokens_count += len(data[i])\nlogger.info('Tokens count %d' % tokens_count)\n\n\nlogger.info(\"Splitting corpus examples by token id... \")\nprocessed_binarized_corpus = []\nfor i in range(data_len):\n logger.info(' Example %d ' % i)\n new_examples = magicsplit(data[i], int(args.token_id))\n\n # If option is specified, we append the last new example to the second last one\n if args.join_last_two_examples and len(new_examples) > 1:\n new_examples[len(new_examples)-2] += new_examples[len(new_examples)-1]\n del new_examples[len(new_examples)-1]\n\n # Simpler version of the two for loops, which does not allow merging together samples\n #for new_example in new_examples:\n # processed_binarized_corpus.append(new_example + [int(args.token_id)])\n\n s = int(math.floor(len(new_examples) / args.consecutive_examples_to_merge))\n for j in range(1, s):\n start_index = j*args.consecutive_examples_to_merge\n merged_example = []\n for k in reversed(range(args.consecutive_examples_to_merge)):\n merged_example += new_examples[start_index-k-1] + [int(args.token_id)]\n processed_binarized_corpus.append(merged_example)\n\n if s > 0:\n merged_example = []\n for k in range((s-1)*args.consecutive_examples_to_merge, len(new_examples)):\n merged_example += new_examples[k] + [int(args.token_id)]\n processed_binarized_corpus.append(merged_example)\n else:\n merged_example = []\n for k in range(len(new_examples)):\n merged_example += new_examples[k] + [int(args.token_id)]\n processed_binarized_corpus.append(merged_example)\n\n\nlogger.info('New data len is %d' % len(processed_binarized_corpus))\n\n# Count number of tokens\nprocessed_tokens_count = 0\nfor i in range(len(processed_binarized_corpus)):\n processed_tokens_count += len(processed_binarized_corpus[i])\nlogger.info('New tokens count %d' % processed_tokens_count)\n\n# When splitting by end-of-utterance token </s>, there are some instances with multiple </s> at the end of each example. Our splitting method will effectively remove these, but it is not of any concern to us.\n# assert(processed_tokens_count == tokens_count)\n\nlogger.info(\"Reshuffling corpus.\")\nrng = numpy.random.RandomState(13248)\nrng.shuffle(processed_binarized_corpus)\n\nlogger.info(\"Saving corpus.\")\nsafe_pickle(processed_binarized_corpus, args.output + \".pkl\")\n\nlogger.info(\"Corpus saved. All done!\")\n"
] | [
[
"numpy.random.RandomState"
]
] |
YosefLab/SingleCellLineageTracing | [
"010072b307f7eadbf10dc4af8b2165e48f1736a7",
"010072b307f7eadbf10dc4af8b2165e48f1736a7"
] | [
"test/simulator_tests/birth_death_simulator_test.py",
"test/preprocess_tests/align_sequence_test.py"
] | [
"import unittest\n\nimport networkx as nx\nimport numpy as np\n\nfrom typing import List, Tuple\n\n\nfrom cassiopeia.data.CassiopeiaTree import CassiopeiaTree\nfrom cassiopeia.mixins import TreeSimulatorError\nfrom cassiopeia.simulator.BirthDeathFitnessSimulator import (\n BirthDeathFitnessSimulator,\n)\n\nimport cassiopeia.data.utilities as utilities\n\n\ndef extract_tree_statistics(\n tree: CassiopeiaTree,\n) -> Tuple[List[float], int, bool]:\n \"\"\"A helper function for testing simulated trees.\n\n Outputs the total lived time for each extant lineage, the number of extant\n lineages, and whether the tree has the expected node degrees (to ensure\n unifurcations were collapsed).\n\n Args:\n tree: The tree to test\n\n Returns:\n The total time lived for each leaf, the number of leaves, and if the\n degrees only have degree 0 or 2\n \"\"\"\n\n times = []\n out_degrees = []\n for i in tree.nodes:\n if tree.is_leaf(i):\n times.append(tree.get_time(i))\n out_degrees.append(len(tree.children(i)))\n out_degrees.pop(0)\n\n correct_degrees = all(x == 2 or x == 0 for x in out_degrees)\n\n return times, len(times), correct_degrees\n\n\nclass BirthDeathSimulatorTest(unittest.TestCase):\n def test_bad_waiting_distributions(self):\n \"\"\"Ensures errors when invalid distributions are given.\"\"\"\n with self.assertRaises(TreeSimulatorError):\n bd_sim = BirthDeathFitnessSimulator(\n lambda _: -1, 1, experiment_time=1\n )\n tree = bd_sim.simulate_tree()\n\n with self.assertRaises(TreeSimulatorError):\n bd_sim = BirthDeathFitnessSimulator(lambda _: 0, 1, num_extant=4)\n tree = bd_sim.simulate_tree()\n\n with self.assertRaises(TreeSimulatorError):\n bd_sim = BirthDeathFitnessSimulator(\n lambda _: 1, 1, lambda: -1, num_extant=1\n )\n tree = bd_sim.simulate_tree()\n\n with self.assertRaises(TreeSimulatorError):\n bd_sim = BirthDeathFitnessSimulator(\n lambda _: 1, 1, lambda: 0, experiment_time=1\n )\n tree = bd_sim.simulate_tree()\n\n with self.assertRaises(TreeSimulatorError):\n bd_sim = BirthDeathFitnessSimulator(\n lambda _: 1,\n 1,\n lambda: 0,\n mutation_distribution=lambda: -1,\n fitness_distribution=lambda: 1,\n experiment_time=1,\n )\n tree = bd_sim.simulate_tree()\n\n def test_bad_stopping_conditions(self):\n \"\"\"Ensures errors when an invalid stopping conditions are given.\"\"\"\n with self.assertRaises(TreeSimulatorError):\n bd_sim = BirthDeathFitnessSimulator(lambda _: 1, 1, lambda: 2)\n\n with self.assertRaises(TreeSimulatorError):\n bd_sim = BirthDeathFitnessSimulator(\n lambda _: 1, 1, lambda: 2, num_extant=0.5\n )\n\n with self.assertRaises(TreeSimulatorError):\n bd_sim = BirthDeathFitnessSimulator(\n lambda _: 1, 1, lambda: 2, num_extant=-1\n )\n\n with self.assertRaises(TreeSimulatorError):\n bd_sim = BirthDeathFitnessSimulator(\n lambda _: 1, 1, lambda: 2, num_extant=0\n )\n\n with self.assertRaises(TreeSimulatorError):\n bd_sim = BirthDeathFitnessSimulator(\n lambda _: 1, 1, lambda: 2, experiment_time=-1\n )\n\n with self.assertRaises(TreeSimulatorError):\n bd_sim = BirthDeathFitnessSimulator(\n lambda _: 1, 1, lambda: 2, experiment_time=0\n )\n\n def test_dead_at_start(self):\n \"\"\"Ensures errors in base case where all lineages die on first event.\"\"\"\n with self.assertRaises(TreeSimulatorError):\n bd_sim = BirthDeathFitnessSimulator(\n lambda _: 2, 1, lambda: 1, num_extant=4\n )\n tree = bd_sim.simulate_tree()\n\n with self.assertRaises(TreeSimulatorError):\n bd_sim = BirthDeathFitnessSimulator(\n lambda _: 2, 1, lambda: 1, experiment_time=4\n )\n tree = bd_sim.simulate_tree()\n\n def test_dead_before_end(self):\n \"\"\"Ensures errors when all lineages die before stopping condition.\"\"\"\n birth_wd = lambda scale: np.random.exponential(scale)\n death_wd = lambda: np.random.exponential(0.6)\n\n with self.assertRaises(TreeSimulatorError):\n bd_sim = BirthDeathFitnessSimulator(\n birth_wd, 0.5, death_wd, num_extant=8, random_seed=5\n )\n tree = bd_sim.simulate_tree()\n\n with self.assertRaises(TreeSimulatorError):\n bd_sim = BirthDeathFitnessSimulator(\n birth_wd, 0.5, death_wd, experiment_time=2, random_seed=5\n )\n tree = bd_sim.simulate_tree()\n\n def test_single_lineage(self):\n \"\"\"Tests base case that stopping conditions work before divisions.\"\"\"\n bd_sim = BirthDeathFitnessSimulator(lambda _: 1, 1, num_extant=1)\n tree = bd_sim.simulate_tree()\n results = extract_tree_statistics(tree)\n self.assertEqual(results[1], 1)\n self.assertEqual(tree.get_branch_length(\"0\", \"1\"), 1.0)\n self.assertEqual(results[0], [1])\n\n bd_sim = BirthDeathFitnessSimulator(lambda _: 1, 1, experiment_time=1)\n tree = bd_sim.simulate_tree()\n results = extract_tree_statistics(tree)\n self.assertEqual(results[1], 1)\n self.assertEqual(tree.get_branch_length(\"0\", \"1\"), 1.0)\n self.assertEqual(results[0], [1])\n\n def test_constant_yule(self):\n \"\"\"Tests small case without death with constant waiting times.\"\"\"\n bd_sim = BirthDeathFitnessSimulator(lambda _: 1, 1, num_extant=32)\n tree = bd_sim.simulate_tree()\n results = extract_tree_statistics(tree)\n for i in results[0]:\n self.assertEqual(i, 6)\n self.assertEqual(results[1], 32)\n self.assertTrue(results[2])\n\n bd_sim = BirthDeathFitnessSimulator(lambda _: 1, 1, experiment_time=6)\n tree = bd_sim.simulate_tree()\n results = extract_tree_statistics(tree)\n for i in results[0]:\n self.assertEqual(i, 6)\n self.assertEqual(results[1], 32)\n self.assertTrue(results[2])\n\n def test_nonconstant_yule(self):\n \"\"\"Tests case without death with variable waiting times.\"\"\"\n birth_wd = lambda scale: np.random.exponential(scale)\n\n bd_sim = BirthDeathFitnessSimulator(\n birth_wd, 1, num_extant=16, random_seed=54\n )\n tree = bd_sim.simulate_tree()\n results = extract_tree_statistics(tree)\n self.assertTrue(all(np.isclose(x, results[0][0]) for x in results[0]))\n self.assertEqual(results[1], 16)\n self.assertTrue(results[2])\n self.assertEqual(max([int(i) for i in tree.nodes]), 31)\n\n bd_sim = BirthDeathFitnessSimulator(\n birth_wd, 1, experiment_time=2, random_seed=54\n )\n tree = bd_sim.simulate_tree()\n results = extract_tree_statistics(tree)\n for i in results[0]:\n self.assertEqual(i, 2)\n self.assertTrue(results[2])\n\n def test_nonconstant_birth_death(self):\n \"\"\"Tests case with with variable birth and death waiting times.\n Also, tests pruning dead lineages and unifurcation collapsing.\"\"\"\n birth_wd = lambda scale: np.random.exponential(scale)\n death_wd = lambda: np.random.exponential(1.5)\n\n bd_sim = BirthDeathFitnessSimulator(\n birth_wd, 0.5, death_wd, num_extant=8, random_seed=1234\n )\n tree = bd_sim.simulate_tree()\n results = extract_tree_statistics(tree)\n self.assertTrue(all(np.isclose(x, results[0][0]) for x in results[0]))\n self.assertEqual(results[1], 8)\n self.assertTrue(results[2])\n self.assertNotIn(\"9\", tree.nodes)\n self.assertNotIn(\"2\", tree.nodes)\n\n bd_sim = BirthDeathFitnessSimulator(\n birth_wd, 0.5, death_wd, experiment_time=2, random_seed=1234\n )\n tree = bd_sim.simulate_tree()\n results = extract_tree_statistics(tree)\n for i in results[0]:\n self.assertTrue(np.isclose(i, 2))\n self.assertTrue(results[2])\n self.assertNotIn(\"9\", tree.nodes)\n self.assertNotIn(\"2\", tree.nodes)\n\n def test_nonconstant_birth_death_no_unifurcation_collapsing(self):\n \"\"\"Tests case with with variable birth and death waiting times.\n Checks that unifurcations are not collapsed.\"\"\"\n birth_wd = lambda scale: np.random.exponential(scale)\n death_wd = lambda: np.random.exponential(1.5)\n\n bd_sim = BirthDeathFitnessSimulator(\n birth_wd,\n 0.5,\n death_wd,\n num_extant=8,\n collapse_unifurcations=False,\n random_seed=12,\n )\n tree = bd_sim.simulate_tree()\n results = extract_tree_statistics(tree)\n self.assertTrue(all(np.isclose(x, results[0][0]) for x in results[0]))\n self.assertEqual(results[1], 8)\n self.assertFalse(results[2])\n self.assertNotIn(\"3\", tree.nodes)\n self.assertIn(\"2\", tree.nodes)\n self.assertIn(\"6\", tree.nodes)\n\n bd_sim = BirthDeathFitnessSimulator(\n birth_wd,\n 0.5,\n death_wd,\n experiment_time=1.3,\n collapse_unifurcations=False,\n random_seed=12,\n )\n tree = bd_sim.simulate_tree()\n results = extract_tree_statistics(tree)\n for i in results[0]:\n self.assertTrue(np.isclose(i, 1.3))\n self.assertFalse(results[2])\n self.assertNotIn(\"3\", tree.nodes)\n self.assertIn(\"2\", tree.nodes)\n self.assertIn(\"6\", tree.nodes)\n\n def test_nonconstant_birth_death_both_stopping_conditions(self):\n \"\"\"Tests case with with variable birth and death waiting times.\n Checks that using both stopping conditions works fine.\"\"\"\n birth_wd = lambda scale: np.random.exponential(scale)\n death_wd = lambda: np.random.exponential(1.5)\n\n bd_sim = BirthDeathFitnessSimulator(\n birth_wd,\n 0.5,\n death_wd,\n num_extant=8,\n experiment_time=2,\n random_seed=17,\n )\n tree = bd_sim.simulate_tree()\n results = extract_tree_statistics(tree)\n self.assertTrue(all(np.isclose(x, results[0][0]) for x in results[0]))\n self.assertTrue(all(x > 1 for x in results[0]))\n self.assertEqual(results[1], 8)\n self.assertTrue(results[2])\n\n bd_sim = BirthDeathFitnessSimulator(\n birth_wd,\n 0.5,\n death_wd,\n num_extant=8,\n experiment_time=1,\n random_seed=17,\n )\n tree = bd_sim.simulate_tree()\n results = extract_tree_statistics(tree)\n for i in results[0]:\n self.assertTrue(np.isclose(i, 1))\n self.assertEqual(results[1], 3)\n self.assertTrue(results[2])\n\n def test_nonconstant_yule_with_predictable_fitness(self):\n \"\"\"Tests case with birth and death with constant fitness.\"\"\"\n\n def check_fitness_values_as_expected(tree: nx.DiGraph):\n \"\"\"Checks if the fitness value stored at each node is what we\n expect given deterministic fitness evolution\"\"\"\n tree = tree.copy()\n for u, v in tree.edges:\n tree[u][v][\"val\"] = 1\n tree.nodes[\"0\"][\"depth\"] = 0\n for u, v in nx.dfs_edges(tree, source=\"0\"):\n tree.nodes[v][\"depth\"] = (\n tree.nodes[u][\"depth\"] + tree[u][v][\"val\"]\n )\n leaves = [n for n in tree if tree.out_degree(n) == 0]\n for i in tree.nodes:\n if i in leaves:\n self.assertTrue(\n np.isclose(\n tree.nodes[i][\"birth_scale\"],\n 0.5 * 0.98 ** (2 * (tree.nodes[i][\"depth\"] - 1)),\n )\n )\n else:\n self.assertTrue(\n np.isclose(\n tree.nodes[i][\"birth_scale\"],\n 0.5 * 0.98 ** (2 * tree.nodes[i][\"depth\"]),\n )\n )\n\n birth_wd = lambda scale: np.random.exponential(scale)\n\n bd_sim = BirthDeathFitnessSimulator(\n birth_wd,\n 0.5,\n mutation_distribution=lambda: 2,\n fitness_distribution=lambda: 1,\n fitness_base=0.98,\n num_extant=8,\n random_seed=1234,\n )\n tree = bd_sim.simulate_tree()\n results = extract_tree_statistics(tree)\n self.assertTrue(all(np.isclose(x, results[0][0]) for x in results[0]))\n self.assertEqual(results[1], 8)\n self.assertTrue(results[2])\n check_fitness_values_as_expected(tree.get_tree_topology())\n\n bd_sim = BirthDeathFitnessSimulator(\n birth_wd,\n 0.5,\n mutation_distribution=lambda: 2,\n fitness_distribution=lambda: 1,\n fitness_base=0.98,\n experiment_time=0.6,\n random_seed=1234,\n )\n tree = bd_sim.simulate_tree()\n results = extract_tree_statistics(tree)\n for i in results[0]:\n self.assertTrue(np.isclose(i, 0.6))\n self.assertTrue(results[2])\n check_fitness_values_as_expected(tree.get_tree_topology())\n\n def test_nonconstant_birth_death_with_variable_fitness(self):\n \"\"\"Tests a case with variable birth and death waiting times, as well\n as variable fitness evolution. Also tests pruning and collapsing.\"\"\"\n\n birth_wd = lambda scale: np.random.exponential(scale)\n death_wd = lambda: np.random.exponential(0.6)\n mut_dist = lambda: 1 if np.random.uniform() < 0.2 else 0\n fit_dist = lambda: np.random.uniform(-1, 1)\n\n bd_sim = BirthDeathFitnessSimulator(\n birth_wd,\n 0.5,\n death_wd,\n mut_dist,\n fit_dist,\n 1.5,\n num_extant=8,\n random_seed=12364,\n )\n tree = bd_sim.simulate_tree()\n results = extract_tree_statistics(tree)\n self.assertTrue(all(np.isclose(x, results[0][0]) for x in results[0]))\n self.assertEqual(results[1], 8)\n self.assertTrue(results[2])\n self.assertNotIn(2, tree.nodes)\n self.assertNotIn(3, tree.nodes)\n\n bd_sim = BirthDeathFitnessSimulator(\n birth_wd,\n 0.5,\n death_wd,\n mut_dist,\n fit_dist,\n 1.5,\n experiment_time=3,\n random_seed=12364,\n )\n tree = bd_sim.simulate_tree()\n results = extract_tree_statistics(tree)\n for i in results[0]:\n self.assertTrue(np.isclose(i, 3))\n self.assertTrue(results[2])\n self.assertNotIn(2, tree.nodes)\n self.assertNotIn(3, tree.nodes)\n\n\nif __name__ == \"__main__\":\n unittest.main()\n",
"\"\"\"\nTests for the sequence alignment in pipeline.py.\n\"\"\"\nimport unittest\n\nimport numpy as np\nimport pandas as pd\n\nimport cassiopeia\n\n\nclass TestAlignSequence(unittest.TestCase):\n def setUp(self):\n\n self.queries = pd.DataFrame.from_dict(\n {\n \"cellBC\": [\"A\", \"A\", \"A\", \"B\", \"B\", \"C\", \"C\", \"C\"],\n \"UMI\": [\"1\", \"2\", \"3\", \"1\", \"2\", \"1\", \"2\", \"3\"],\n \"readCount\": [20, 30, 30, 40, 40, 10, 10, 15],\n \"seq\": [\n \"AACCTTGG\",\n \"ACTG\",\n \"AACCTTGGACTGCATCG\",\n \"AATTAA\",\n \"ACTGGACT\",\n \"AACCTTGGGG\",\n \"AAAAAAAAAAA\",\n \"TACTCTATA\",\n ],\n }\n )\n self.queries[\"readName\"] = self.queries.apply(\n lambda x: \"_\".join([x.cellBC, x.UMI, str(x.readCount)]), axis=1\n )\n\n self.reference = \"AACCTTGG\"\n\n def test_alignment_dataframe_structure(self):\n\n aln_df = cassiopeia.pp.align_sequences(\n self.queries,\n ref=self.reference,\n gap_open_penalty=20,\n gap_extend_penalty=1,\n n_threads=2,\n )\n\n self.assertEqual(aln_df.shape[0], self.queries.shape[0])\n\n for cellBC in self.queries[\"cellBC\"].unique():\n self.assertIn(cellBC, aln_df[\"cellBC\"].unique())\n\n expected_columns = [\n \"cellBC\",\n \"UMI\",\n \"AlignmentScore\",\n \"CIGAR\",\n \"QueryBegin\",\n \"ReferenceBegin\",\n \"Seq\",\n \"readName\",\n \"readCount\",\n ]\n\n for column in expected_columns:\n self.assertIn(column, aln_df.columns)\n\n def test_extremely_large_gap_open_penalty(self):\n\n aln_df = cassiopeia.pp.align_sequences(\n self.queries,\n ref=self.reference,\n gap_open_penalty=255,\n gap_extend_penalty=1,\n )\n\n # since the gap open penalty is so large, enforce that\n # no gaps should occur\n for ind, row in aln_df.iterrows():\n\n self.assertNotIn(\"D\", row.CIGAR)\n self.assertNotIn(\"I\", row.CIGAR)\n\n def test_default_alignment_works(self):\n\n aln_df = cassiopeia.pp.align_sequences(\n self.queries,\n ref=self.reference,\n gap_open_penalty=2,\n gap_extend_penalty=1,\n )\n\n expected_alignments = {\n \"A_1_20\": (\"8M\", 40),\n \"A_2_30\": (\"2M2D2M\", 17),\n \"A_3_30\": (\"8M\", 40),\n \"B_1_40\": (\"2M2D2M\", 17),\n \"B_2_40\": (\"2M2D3M\", 22),\n \"C_1_10\": (\"8M\", 40),\n \"C_2_10\": (\"2M\", 10),\n \"C_3_15\": (\"2M1I2M1I1M\", 21),\n }\n\n for read_name in aln_df[\"readName\"].unique():\n\n expected_cigar = expected_alignments[read_name][0]\n expected_score = expected_alignments[read_name][1]\n\n self.assertEqual(\n aln_df.loc[aln_df[\"readName\"] == read_name, \"CIGAR\"].iloc[0],\n expected_cigar,\n )\n self.assertEqual(\n aln_df.loc[aln_df[\"readName\"] == read_name, \"AlignmentScore\"].iloc[0],\n expected_score,\n )\n\n def test_global_alignment(self):\n\n aln_df = cassiopeia.pp.align_sequences(\n self.queries,\n ref=self.reference,\n gap_open_penalty=2,\n gap_extend_penalty=1,\n method=\"global\",\n )\n\n expected_alignments = {\n \"A_1_20\": (\"8M\", 40),\n \"A_2_30\": (\"1M2D2M1D1M1D\", 15),\n \"A_3_30\": (\"8M9I\", 40),\n \"B_1_40\": (\"2M2D2M2D2I\", 14),\n \"B_2_40\": (\"1M2D2M1D2M3I\", 20),\n \"C_1_10\": (\"8M2I\", 40),\n \"C_2_10\": (\"2M6D9I\", 3),\n \"C_3_15\": (\"1I1M1D1M1I2M1I1M1I2D\", 15),\n }\n\n for read_name in aln_df[\"readName\"].unique():\n\n expected_cigar = expected_alignments[read_name][0]\n expected_score = expected_alignments[read_name][1]\n\n self.assertEqual(\n aln_df.loc[aln_df[\"readName\"] == read_name, \"CIGAR\"].iloc[0],\n expected_cigar,\n )\n self.assertEqual(\n aln_df.loc[aln_df[\"readName\"] == read_name, \"AlignmentScore\"].iloc[0],\n expected_score,\n )\n\n\nif __name__ == \"__main__\":\n unittest.main()\n"
] | [
[
"numpy.random.exponential",
"numpy.random.uniform",
"numpy.isclose"
],
[
"pandas.DataFrame.from_dict"
]
] |
ssccutyy/KWS-Transformer | [
"7ae6d2e8fce1a293d88eedc0dbfacae726151a08"
] | [
"kws_streaming/train/train.py"
] | [
"# coding=utf-8\n# Copyright (c) 2021, Arm Limited and Contributors.\n# SPDX-License-Identifier: Apache-2.0\n# Copyright 2021 The Google Research 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# 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\"\"\"Train utility functions, based on tensorflow/examples/speech_commands.\n\n It consists of several steps:\n 1. Creates model.\n 2. Reads data\n 3. Trains model\n 4. Select the best model and evaluates it\n\"\"\"\n\nimport json\nfrom types import SimpleNamespace\nimport os.path\nimport pprint\nfrom absl import logging\nimport numpy as np\nimport tensorflow.compat.v1 as tf\nimport tensorflow_addons as tfa\nimport kws_streaming.data.input_data as input_data\nfrom kws_streaming.models import models\nfrom kws_streaming.models import utils\n\nimport math\n\nfrom transformers import AdamWeightDecay\n\n\nfrom kws_streaming.models import model_flags\n\n\ndef train(flags):\n \"\"\"Model training.\"\"\"\n\n flags.training = True\n\n # Set the verbosity based on flags (default is INFO, so we see all messages)\n logging.set_verbosity(flags.verbosity)\n\n # Start a new TensorFlow session.\n tf.reset_default_graph()\n config = tf.ConfigProto()\n config.gpu_options.allow_growth = True\n sess = tf.Session(config=config)\n tf.keras.backend.set_session(sess)\n\n audio_processor = input_data.AudioProcessor(flags)\n\n time_shift_samples = int((flags.time_shift_ms * flags.sample_rate) / 1000)\n\n # Figure out the learning rates for each training phase. Since it's often\n # effective to have high learning rates at the start of training, followed by\n # lower levels towards the end, the number of steps and learning rates can be\n # specified as comma-separated lists to define the rate at each stage. For\n # example --how_many_training_steps=10000,3000 --learning_rate=0.001,0.0001\n # will run 13,000 training loops in total, with a rate of 0.001 for the first\n # 10,000, and 0.0001 for the final 3,000.\n training_steps_list = list(map(int, flags.how_many_training_steps.split(',')))\n learning_rates_list = list(map(float, flags.learning_rate.split(',')))\n if len(training_steps_list) != len(learning_rates_list):\n raise Exception(\n '--how_many_training_steps and --learning_rate must be equal length '\n 'lists, but are %d and %d long instead' % (len(training_steps_list),\n len(learning_rates_list)))\n logging.info(flags)\n\n model = models.MODELS[flags.model_name](flags)\n if flags.distill_teacher_json:\n with open(flags.distill_teacher_json, 'r') as f:\n teacher_flags = json.load(f, object_hook=lambda d: SimpleNamespace(\n **{ k: v for k, v in flags.__dict__.items() if not k in d },\n **d))\n teacher_base = models.MODELS[teacher_flags.model_name](teacher_flags)\n hard_labels = tf.keras.layers.Lambda(lambda logits: tf.one_hot(tf.math.argmax(logits, axis=-1), depth=flags.label_count))\n teacher = tf.keras.models.Sequential([teacher_base, hard_labels])\n teacher_base.trainable = False\n teacher.trainable = False\n else:\n teacher = None\n teacher_flags = None\n\n base_model = model\n\n logging.info(model.summary())\n\n # save model summary\n utils.save_model_summary(model, flags.train_dir)\n\n # save model and data flags\n with open(os.path.join(flags.train_dir, 'flags.txt'), 'wt') as f:\n pprint.pprint(flags, stream=f)\n\n loss = tf.keras.losses.CategoricalCrossentropy(from_logits=True, label_smoothing=flags.label_smoothing)\n metrics = ['accuracy']\n\n if flags.optimizer == 'adam':\n optimizer = tf.keras.optimizers.Adam(epsilon=flags.optimizer_epsilon)\n elif flags.optimizer == 'momentum':\n optimizer = tf.keras.optimizers.SGD(momentum=0.9)\n elif flags.optimizer == 'novograd':\n optimizer = tfa.optimizers.NovoGrad(\n lr=0.05,\n beta_1=flags.novograd_beta_1,\n beta_2=flags.novograd_beta_2,\n weight_decay=flags.novograd_weight_decay,\n grad_averaging=bool(flags.novograd_grad_averaging))\n elif flags.optimizer == 'adamw':\n # Exclude some layers for weight decay\n exclude = [\"pos_emb\", \"class_emb\", \"layer_normalization\", \"bias\"]\n optimizer = AdamWeightDecay(learning_rate=0.05, weight_decay_rate=flags.l2_weight_decay, exclude_from_weight_decay=exclude)\n else:\n raise ValueError('Unsupported optimizer:%s' % flags.optimizer)\n\n loss_weights = [ 0.5, 0.5, 0.0 ] if teacher else [ 1. ] # equally weight losses form label and teacher, ignore ensemble output\n model.compile(optimizer=optimizer, loss=loss, loss_weights=loss_weights, metrics=metrics)\n\n train_writer = tf.summary.FileWriter(flags.summaries_dir + '/train',\n sess.graph)\n validation_writer = tf.summary.FileWriter(flags.summaries_dir + '/validation')\n\n sess.run(tf.global_variables_initializer())\n\n if flags.start_checkpoint:\n model.load_weights(flags.start_checkpoint).expect_partial()\n logging.info('Weights loaded from %s', flags.start_checkpoint)\n\n if teacher_flags and teacher_flags.start_checkpoint:\n # Load weights into teacher base as this is the actual model that was saved, teacher includes hard label head\n teacher_base.load_weights(teacher_flags.start_checkpoint).assert_existing_objects_matched()\n logging.info('Distillation teacher weights loaded from %s', teacher_flags.start_checkpoint)\n\n start_step = 0\n\n logging.info('Training from step: %d ', start_step)\n\n # Save graph.pbtxt.\n tf.train.write_graph(sess.graph_def, flags.train_dir, 'graph.pbtxt')\n\n # Save list of words.\n with tf.io.gfile.GFile(os.path.join(flags.train_dir, 'labels.txt'), 'w') as f:\n f.write('\\n'.join(audio_processor.words_list))\n\n best_accuracy = 0.0\n\n # prepare parameters for exp learning rate decay\n training_steps_max = np.sum(training_steps_list)\n lr_init = learning_rates_list[0]\n exp_rate = -np.log(learning_rates_list[-1] / lr_init)/training_steps_max\n mode = 'training'\n\n if flags.lr_schedule == 'cosine':\n # Currently, no restarts are performed, so it is just a cosine decay over the entire\n # training process. I think this is how DeiT does it.\n lr_init = lr_init * flags.batch_size / 512\n num_train = audio_processor.set_size(mode)\n warmup_steps = int((num_train / flags.batch_size) * flags.warmup_epochs)\n first_decay_steps=training_steps_max\n\n # Training loop.\n for training_step in range(start_step, training_steps_max + 1):\n if training_step > 0:\n offset = (training_step -\n 1) * flags.batch_size if flags.pick_deterministically else 0\n\n # Pull the audio samples we'll use for training.\n train_fingerprints, train_ground_truth = audio_processor.get_data(\n flags.batch_size, offset, flags, flags.background_frequency,\n flags.background_volume, time_shift_samples, mode,\n flags.resample, flags.volume_resample, sess)\n\n if flags.lr_schedule == 'exp':\n learning_rate_value = lr_init * np.exp(-exp_rate * training_step)\n elif flags.lr_schedule == 'linear':\n # Figure out what the current learning rate is.\n training_steps_sum = 0\n for i in range(len(training_steps_list)):\n training_steps_sum += training_steps_list[i]\n if training_step <= training_steps_sum:\n learning_rate_value = learning_rates_list[i]\n break\n elif flags.lr_schedule == 'cosine':\n learning_rate_value = lr_init * min(1, float(training_step) / max(1, warmup_steps)) * (math.cos(math.pi * training_step / training_steps_max) + 1) / 2.\n else:\n raise ValueError('Wrong lr_schedule: %s' % flags.lr_schedule)\n\n tf.keras.backend.set_value(model.optimizer.learning_rate, learning_rate_value)\n\n one_hot_labels = tf.keras.utils.to_categorical(train_ground_truth, num_classes=flags.label_count)\n\n if teacher:\n teacher_labels = teacher.predict_on_batch(train_fingerprints)\n one_hot_labels = [ one_hot_labels, teacher_labels, one_hot_labels ] # third is for the ensemble output, gradient is unused\n\n result = model.train_on_batch(train_fingerprints, one_hot_labels)\n\n if teacher:\n loss_total, loss_label, loss_teacher, loss_average, acc_label, acc_teacher, acc_ensemble = result\n differences = (teacher_labels != one_hot_labels).astype(dtype=int).sum()\n logging.info(\n 'Step #%d: rate %f, accuracy %.2f%%, cross entropy %f, teacher acc %.2f%% (%d diff), teacher cross entropy %f, ensemble acc %.2f%%',\n *(training_step, learning_rate_value, acc_label * 100, loss_total, acc_teacher * 100, differences, loss_teacher, acc_ensemble * 100))\n summary = tf.Summary(value=[\n tf.Summary.Value(tag='accuracy', simple_value=acc_label),\n tf.Summary.Value(tag='teacher_accuracy', simple_value=acc_teacher),\n tf.Summary.Value(tag='ensemble_accuracy', simple_value=acc_ensemble),\n ])\n else:\n loss_label, acc_label = result\n logging.info(\n 'Step #%d: rate %f, accuracy %.2f%%, cross entropy %f',\n *(training_step, learning_rate_value, acc_label * 100, loss_label))\n summary = tf.Summary(value=[\n tf.Summary.Value(tag='accuracy', simple_value=acc_label),\n ])\n\n train_writer.add_summary(summary, training_step)\n\n is_last_step = (training_step == training_steps_max)\n if (training_step % flags.eval_step_interval) == 0 or is_last_step:\n set_size = audio_processor.set_size('validation')\n set_size = int(set_size / flags.batch_size) * flags.batch_size\n total_accuracy = 0.0\n count = 0.0\n for i in range(0, set_size, flags.batch_size):\n validation_fingerprints, validation_ground_truth = audio_processor.get_data(\n flags.batch_size, i, flags, 0.0,\n 0.0, 0, 'validation',\n 0.0, 0.0, sess)\n\n one_hot_labels = tf.keras.utils.to_categorical(validation_ground_truth, num_classes=flags.label_count)\n if teacher:\n one_hot_labels = [ one_hot_labels, one_hot_labels, one_hot_labels ]\n # Run a validation step and capture training summaries for TensorBoard\n # with the `merged` op.\n result = model.test_on_batch(validation_fingerprints,\n one_hot_labels)\n\n if teacher:\n loss_total, loss_label, loss_teacher, loss_average, acc_label, acc_teacher, acc_ensemble = result\n summary = tf.Summary(value=[\n tf.Summary.Value(tag='accuracy', simple_value=acc_ensemble),\n tf.Summary.Value(tag='label_head_accuracy', simple_value=acc_label),\n tf.Summary.Value(tag='distill_head_accuracy', simple_value=acc_teacher),\n ])\n accuracy = acc_ensemble\n else:\n loss_label, acc_label = result\n summary = tf.Summary(value=[\n tf.Summary.Value(tag='accuracy', simple_value=acc_label),])\n accuracy = acc_label\n\n validation_writer.add_summary(summary, training_step)\n\n total_accuracy += accuracy\n count = count + 1.0\n\n total_accuracy = total_accuracy / count\n logging.info('Step %d: Validation accuracy = %.2f%% (N=%d)',\n *(training_step, total_accuracy * 100, set_size))\n\n # Save the model checkpoint when validation accuracy improves\n if total_accuracy >= best_accuracy:\n best_accuracy = total_accuracy\n # overwrite the best model weights\n model.save_weights(flags.train_dir + 'best_weights')\n logging.info('So far the best validation accuracy is %.2f%%',\n (best_accuracy * 100))\n\n tf.keras.backend.set_learning_phase(0)\n set_size = audio_processor.set_size('testing')\n set_size = int(set_size / flags.batch_size) * flags.batch_size\n logging.info('set_size=%d', set_size)\n total_accuracy = 0.0\n count = 0.0\n\n for i in range(0, set_size, flags.batch_size):\n test_fingerprints, test_ground_truth = audio_processor.get_data(\n flags.batch_size, i, flags, 0.0, 0.0, 0, 'testing', 0.0, 0.0, sess)\n\n one_hot_labels = tf.keras.utils.to_categorical(test_ground_truth, num_classes=flags.label_count)\n if teacher:\n one_hot_labels = [ one_hot_labels, one_hot_labels, one_hot_labels ]\n result = model.test_on_batch(test_fingerprints, one_hot_labels)\n\n total_accuracy += result[-1] if teacher else result[1]\n count = count + 1.0\n total_accuracy = total_accuracy / count\n\n logging.info('Final test accuracy = %.2f%% (N=%d)',\n *(total_accuracy * 100, set_size))\n with open(os.path.join(flags.train_dir, 'accuracy_last.txt'), 'wt') as fd:\n fd.write(str(total_accuracy * 100))\n model.save_weights(flags.train_dir + 'last_weights')\n\nif __name__ == '__main__':\n flags = model_flags.update_flags(None)\n train(flags)"
] | [
[
"numpy.exp",
"tensorflow.compat.v1.reset_default_graph",
"tensorflow.compat.v1.keras.backend.set_session",
"tensorflow.compat.v1.keras.optimizers.SGD",
"tensorflow.compat.v1.summary.FileWriter",
"tensorflow.compat.v1.train.write_graph",
"tensorflow.compat.v1.global_variables_initializer",
"numpy.log",
"tensorflow.compat.v1.keras.backend.set_learning_phase",
"tensorflow.compat.v1.keras.models.Sequential",
"tensorflow.compat.v1.ConfigProto",
"tensorflow.compat.v1.keras.losses.CategoricalCrossentropy",
"tensorflow.compat.v1.keras.backend.set_value",
"tensorflow.compat.v1.Session",
"tensorflow.compat.v1.keras.utils.to_categorical",
"tensorflow.compat.v1.Summary.Value",
"numpy.sum",
"tensorflow.compat.v1.keras.optimizers.Adam",
"tensorflow.compat.v1.math.argmax"
]
] |
paudetseis/OBStools | [
"c6c02d8864c25a14f22d1fae17ff5ad911b9ff00"
] | [
"obstools/scripts/atacr_clean_spectra.py"
] | [
"#!/usr/bin/env python\n\n# Copyright 2019 Pascal Audet & Helen Janiszewski\n#\n# This file is part of OBStools.\n#\n# Permission is hereby granted, free of charge, to any person obtaining a copy\n# of this software and associated documentation files (the \"Software\"), to deal\n# in the Software without restriction, including without limitation the rights\n# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n# copies of the Software, and to permit persons to whom the Software is\n# furnished to do so, subject to the following conditions:\n#\n# The above copyright notice and this permission notice shall be included in\n# all copies or substantial portions of the Software.\n#\n# THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n# SOFTWARE.\n\n\n# Import modules and functions\nimport numpy as np\nimport pickle\nimport stdb\nfrom obstools.atacr import StaNoise, Power, Cross, Rotation\nfrom obstools.atacr import utils, plotting\nfrom pathlib import Path\n\nfrom argparse import ArgumentParser\nfrom os.path import exists as exist\nfrom obspy import UTCDateTime\nfrom numpy import nan\n\n\ndef get_cleanspec_arguments(argv=None):\n \"\"\"\n Get Options from :class:`~optparse.OptionParser` objects.\n\n Calling options for the script `obs_clean_spectra.py` that accompany this\n package.\n\n \"\"\"\n\n parser = ArgumentParser(\n usage=\"%(prog)s [options] <indb>\",\n description=\"Script used \"\n \"to extract daily spectra calculated from \" +\n \"`obs_daily_spectra.py` and flag days for outlier \" +\n \"PSDs and calculate spectral averages of the \" +\n \"corresponding Fourier transforms over the entire \" +\n \"time period specified. The stations are processed \" +\n \"one by one and the data are stored to disk.\")\n parser.add_argument(\n \"indb\",\n help=\"Station Database to process from.\",\n type=str)\n\n # General Settings\n parser.add_argument(\n \"--keys\",\n action=\"store\",\n type=str,\n dest=\"stkeys\",\n default=\"\",\n help=\"Specify a comma separated list of station \" +\n \"keys for which to perform the analysis. These must \" +\n \"be contained within the station database. Partial \" +\n \"keys will be used to match against those in the \" +\n \"dictionary. For instance, providing IU will match \" +\n \"with all stations in the IU network. \" +\n \"[Default processes all stations in the database]\")\n parser.add_argument(\n \"-O\", \"--overwrite\",\n action=\"store_true\",\n dest=\"ovr\",\n default=False,\n help=\"Force the overwriting of pre-existing data. \" +\n \"[Default False]\")\n\n # Event Selection Criteria\n DaysGroup = parser.add_argument_group(\n title=\"Time Search Settings\",\n description=\"Time settings associated with \" +\n \"searching for day-long seismograms\")\n DaysGroup.add_argument(\n \"--start\",\n action=\"store\",\n type=str,\n dest=\"startT\",\n default=\"\",\n help=\"Specify a UTCDateTime compatible string \" +\n \"representing the start day for the data search. \" +\n \"This will override any station start times. \" +\n \"[Default start date of each station in database]\")\n DaysGroup.add_argument(\n \"--end\",\n action=\"store\",\n type=str,\n dest=\"endT\",\n default=\"\",\n help=\"Specify a UTCDateTime compatible string \" +\n \"representing the start time for the data search. \" +\n \"This will override any station end times. \" +\n \"[Default end date of each station in database]\")\n\n # Constants Settings\n ConstGroup = parser.add_argument_group(\n title='Parameter Settings',\n description=\"Miscellaneous default values \" +\n \"and settings\")\n ConstGroup.add_argument(\n \"--freq-band\",\n action=\"store\",\n type=str,\n dest=\"pd\",\n default=None,\n help=\"Specify comma-separated frequency limits \" +\n \"(float, in Hz) over which to calculate spectral \" +\n \"features used in flagging the days/windows. \" +\n \"[Default 0.004,2.0]\")\n ConstGroup.add_argument(\n \"--tolerance\",\n action=\"store\",\n type=float,\n dest=\"tol\",\n default=1.5,\n help=\"Specify parameter for tolerance threshold. \" +\n \"If spectrum > std*tol, window is flagged as bad. \" +\n \"[Default 1.5]\")\n ConstGroup.add_argument(\n \"--alpha\",\n action=\"store\",\n type=float,\n dest=\"alpha\",\n default=0.05,\n help=\"Confidence level for f-test, for iterative \" +\n \"flagging of windows. [Default 0.05, or 95 percent confidence]\")\n\n # Constants Settings\n FigureGroup = parser.add_argument_group(\n title='Figure Settings',\n description=\"Flags for plotting figures\")\n FigureGroup.add_argument(\n \"--figQC\",\n action=\"store_true\",\n dest=\"fig_QC\",\n default=False,\n help=\"Plot Quality-Control figure. \" +\n \"[Default does not plot figure]\")\n FigureGroup.add_argument(\n \"--debug\",\n action=\"store_true\",\n dest=\"debug\",\n default=False,\n help=\"Plot intermediate steps for debugging. \" +\n \"[Default does not plot figure]\")\n FigureGroup.add_argument(\n \"--figAverage\",\n action=\"store_true\",\n dest=\"fig_average\",\n default=False,\n help=\"Plot daily average figure. \" +\n \"[Default does not plot figure]\")\n FigureGroup.add_argument(\n \"--figCoh\",\n action=\"store_true\",\n dest=\"fig_coh_ph\",\n default=False,\n help=\"Plot Coherence and Phase figure. \" +\n \"[Default does not plot figure]\")\n FigureGroup.add_argument(\n \"--figCross\",\n action=\"store_true\",\n dest=\"fig_av_cross\",\n default=False,\n help=\"Plot cross-spectra figure. \" +\n \"[Default does not plot figure]\")\n FigureGroup.add_argument(\n \"--save-fig\",\n action=\"store_true\",\n dest=\"saveplot\",\n default=False,\n help=\"Set this option if you wish to save the figure(s). [Default \" +\n \"does not save figure]\")\n FigureGroup.add_argument(\n \"--format\",\n action=\"store\",\n type=str,\n dest=\"form\",\n default=\"png\",\n help=\"Specify format of figure. Can be any one of the valid\" +\n \"matplotlib formats: 'png', 'jpg', 'eps', 'pdf'. [Default 'png']\")\n\n args = parser.parse_args(argv)\n\n # Check inputs\n if not exist(args.indb):\n parser.error(\"Input file \" + args.indb + \" does not exist\")\n\n # create station key list\n if len(args.stkeys) > 0:\n args.stkeys = args.stkeys.split(',')\n\n # construct start time\n if len(args.startT) > 0:\n try:\n args.startT = UTCDateTime(args.startT)\n except Exception:\n parser.error(\n \"Error: Cannot construct UTCDateTime from start time: \" +\n args.startT)\n else:\n args.startT = None\n\n # construct end time\n if len(args.endT) > 0:\n try:\n args.endT = UTCDateTime(args.endT)\n except Exception:\n parser.error(\n \"Error: Cannot construct UTCDateTime from end time: \" +\n args.endT)\n else:\n args.endT = None\n\n if args.pd is None:\n args.pd = [0.004, 2.0]\n else:\n args.pd = [float(val) for val in args.pd.split(',')]\n args.pd = sorted(args.pd)\n if (len(args.pd)) != 2:\n raise(Exception(\n \"Error: --freq-band should contain 2 \" +\n \"comma-separated floats\"))\n\n return args\n\n\ndef main(args=None):\n\n if args is None:\n # Run Input Parser\n args = get_cleanspec_arguments()\n\n # Load Database\n # stdb>0.1.3\n try:\n db, stkeys = stdb.io.load_db(fname=args.indb, keys=args.stkeys)\n\n # stdb=0.1.3\n except Exception:\n db = stdb.io.load_db(fname=args.indb)\n\n # Construct station key loop\n allkeys = db.keys()\n sorted(allkeys)\n\n # Extract key subset\n if len(args.stkeys) > 0:\n stkeys = []\n for skey in args.stkeys:\n stkeys.extend([s for s in allkeys if skey in s])\n else:\n stkeys = db.keys()\n sorted(stkeys)\n\n # Loop over station keys\n for stkey in list(stkeys):\n\n # Extract station information from dictionary\n sta = db[stkey]\n\n # Path where spectra are located\n specpath = Path('SPECTRA') / stkey\n if not specpath.is_dir():\n raise(Exception(\n \"Path to \" + str(specpath) +\n \" doesn`t exist - aborting\"))\n\n # Path where average spectra will be saved\n avstpath = Path('AVG_STA') / stkey\n if not avstpath.is_dir():\n print(\"Path to \"+str(avstpath)+\" doesn`t exist - creating it\")\n avstpath.mkdir(parents=True)\n\n # Path where plots will be saved\n if args.saveplot:\n plotpath = avstpath / 'PLOTS'\n if not plotpath.is_dir():\n plotpath.mkdir(parents=True)\n else:\n plotpath = False\n\n # Get catalogue search start time\n if args.startT is None:\n tstart = sta.startdate\n else:\n tstart = args.startT\n\n # Get catalogue search end time\n if args.endT is None:\n tend = sta.enddate\n else:\n tend = args.endT\n\n if tstart > sta.enddate or tend < sta.startdate:\n continue\n\n # Temporary print locations\n tlocs = sta.location\n if len(tlocs) == 0:\n tlocs = ['']\n for il in range(0, len(tlocs)):\n if len(tlocs[il]) == 0:\n tlocs[il] = \"--\"\n sta.location = tlocs\n\n # Update Display\n print(\"\\n|===============================================|\")\n print(\"|===============================================|\")\n print(\"| {0:>8s} |\".format(\n sta.station))\n print(\"|===============================================|\")\n print(\"|===============================================|\")\n print(\"| Station: {0:>2s}.{1:5s} |\".format(\n sta.network, sta.station))\n print(\"| Channel: {0:2s}; Locations: {1:15s} |\".format(\n sta.channel, \",\".join(tlocs)))\n print(\"| Lon: {0:7.2f}; Lat: {1:6.2f} |\".format(\n sta.longitude, sta.latitude))\n print(\"| Start time: {0:19s} |\".format(\n sta.startdate.strftime(\"%Y-%m-%d %H:%M:%S\")))\n print(\"| End time: {0:19s} |\".format(\n sta.enddate.strftime(\"%Y-%m-%d %H:%M:%S\")))\n print(\"|-----------------------------------------------|\")\n\n # Filename for output average spectra\n dstart = str(tstart.year).zfill(4)+'.'+str(tstart.julday).zfill(3)+'-'\n dend = str(tend.year).zfill(4)+'.'+str(tend.julday).zfill(3)+'.'\n fileavst = avstpath / (dstart+dend+'avg_sta.pkl')\n\n if fileavst.exists():\n if not args.ovr:\n print(\"* -> file \"+str(fileavst)+\" exists - continuing\")\n continue\n\n # Containers for power and cross spectra\n coh_all = []\n ph_all = []\n coh_12_all = []\n coh_1Z_all = []\n coh_1P_all = []\n coh_2Z_all = []\n coh_2P_all = []\n coh_ZP_all = []\n ph_12_all = []\n ph_1Z_all = []\n ph_1P_all = []\n ph_2Z_all = []\n ph_2P_all = []\n ph_ZP_all = []\n ad_12_all = []\n ad_1Z_all = []\n ad_1P_all = []\n ad_2Z_all = []\n ad_2P_all = []\n ad_ZP_all = []\n nwins = []\n\n t1 = tstart\n\n # Initialize StaNoise object\n stanoise = StaNoise()\n\n # Loop through each day withing time range\n while t1 < tend:\n\n year = str(t1.year).zfill(4)\n jday = str(t1.julday).zfill(3)\n\n tstamp = year+'.'+jday+'.'\n filespec = specpath / (tstamp + 'spectra.pkl')\n\n # Load file if it exists\n if filespec.exists():\n print(\"\\n\"+\"*\"*60)\n print('* Calculating noise spectra for key ' +\n stkey+' and day '+year+'.'+jday)\n print(\"* -> file \"+str(filespec)+\" found - loading\")\n file = open(filespec, 'rb')\n daynoise = pickle.load(file)\n file.close()\n stanoise += daynoise\n else:\n t1 += 3600.*24.\n continue\n\n coh_all.append(daynoise.rotation.coh)\n ph_all.append(daynoise.rotation.ph)\n\n # Coherence\n coh_12_all.append(\n utils.smooth(\n utils.coherence(\n daynoise.cross.c12,\n daynoise.power.c11,\n daynoise.power.c22), 50))\n coh_1Z_all.append(\n utils.smooth(\n utils.coherence(\n daynoise.cross.c1Z,\n daynoise.power.c11,\n daynoise.power.cZZ), 50))\n coh_1P_all.append(\n utils.smooth(\n utils.coherence(\n daynoise.cross.c1P,\n daynoise.power.c11,\n daynoise.power.cPP), 50))\n coh_2Z_all.append(\n utils.smooth(\n utils.coherence(\n daynoise.cross.c2Z,\n daynoise.power.c22,\n daynoise.power.cZZ), 50))\n coh_2P_all.append(\n utils.smooth(\n utils.coherence(\n daynoise.cross.c2P,\n daynoise.power.c22,\n daynoise.power.cPP), 50))\n coh_ZP_all.append(\n utils.smooth(\n utils.coherence(\n daynoise.cross.cZP,\n daynoise.power.cZZ,\n daynoise.power.cPP), 50))\n\n # Phase\n try:\n ph_12_all.append(\n 180./np.pi*utils.phase(daynoise.cross.c12))\n except Exception:\n ph_12_all.append(None)\n try:\n ph_1Z_all.append(\n 180./np.pi*utils.phase(daynoise.cross.c1Z))\n except Exception:\n ph_1Z_all.append(None)\n try:\n ph_1P_all.append(\n 180./np.pi*utils.phase(daynoise.cross.c1P))\n except Exception:\n ph_1P_all.append(None)\n try:\n ph_2Z_all.append(\n 180./np.pi*utils.phase(daynoise.cross.c2Z))\n except Exception:\n ph_2Z_all.append(None)\n try:\n ph_2P_all.append(\n 180./np.pi*utils.phase(daynoise.cross.c2P))\n except Exception:\n ph_2P_all.append(None)\n try:\n ph_ZP_all.append(\n 180./np.pi*utils.phase(daynoise.cross.cZP))\n except Exception:\n ph_ZP_all.append(None)\n\n # Admittance\n ad_12_all.append(utils.smooth(utils.admittance(\n daynoise.cross.c12, daynoise.power.c11), 50))\n ad_1Z_all.append(utils.smooth(utils.admittance(\n daynoise.cross.c1Z, daynoise.power.c11), 50))\n ad_1P_all.append(utils.smooth(utils.admittance(\n daynoise.cross.c1P, daynoise.power.c11), 50))\n ad_2Z_all.append(utils.smooth(utils.admittance(\n daynoise.cross.c2Z, daynoise.power.c22), 50))\n ad_2P_all.append(utils.smooth(utils.admittance(\n daynoise.cross.c2P, daynoise.power.c22), 50))\n ad_ZP_all.append(utils.smooth(utils.admittance(\n daynoise.cross.cZP, daynoise.power.cZZ), 50))\n\n t1 += 3600.*24.\n\n # Convert to numpy arrays\n coh_all = np.array(coh_all)\n ph_all = np.array(ph_all)\n coh_12_all = np.array(coh_12_all)\n coh_1Z_all = np.array(coh_1Z_all)\n coh_1P_all = np.array(coh_1P_all)\n coh_2Z_all = np.array(coh_2Z_all)\n coh_2P_all = np.array(coh_2P_all)\n coh_ZP_all = np.array(coh_ZP_all)\n ph_12_all = np.array(ph_12_all)\n ph_1Z_all = np.array(ph_1Z_all)\n ph_1P_all = np.array(ph_1P_all)\n ph_2Z_all = np.array(ph_2Z_all)\n ph_2P_all = np.array(ph_2P_all)\n ph_ZP_all = np.array(ph_ZP_all)\n ad_12_all = np.array(ad_12_all)\n ad_1Z_all = np.array(ad_1Z_all)\n ad_1P_all = np.array(ad_1P_all)\n ad_2Z_all = np.array(ad_2Z_all)\n ad_2P_all = np.array(ad_2P_all)\n ad_ZP_all = np.array(ad_ZP_all)\n\n # Store transfer functions as objects for plotting\n coh = Cross(coh_12_all, coh_1Z_all, coh_1P_all,\n coh_2Z_all, coh_2P_all, coh_ZP_all)\n ph = Cross(ph_12_all, ph_1Z_all, ph_1P_all,\n ph_2Z_all, ph_2P_all, ph_ZP_all)\n ad = Cross(ad_12_all, ad_1Z_all, ad_1P_all,\n ad_2Z_all, ad_2P_all, ad_ZP_all)\n\n # Quality control to identify outliers\n stanoise.QC_sta_spectra(pd=args.pd, tol=args.tol, alpha=args.alpha,\n fig_QC=args.fig_QC, debug=args.debug,\n save=plotpath, form=args.form)\n\n # Average spectra for good days\n stanoise.average_sta_spectra(\n fig_average=args.fig_average,\n save=plotpath, form=args.form)\n\n if args.fig_av_cross:\n fname = stkey + '.' + 'av_coherence'\n plot = plotting.fig_av_cross(\n stanoise.f, coh, stanoise.gooddays,\n 'Coherence', stanoise.ncomp, key=stkey, lw=0.5)\n # if plotpath.is_dir():\n if plotpath:\n plot.savefig(\n str(plotpath / (fname + '.' + args.form)),\n dpi=300, bbox_inches='tight', format=args.form)\n else:\n plot.show()\n\n fname = stkey + '.' + 'av_admittance'\n plot = plotting.fig_av_cross(\n stanoise.f, ad, stanoise.gooddays,\n 'Admittance', stanoise.ncomp, key=stkey, lw=0.5)\n\n if plotpath:\n plot.savefig(\n str(plotpath / (fname + '.' + args.form)),\n dpi=300, bbox_inches='tight', format=args.form)\n else:\n plot.show()\n\n fname = stkey + '.' + 'av_phase'\n plot = plotting.fig_av_cross(\n stanoise.f, ph, stanoise.gooddays,\n 'Phase', stanoise.ncomp, key=stkey, marker=',', lw=0)\n\n if plotpath:\n plot.savefig(\n str(plotpath / (fname + '.' + args.form)),\n dpi=300, bbox_inches='tight', format=args.form)\n else:\n plot.show()\n\n if args.fig_coh_ph and stanoise.direc is not None:\n fname = stkey + '.' + 'coh_ph'\n plot = plotting.fig_coh_ph(coh_all, ph_all, stanoise.direc)\n if plotpath:\n plot.savefig(\n str(plotpath / (fname + '.' + args.form)),\n dpi=300, bbox_inches='tight', format=args.form)\n else:\n plot.show()\n\n # Save to file\n stanoise.save(fileavst)\n\n\nif __name__ == \"__main__\":\n\n # Run main program\n main()\n"
] | [
[
"numpy.array"
]
] |
tempoCollaboration/OQuPy | [
"a389a161991a59259e5df47d8e0f405fcac75fe5"
] | [
"oqupy/backends/tempo_backend.py"
] | [
"# Copyright 2020 The TEMPO Collaboration\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\"\"\"\nModule for tempo and mean-field tempo backend.\n\"\"\"\n\nfrom typing import Callable, Dict, Optional, Tuple\nfrom copy import copy\n\nfrom numpy import ndarray, moveaxis, dot\n\nfrom oqupy import operators\nfrom oqupy.config import TEMPO_BACKEND_CONFIG\nfrom oqupy.backends import node_array as na\nfrom oqupy.util import create_delta\n\nclass BaseTempoBackend:\n \"\"\"\n Backend class for TEMPO.\n\n Parameters\n ----------\n initial_state: ndarray\n The initial density matrix (as a vector).\n influence: callable(int) -> ndarray\n Callable that takes an integer `step` and returns the influence super\n operator of that `step`.\n unitary_transform: ndarray\n Unitary that transforms the coupling operator into a diagonal form.\n sum_north: ndarray\n The summing vector for the north legs.\n sum_west: ndarray\n The summing vector for the west legs.\n dkmax: int\n Number of influences to include. If ``dkmax == None`` then all\n influences are included.\n epsrel: float\n Maximal relative SVD truncation error.\n \"\"\"\n def __init__(\n self,\n initial_state: ndarray,\n influence: Callable[[int], ndarray],\n unitary_transform: ndarray,\n sum_north: ndarray,\n sum_west: ndarray,\n dkmax: int,\n epsrel: float,\n config: Optional[Dict] = None):\n \"\"\"Create a TempoBackend object. \"\"\"\n self._initial_state = initial_state\n self._influence = influence\n self._unitary_transform = unitary_transform\n self._sum_north = sum_north\n self._sum_west = sum_west\n self._dkmax = dkmax\n self._epsrel = epsrel\n self._step = None\n self._state = None\n self._config = TEMPO_BACKEND_CONFIG if config is None else config\n self._mps = None\n self._mpo = None\n self._super_u = None\n self._super_u_dagg = None\n self._sum_north_na = None\n\n @property\n def step(self) -> int:\n \"\"\"The current step in the TEMPO computation. \"\"\"\n return self._step\n\n def _initialize_mps_mpo(self) :\n \"\"\"ToDo\"\"\"\n self._initial_state = copy(self._initial_state).reshape(-1)\n\n self._super_u = operators.left_right_super(\n self._unitary_transform,\n self._unitary_transform.conjugate().T)\n self._super_u_dagg = operators.left_right_super(\n self._unitary_transform.conjugate().T,\n self._unitary_transform)\n\n self._sum_north_na = na.NodeArray([self._sum_north],\n left=False,\n right=False,\n name=\"Sum north\")\n influences = []\n if self._dkmax is None:\n dkmax_pre_compute = 1\n else:\n dkmax_pre_compute = self._dkmax + 1\n\n for i in range(dkmax_pre_compute):\n infl = self._influence(i)\n infl_four_legs = create_delta(infl, [1, 0, 0, 1])\n if i == 0:\n tmp = dot(moveaxis(infl_four_legs, 1, -1),\n self._super_u_dagg)\n tmp = moveaxis(tmp, -1, 1)\n tmp = dot(tmp, self._super_u.T)\n infl_four_legs = tmp\n influences.append(infl_four_legs)\n\n self._mps = na.NodeArray([self._initial_state],\n left=False,\n right=False,\n name=\"Thee MPS\")\n self._mpo = na.NodeArray(list(reversed(influences)),\n left=True,\n right=True,\n name=\"Thee Time Evolving MPO\")\n\n\n def _compute_system_step(self, current_step, prop_1, prop_2) -> ndarray:\n \"\"\"\n Takes a step in the TEMPO tensor network computation.\n\n For example, for at step 4, we start with:\n\n A ... self._mps\n B ... self._mpo\n w ... self._sum_west\n n ... self._sum_north_array\n p1 ... prop_1\n p2 ... prop_2\n\n n n n n\n | | | |\n\n | | | | |\n w~~ ~~B~~B~~B~~B~~ ~~p2\n | | | |\n p1\n | | | |\n A~~A~~A~~A\n\n return:\n step = 4\n state = contraction of A,B,w,n,p1\n\n effects:\n self._mpo will grow to the left with the next influence functional\n self._mps will be contraction of A,B,w,p1,p2\n\n Returns\n -------\n step: int\n The current step count.\n state: ndarray\n Density matrix at the current step.\n\n \"\"\"\n prop_1_na = na.NodeArray([prop_1.T],\n left=False,\n right=False,\n name=\"first half-step\")\n prop_2_na = na.NodeArray([prop_2.T],\n left=True,\n right=False,\n name=\"second half-step\")\n\n if self._dkmax is None:\n mpo = self._mpo.copy()\n infl = self._influence(len(mpo))\n infl_four_legs = create_delta(infl, [1, 0, 0, 1])\n infl_na = na.NodeArray([infl_four_legs],\n left=True,\n right=True)\n self._mpo = na.join(infl_na,\n self._mpo,\n name=\"The Time Evolving MPO\",\n copy=False)\n elif current_step <= self._dkmax:\n _, mpo = na.split(self._mpo,\n int(0 - current_step),\n copy=True)\n else: # current_step > self._dkmax\n mpo = self._mpo.copy()\n infl = self._influence(self._dkmax-current_step)\n if infl is not None:\n infl_four_legs = create_delta(infl, [1, 0, 0, 1])\n infl_na = na.NodeArray([infl_four_legs],\n left=True,\n right=True)\n _, mpo = na.split(self._mpo,\n index=1,\n copy=True)\n mpo = na.join(infl_na,\n mpo,\n name=\"Thee Time Evolving MPO\",\n copy=False)\n\n mpo.name = \"temporary MPO\"\n mpo.apply_vector(self._sum_west, left=True)\n\n self._mps.zip_up(prop_1_na,\n axes=[(0,0)],\n left_index=-1,\n right_index=-1,\n direction=\"left\",\n max_singular_values=None,\n max_truncation_err=self._epsrel,\n relative=True,\n copy=False)\n\n if len(self._mps) != len(mpo):\n self._mps.contract(self._sum_north_na,\n axes=[(0,0)],\n left_index=0,\n right_index=0,\n direction=\"right\",\n copy=True)\n\n self._mps.zip_up(mpo,\n axes=[(0, 0)],\n left_index=0,\n right_index=-1,\n direction=\"right\",\n max_singular_values=None,\n max_truncation_err=self._epsrel,\n relative=True,\n copy=False)\n\n self._mps.svd_sweep(from_index=-1,\n to_index=0,\n max_singular_values=None,\n max_truncation_err=self._epsrel,\n relative=True)\n\n self._mps = na.join(self._mps,\n prop_2_na,\n copy=False,\n name=f\"The MPS ({current_step})\")\n\n tmp_mps = self._mps.copy()\n for _ in range(len(tmp_mps)-1):\n tmp_mps.contract(self._sum_north_na,\n axes=[(0,0)],\n left_index=0,\n right_index=0,\n direction=\"right\",\n copy=True)\n\n assert len(tmp_mps) == 1\n assert not tmp_mps.left\n assert not tmp_mps.right\n assert tmp_mps.rank == 1\n state = tmp_mps.nodes[0].get_tensor()\n\n return state\n\nclass TempoBackend(BaseTempoBackend):\n \"\"\"\n ToDo\n \"\"\"\n def __init__(\n self,\n initial_state: ndarray,\n influence: Callable[[int], ndarray],\n unitary_transform: ndarray,\n propagators: Callable[[int], Tuple[ndarray, ndarray]],\n sum_north: ndarray,\n sum_west: ndarray,\n dkmax: int,\n epsrel: float,\n config: Optional[Dict] = None):\n \"\"\"Create a TempoBackend object. \"\"\"\n super().__init__(\n initial_state,\n influence,\n unitary_transform,\n sum_north,\n sum_west,\n dkmax,\n epsrel,\n config)\n self._propagators = propagators\n\n def initialize(self)-> Tuple[int, ndarray]:\n \"\"\"\n ToDo\n \"\"\"\n self._step = 0\n self._initialize_mps_mpo()\n self._state = self._initial_state\n return self._step, copy(self._state)\n\n def compute_step(self) -> Tuple[int, ndarray]:\n \"\"\"\n ToDo\n \"\"\"\n self._step += 1\n prop_1, prop_2 = self._propagators(self._step-1)\n self._state = self._compute_system_step(self._step, prop_1, prop_2)\n return self._step, copy(self._state)\n\n\nclass TempoWithFieldBackend(BaseTempoBackend):\n \"\"\"\n backend for tensor network tempo with coherent field evolution.\n Note the only difference from TensorNetworkTempoBackend in the\n signature is the addition of the initial_field and compute_field\n parameters, and the change of the propagator signature.\n\n Parameters\n ----------\n initial_state: ndarray\n The initial density matrix (as a vector).\n initial_field: complex\n The initial field value.\n influence: callable(int) -> ndarray\n Callable that takes an integer `step` and returns the influence super\n operator of that `step`.\n unitary_transform: ndarray\n Unitary that transforms the coupling operator into a diagonal form.\n propagators: callable(int, ndarray, complex) -> ndarray, ndarray\n Callable that takes an integer `step`, an ndarray `state` and a complex\n `field` and returns the first and second half of the system propagator\n of that `step`.\n compute_field: callable(int, ndarray, complex, ndarray) -> complex\n Callable that takes an integer `step`, a complex `field` (the current\n value of the field) and two ndarrays for (respectively) the current and\n next density matrix as vectors, and returns the next field value.\n sum_north: ndarray\n The summing vector for the north legs.\n sum_west: ndarray\n The summing vector for the west legs.\n dkmax: int\n Number of influences to include. If ``dkmax == -1`` then all influences\n are included.\n epsrel: float\n Maximal relative SVD truncation error.\n \"\"\"\n def __init__(\n self,\n initial_state: ndarray,\n initial_field: ndarray,\n influence: Callable[[int], ndarray],\n unitary_transform: ndarray,\n propagators: Callable[[int, ndarray, complex],\n Tuple[ndarray, ndarray]],\n compute_field: Callable[[float, ndarray, complex], complex],\n sum_north: ndarray,\n sum_west: ndarray,\n dkmax: int,\n epsrel: float,\n config: Dict):\n # Field specific variables\n self._initial_field = initial_field\n self._compute_field = compute_field\n self._field = initial_field\n self._propagators = propagators\n \"\"\"Create a TempoWithFieldBackend object. \"\"\"\n super().__init__(initial_state,\n influence,\n unitary_transform,\n sum_north,\n sum_west,\n dkmax,\n epsrel,\n config)\n\n def initialize(self) -> Tuple[int, ndarray, complex]:\n \"\"\"See BaseBackend.initialize() for main docstring.\"\"\"\n self._step = 0\n self._initialize_mps_mpo()\n self._state = self._initial_state\n self._field = self._initial_field\n return self._step, copy(self._state), self._field\n\n def compute_step(self) -> Tuple[int, ndarray, complex]:\n \"\"\"\n ToDo\n \"\"\"\n current_step = self._step\n next_step = current_step + 1\n current_state = copy(self._state)\n current_field = self._field\n prop_1, prop_2 = self._propagators(current_step, current_state,\n current_field)\n next_state = self._compute_system_step(next_step, prop_1, prop_2)\n next_field = self._compute_field(current_step, current_state,\n current_field, next_state)\n self._state = next_state\n self._field = next_field\n self._step = next_step\n\n return self._step, copy(self._state), self._field\n"
] | [
[
"numpy.moveaxis",
"numpy.dot"
]
] |
j-chan-hkust/deep_testing_of_advanced_learning_systems | [
"ec535e2b4dc489d407b664a138d3f5262b71d21e",
"ec535e2b4dc489d407b664a138d3f5262b71d21e"
] | [
"2_data_collection/CIFAR_10/vgg16_CIFAR10.py",
"4_Coverage_Evaluation/MNIST/utils.py"
] | [
"from __future__ import print_function\nimport keras\nfrom keras.datasets import cifar10\nfrom keras.preprocessing.image import ImageDataGenerator\nfrom keras.models import Sequential\nfrom keras.layers import Dense, Dropout, Activation, Flatten\nfrom keras.layers import Conv2D, MaxPooling2D, BatchNormalization\nfrom keras import optimizers\nimport numpy as np\nfrom keras.layers.core import Lambda\nfrom keras import backend as K\nfrom keras import regularizers\n\nclass cifar10vgg:\n def __init__(self,train=True):\n self.num_classes = 10\n self.weight_decay = 0.0005\n self.x_shape = [32,32,3]\n\n self.model = self.build_model()\n if train:\n self.model = self.train(self.model)\n else:\n self.model.load_weights('cifar10vgg.h5')\n\n\n def build_model(self):\n # Build the network of vgg for 10 classes with massive dropout and weight decay as described in the paper.\n\n model = Sequential()\n weight_decay = self.weight_decay\n\n model.add(Conv2D(64, (3, 3), padding='same',\n input_shape=self.x_shape,kernel_regularizer=regularizers.l2(weight_decay)))\n model.add(Activation('relu'))\n model.add(BatchNormalization())\n model.add(Dropout(0.3))\n\n model.add(Conv2D(64, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))\n model.add(Activation('relu'))\n model.add(BatchNormalization())\n\n model.add(MaxPooling2D(pool_size=(2, 2)))\n\n model.add(Conv2D(128, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))\n model.add(Activation('relu'))\n model.add(BatchNormalization())\n model.add(Dropout(0.4))\n\n model.add(Conv2D(128, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))\n model.add(Activation('relu'))\n model.add(BatchNormalization())\n\n model.add(MaxPooling2D(pool_size=(2, 2)))\n\n model.add(Conv2D(256, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))\n model.add(Activation('relu'))\n model.add(BatchNormalization())\n model.add(Dropout(0.4))\n\n model.add(Conv2D(256, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))\n model.add(Activation('relu'))\n model.add(BatchNormalization())\n model.add(Dropout(0.4))\n\n model.add(Conv2D(256, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))\n model.add(Activation('relu'))\n model.add(BatchNormalization())\n\n model.add(MaxPooling2D(pool_size=(2, 2)))\n\n\n model.add(Conv2D(512, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))\n model.add(Activation('relu'))\n model.add(BatchNormalization())\n model.add(Dropout(0.4))\n\n model.add(Conv2D(512, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))\n model.add(Activation('relu'))\n model.add(BatchNormalization())\n model.add(Dropout(0.4))\n\n model.add(Conv2D(512, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))\n model.add(Activation('relu'))\n model.add(BatchNormalization())\n\n model.add(MaxPooling2D(pool_size=(2, 2)))\n\n\n model.add(Conv2D(512, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))\n model.add(Activation('relu'))\n model.add(BatchNormalization())\n model.add(Dropout(0.4))\n\n model.add(Conv2D(512, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))\n model.add(Activation('relu'))\n model.add(BatchNormalization())\n model.add(Dropout(0.4))\n\n model.add(Conv2D(512, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))\n model.add(Activation('relu'))\n model.add(BatchNormalization())\n\n model.add(MaxPooling2D(pool_size=(2, 2)))\n model.add(Dropout(0.5))\n\n model.add(Flatten())\n model.add(Dense(512,kernel_regularizer=regularizers.l2(weight_decay)))\n model.add(Activation('relu'))\n model.add(BatchNormalization())\n\n model.add(Dropout(0.5))\n model.add(Dense(self.num_classes))\n model.add(Activation('softmax'))\n return model\n\n\n def normalize(self,X_train,X_test):\n #this function normalize inputs for zero mean and unit variance\n # it is used when training a model.\n # Input: training set and test set\n # Output: normalized training set and test set according to the trianing set statistics.\n mean = np.mean(X_train,axis=(0,1,2,3))\n std = np.std(X_train, axis=(0, 1, 2, 3))\n X_train = (X_train-mean)/(std+1e-7)\n X_test = (X_test-mean)/(std+1e-7)\n return X_train, X_test\n\n def normalize_production(self,x):\n #this function is used to normalize instances in production according to saved training set statistics\n # Input: X - a training set\n # Output X - a normalized training set according to normalization constants.\n\n #these values produced during first training and are general for the standard cifar10 training set normalization\n mean = 120.707\n std = 64.15\n return (x-mean)/(std+1e-7)\n\n def predict(self,x,normalize=True,batch_size=50):\n if normalize:\n x = self.normalize_production(x)\n return self.model.predict(x,batch_size)\n\n def train(self,model):\n\n model.load_weights(\"cifar10vgg.h5\")\n #training parameters\n batch_size = 128\n maxepoches = 250\n learning_rate = 0.01\n lr_decay = 1e-6\n lr_drop = 20\n # The data, shuffled and split between train and test sets:\n (x_train, y_train), (x_test, y_test) = cifar10.load_data()\n x_train = x_train.astype('float32')\n x_test = x_test.astype('float32')\n x_train, x_test = self.normalize(x_train, x_test)\n\n y_train = keras.utils.to_categorical(y_train, self.num_classes)\n y_test = keras.utils.to_categorical(y_test, self.num_classes)\n\n def lr_scheduler(epoch):\n return learning_rate * (0.5 ** (epoch // lr_drop))\n reduce_lr = keras.callbacks.LearningRateScheduler(lr_scheduler)\n\n #data augmentation\n datagen = ImageDataGenerator(\n featurewise_center=False, # set input mean to 0 over the dataset\n samplewise_center=False, # set each sample mean to 0\n featurewise_std_normalization=False, # divide inputs by std of the dataset\n samplewise_std_normalization=False, # divide each input by its std\n zca_whitening=False, # apply ZCA whitening\n rotation_range=15, # randomly rotate images in the range (degrees, 0 to 180)\n width_shift_range=0.1, # randomly shift images horizontally (fraction of total width)\n height_shift_range=0.1, # randomly shift images vertically (fraction of total height)\n horizontal_flip=True, # randomly flip images\n vertical_flip=False) # randomly flip images\n # (std, mean, and principal components if ZCA whitening is applied).\n datagen.fit(x_train)\n\n\n\n #optimization details\n sgd = optimizers.SGD(lr=learning_rate, decay=lr_decay, momentum=0.9, nesterov=True)\n model.compile(loss='categorical_crossentropy', optimizer=sgd,metrics=['accuracy'])\n\n\n # training process in a for loop with learning rate drop every 25 epoches.\n\n historytemp = model.fit_generator(datagen.flow(x_train, y_train,\n batch_size=batch_size),\n steps_per_epoch=x_train.shape[0] // batch_size,\n epochs=maxepoches,\n validation_data=(x_test, y_test),callbacks=[reduce_lr],verbose=2)\n model.save_weights('cifar10vgg.h5')\n return model\n\nif __name__ == '__main__':\n\n\n (x_train, y_train), (x_test, y_test) = cifar10.load_data()\n x_train = x_train.astype('float32')\n x_test = x_test.astype('float32')\n\n y_train = keras.utils.to_categorical(y_train, 10)\n y_test = keras.utils.to_categorical(y_test, 10)\n\n model = cifar10vgg()\n\n predicted_x = model.predict(x_test)\n residuals = np.argmax(predicted_x,1)!=np.argmax(y_test,1)\n\n loss = sum(residuals)/len(residuals)\n print(\"the validation 0/1 loss is: \",loss)\n",
"# some utils taken from the DeepXplore Implementation\n\nimport random\nfrom collections import defaultdict\n\nimport numpy as np\nfrom keras import backend as K\nfrom keras.models import Model\nfrom keras.preprocessing import image\nfrom keras import models, layers, activations\n\nfrom scipy.spatial.distance import mahalanobis\nfrom numpy.linalg import inv\nfrom itertools import combinations\n\n\n#loads a mnist image\ndef preprocess_image(img_path):\n img = image.load_img(img_path, target_size=(28, 28), grayscale=True)\n input_img_data = image.img_to_array(img)\n input_img_data = input_img_data.reshape(1, 28, 28, 1)\n\n input_img_data = input_img_data.astype('float32')\n input_img_data /= 255\n # input_img_data = preprocess_input(input_img_data) # final input shape = (1,224,224,3)\n return input_img_data\n\ndef init_neuron_cov_dict(model, model_layer_dict):\n for layer in model.layers:\n if 'flatten' in layer.name or 'input' in layer.name:\n continue\n for index in range(layer.output_shape[-1]):\n model_layer_dict[(layer.name, index)] = False\n\n\ndef neuron_to_cover(model_layer_dict):\n not_covered = [(layer_name, index) for (layer_name, index), v in model_layer_dict.items() if not v]\n if not_covered:\n layer_name, index = random.choice(not_covered)\n else:\n layer_name, index = random.choice(model_layer_dict.keys())\n return layer_name, index\n\n\ndef get_neuron_coverage(model_layer_dict):\n covered_neurons = len([v for v in model_layer_dict.values() if v])\n total_neurons = len(model_layer_dict)\n return covered_neurons, total_neurons, covered_neurons / float(total_neurons)\n\n\ndef update_neuron_coverage(input_data, model, model_layer_dict, threshold=0):\n layer_names = [layer.name for layer in model.layers if\n 'flatten' not in layer.name and 'input' not in layer.name]\n\n intermediate_layer_model = Model(inputs=model.input,\n outputs=[model.get_layer(layer_name).output for layer_name in layer_names])\n intermediate_layer_outputs = intermediate_layer_model.predict(input_data)\n\n for i, intermediate_layer_output in enumerate(intermediate_layer_outputs):\n scaled = scale(intermediate_layer_output[0])\n for num_neuron in range(scaled.shape[-1]):\n if np.mean(scaled[..., num_neuron]) > threshold and not model_layer_dict[(layer_names[i], num_neuron)]:\n model_layer_dict[(layer_names[i], num_neuron)] = True\n print(\"new coverage found\")\n\n\n#To test\n\n#gets the distance of the points in standard deviations\n#note that it assumes that the points are normally distributed\ndef distance(point, mean, covarianceMatrix):\n return mahalanobis(point, mean, inv(covarianceMatrix))\n\n# an adaptation of some code from deepXplore\n# initializes a dictionary that will store which qudrants have been covered\n# model - the model we are looking to covered\n# layer_index - the layer we are exploring\n# group_size - size of the group of neurons we are analyzing\n# model_layer_dict - the object we want to initialize\ndef init_orthant_cov_dict(model, layer_index, group_size, model_layer_dict):\n layer = model.layers[layer_index]\n # some error handling\n if 'flatten' in layer.name or 'input' in layer.name:\n print(\"error in init_dict: layer_index points to the wrong layer\")\n # we initialize each combination\n for neuron_group in combinations(range(layer.output_shape[-1]), group_size): # layer.output_shape[-1] returns the number of total_neurons\n for orthant in range(2^group_size-1):\n model_layer_dict[(neuron_group, orthant)] = False\n\ndef get_orthant_coverage(model_layer_dict):\n covered_orthants = len([v for v in model_layer_dict.values() if v])\n total_orthants = len(model_layer_dict)\n return covered_orthants, total_orthants, covered_orthants / float(total_orthants)\n\n#this is meant to pick a orthant that is not covered\n# we actually don't need to use this just yet, maybe if I decide to implement for DeepXplore\ndef next_orthant_to_cover(model_layer_dict):\n not_covered = [(neuron_group, orthant) for (neuron_group, orthant), v in model_layer_dict.items() if not v]\n if not_covered:\n neuron_group, orthant = random.choice(not_covered)\n else:\n neuron_group, orthant = random.choice(model_layer_dict.keys())\n return neuron_group, orthant\n\n\n# creates a shortened model that ends at the nth layer, and has no activation function\n# same code as from collect_data\ndef create_shortened_model(model, layer_depth):\n # we get the neuron output for the penultimate layer for each neuron\n\n # implemented with help from the suggestion at: https://stackoverflow.com/questions/45492318/keras-retrieve-value-of-node-before-activation-function\n # we recreate the model, delete layers up to and including the layer we want to analyze, add a blank layer with no activation, and then import the old weights to this layer.\n\n #make a new model\n\n # some simple input checks\n if(layer_depth < 0):\n println ('layer depth must be positive!')\n sys.exit()\n\n if(layer_depth > len(model.layers)):\n println ('layer depth too large!')\n sys.exit()\n\n # save the original weights\n wgts = model.layers[layer_depth].get_weights()\n nthLayerNeurons = model.layers[layer_depth].output_shape[1]\n\n #remove layers up to the nth layer\n for i in range(len(model.layers)-layer_depth):\n model.pop()\n model.summary\n # add new layer with no activation\n model.add(layers.Dense(nthLayerNeurons,activation = None))\n\n # with the new layer, load the previous weights\n model.layers[layer_depth].set_weights(wgts)\n\n # get the output of this new model.\n return Model(inputs=model.input, outputs=model.layers[layer_depth].output )\n\n#this code updates the coverage given a certain input\ndef update_orthant_coverage(input_data, shortened_model, model_layer_dict, mean_vector, covariance_matrix, group_size=1, sd_threshold=1):\n\n layer_outputs = shortened_model.predict(input_data) #get the output\n # the reason that we use layer_outputs[0] is change it into a single row, rather than an array with a row.\n\n for neuron_group in combinations(range(layer_outputs.shape[-1]),group_size):\n group_output = np.asarray([layer_outputs[0][i] for i in neuron_group]) #get a list of the outputs\n\n # we do binary addition to get the correct orthant index.\n # for example, if we only have a 2 variables, we have 4 quadrants. we need to classify into 0,1,2,3 index\n #init the tools to find which orthant is being explored\n orthant = 0\n add = int(1)\n for neuron_index in neuron_group:\n if layer_outputs[0][neuron_index] > mean_vector[neuron_index]:\n orthant += add\n add *= 2\n\n if model_layer_dict[(neuron_group,orthant)] == True:\n continue #don't do the expensive action of loading the group cov, group mean, and calculating the distance\n\n group_mean = np.asarray([mean_vector[i] for i in neuron_group]) #list of mean\n #initialize the group numpy array for later calculation\n group_cov_matrix = np.asarray([[covariance_matrix[j][i] for i in neuron_group] for j in neuron_group]) #dont ask me why\n\n if(distance(group_output, group_mean, group_cov_matrix)>sd_threshold):\n model_layer_dict[(neuron_group,orthant)] = True\n\n# just a simple check if we have full coverage works for any coverage\ndef full_coverage(model_layer_dict):\n if False in model_layer_dict.values():\n return False\n return True\n\n\n# from here on is code from deepxplore\n\n# util function to convert a tensor into a valid image\ndef deprocess_image(x):\n x *= 255\n x = np.clip(x, 0, 255).astype('uint8')\n return x.reshape(x.shape[1], x.shape[2]) # original shape (1,img_rows, img_cols,1)\n\n\ndef normalize(x):\n # utility function to normalize a tensor by its L2 norm\n return x / (K.sqrt(K.mean(K.square(x))) + 1e-5)\n\n\ndef constraint_occl(gradients, start_point, rect_shape):\n new_grads = np.zeros_like(gradients)\n new_grads[:, start_point[0]:start_point[0] + rect_shape[0],\n start_point[1]:start_point[1] + rect_shape[1]] = gradients[:, start_point[0]:start_point[0] + rect_shape[0],\n start_point[1]:start_point[1] + rect_shape[1]]\n return new_grads\n\n\ndef constraint_light(gradients):\n new_grads = np.ones_like(gradients)\n grad_mean = np.mean(gradients)\n return grad_mean * new_grads\n\n\ndef constraint_black(gradients, rect_shape=(6, 6)):\n start_point = (\n random.randint(0, gradients.shape[1] - rect_shape[0]), random.randint(0, gradients.shape[2] - rect_shape[1]))\n new_grads = np.zeros_like(gradients)\n patch = gradients[:, start_point[0]:start_point[0] + rect_shape[0], start_point[1]:start_point[1] + rect_shape[1]]\n if np.mean(patch) < 0:\n new_grads[:, start_point[0]:start_point[0] + rect_shape[0],\n start_point[1]:start_point[1] + rect_shape[1]] = -np.ones_like(patch)\n return new_grads\n\n\ndef init_coverage_tables(model1, model1_layer_index, model2, model2_layer_index, model3, model3_layer_index, group_size = 1):\n model_layer_dict1 = defaultdict(bool)\n model_layer_dict2 = defaultdict(bool)\n model_layer_dict3 = defaultdict(bool)\n init_dict(model1, model1_layer_index, group_size, model_layer_dict1)\n init_dict(model2, model2_layer_index, group_size, model_layer_dict2)\n init_dict(model3, model3_layer_index, group_size, model_layer_dict3)\n return model_layer_dict1, model_layer_dict2, model_layer_dict3\n\ndef init_neuron_coverage_table(model1):\n model_layer_dict1 = defaultdict(bool)\n init_neuron_cov_dict(model1, model_layer_dict1)\n return model_layer_dict1\n\ndef init_orthant_coverage_table(model1, layer_index, group_size):\n model_layer_dict1 = defaultdict(bool)\n init_orthant_cov_dict(model1, layer_index, group_size, model_layer_dict1)\n return model_layer_dict1\n\ndef scale(intermediate_layer_output, rmax=1, rmin=0):\n X_std = (intermediate_layer_output - intermediate_layer_output.min()) / (\n intermediate_layer_output.max() - intermediate_layer_output.min())\n X_scaled = X_std * (rmax - rmin) + rmin\n return X_scaled\n\n\ndef fired(model, layer_name, index, input_data, threshold=0):\n intermediate_layer_model = Model(inputs=model.input, outputs=model.get_layer(layer_name).output)\n intermediate_layer_output = intermediate_layer_model.predict(input_data)[0]\n scaled = scale(intermediate_layer_output)\n if np.mean(scaled[..., index]) > threshold:\n return True\n return False\n\n\ndef diverged(predictions1, predictions2, predictions3, target):\n # if predictions2 == predictions3 == target and predictions1 != target:\n if not predictions1 == predictions2 == predictions3:\n return True\n return False\n"
] | [
[
"numpy.std",
"numpy.argmax",
"numpy.mean"
],
[
"numpy.zeros_like",
"numpy.ones_like",
"numpy.asarray",
"numpy.mean",
"numpy.clip",
"numpy.linalg.inv"
]
] |
kul-group/MAZE-sim | [
"0f85e74bf93f9242a73bcfaa20a593ae966f38fa",
"0f85e74bf93f9242a73bcfaa20a593ae966f38fa"
] | [
"scraps/forcefield_v2.py",
"demos/double_defect_maker.py"
] | [
"from maze.extra_framework_maker import ExtraFrameworkMaker, ExtraFrameworkAnalyzer\nfrom maze.io_zeolite import read_vasp\nfrom maze.zeolite import PerfectZeolite, Zeolite\nfrom ase.neighborlist import natural_cutoffs, NeighborList\nimport os\nfrom pathlib import Path\nfrom ase.io import write, read, gromacs, proteindatabank\nfrom ase.visualize import view\nimport copy\nimport shutil\nfrom glob import glob\nfrom ase.constraints import FixAtoms\nfrom simtk.openmm.app import *\nfrom simtk.openmm import *\nfrom simtk.unit import *\nfrom sys import stdout\nfrom ase.geometry.analysis import Analysis\nimport numpy as np\nfrom itertools import permutations\nfrom lxml import etree\nfrom contextlib import closing\nfrom collections import OrderedDict\nfrom scipy.optimize import least_squares, minimize\nimport matplotlib.pyplot as plt\nfrom statistics import mode\nimport pickle\nimport time\nfrom ase.data import atomic_masses, atomic_numbers\n\n\ndef get_EF_atom_indices(atoms):\n \"\"\"\n for index tracking, to ensure we are comparing the DFT and FF forces on the same EF atoms after before and after\n scooping out the smaller cluster.\n alse used for recentering the cluster based on the EF-O atom\n \"\"\"\n TM_list = ['Pt', 'Cu', 'Co', 'Pd', 'Fe', 'Cr', 'Rh', 'Ru']\n index_EF_TM = [a.index for a in atoms if a.symbol in TM_list]\n index_Al = [a.index for a in atoms if a.symbol == 'Al']\n nl = NeighborList(natural_cutoffs(atoms), bothways=True, self_interaction=False)\n nl.update(atoms)\n Al_neigh_list = np.concatenate((nl.get_neighbors(index_Al[0])[0], nl.get_neighbors(index_Al[1])[0]))\n Al_neigh_list = [x for x in Al_neigh_list if atoms[x].symbol == 'O']\n\n TM_neigh_list = np.concatenate((nl.get_neighbors(index_EF_TM[0])[0], nl.get_neighbors(index_EF_TM[1])[0]))\n centering_o = [[x for x in TM_neigh_list if list(TM_neigh_list).count(x) > 1 and x not in Al_neigh_list][0]]\n return index_EF_TM + centering_o\n\n\ndef get_capped_cluster(atoms, folder_path, file_name, save_traj, EF_O_index):\n \"\"\" #TODO: check whether capping is necessary\n Inconsistent capping (remove all caps for now, does not need this cluster to be physical)\n Possible fix: change mult in neighbor list\n\n Extract smaller cluster containing the extra-framework atoms and cap all the O. Then the capped cluster is moved\n to the center of the cell to avoid boundary issue.\n Save cluster in both .traj file and .pdb format.\n :param atoms:\n :param folder_path:\n :param file_name:\n :param save_traj: if True, save clusters into .traj as well, for later comparison and trouble shooting\n :param EF_O_index: if not none, will use this value, else, will find the index using Extraframework code\n :return: 1. EF-cluster including 13 atoms, index of the EF atoms in original zeolite, index of the EF atoms in\n the current cluster (the later two output index lists share the ordering)\n \"\"\"\n EFMaker = ExtraFrameworkAnalyzer(atoms)\n cluster = atoms[[index for index in EFMaker.get_extraframework_cluster(EF_O_index)]]\n\n cluster_EF_index = get_EF_atom_indices(cluster)\n centering_pos = cluster.get_positions()[cluster_EF_index[-1]]\n recentered_cluster = EFMaker.recentering_atoms(cluster, centering_pos)[0]\n # FIXME: recentering doesn't work well for very small unit cells. eg. SOD\n # cluster = Zeolite(cluster).cap_atoms()\n\n proteindatabank.write_proteindatabank(folder_path + '/%s.pdb' % file_name, recentered_cluster)\n if save_traj is True:\n write(folder_path + '/%s.traj' % file_name, recentered_cluster)\n\n return cluster, EFMaker.get_extraframework_cluster(EF_O_index), cluster_EF_index\n\n\ndef label_pdb(folder_path, file_name, del_unlabeled_pdb):\n \"\"\"\n Relabeling the Atom name in proteindatabank file. (required step for openMM)\n The same atom type connecting to different neighboring types are treated differently due to differences in their\n chemical environments, and is therefore named separately.\n :param folder_path:\n :param file_name:\n :param del_unlabeled_pdb:\n \"\"\"\n filein = open(folder_path + '/%s.pdb' % file_name, 'r')\n fileout = open(folder_path + '/%s_labeled.pdb' % file_name, 'w')\n\n name_list = []\n for line in filein.readlines():\n if line.startswith('ATOM') or line.startswith('HETATM'):\n name = line[12:16].strip()\n name_list.append(name)\n name = name + str(name_list.count(name))\n name = name.rjust(4)\n line = line.replace(line[12:16], name, 1)\n # only replacing the first occurrence of line[12:16], atomic symbols are maintained\n fileout.writelines(line)\n\n filein.close()\n fileout.close()\n if del_unlabeled_pdb is True:\n os.remove(folder_path + '/%s.pdb' % file_name)\n\n\ndef get_bonds(cluster, mult=1, excluded_index=None, excluded_pair=None):\n \"\"\"\n Using ase.geometry.analysis.Analysis to get all bonds, then remove the repeated ones.\n Function also allows removing certain bonding pair defined by user (excluded_pair).\n Or removing pairs including certain atomic indices (excluded_index).\n :param cluster:\n :param mult:\n :param excluded_index: list of integers\n :param excluded_pair: list of lists\n :return: full bonding list, shortened list.\n If both excluded_index and excluded_pair are None, bonding list == shortened list\n \"\"\"\n if excluded_index is None:\n excluded_index = []\n if excluded_pair is None:\n excluded_pair = []\n\n nl = NeighborList(natural_cutoffs(cluster, mult=mult), bothways=True, self_interaction=False)\n nl.update(cluster)\n\n bond_list, shortened_list = [], []\n for count, indices in enumerate(Analysis(cluster, nl=nl).all_bonds[0]):\n for index in indices:\n if [count, index] not in bond_list and [index, count] not in bond_list:\n bond_list.append([count, index])\n\n for bond in bond_list:\n if all(single_index not in bond for single_index in excluded_index) and \\\n all(tuple(bond) not in list(permutations(pair)) for pair in excluded_pair):\n shortened_list.append(bond)\n\n return bond_list, shortened_list\n\n\ndef get_angles(cluster, mult=1, excluded_index=None, excluded_pair=None):\n \"\"\"\n #TODO: consider combining get_bonds and get_angles function\n ase.geometry.analysis.Analysis.unique_angles function does not work, return all angles.\n three-body interactions.\n :param excluded_pair: excluding all [particle1, particle2, particle3] lists involving the excluded pair\n \"\"\"\n if excluded_index is None:\n excluded_index = []\n if excluded_pair is None:\n excluded_pair = []\n\n nl = NeighborList(natural_cutoffs(cluster, mult=mult), bothways=True, self_interaction=False)\n nl.update(cluster)\n\n angle_list, shortened_list = [], []\n for count, indices in enumerate(Analysis(cluster, nl=nl).all_angles[0]):\n for index in indices:\n if all(list(val) not in angle_list for val in list(permutations([count, index[0], index[1]]))):\n angle_list.append([count, index[0], index[1]])\n\n for angle in angle_list:\n if all(single_index not in angle for single_index in excluded_index) and \\\n all(list(value) not in excluded_pair for value in list(permutations(angle, 2))):\n shortened_list.append(angle)\n\n return angle_list, shortened_list\n\n\ndef write_xml(atoms, bonds, save_as):\n # on-the-fly generation of force field xml file, matching atoms and bonds with pdb file\n root = etree.Element('ForceField')\n\n xml_section = etree.SubElement(root, \"AtomTypes\")\n for atom in atoms:\n element_type = ''.join(filter(lambda x: not x.isdigit(), atom.name))\n # properties = {'name': atom.name, 'class': atom.name, 'element': element_type, 'mass': str(atomic_mass)}\n if element_type == 'Cu' or atom.name == 'O9':\n atomic_mass = atomic_masses[atomic_numbers[element_type]]\n else:\n atomic_mass = 0.0\n properties = {'name': atom.name, 'class': atom.name, 'element': element_type, 'mass': str(atomic_mass)}\n etree.SubElement(xml_section, 'Type', **properties)\n\n xml_section = etree.SubElement(root, 'Residues')\n xml_residue = etree.SubElement(xml_section, 'Residue', name='MOL')\n for atom in atoms:\n etree.SubElement(xml_residue, 'Atom', name=atom.name, type=atom.name)\n for bond in bonds:\n etree.SubElement(xml_residue, 'Bond', atomName1=bond[0].name, atomName2=bond[1].name)\n\n tree = etree.ElementTree(root)\n xml = etree.tostring(tree, pretty_print=True).decode('utf-8')\n\n with closing(open(save_as, 'w')) as f:\n f.write(xml)\n\n\ndef check_atom_types(cluster, index):\n \"\"\" assign atom types, same element connected to different neighbors are assigned into different classes.\n For example, extra-framework O (in Cu-O-Cu) is in a different class from framework O (Si-O-Si). Each class\n assignment is unique (each atom belongs to one class and one class only).\n O_EF: extra-framework O\n O-Cu: framework O, connecting to one T-site(Al) and Cu\n O-H: framework O, connecting to one T-site(Al) and H (capping)\n \"\"\"\n nl = NeighborList(natural_cutoffs(cluster), bothways=True, self_interaction=False)\n nl.update(cluster)\n\n class_Al = [atom.index for atom in cluster if atom.symbol == 'Al']\n class_Cu = [atom.index for atom in cluster if atom.symbol == 'Cu']\n class_H = [atom.index for atom in cluster if atom.symbol == 'H']\n class_O_EF = [get_EF_atom_indices(cluster)[-1]]\n class_O_Cu = [atom.index for atom in cluster if atom.symbol == 'O' and atom.index not in class_O_EF and\n all(val not in class_H for val in nl.get_neighbors(atom.index)[0])]\n class_O_H = [atom.index for atom in cluster if atom.symbol == 'O' and atom.index not in class_O_EF + class_O_Cu]\n\n if index in class_Al:\n return 'Al'\n if index in class_Cu:\n return 'Cu'\n if index in class_H:\n return 'H'\n if index in class_O_EF:\n return 'O-EF'\n if index in class_O_Cu:\n return 'O-Cu'\n if index in class_O_H:\n return 'O-H'\n else:\n return 'None'\n\n\ndef get_property_types(cluster, property_list):\n \"\"\" assign all bonding pairs or angles into different types based on differences in atom types. For example,\n O(extra-framework)-Cu is different from O(framework)-Cu.\n :param property_list: bond or angle index list of the cluster of interests\n :return type_dict: return a dictionary of all unique bond-pairs or angle types, with \"keys\" being integers starting\n from 0, and \"values\" being a list of two atom types string for bonds or three atom types string for angles.\n eg. {0: [AtomClass1, AtomClass2], 1: [AtomClass1, AtomClass3], ...} for bonds\n Note: Bond types such as [AtomClass1, AtomClass2] and [AtomClass2, AtomClass1] are considered the same. Same rules\n also apply for angles.\n :return whole_type_list: return the entire list of bond or angle types assignment of the input.\n len(whole_type_list) = len(my_list)\n \"\"\"\n type_dict, repeated_list, whole_type_list, count = {}, [], [], 0\n\n for items in property_list:\n my_list = []\n for val in items:\n my_list.append(check_atom_types(cluster, val))\n whole_type_list.append(my_list)\n if all(list(pair) not in repeated_list for pair in list(permutations(my_list))):\n repeated_list.append(my_list)\n type_dict[count] = my_list\n count += 1\n\n return type_dict, whole_type_list\n\n\ndef _get_index_dict(type_dict, whole_type_list, index_list):\n \"\"\" assign bond pairs or angles indices into different bond or angle types, all the pairs or angles within the same\n types will share the same set of force field parameters.\n :param type_dict:\n :param whole_type_list:\n :param index_list:\n :return index_dict: return a dictionary of all bond-pairs or angle indices for each unique bond or angle type,\n using the the same keys as type_dict.\n \"\"\"\n index_dict = {}\n for key, value in type_dict.items():\n temp_list = []\n for count, items in enumerate(whole_type_list):\n if any(list(pair) == value for pair in list(permutations(items))):\n temp_list.append(index_list[count])\n index_dict[key] = temp_list\n\n return index_dict\n\n\ndef get_type_index_pair(type_dict, whole_type_list, index_list):\n \"\"\" write bond_type and bond_index into a single dictionary; can use tuples as dictionary key, not lists\n :param type_dict:\n :param whole_type_list:\n :param index_list:\n \"\"\"\n bond_index_dict = _get_index_dict(type_dict, whole_type_list, index_list)\n type_index_dict = {}\n for key, value in type_dict.items():\n type_index_dict[tuple(value)] = bond_index_dict[key]\n return type_index_dict\n\n\ndef pretty_print(my_dict):\n \"\"\" for better visualization of the bond (or angle) types and bond (or angle) indices that belong to certain types.\n \"\"\"\n for key, value in my_dict.items():\n print(key, '-->', value)\n\n\ndef shorten_index_list_by_types(type_index_dict, exclude_atom_type=None, exclude_property_type=None,\n include_property_type=None, case=0):\n \"\"\"\n allow excluding certain property types or only including certain types\n \"\"\"\n\n if exclude_atom_type is not None and exclude_property_type is None:\n case = 1\n if exclude_property_type is not None and exclude_atom_type is None:\n case = 2\n if exclude_property_type is not None and exclude_atom_type is not None:\n case = 3\n if include_property_type is not None:\n case = 4\n\n shortened_list = []\n for type_list, index_list in type_index_dict.items():\n if case == 1 and all(single_type not in type_list for single_type in exclude_atom_type):\n shortened_list.extend(index_list)\n elif case == 2 and all(list(value) not in exclude_property_type for value in list(permutations(type_list))):\n shortened_list.extend(index_list)\n elif case == 3 and all(single_type not in type_list for single_type in exclude_atom_type) and \\\n all(list(value) not in exclude_property_type for value in list(permutations(type_list))):\n shortened_list.extend(index_list)\n elif case == 4 and any(list(value) in include_property_type for value in list(permutations(type_list))):\n shortened_list.extend(index_list)\n\n return shortened_list\n\n\ndef set_up_openMM_system(folder_path, cluster_tag_number, shortened_bond_list):\n \"\"\" Feed pdb topology file and xml force field file into openMM, generate a system for the MD simulation/force\n calculation.\n :param folder_path:\n :param cluster_tag_number:\n :param shortened_bond_list:\n :return pdb:\n :return system:\n \"\"\"\n pdb = PDBFile(folder_path + '/cluster_%s_labeled.pdb' % cluster_tag_number)\n atoms = list(pdb.topology.atoms())\n\n for index in shortened_bond_list:\n pdb.topology.addBond(atoms[index[0]], atoms[index[1]])\n bonds = list(pdb.topology.bonds())\n\n write_xml(atoms, bonds, folder_path + '/forcefield.xml')\n FF = ForceField(folder_path + '/forcefield.xml')\n system = FF.createSystem(pdb.topology)\n return pdb, system\n\n\ndef custom_openMM_force_object(system, bond_list, bond_type_index_dict, bond_param_dict, angle_list=None,\n angle_type_index_dict=None, angle_param_dict=None):\n \"\"\" #todo: add argument allowing this custom function to be fed in as an input (more flexible used-designed ff)\n :param bond_list: list to be included into force field\n :param angle_list:\n :param bond_type_index_dict: {(type): [index], ...}\n :param angle_type_index_dict:\n :param bond_param_dict: {(type): [param], ...} Note: parameters here uses the standard units, kJ, nm, ...\n :param angle_param_dict:\n :return system: openMM system with custom forces added onto it\n \"\"\"\n force = CustomBondForce(\"D*(1-exp(-alpha*(r-r0)))^2\") # Morse bond\n force.addPerBondParameter(\"D\")\n force.addPerBondParameter(\"alpha\")\n force.addPerBondParameter(\"r0\")\n force.setUsesPeriodicBoundaryConditions(periodic=True)\n\n for bond in bond_list:\n for my_type, my_index in bond_type_index_dict.items():\n if any(list(val) in my_index for val in list(permutations(bond))):\n try:\n force.addBond(int(bond[0]), int(bond[1]), bond_param_dict.get(my_type))\n except:\n my_type = tuple(reversed(my_type))\n force.addBond(int(bond[0]), int(bond[1]), bond_param_dict.get(my_type))\n # note: consider updating the info_dict to make it order insensitive\n system.addForce(force)\n\n force = HarmonicAngleForce() # Harmonic angle\n force.setUsesPeriodicBoundaryConditions(periodic=True) # adding periodic conditions\n\n for angle in angle_list:\n for my_type, my_index in angle_type_index_dict.items():\n if any(list(val) in my_index for val in list(permutations(angle))):\n type_tag = [tuple(val) for val in list(angle_param_dict.keys()) if val in list(permutations(my_type))]\n force.addAngle(int(angle[0]), int(angle[1]), int(angle[2]), *angle_param_dict.get(type_tag[0]))\n system.addForce(force)\n\n # assert(system.usesPeriodicBoundaryConditions() == True)\n return system\n\n\ndef get_openMM_forces(pdb, system, bond_list, bond_type_index_dict, bond_param_dict, angle_list=None,\n angle_type_index_dict=None, angle_param_dict=None):\n \"\"\" forces for a single configuration\n use numb to keep track of individual configurations\n integrator used for advancing the equations of motion in MD\n doesn't matter what we pick here since we only need the forces on the initial structure, but do need to have it\n :return: forces values on atoms in units of eV/A\n \"\"\"\n system = custom_openMM_force_object(system, bond_list, bond_type_index_dict, bond_param_dict, angle_list,\n angle_type_index_dict, angle_param_dict)\n integrator = LangevinMiddleIntegrator(3 * kelvin, 1 / picosecond, 0.4 * picoseconds) # randomly picked\n simulation = Simulation(pdb.topology, system, integrator)\n simulation.context.setPositions(pdb.positions)\n state = simulation.context.getState(getForces=True)\n forces = np.array(state.getForces(asNumpy=True)) * 1.0364e-2 * 0.1 # convert forces from kJ/nm mol to eV/A\n\n return forces\n\n\n# NOTE: section below deals with multiple input structures for force field training\n\ndef get_EF_O_index(traj):\n \"\"\"\n get the mode of EF_O, and use that to extract the EF cluster for the force field training\n all EF atoms should have the same indices regardless of there is binds on the zeolite, as long as the zeolite\n framework is the same - (all EF atoms, aka. Cu-O-Cu insertion follows the same procedures)\n :param traj: traj of configurations containing all atoms, including both the zeolite backbone and EF atoms\n \"\"\"\n EF_O_index_list = []\n for atoms in traj:\n try:\n EFAnalyzer = ExtraFrameworkAnalyzer(atoms)\n EF_O_index_list.append(EFAnalyzer.get_extraframework_cluster()[-1])\n except:\n ...\n return mode(tuple(EF_O_index_list))\n\n\ndef prep_topologies(folder_path, sample_zeolite, traj_name=None, save_traj=False, del_unlabeled_pdb=False,\n show_all=False):\n \"\"\"\n :param folder_path:\n :param sample_zeolite:\n :param traj_name:\n :param save_traj:\n :param del_unlabeled_pdb:\n :param show_all:\n \"\"\"\n if traj_name is not None:\n traj = read(folder_path + '/%s.traj' % traj_name, ':')\n output_dir = os.path.join(folder_path, traj_name)\n else:\n traj = read(folder_path + '/%s.traj' % sample_zeolite, ':')\n output_dir = os.path.join(folder_path, sample_zeolite)\n Path(output_dir).mkdir(parents=True, exist_ok=True)\n\n cluster_traj, EF_O_index, EF_atoms_index, cluster_EF_index = [], get_EF_O_index(traj[0:100]), [], []\n for count, atoms in enumerate(traj):\n try:\n cluster, EF_atoms_index, cluster_EF_index = get_capped_cluster(atoms, output_dir, 'cluster_' + str(count),\n save_traj, [EF_O_index])\n label_pdb(output_dir, 'cluster_%s' % str(count), del_unlabeled_pdb)\n cluster_traj.append(cluster)\n print(sample_zeolite, count)\n except:\n print(sample_zeolite, count, 'failed!')\n\n if show_all is True:\n view(cluster_traj)\n\n return EF_atoms_index, cluster_EF_index\n\n\ndef reformat_inputs(bond_param_dict, angle_param_dict):\n \"\"\" reformat input dict into lists\n :return bond_type: List[List[str]] eg. ['Cu', 'O']\n :return angle_type: List[List[str]] eg. ['Cu', 'O', 'Cu']\n :return param_list: List[float], extend all parameters into a single list, since scipy.optimize.minimize can only\n take an 1D array as initial guess parameter\n \"\"\"\n bond_type, angle_type, param_list = [], [], []\n for types, indices in bond_param_dict.items():\n bond_type.append(list(types))\n param_list.extend([val for val in np.array(indices)])\n\n for types, indices in angle_param_dict.items():\n angle_type.append(list(types))\n param_list.extend([val for val in np.array(indices)])\n\n return bond_type, angle_type, param_list\n\n\ndef get_required_objects_for_ff(folder_path, cluster_tag_number, included_bond_type, included_angle_type,\n bond_type_index_dict, angle_type_index_dict):\n \"\"\" To reduce computational cost, objects such as pdb, system, shortened_bond_list, bond_type_index_dict are kept\n fixed for each configuration during the optimization (only run once).\n \"\"\"\n\n shortened_bond_list = shorten_index_list_by_types(bond_type_index_dict, include_property_type=included_bond_type)\n shortened_angle_list = shorten_index_list_by_types(angle_type_index_dict, include_property_type=included_angle_type)\n pdb, system = set_up_openMM_system(folder_path, cluster_tag_number, shortened_bond_list)\n\n return pdb, system, shortened_bond_list, shortened_angle_list\n\n\ndef get_FF_forces(param, info_dict, ini_bond_param_dict, ini_angle_param_dict, bond_type_index_dict,\n angle_type_index_dict, EF_index):\n \"\"\" openMM forces for multiple configuration based on the same set of parameters\n \"\"\"\n bond_param_dict, angle_param_dict, number_of_bond_param = {}, {}, 0\n for count, (types, indices) in enumerate(ini_bond_param_dict.items()):\n bond_param_dict[types] = list(param[count * len(indices):(count + 1) * len(indices)])\n number_of_bond_param += len(indices)\n\n for count, (types, indices) in enumerate(ini_angle_param_dict.items()):\n angle_param_dict[types] = list(\n param[count * len(indices) + number_of_bond_param:(count + 1) * len(indices) + number_of_bond_param])\n\n predicted_f = []\n my_dict = copy.deepcopy(info_dict)\n for config_tag, info_list in my_dict.items():\n ff_forces = get_openMM_forces(info_list[0], info_list[1], info_list[2], bond_type_index_dict, bond_param_dict,\n info_list[3], angle_type_index_dict, angle_param_dict)[EF_index]\n predicted_f.append([force_list for force_list in ff_forces])\n\n return predicted_f\n\n\ndef get_DFT_forces_single(atoms, atom_index):\n \"\"\"\n reference DFT forces on single atoms\n \"\"\"\n f_vec = atoms.calc.results['forces'][atom_index] # self.atoms.get_forces()[atom_index]\n f_mag = np.linalg.norm(f_vec)\n return f_vec\n\n\ndef get_residue(param, info_dict, DFT_f, weights, ini_bond_param_dict, ini_angle_param_dict,\n bond_type_index_dict, angle_type_index_dict, EF_index):\n \"\"\"\n optimize force field parameters by minimizing this loss function (MSE), weighted by DFT electronic energies\n k (Boltzmann's constant) = 8.617e-5 eV/K\n T = 298 K\n \"\"\"\n predicted_f = get_FF_forces(param, info_dict, ini_bond_param_dict, ini_angle_param_dict, bond_type_index_dict,\n angle_type_index_dict, EF_index)\n residue = np.reshape(np.array(np.reshape(predicted_f, [-1, 3])) - np.array(np.reshape(DFT_f, [-1, 3])), -1)\n weighted_residue = residue * weights # 39 number of atoms\n print(np.mean(weighted_residue ** 2))\n return np.mean(weighted_residue ** 2)\n\n\ndef get_fitting_parameters(initial_param, info_dict, DFT_f, weights, ini_bond_param_dict, ini_angle_param_dict,\n bond_type_index_dict, angle_type_index_dict, EF_index):\n # todo: more flexible bond reformating and feeding\n bounds = ((-np.Inf, np.Inf), (-np.Inf, np.Inf), (0, np.Inf), (-np.Inf, np.Inf), (-np.Inf, np.Inf),\n (0, np.Inf), (-np.Inf, np.Inf), (-np.Inf, np.Inf), (0, np.Inf), (0, np.pi),\n (-np.Inf, np.Inf), (0, np.pi), (-np.Inf, np.Inf), (0, np.pi), (-np.Inf, np.Inf))\n res = minimize(get_residue, initial_param, method='Powell', bounds=bounds, options={'ftol': 0.01, 'maxiter': 1000},\n args=(info_dict, DFT_f, weights, ini_bond_param_dict, ini_angle_param_dict,\n bond_type_index_dict, angle_type_index_dict, EF_index))\n print(res.success)\n return res\n\n\ndef make_parity_plot(ff_forces, dft_forces, atom_name):\n \"\"\" plot FF forces vs. DFT forces\n \"\"\"\n plt.figure()\n fig, ax = plt.subplots()\n plt.plot(dft_forces, ff_forces, 'o')\n plt.xlabel('DFT_force', fontsize=18)\n plt.ylabel('FF_force', fontsize=18)\n lims = [np.min([ax.get_xlim(), ax.get_ylim()]), np.max([ax.get_xlim(), ax.get_ylim()])]\n ax.plot(lims, lims, 'k-', alpha=0.75, zorder=0)\n ax.set_aspect('equal')\n ax.set_xlim(lims)\n ax.set_ylim(lims)\n plt.title('Force fitting on %s' % atom_name, fontsize=18)\n plt.show()\n\n\ndef func():\n tic = time.perf_counter()\n zeolite = 'SOD'\n folder_path, sample_zeolite, traj_name = '/Users/jiaweiguo/Box/openMM_FF', zeolite, zeolite + '_md'\n # prep_topologies(folder_path, sample_zeolite, traj_name, del_unlabeled_pdb=True)\n \"\"\"\n ini_bond_param_dict = {('O-Cu', 'Cu'): [1.2, 4, 0.3], ('O-EF', 'Cu'): [1.2, 4, 0.2], ('Al', 'Cu'): [1.2, 4, 0.4]}\n ini_angle_param_dict = {('Cu', 'O-EF', 'Cu'): [2.3, 10], ('O-Cu', 'Cu', 'O-EF'): [2.3, 10],\n ('Al', 'Cu', 'O-EF'): [2.3, 10]}\n \"\"\"\n ini_bond_param_dict = {('O-Cu', 'Cu'): [60.097, 2.267, 0.228], ('O-EF', 'Cu'): [4405.247, 4.163, 0.177],\n ('Al', 'Cu'): [-2.656, 4.608, 0.413]}\n ini_angle_param_dict = {('Cu', 'O-EF', 'Cu'): [2.458, 16.552], ('O-Cu', 'Cu', 'O-EF'): [3.266, 4.136],\n ('Al', 'Cu', 'O-EF'): [1.925, 1.673]}\n included_bond_type, included_angle_type, ini_param = reformat_inputs(ini_bond_param_dict, ini_angle_param_dict)\n\n # set up type_index_dict using a single set of data #fixme: randomly pick several initial clusters to built dict\n cluster = read(os.path.join(folder_path, traj_name) + '/cluster_0_labeled.pdb', '0')\n bond_index_list, shortened_bond_index_list = get_bonds(cluster, mult=2)\n bond_type_dict, whole_bond_type_list = get_property_types(cluster, bond_index_list)\n angle_index_list, shortened_angle_index_list = get_angles(cluster, mult=2)\n angle_type_dict, whole_angle_type_list = get_property_types(cluster, angle_index_list)\n bond_type_index_dict = get_type_index_pair(bond_type_dict, whole_bond_type_list, bond_index_list)\n angle_type_index_dict = get_type_index_pair(angle_type_dict, whole_angle_type_list, angle_index_list)\n\n numb_skip = 2000\n info_dict, output_path = {}, os.path.join(folder_path, traj_name)\n files = [files for files in os.listdir(os.path.join(folder_path, traj_name)) if '.pdb' in files]\n for cluster_tag_number in np.arange(0, len(files), numb_skip):\n cluster_tag_number = int(cluster_tag_number)\n pdb, system, shortened_bond_list, shortened_angle_list = \\\n get_required_objects_for_ff(output_path, cluster_tag_number, included_bond_type, included_angle_type,\n bond_type_index_dict, angle_type_index_dict)\n info_dict[cluster_tag_number] = [pdb, system, shortened_bond_list, shortened_angle_list]\n print(cluster_tag_number)\n\n with open(output_path + '/info_dict_%s.pickle' % numb_skip, 'wb') as f:\n pickle.dump(info_dict, f)\n\n with open(folder_path + '/EF_index_dict.pickle', 'rb') as f:\n EF_index_dict = pickle.load(f)\n\n traj = read(folder_path + '/%s.traj' % traj_name, '0::%s' % numb_skip)\n DFT_f = []\n for atoms in traj:\n DFT_f.append([get_DFT_forces_single(atoms, atom_index=val) for val in EF_index_dict.get(zeolite)[-3:]])\n print(np.array(DFT_f).shape)\n\n ref_E = read(folder_path + '/%s.traj' % traj_name, '-1').calc.results['energy']\n DFT_E = []\n for atoms in traj:\n DFT_E.append(atoms.calc.results['energy'])\n\n with open(os.path.join(folder_path, traj_name) + '/info_dict_%s.pickle' % numb_skip, 'rb') as f:\n info_dict = pickle.load(f)\n\n with open(folder_path + '/cluster_EF_index_dict.pickle', 'rb') as f:\n cluster_EF_index_dict = pickle.load(f)\n\n my_dict = copy.deepcopy(info_dict) # important, need to keep openMM \"systems\" fixed\n weights = []\n for value in np.exp(-(np.array(DFT_E) - ref_E) / len(traj[0]) / (8.617e-5 * 298)):\n weights.extend([value, value, value, value, value, value, value, value, value])\n res = get_fitting_parameters(ini_param, my_dict, DFT_f, np.array(weights), ini_bond_param_dict, ini_angle_param_dict,\n bond_type_index_dict, angle_type_index_dict, cluster_EF_index_dict.get(zeolite))\n\n print([np.around(float(val), decimals=3) for val in res.x])\n FF_f = get_FF_forces(res.x, info_dict, ini_bond_param_dict, ini_angle_param_dict, bond_type_index_dict,\n angle_type_index_dict, cluster_EF_index_dict.get(zeolite))\n make_parity_plot(np.array(np.reshape(FF_f, [-1, 3])), np.array(np.reshape(DFT_f, [-1, 3])), 'Cu-O-Cu')\n\n force_dict = {'FF': np.array(np.reshape(FF_f, [-1, 3])), 'DFT': np.array(np.reshape(DFT_f, [-1, 3]))}\n with open(output_path + '/forces_%s.pickle' % numb_skip, 'wb') as f:\n pickle.dump(force_dict, f)\n\n toc = time.perf_counter()\n print(f\"Program terminated in {toc - tic:0.4f} seconds\")\n\n\nif __name__ == '__main__':\n # func()\n \n \"\"\" weighting factor for the loss function\n zeolite = 'SOD'\n folder_path, traj_name, numb_skip = '/Users/jiaweiguo/Box/openMM_FF', zeolite + '_md', 2000\n traj = read(folder_path + '/%s.traj' % traj_name, '0::%s' % numb_skip)\n ref_E = read(folder_path + '/%s.traj' % traj_name, '-1').calc.results['energy']\n DFT_E = []\n for atoms in traj:\n DFT_E.append(atoms.calc.results['energy'])\n weight = np.exp(-(np.array(DFT_E) - ref_E) / len(traj[0]) / (8.617e-5 * 298))\n plt.plot(DFT_E, weight, 'o')\n plt.xlabel('DFT electronic energies (eV)', fontsize=16)\n plt.ylabel('Boltzmann weighting', fontsize=16)\n plt.show()\n \"\"\"\n",
"from ase.io import read, write\nfrom ase import Atoms\nfrom maze import Zeotype, OpenDefect, ImperfectZeotype\nimport os\nfrom ase.visualize import view\nfrom pathlib import Path\nfrom collections import defaultdict\nfrom typing import List\nimport numpy as np\n\n\n# %%\ndef defect_maker(cif_dir, zeolite_code, output_dir, savefiles=True):\n zeolite = Zeotype.build_from_cif_with_labels(cif_dir)\n open_defect = OpenDefect(zeolite)\n unique_t_site_indices = {}\n for site_name, value in zeolite._site_to_atom_indices.items():\n if 'T' in site_name:\n unique_t_site_indices[site_name] = value[1]\n\n # build dictionary of open defects\n unique_t_site_to_od = defaultdict(list)\n for site_name, t_site in unique_t_site_indices.items():\n for o_index in open_defect.neighbor_list.get_neighbors(t_site)[0]:\n for si_index in open_defect.neighbor_list.get_neighbors(o_index)[0]:\n if si_index == t_site:\n continue\n pos = open_defect.get_positions()[si_index]\n new_od = open_defect.delete_atoms([si_index]).cap_atoms()\n unique_t_site_to_od[site_name].append(new_od)\n\n # save T sites\n if savefiles: #I made this change\n for site_name, od_list in unique_t_site_to_od.items():\n output_dir2 = os.path.join(output_dir, zeolite_code, site_name)\n Path(output_dir2).mkdir(parents=True, exist_ok=True)\n for index, od in enumerate(od_list):\n output_filename = zeolite_code + '_' + site_name + '_' + str(index) + '.traj'\n my_path = os.path.join(output_dir2, output_filename)\n write(my_path, od)\n\n return unique_t_site_to_od # and most importantly I made this chnage\n\n\n# helper functions for second defect function\ndef find_removed_atoms(iz: ImperfectZeotype) -> List[int]:\n \"\"\"\n Finds the atoms removed from the iz by comparing it with parent MAZE-sim\n :param iz: imperfect MAZE-sim to check for missing atoms\n :return: list of indices of missing atoms (using parent indexing)\n \"\"\"\n missing_list = []\n for atom in iz.parent_zeotype:\n value = iz.index_mapper.get_index(iz.parent_zeotype.name, iz.name, atom.index)\n if value is None:\n missing_list.append(atom.index)\n\n return missing_list\n\ndef find_neighbor_si(z: Zeotype, first_si_index: int):\n \"\"\"\n Finds the first neighboring Si\n :param z: the MAZE-sim object\n :param first_si_index: the first Si index to find a neighbor too\n :return: the first neighboring si index\n \"\"\"\n z.update_nl()\n for o_index in z.neighbor_list.get_neighbors(first_si_index)[0]:\n for si_index in z.neighbor_list.get_neighbors(o_index)[0]:\n if si_index == first_si_index:\n continue\n return si_index\n\ndef find_index_common_oxygen(iz, site_1: int, site_2: int) -> int:\n \"\"\"\n Finds a common oxygen, if it exists, between two T sites\n :param iz: imperfect MAZE-sim (or subclass) containing T sites\n :param site_1: index of T site 1\n :param site_2: index of T site 2\n :return:\n \"\"\"\n iz.update_nl()\n nl1 = iz.neighbor_list.get_neighbors(site_1)[0]\n nl2 = iz.neighbor_list.get_neighbors(site_2)[0]\n # find common oxygen\n for i in nl1:\n if i in nl2:\n if iz[i].symbol == 'O':\n return i\n\n assert False, 'No middle oxygen found!!'\n\ndef remove_two_T_sites(iz, site_1: int, site_2: int) -> ImperfectZeotype:\n \"\"\"\n Removes two T sites that are adjacent to eachother\n :param iz: Impefect MAZE-sim with two T sites\n :param site_1: the index of the first site to remove\n :param site_2: the index of the second site to remove\n :return:\n \"\"\"\n indices_to_remove = [site_1, site_2, find_index_common_oxygen(iz, site_1, site_2)]\n return iz.delete_atoms(indices_to_remove)\n\ndef second_defect(od_dict, T_site_str, list_pos, cif_name, out_path, savefile: bool =True):\n \"\"\"\n Second defect creator\n :param od_dict: dictionary of open defects (this is to allow it to integrate with the other code better)\n :param T_site_str: The key for the open defects dictionary\n :param list_pos: The position in the list of od_dict[T_site_str]\n :param cif_name: the name of the cif file used to build the zeolite\n :param out_path: the output path\n :param savefile: bool if a file should be saved or not\n :return: an open defect with an additional adjacent site removed\n \"\"\"\n od = od_dict[T_site_str][list_pos] # get specific open defect\n complete_od = OpenDefect(od.parent_zeotype) # create an opendefect object without the removed index\n removed_atom_index = find_removed_atoms(od)[0]\n\n neighbor_si_index = find_neighbor_si(complete_od, removed_atom_index)\n new_od = remove_two_T_sites(complete_od, removed_atom_index, neighbor_si_index).cap_atoms()\n my_path = os.path.join(out_path, cif_name + '_' + str(neighbor_si_index) + '.traj')\n if savefile:\n write(my_path, new_od)\n return new_od\n\n\n# .add_atoms(Atoms('Ir', positions=[pos]), 'Ir')\n\n# %%'\n\n# %%\n\n\ndef insert_HM(cif_dir, out_path, cif_name, si_index):\n atoms = read(cif_dir + str(si_index) + '.traj', '-1')\n zeolite = Zeotype(atoms)\n open_defect = OpenDefect(zeolite)\n atoms_H = [a.index for a in open_defect if a.symbol in ['H']]\n pos_H = open_defect.get_positions()[atoms_H]\n cell_dim = atoms.get_cell_lengths_and_angles()[0:3]\n for row in pos_H:\n for index, item in enumerate(row):\n if item >= cell_dim[index]:\n item -= cell_dim[index]\n row[index] = item\n elif item < 0:\n item += cell_dim[index]\n row[index] = item\n else:\n continue\n pos = np.mean(pos_H, axis=0)\n new_od = open_defect.add_atoms(Atoms('Ir', positions=[pos]), 'Ir')\n # my_path = os.path.join(out_path, cif_name + '_' + str(si_index) + '_Ir.traj')\n # write(my_path, new_od)\n return np.mean(pos)\n\n\ndef insert_HM_2(open_defect, si_index):\n atoms_types, _ = open_defect.count_elements\n atoms_H = atoms_types['H']\n pos_H = open_defect.get_positions()[atoms_H]\n cell_dim = open_defect.get_cell_lengths_and_angles()[0:3]\n for row in pos_H:\n for index, item in enumerate(row):\n if item >= cell_dim[index]:\n item -= cell_dim[index]\n row[index] = item\n elif item < 0:\n item += cell_dim[index]\n row[index] = item\n else:\n continue\n pos = np.mean(pos_H, axis=0)\n new_od = open_defect.add_atoms(Atoms('Ir', positions=[pos]), 'Ir')\n return np.mean(pos)\n\n\nif __name__ == \"__main__\":\n #defect_maker('/Users/jiaweiguo/Desktop/0125Proposal/BEA.cif', 'BEA', '/Users/jiaweiguo/Desktop/0125Proposal')\n od_dict = defect_maker('/data/BEA.cif', 'BEA', '//data/test_output',\n savefiles=False)\n my_od = second_defect(od_dict, 'T3', 3, 'BEA', '//data/test_output', savefile=False)\n view(my_od)\n # second_defect(cif_dir, out_path, 'BEA_T1_3', 189)\n # second_defect(cif_dir, out_path, 'BEA_T1_3', 141)\n # second_defect(cif_dir, out_path, 'BEA_T1_3', 177)\n # cif_dir = '/Users/jiaweiguo/Desktop/0125Proposal/BEA/T1/BEA_T1_3.traj'\n # out_path = '/Users/jiaweiguo/Desktop/0125Proposal/BEA/T1/'\n # cif_dir = '/Users/jiaweiguo/Desktop/0125Proposal/BEA/T1/BEA_T1_3_'\n # out_path = '/Users/jiaweiguo/Desktop/0125Proposal/BEA/T1/'\n # insert_HM(cif_dir, out_path, 'BEA_T1_3', 141)\n # insert_HM(cif_dir, out_path, 'BEA_T1_3', 189)\n # insert_HM(cif_dir, out_path, 'BEA_T1_3', 177)\n #\n"
] | [
[
"numpy.array",
"numpy.linalg.norm",
"numpy.reshape",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.title",
"matplotlib.pyplot.subplots",
"numpy.mean",
"matplotlib.pyplot.figure",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.show",
"scipy.optimize.minimize"
],
[
"numpy.mean"
]
] |
Duncanswilson/keras | [
"32aa192548b6b59bf407e583fbd246ba9f5f5676"
] | [
"keras/layers/recurrent.py"
] | [
"# -*- coding: utf-8 -*-\n\"\"\"Recurrent layers and their base classes.\n\"\"\"\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport numpy as np\nimport warnings\n\nfrom .. import backend as K\nfrom .. import activations\nfrom .. import initializers\nfrom .. import regularizers\nfrom .. import constraints\nfrom ..engine import Layer\nfrom ..engine import InputSpec\nfrom ..utils.generic_utils import has_arg\n\n# Legacy support.\nfrom ..legacy.layers import Recurrent\nfrom ..legacy import interfaces\n\n\nclass StackedRNNCells(Layer):\n \"\"\"Wrapper allowing a stack of RNN cells to behave as a single cell.\n\n Used to implement efficient stacked RNNs.\n\n # Arguments\n cells: List of RNN cell instances.\n\n # Examples\n\n ```python\n cells = [\n keras.layers.LSTMCell(output_dim),\n keras.layers.LSTMCell(output_dim),\n keras.layers.LSTMCell(output_dim),\n ]\n\n inputs = keras.Input((timesteps, input_dim))\n x = keras.layers.RNN(cells)(inputs)\n ```\n \"\"\"\n\n def __init__(self, cells, **kwargs):\n for cell in cells:\n if not hasattr(cell, 'call'):\n raise ValueError('All cells must have a `call` method. '\n 'received cells:', cells)\n if not hasattr(cell, 'state_size'):\n raise ValueError('All cells must have a '\n '`state_size` attribute. '\n 'received cells:', cells)\n self.cells = cells\n super(StackedRNNCells, self).__init__(**kwargs)\n\n @property\n def state_size(self):\n # States are a flat list\n # in reverse order of the cell stack.\n # This allows to preserve the requirement\n # `stack.state_size[0] == output_dim`.\n # e.g. states of a 2-layer LSTM would be\n # `[h2, c2, h1, c1]`\n # (assuming one LSTM has states [h, c])\n state_size = []\n for cell in self.cells[::-1]:\n if hasattr(cell.state_size, '__len__'):\n state_size += list(cell.state_size)\n else:\n state_size.append(cell.state_size)\n return tuple(state_size)\n\n def call(self, inputs, states, **kwargs):\n # Recover per-cell states.\n nested_states = []\n for cell in self.cells[::-1]:\n if hasattr(cell.state_size, '__len__'):\n nested_states.append(states[:len(cell.state_size)])\n states = states[len(cell.state_size):]\n else:\n nested_states.append([states[0]])\n states = states[1:]\n nested_states = nested_states[::-1]\n\n # Call the cells in order and store the returned states.\n new_nested_states = []\n for cell, states in zip(self.cells, nested_states):\n inputs, states = cell.call(inputs, states, **kwargs)\n new_nested_states.append(states)\n\n # Format the new states as a flat list\n # in reverse cell order.\n states = []\n for cell_states in new_nested_states[::-1]:\n states += cell_states\n return inputs, states\n\n def build(self, input_shape):\n for cell in self.cells:\n if isinstance(cell, Layer):\n cell.build(input_shape)\n if hasattr(cell.state_size, '__len__'):\n output_dim = cell.state_size[0]\n else:\n output_dim = cell.state_size\n input_shape = (input_shape[0], input_shape[1], output_dim)\n self.built = True\n\n def get_config(self):\n cells = []\n for cell in self.cells:\n cells.append({'class_name': cell.__class__.__name__,\n 'config': cell.get_config()})\n config = {'cells': cells}\n base_config = super(StackedRNNCells, self).get_config()\n return dict(list(base_config.items()) + list(config.items()))\n\n @classmethod\n def from_config(cls, config, custom_objects=None):\n from . import deserialize as deserialize_layer\n cells = []\n for cell_config in config.pop('cells'):\n cells.append(deserialize_layer(cell_config,\n custom_objects=custom_objects))\n return cls(cells, **config)\n\n @property\n def trainable_weights(self):\n if not self.trainable:\n return []\n weights = []\n for cell in self.cells:\n if isinstance(cell, Layer):\n weights += cell.trainable_weights\n return weights\n\n @property\n def non_trainable_weights(self):\n weights = []\n for cell in self.cells:\n if isinstance(cell, Layer):\n weights += cell.non_trainable_weights\n if not self.trainable:\n trainable_weights = []\n for cell in self.cells:\n if isinstance(cell, Layer):\n trainable_weights += cell.trainable_weights\n return trainable_weights + weights\n return weights\n\n def get_weights(self):\n \"\"\"Retrieves the weights of the model.\n\n # Returns\n A flat list of Numpy arrays.\n \"\"\"\n weights = []\n for cell in self.cells:\n if isinstance(cell, Layer):\n weights += cell.weights\n return K.batch_get_value(weights)\n\n def set_weights(self, weights):\n \"\"\"Sets the weights of the model.\n\n # Arguments\n weights: A list of Numpy arrays with shapes and types matching\n the output of `model.get_weights()`.\n \"\"\"\n tuples = []\n for cell in self.cells:\n if isinstance(cell, Layer):\n num_param = len(cell.weights)\n weights = weights[:num_param]\n for sw, w in zip(cell.weights, weights):\n tuples.append((sw, w))\n weights = weights[num_param:]\n K.batch_set_value(tuples)\n\n @property\n def losses(self):\n losses = []\n for cell in self.cells:\n if isinstance(cell, Layer):\n cell_losses = cell.losses\n losses += cell_losses\n return losses\n\n def get_losses_for(self, inputs=None):\n losses = []\n for cell in self.cells:\n if isinstance(cell, Layer):\n cell_losses = cell.get_losses_for(inputs)\n losses += cell_losses\n return losses\n\n\nclass RNN(Layer):\n \"\"\"Base class for recurrent layers.\n\n # Arguments\n cell: A RNN cell instance. A RNN cell is a class that has:\n - a `call(input_at_t, states_at_t)` method, returning\n `(output_at_t, states_at_t_plus_1)`. The call method of the\n cell can also take the optional argument `constants`, see\n section \"Note on passing external constants\" below.\n - a `state_size` attribute. This can be a single integer\n (single state) in which case it is\n the size of the recurrent state\n (which should be the same as the size of the cell output).\n This can also be a list/tuple of integers\n (one size per state). In this case, the first entry\n (`state_size[0]`) should be the same as\n the size of the cell output.\n It is also possible for `cell` to be a list of RNN cell instances,\n in which cases the cells get stacked on after the other in the RNN,\n implementing an efficient stacked RNN.\n return_sequences: Boolean. Whether to return the last output.\n in the output sequence, or the full sequence.\n return_state: Boolean. Whether to return the last state\n in addition to the output.\n go_backwards: Boolean (default False).\n If True, process the input sequence backwards and return the\n reversed sequence.\n stateful: Boolean (default False). If True, the last state\n for each sample at index i in a batch will be used as initial\n state for the sample of index i in the following batch.\n unroll: Boolean (default False).\n If True, the network will be unrolled,\n else a symbolic loop will be used.\n Unrolling can speed-up a RNN,\n although it tends to be more memory-intensive.\n Unrolling is only suitable for short sequences.\n input_dim: dimensionality of the input (integer).\n This argument (or alternatively,\n the keyword argument `input_shape`)\n is required when using this layer as the first layer in a model.\n input_length: Length of input sequences, to be specified\n when it is constant.\n This argument is required if you are going to connect\n `Flatten` then `Dense` layers upstream\n (without it, the shape of the dense outputs cannot be computed).\n Note that if the recurrent layer is not the first layer\n in your model, you would need to specify the input length\n at the level of the first layer\n (e.g. via the `input_shape` argument)\n\n # Input shape\n 3D tensor with shape `(batch_size, timesteps, input_dim)`.\n\n # Output shape\n - if `return_state`: a list of tensors. The first tensor is\n the output. The remaining tensors are the last states,\n each with shape `(batch_size, units)`.\n - if `return_sequences`: 3D tensor with shape\n `(batch_size, timesteps, units)`.\n - else, 2D tensor with shape `(batch_size, units)`.\n\n # Masking\n This layer supports masking for input data with a variable number\n of timesteps. To introduce masks to your data,\n use an [Embedding](embeddings.md) layer with the `mask_zero` parameter\n set to `True`.\n\n # Note on using statefulness in RNNs\n You can set RNN layers to be 'stateful', which means that the states\n computed for the samples in one batch will be reused as initial states\n for the samples in the next batch. This assumes a one-to-one mapping\n between samples in different successive batches.\n\n To enable statefulness:\n - specify `stateful=True` in the layer constructor.\n - specify a fixed batch size for your model, by passing\n if sequential model:\n `batch_input_shape=(...)` to the first layer in your model.\n else for functional model with 1 or more Input layers:\n `batch_shape=(...)` to all the first layers in your model.\n This is the expected shape of your inputs\n *including the batch size*.\n It should be a tuple of integers, e.g. `(32, 10, 100)`.\n - specify `shuffle=False` when calling fit().\n\n To reset the states of your model, call `.reset_states()` on either\n a specific layer, or on your entire model.\n\n # Note on specifying the initial state of RNNs\n You can specify the initial state of RNN layers symbolically by\n calling them with the keyword argument `initial_state`. The value of\n `initial_state` should be a tensor or list of tensors representing\n the initial state of the RNN layer.\n\n You can specify the initial state of RNN layers numerically by\n calling `reset_states` with the keyword argument `states`. The value of\n `states` should be a numpy array or list of numpy arrays representing\n the initial state of the RNN layer.\n\n # Note on passing external constants to RNNs\n You can pass \"external\" constants to the cell using the `constants`\n keyword argument of `RNN.__call__` (as well as `RNN.call`) method. This\n requires that the `cell.call` method accepts the same keyword argument\n `constants`. Such constants can be used to condition the cell\n transformation on additional static inputs (not changing over time),\n a.k.a. an attention mechanism.\n\n # Examples\n\n ```python\n # First, let's define a RNN Cell, as a layer subclass.\n\n class MinimalRNNCell(keras.layers.Layer):\n\n def __init__(self, units, **kwargs):\n self.units = units\n self.state_size = units\n super(MinimalRNNCell, self).__init__(**kwargs)\n\n def build(self, input_shape):\n self.kernel = self.add_weight(shape=(input_shape[-1], self.units),\n initializer='uniform',\n name='kernel')\n self.recurrent_kernel = self.add_weight(\n shape=(self.units, self.units),\n initializer='uniform',\n name='recurrent_kernel')\n self.built = True\n\n def call(self, inputs, states):\n prev_output = states[0]\n h = K.dot(inputs, self.kernel)\n output = h + K.dot(prev_output, self.recurrent_kernel)\n return output, [output]\n\n # Let's use this cell in a RNN layer:\n\n cell = MinimalRNNCell(32)\n x = keras.Input((None, 5))\n layer = RNN(cell)\n y = layer(x)\n\n # Here's how to use the cell to build a stacked RNN:\n\n cells = [MinimalRNNCell(32), MinimalRNNCell(64)]\n x = keras.Input((None, 5))\n layer = RNN(cells)\n y = layer(x)\n ```\n \"\"\"\n\n def __init__(self, cell,\n return_sequences=False,\n return_state=False,\n go_backwards=False,\n stateful=False,\n unroll=False,\n **kwargs):\n if isinstance(cell, (list, tuple)):\n cell = StackedRNNCells(cell)\n if not hasattr(cell, 'call'):\n raise ValueError('`cell` should have a `call` method. '\n 'The RNN was passed:', cell)\n if not hasattr(cell, 'state_size'):\n raise ValueError('The RNN cell should have '\n 'an attribute `state_size` '\n '(tuple of integers, '\n 'one integer per RNN state).')\n super(RNN, self).__init__(**kwargs)\n self.cell = cell\n self.return_sequences = return_sequences\n self.return_state = return_state\n self.go_backwards = go_backwards\n self.stateful = stateful\n self.unroll = unroll\n\n self.supports_masking = True\n self.input_spec = [InputSpec(ndim=3)]\n self.state_spec = None\n self._states = None\n self.constants_spec = None\n self._num_constants = None\n\n @property\n def states(self):\n if self._states is None:\n if isinstance(self.cell.state_size, int):\n num_states = 1\n else:\n num_states = len(self.cell.state_size)\n return [None for _ in range(num_states)]\n return self._states\n\n @states.setter\n def states(self, states):\n self._states = states\n\n def compute_output_shape(self, input_shape):\n if isinstance(input_shape, list):\n input_shape = input_shape[0]\n\n if hasattr(self.cell.state_size, '__len__'):\n state_size = self.cell.state_size\n else:\n state_size = [self.cell.state_size]\n output_dim = state_size[0]\n\n if self.return_sequences:\n output_shape = (input_shape[0], input_shape[1], output_dim)\n else:\n output_shape = (input_shape[0], output_dim)\n\n if self.return_state:\n state_shape = [(input_shape[0], dim) for dim in state_size]\n return [output_shape] + state_shape\n else:\n return output_shape\n\n def compute_mask(self, inputs, mask):\n if isinstance(mask, list):\n mask = mask[0]\n output_mask = mask if self.return_sequences else None\n if self.return_state:\n state_mask = [None for _ in self.states]\n return [output_mask] + state_mask\n else:\n return output_mask\n\n def build(self, input_shape):\n # Note input_shape will be list of shapes of initial states and\n # constants if these are passed in __call__.\n if self._num_constants is not None:\n constants_shape = input_shape[-self._num_constants:]\n else:\n constants_shape = None\n\n if isinstance(input_shape, list):\n input_shape = input_shape[0]\n\n batch_size = input_shape[0] if self.stateful else None\n input_dim = input_shape[-1]\n self.input_spec[0] = InputSpec(shape=(batch_size, None, input_dim))\n\n # allow cell (if layer) to build before we set or validate state_spec\n if isinstance(self.cell, Layer):\n step_input_shape = (input_shape[0],) + input_shape[2:]\n if constants_shape is not None:\n self.cell.build([step_input_shape] + constants_shape)\n else:\n self.cell.build(step_input_shape)\n\n # set or validate state_spec\n if hasattr(self.cell.state_size, '__len__'):\n state_size = list(self.cell.state_size)\n else:\n state_size = [self.cell.state_size]\n\n if self.state_spec is not None:\n # initial_state was passed in call, check compatibility\n if [spec.shape[-1] for spec in self.state_spec] != state_size:\n raise ValueError(\n 'An `initial_state` was passed that is not compatible with '\n '`cell.state_size`. Received `state_spec`={}; '\n 'however `cell.state_size` is '\n '{}'.format(self.state_spec, self.cell.state_size))\n else:\n self.state_spec = [InputSpec(shape=(None, dim))\n for dim in state_size]\n if self.stateful:\n self.reset_states()\n\n def get_initial_state(self, inputs):\n # build an all-zero tensor of shape (samples, output_dim)\n initial_state = K.zeros_like(inputs) # (samples, timesteps, input_dim)\n initial_state = K.sum(initial_state, axis=(1, 2)) # (samples,)\n initial_state = K.expand_dims(initial_state) # (samples, 1)\n if hasattr(self.cell.state_size, '__len__'):\n return [K.tile(initial_state, [1, dim])\n for dim in self.cell.state_size]\n else:\n return [K.tile(initial_state, [1, self.cell.state_size])]\n\n def __call__(self, inputs, initial_state=None, constants=None, **kwargs):\n inputs, initial_state, constants = self._standardize_args(\n inputs, initial_state, constants)\n\n if initial_state is None and constants is None:\n return super(RNN, self).__call__(inputs, **kwargs)\n\n # If any of `initial_state` or `constants` are specified and are Keras\n # tensors, then add them to the inputs and temporarily modify the\n # input_spec to include them.\n\n additional_inputs = []\n additional_specs = []\n if initial_state is not None:\n kwargs['initial_state'] = initial_state\n additional_inputs += initial_state\n self.state_spec = [InputSpec(shape=K.int_shape(state))\n for state in initial_state]\n additional_specs += self.state_spec\n if constants is not None:\n kwargs['constants'] = constants\n additional_inputs += constants\n self.constants_spec = [InputSpec(shape=K.int_shape(constant))\n for constant in constants]\n self._num_constants = len(constants)\n additional_specs += self.constants_spec\n # at this point additional_inputs cannot be empty\n is_keras_tensor = hasattr(additional_inputs[0], '_keras_history')\n for tensor in additional_inputs:\n if hasattr(tensor, '_keras_history') != is_keras_tensor:\n raise ValueError('The initial state or constants of an RNN'\n ' layer cannot be specified with a mix of'\n ' Keras tensors and non-Keras tensors')\n\n if is_keras_tensor:\n # Compute the full input spec, including state and constants\n full_input = [inputs] + additional_inputs\n full_input_spec = self.input_spec + additional_specs\n # Perform the call with temporarily replaced input_spec\n original_input_spec = self.input_spec\n self.input_spec = full_input_spec\n output = super(RNN, self).__call__(full_input, **kwargs)\n self.input_spec = original_input_spec\n return output\n else:\n return super(RNN, self).__call__(inputs, **kwargs)\n\n def call(self,\n inputs,\n mask=None,\n training=None,\n initial_state=None,\n constants=None):\n # input shape: `(samples, time (padded with zeros), input_dim)`\n # note that the .build() method of subclasses MUST define\n # self.input_spec and self.state_spec with complete input shapes.\n if isinstance(inputs, list):\n inputs = inputs[0]\n if initial_state is not None:\n pass\n elif self.stateful:\n initial_state = self.states\n else:\n initial_state = self.get_initial_state(inputs)\n\n if isinstance(mask, list):\n mask = mask[0]\n\n if len(initial_state) != len(self.states):\n raise ValueError('Layer has ' + str(len(self.states)) +\n ' states but was passed ' +\n str(len(initial_state)) +\n ' initial states.')\n input_shape = K.int_shape(inputs)\n timesteps = input_shape[1]\n if self.unroll and timesteps in [None, 1]:\n raise ValueError('Cannot unroll a RNN if the '\n 'time dimension is undefined or equal to 1. \\n'\n '- If using a Sequential model, '\n 'specify the time dimension by passing '\n 'an `input_shape` or `batch_input_shape` '\n 'argument to your first layer. If your '\n 'first layer is an Embedding, you can '\n 'also use the `input_length` argument.\\n'\n '- If using the functional API, specify '\n 'the time dimension by passing a `shape` '\n 'or `batch_shape` argument to your Input layer.')\n\n kwargs = {}\n if has_arg(self.cell.call, 'training'):\n kwargs['training'] = training\n\n if constants:\n if not has_arg(self.cell.call, 'constants'):\n raise ValueError('RNN cell does not support constants')\n\n def step(inputs, states):\n constants = states[-self._num_constants:]\n states = states[:-self._num_constants]\n return self.cell.call(inputs, states, constants=constants,\n **kwargs)\n else:\n def step(inputs, states):\n return self.cell.call(inputs, states, **kwargs)\n\n last_output, outputs, states = K.rnn(step,\n inputs,\n initial_state,\n constants=constants,\n go_backwards=self.go_backwards,\n mask=mask,\n unroll=self.unroll,\n input_length=timesteps)\n if self.stateful:\n updates = []\n for i in range(len(states)):\n updates.append((self.states[i], states[i]))\n self.add_update(updates, inputs)\n\n if self.return_sequences:\n output = outputs\n else:\n output = last_output\n\n # Properly set learning phase\n if getattr(last_output, '_uses_learning_phase', False):\n output._uses_learning_phase = True\n for state in states:\n state._uses_learning_phase = True\n\n if self.return_state:\n if not isinstance(states, (list, tuple)):\n states = [states]\n else:\n states = list(states)\n return [output] + states\n else:\n return output\n\n def _standardize_args(self, inputs, initial_state, constants):\n \"\"\"Standardize `__call__` to a single list of tensor inputs.\n\n When running a model loaded from file, the input tensors\n `initial_state` and `constants` can be passed to `RNN.__call__` as part\n of `inputs` instead of by the dedicated keyword arguments. This method\n makes sure the arguments are separated and that `initial_state` and\n `constants` are lists of tensors (or None).\n\n # Arguments\n inputs: tensor or list/tuple of tensors\n initial_state: tensor or list of tensors or None\n constants: tensor or list of tensors or None\n\n # Returns\n inputs: tensor\n initial_state: list of tensors or None\n constants: list of tensors or None\n \"\"\"\n if isinstance(inputs, list):\n assert initial_state is None and constants is None\n if self._num_constants is not None:\n constants = inputs[-self._num_constants:]\n inputs = inputs[:-self._num_constants]\n if len(inputs) > 1:\n initial_state = inputs[1:]\n inputs = inputs[0]\n\n def to_list_or_none(x):\n if x is None or isinstance(x, list):\n return x\n if isinstance(x, tuple):\n return list(x)\n return [x]\n\n initial_state = to_list_or_none(initial_state)\n constants = to_list_or_none(constants)\n\n return inputs, initial_state, constants\n\n def reset_states(self, states=None):\n if not self.stateful:\n raise AttributeError('Layer must be stateful.')\n batch_size = self.input_spec[0].shape[0]\n if not batch_size:\n raise ValueError('If a RNN is stateful, it needs to know '\n 'its batch size. Specify the batch size '\n 'of your input tensors: \\n'\n '- If using a Sequential model, '\n 'specify the batch size by passing '\n 'a `batch_input_shape` '\n 'argument to your first layer.\\n'\n '- If using the functional API, specify '\n 'the batch size by passing a '\n '`batch_shape` argument to your Input layer.')\n # initialize state if None\n if self.states[0] is None:\n if hasattr(self.cell.state_size, '__len__'):\n self.states = [K.zeros((batch_size, dim))\n for dim in self.cell.state_size]\n else:\n self.states = [K.zeros((batch_size, self.cell.state_size))]\n elif states is None:\n if hasattr(self.cell.state_size, '__len__'):\n for state, dim in zip(self.states, self.cell.state_size):\n K.set_value(state, np.zeros((batch_size, dim)))\n else:\n K.set_value(self.states[0],\n np.zeros((batch_size, self.cell.state_size)))\n else:\n if not isinstance(states, (list, tuple)):\n states = [states]\n if len(states) != len(self.states):\n raise ValueError('Layer ' + self.name + ' expects ' +\n str(len(self.states)) + ' states, '\n 'but it received ' + str(len(states)) +\n ' state values. Input received: ' +\n str(states))\n for index, (value, state) in enumerate(zip(states, self.states)):\n if hasattr(self.cell.state_size, '__len__'):\n dim = self.cell.state_size[index]\n else:\n dim = self.cell.state_size\n if value.shape != (batch_size, dim):\n raise ValueError('State ' + str(index) +\n ' is incompatible with layer ' +\n self.name + ': expected shape=' +\n str((batch_size, dim)) +\n ', found shape=' + str(value.shape))\n # TODO: consider batch calls to `set_value`.\n K.set_value(state, value)\n\n def get_config(self):\n config = {'return_sequences': self.return_sequences,\n 'return_state': self.return_state,\n 'go_backwards': self.go_backwards,\n 'stateful': self.stateful,\n 'unroll': self.unroll}\n if self._num_constants is not None:\n config['num_constants'] = self._num_constants\n\n cell_config = self.cell.get_config()\n config['cell'] = {'class_name': self.cell.__class__.__name__,\n 'config': cell_config}\n base_config = super(RNN, self).get_config()\n return dict(list(base_config.items()) + list(config.items()))\n\n @classmethod\n def from_config(cls, config, custom_objects=None):\n from . import deserialize as deserialize_layer\n cell = deserialize_layer(config.pop('cell'),\n custom_objects=custom_objects)\n num_constants = config.pop('num_constants', None)\n layer = cls(cell, **config)\n layer._num_constants = num_constants\n return layer\n\n @property\n def trainable_weights(self):\n if not self.trainable:\n return []\n if isinstance(self.cell, Layer):\n return self.cell.trainable_weights\n return []\n\n @property\n def non_trainable_weights(self):\n if isinstance(self.cell, Layer):\n if not self.trainable:\n return self.cell.weights\n return self.cell.non_trainable_weights\n return []\n\n @property\n def losses(self):\n if isinstance(self.cell, Layer):\n return self.cell.losses\n return []\n\n def get_losses_for(self, inputs=None):\n if isinstance(self.cell, Layer):\n cell_losses = self.cell.get_losses_for(inputs)\n return cell_losses + super(RNN, self).get_losses_for(inputs)\n return super(RNN, self).get_losses_for(inputs)\n\n\nclass SimpleRNNCell(Layer):\n \"\"\"Cell class for SimpleRNN.\n\n # Arguments\n units: Positive integer, dimensionality of the output space.\n activation: Activation function to use\n (see [activations](../activations.md)).\n If you pass None, no activation is applied\n (ie. \"linear\" activation: `a(x) = x`).\n use_bias: Boolean, whether the layer uses a bias vector.\n kernel_initializer: Initializer for the `kernel` weights matrix,\n used for the linear transformation of the inputs\n (see [initializers](../initializers.md)).\n recurrent_initializer: Initializer for the `recurrent_kernel`\n weights matrix,\n used for the linear transformation of the recurrent state\n (see [initializers](../initializers.md)).\n bias_initializer: Initializer for the bias vector\n (see [initializers](../initializers.md)).\n kernel_regularizer: Regularizer function applied to\n the `kernel` weights matrix\n (see [regularizer](../regularizers.md)).\n recurrent_regularizer: Regularizer function applied to\n the `recurrent_kernel` weights matrix\n (see [regularizer](../regularizers.md)).\n bias_regularizer: Regularizer function applied to the bias vector\n (see [regularizer](../regularizers.md)).\n kernel_constraint: Constraint function applied to\n the `kernel` weights matrix\n (see [constraints](../constraints.md)).\n recurrent_constraint: Constraint function applied to\n the `recurrent_kernel` weights matrix\n (see [constraints](../constraints.md)).\n bias_constraint: Constraint function applied to the bias vector\n (see [constraints](../constraints.md)).\n dropout: Float between 0 and 1.\n Fraction of the units to drop for\n the linear transformation of the inputs.\n recurrent_dropout: Float between 0 and 1.\n Fraction of the units to drop for\n the linear transformation of the recurrent state.\n \"\"\"\n\n def __init__(self, units,\n activation='tanh',\n use_bias=True,\n kernel_initializer='glorot_uniform',\n recurrent_initializer='orthogonal',\n bias_initializer='zeros',\n kernel_regularizer=None,\n recurrent_regularizer=None,\n bias_regularizer=None,\n kernel_constraint=None,\n recurrent_constraint=None,\n bias_constraint=None,\n dropout=0.,\n recurrent_dropout=0.,\n **kwargs):\n super(SimpleRNNCell, self).__init__(**kwargs)\n self.units = units\n self.activation = activations.get(activation)\n self.use_bias = use_bias\n\n self.kernel_initializer = initializers.get(kernel_initializer)\n self.recurrent_initializer = initializers.get(recurrent_initializer)\n self.bias_initializer = initializers.get(bias_initializer)\n\n self.kernel_regularizer = regularizers.get(kernel_regularizer)\n self.recurrent_regularizer = regularizers.get(recurrent_regularizer)\n self.bias_regularizer = regularizers.get(bias_regularizer)\n\n self.kernel_constraint = constraints.get(kernel_constraint)\n self.recurrent_constraint = constraints.get(recurrent_constraint)\n self.bias_constraint = constraints.get(bias_constraint)\n\n self.dropout = min(1., max(0., dropout))\n self.recurrent_dropout = min(1., max(0., recurrent_dropout))\n self.state_size = self.units\n self._dropout_mask = None\n self._recurrent_dropout_mask = None\n\n def build(self, input_shape):\n self.kernel = self.add_weight(shape=(input_shape[-1], self.units),\n name='kernel',\n initializer=self.kernel_initializer,\n regularizer=self.kernel_regularizer,\n constraint=self.kernel_constraint)\n self.recurrent_kernel = self.add_weight(\n shape=(self.units, self.units),\n name='recurrent_kernel',\n initializer=self.recurrent_initializer,\n regularizer=self.recurrent_regularizer,\n constraint=self.recurrent_constraint)\n if self.use_bias:\n self.bias = self.add_weight(shape=(self.units,),\n name='bias',\n initializer=self.bias_initializer,\n regularizer=self.bias_regularizer,\n constraint=self.bias_constraint)\n else:\n self.bias = None\n self.built = True\n\n def call(self, inputs, states, training=None):\n prev_output = states[0]\n if 0 < self.dropout < 1 and self._dropout_mask is None:\n self._dropout_mask = _generate_dropout_mask(\n _generate_dropout_ones(inputs, K.shape(inputs)[-1]),\n self.dropout,\n training=training)\n if (0 < self.recurrent_dropout < 1 and\n self._recurrent_dropout_mask is None):\n self._recurrent_dropout_mask = _generate_dropout_mask(\n _generate_dropout_ones(inputs, self.units),\n self.recurrent_dropout,\n training=training)\n\n dp_mask = self._dropout_mask\n rec_dp_mask = self._recurrent_dropout_mask\n\n if dp_mask is not None:\n h = K.dot(inputs * dp_mask, self.kernel)\n else:\n h = K.dot(inputs, self.kernel)\n if self.bias is not None:\n h = K.bias_add(h, self.bias)\n\n if rec_dp_mask is not None:\n prev_output *= rec_dp_mask\n output = h + K.dot(prev_output, self.recurrent_kernel)\n if self.activation is not None:\n output = self.activation(output)\n\n # Properly set learning phase on output tensor.\n if 0 < self.dropout + self.recurrent_dropout:\n if training is None:\n output._uses_learning_phase = True\n return output, [output]\n\n def get_config(self):\n config = {'units': self.units,\n 'activation': activations.serialize(self.activation),\n 'use_bias': self.use_bias,\n 'kernel_initializer': initializers.serialize(self.kernel_initializer),\n 'recurrent_initializer': initializers.serialize(self.recurrent_initializer),\n 'bias_initializer': initializers.serialize(self.bias_initializer),\n 'kernel_regularizer': regularizers.serialize(self.kernel_regularizer),\n 'recurrent_regularizer': regularizers.serialize(self.recurrent_regularizer),\n 'bias_regularizer': regularizers.serialize(self.bias_regularizer),\n 'kernel_constraint': constraints.serialize(self.kernel_constraint),\n 'recurrent_constraint': constraints.serialize(self.recurrent_constraint),\n 'bias_constraint': constraints.serialize(self.bias_constraint),\n 'dropout': self.dropout,\n 'recurrent_dropout': self.recurrent_dropout}\n base_config = super(SimpleRNNCell, self).get_config()\n return dict(list(base_config.items()) + list(config.items()))\n\n\nclass SimpleRNN(RNN):\n \"\"\"Fully-connected RNN where the output is to be fed back to input.\n\n # Arguments\n units: Positive integer, dimensionality of the output space.\n activation: Activation function to use\n (see [activations](../activations.md)).\n If you pass None, no activation is applied\n (ie. \"linear\" activation: `a(x) = x`).\n use_bias: Boolean, whether the layer uses a bias vector.\n kernel_initializer: Initializer for the `kernel` weights matrix,\n used for the linear transformation of the inputs\n (see [initializers](../initializers.md)).\n recurrent_initializer: Initializer for the `recurrent_kernel`\n weights matrix,\n used for the linear transformation of the recurrent state\n (see [initializers](../initializers.md)).\n bias_initializer: Initializer for the bias vector\n (see [initializers](../initializers.md)).\n kernel_regularizer: Regularizer function applied to\n the `kernel` weights matrix\n (see [regularizer](../regularizers.md)).\n recurrent_regularizer: Regularizer function applied to\n the `recurrent_kernel` weights matrix\n (see [regularizer](../regularizers.md)).\n bias_regularizer: Regularizer function applied to the bias vector\n (see [regularizer](../regularizers.md)).\n activity_regularizer: Regularizer function applied to\n the output of the layer (its \"activation\").\n (see [regularizer](../regularizers.md)).\n kernel_constraint: Constraint function applied to\n the `kernel` weights matrix\n (see [constraints](../constraints.md)).\n recurrent_constraint: Constraint function applied to\n the `recurrent_kernel` weights matrix\n (see [constraints](../constraints.md)).\n bias_constraint: Constraint function applied to the bias vector\n (see [constraints](../constraints.md)).\n dropout: Float between 0 and 1.\n Fraction of the units to drop for\n the linear transformation of the inputs.\n recurrent_dropout: Float between 0 and 1.\n Fraction of the units to drop for\n the linear transformation of the recurrent state.\n return_sequences: Boolean. Whether to return the last output.\n in the output sequence, or the full sequence.\n return_state: Boolean. Whether to return the last state\n in addition to the output.\n go_backwards: Boolean (default False).\n If True, process the input sequence backwards and return the\n reversed sequence.\n stateful: Boolean (default False). If True, the last state\n for each sample at index i in a batch will be used as initial\n state for the sample of index i in the following batch.\n unroll: Boolean (default False).\n If True, the network will be unrolled,\n else a symbolic loop will be used.\n Unrolling can speed-up a RNN,\n although it tends to be more memory-intensive.\n Unrolling is only suitable for short sequences.\n \"\"\"\n\n @interfaces.legacy_recurrent_support\n def __init__(self, units,\n activation='tanh',\n use_bias=True,\n kernel_initializer='glorot_uniform',\n recurrent_initializer='orthogonal',\n bias_initializer='zeros',\n kernel_regularizer=None,\n recurrent_regularizer=None,\n bias_regularizer=None,\n activity_regularizer=None,\n kernel_constraint=None,\n recurrent_constraint=None,\n bias_constraint=None,\n dropout=0.,\n recurrent_dropout=0.,\n return_sequences=False,\n return_state=False,\n go_backwards=False,\n stateful=False,\n unroll=False,\n **kwargs):\n if 'implementation' in kwargs:\n kwargs.pop('implementation')\n warnings.warn('The `implementation` argument '\n 'in `SimpleRNN` has been deprecated. '\n 'Please remove it from your layer call.')\n if K.backend() == 'theano':\n warnings.warn(\n 'RNN dropout is no longer supported with the Theano backend '\n 'due to technical limitations. '\n 'You can either set `dropout` and `recurrent_dropout` to 0, '\n 'or use the TensorFlow backend.')\n dropout = 0.\n recurrent_dropout = 0.\n\n cell = SimpleRNNCell(units,\n activation=activation,\n use_bias=use_bias,\n kernel_initializer=kernel_initializer,\n recurrent_initializer=recurrent_initializer,\n bias_initializer=bias_initializer,\n kernel_regularizer=kernel_regularizer,\n recurrent_regularizer=recurrent_regularizer,\n bias_regularizer=bias_regularizer,\n kernel_constraint=kernel_constraint,\n recurrent_constraint=recurrent_constraint,\n bias_constraint=bias_constraint,\n dropout=dropout,\n recurrent_dropout=recurrent_dropout)\n super(SimpleRNN, self).__init__(cell,\n return_sequences=return_sequences,\n return_state=return_state,\n go_backwards=go_backwards,\n stateful=stateful,\n unroll=unroll,\n **kwargs)\n self.activity_regularizer = regularizers.get(activity_regularizer)\n\n def call(self, inputs, mask=None, training=None, initial_state=None):\n return super(SimpleRNN, self).call(inputs,\n mask=mask,\n training=training,\n initial_state=initial_state)\n\n @property\n def units(self):\n return self.cell.units\n\n @property\n def activation(self):\n return self.cell.activation\n\n @property\n def use_bias(self):\n return self.cell.use_bias\n\n @property\n def kernel_initializer(self):\n return self.cell.kernel_initializer\n\n @property\n def recurrent_initializer(self):\n return self.cell.recurrent_initializer\n\n @property\n def bias_initializer(self):\n return self.cell.bias_initializer\n\n @property\n def kernel_regularizer(self):\n return self.cell.kernel_regularizer\n\n @property\n def recurrent_regularizer(self):\n return self.cell.recurrent_regularizer\n\n @property\n def bias_regularizer(self):\n return self.cell.bias_regularizer\n\n @property\n def kernel_constraint(self):\n return self.cell.kernel_constraint\n\n @property\n def recurrent_constraint(self):\n return self.cell.recurrent_constraint\n\n @property\n def bias_constraint(self):\n return self.cell.bias_constraint\n\n @property\n def dropout(self):\n return self.cell.dropout\n\n @property\n def recurrent_dropout(self):\n return self.cell.recurrent_dropout\n\n def get_config(self):\n config = {'units': self.units,\n 'activation': activations.serialize(self.activation),\n 'use_bias': self.use_bias,\n 'kernel_initializer': initializers.serialize(self.kernel_initializer),\n 'recurrent_initializer': initializers.serialize(self.recurrent_initializer),\n 'bias_initializer': initializers.serialize(self.bias_initializer),\n 'kernel_regularizer': regularizers.serialize(self.kernel_regularizer),\n 'recurrent_regularizer': regularizers.serialize(self.recurrent_regularizer),\n 'bias_regularizer': regularizers.serialize(self.bias_regularizer),\n 'activity_regularizer': regularizers.serialize(self.activity_regularizer),\n 'kernel_constraint': constraints.serialize(self.kernel_constraint),\n 'recurrent_constraint': constraints.serialize(self.recurrent_constraint),\n 'bias_constraint': constraints.serialize(self.bias_constraint),\n 'dropout': self.dropout,\n 'recurrent_dropout': self.recurrent_dropout}\n base_config = super(SimpleRNN, self).get_config()\n del base_config['cell']\n return dict(list(base_config.items()) + list(config.items()))\n\n @classmethod\n def from_config(cls, config):\n if 'implementation' in config:\n config.pop('implementation')\n return cls(**config)\n\n\nclass GRUCell(Layer):\n \"\"\"Cell class for the GRU layer.\n\n # Arguments\n units: Positive integer, dimensionality of the output space.\n activation: Activation function to use\n (see [activations](../activations.md)).\n If you pass None, no activation is applied\n (ie. \"linear\" activation: `a(x) = x`).\n recurrent_activation: Activation function to use\n for the recurrent step\n (see [activations](../activations.md)).\n use_bias: Boolean, whether the layer uses a bias vector.\n kernel_initializer: Initializer for the `kernel` weights matrix,\n used for the linear transformation of the inputs\n (see [initializers](../initializers.md)).\n recurrent_initializer: Initializer for the `recurrent_kernel`\n weights matrix,\n used for the linear transformation of the recurrent state\n (see [initializers](../initializers.md)).\n bias_initializer: Initializer for the bias vector\n (see [initializers](../initializers.md)).\n kernel_regularizer: Regularizer function applied to\n the `kernel` weights matrix\n (see [regularizer](../regularizers.md)).\n recurrent_regularizer: Regularizer function applied to\n the `recurrent_kernel` weights matrix\n (see [regularizer](../regularizers.md)).\n bias_regularizer: Regularizer function applied to the bias vector\n (see [regularizer](../regularizers.md)).\n kernel_constraint: Constraint function applied to\n the `kernel` weights matrix\n (see [constraints](../constraints.md)).\n recurrent_constraint: Constraint function applied to\n the `recurrent_kernel` weights matrix\n (see [constraints](../constraints.md)).\n bias_constraint: Constraint function applied to the bias vector\n (see [constraints](../constraints.md)).\n dropout: Float between 0 and 1.\n Fraction of the units to drop for\n the linear transformation of the inputs.\n recurrent_dropout: Float between 0 and 1.\n Fraction of the units to drop for\n the linear transformation of the recurrent state.\n implementation: Implementation mode, either 1 or 2.\n Mode 1 will structure its operations as a larger number of\n smaller dot products and additions, whereas mode 2 will\n batch them into fewer, larger operations. These modes will\n have different performance profiles on different hardware and\n for different applications.\n \"\"\"\n\n def __init__(self, units,\n activation='tanh',\n recurrent_activation='hard_sigmoid',\n use_bias=True,\n kernel_initializer='glorot_uniform',\n recurrent_initializer='orthogonal',\n bias_initializer='zeros',\n kernel_regularizer=None,\n recurrent_regularizer=None,\n bias_regularizer=None,\n kernel_constraint=None,\n recurrent_constraint=None,\n bias_constraint=None,\n dropout=0.,\n recurrent_dropout=0.,\n implementation=1,\n **kwargs):\n super(GRUCell, self).__init__(**kwargs)\n self.units = units\n self.activation = activations.get(activation)\n self.recurrent_activation = activations.get(recurrent_activation)\n self.use_bias = use_bias\n\n self.kernel_initializer = initializers.get(kernel_initializer)\n self.recurrent_initializer = initializers.get(recurrent_initializer)\n self.bias_initializer = initializers.get(bias_initializer)\n\n self.kernel_regularizer = regularizers.get(kernel_regularizer)\n self.recurrent_regularizer = regularizers.get(recurrent_regularizer)\n self.bias_regularizer = regularizers.get(bias_regularizer)\n\n self.kernel_constraint = constraints.get(kernel_constraint)\n self.recurrent_constraint = constraints.get(recurrent_constraint)\n self.bias_constraint = constraints.get(bias_constraint)\n\n self.dropout = min(1., max(0., dropout))\n self.recurrent_dropout = min(1., max(0., recurrent_dropout))\n self.implementation = implementation\n self.state_size = self.units\n self._dropout_mask = None\n self._recurrent_dropout_mask = None\n\n def build(self, input_shape):\n input_dim = input_shape[-1]\n self.kernel = self.add_weight(shape=(input_dim, self.units * 3),\n name='kernel',\n initializer=self.kernel_initializer,\n regularizer=self.kernel_regularizer,\n constraint=self.kernel_constraint)\n self.recurrent_kernel = self.add_weight(\n shape=(self.units, self.units * 3),\n name='recurrent_kernel',\n initializer=self.recurrent_initializer,\n regularizer=self.recurrent_regularizer,\n constraint=self.recurrent_constraint)\n\n if self.use_bias:\n self.bias = self.add_weight(shape=(self.units * 3,),\n name='bias',\n initializer=self.bias_initializer,\n regularizer=self.bias_regularizer,\n constraint=self.bias_constraint)\n else:\n self.bias = None\n\n self.kernel_z = self.kernel[:, :self.units]\n self.recurrent_kernel_z = self.recurrent_kernel[:, :self.units]\n self.kernel_r = self.kernel[:, self.units: self.units * 2]\n self.recurrent_kernel_r = self.recurrent_kernel[:,\n self.units:\n self.units * 2]\n self.kernel_h = self.kernel[:, self.units * 2:]\n self.recurrent_kernel_h = self.recurrent_kernel[:, self.units * 2:]\n\n if self.use_bias:\n self.bias_z = self.bias[:self.units]\n self.bias_r = self.bias[self.units: self.units * 2]\n self.bias_h = self.bias[self.units * 2:]\n else:\n self.bias_z = None\n self.bias_r = None\n self.bias_h = None\n self.built = True\n\n def call(self, inputs, states, training=None):\n h_tm1 = states[0] # previous memory\n\n if 0 < self.dropout < 1 and self._dropout_mask is None:\n self._dropout_mask = _generate_dropout_mask(\n _generate_dropout_ones(inputs, K.shape(inputs)[-1]),\n self.dropout,\n training=training,\n count=3)\n if (0 < self.recurrent_dropout < 1 and\n self._recurrent_dropout_mask is None):\n self._recurrent_dropout_mask = _generate_dropout_mask(\n _generate_dropout_ones(inputs, self.units),\n self.recurrent_dropout,\n training=training,\n count=3)\n\n # dropout matrices for input units\n dp_mask = self._dropout_mask\n # dropout matrices for recurrent units\n rec_dp_mask = self._recurrent_dropout_mask\n\n if self.implementation == 1:\n if 0. < self.dropout < 1.:\n inputs_z = inputs * dp_mask[0]\n inputs_r = inputs * dp_mask[1]\n inputs_h = inputs * dp_mask[2]\n else:\n inputs_z = inputs\n inputs_r = inputs\n inputs_h = inputs\n x_z = K.dot(inputs_z, self.kernel_z)\n x_r = K.dot(inputs_r, self.kernel_r)\n x_h = K.dot(inputs_h, self.kernel_h)\n if self.use_bias:\n x_z = K.bias_add(x_z, self.bias_z)\n x_r = K.bias_add(x_r, self.bias_r)\n x_h = K.bias_add(x_h, self.bias_h)\n\n if 0. < self.recurrent_dropout < 1.:\n h_tm1_z = h_tm1 * rec_dp_mask[0]\n h_tm1_r = h_tm1 * rec_dp_mask[1]\n h_tm1_h = h_tm1 * rec_dp_mask[2]\n else:\n h_tm1_z = h_tm1\n h_tm1_r = h_tm1\n h_tm1_h = h_tm1\n z = self.recurrent_activation(x_z + K.dot(h_tm1_z,\n self.recurrent_kernel_z))\n r = self.recurrent_activation(x_r + K.dot(h_tm1_r,\n self.recurrent_kernel_r))\n\n hh = self.activation(x_h + K.dot(r * h_tm1_h,\n self.recurrent_kernel_h))\n else:\n if 0. < self.dropout < 1.:\n inputs *= dp_mask[0]\n matrix_x = K.dot(inputs, self.kernel)\n if self.use_bias:\n matrix_x = K.bias_add(matrix_x, self.bias)\n if 0. < self.recurrent_dropout < 1.:\n h_tm1 *= rec_dp_mask[0]\n matrix_inner = K.dot(h_tm1,\n self.recurrent_kernel[:, :2 * self.units])\n\n x_z = matrix_x[:, :self.units]\n x_r = matrix_x[:, self.units: 2 * self.units]\n recurrent_z = matrix_inner[:, :self.units]\n recurrent_r = matrix_inner[:, self.units: 2 * self.units]\n\n z = self.recurrent_activation(x_z + recurrent_z)\n r = self.recurrent_activation(x_r + recurrent_r)\n\n x_h = matrix_x[:, 2 * self.units:]\n recurrent_h = K.dot(r * h_tm1,\n self.recurrent_kernel[:, 2 * self.units:])\n hh = self.activation(x_h + recurrent_h)\n h = z * h_tm1 + (1 - z) * hh\n if 0 < self.dropout + self.recurrent_dropout:\n if training is None:\n h._uses_learning_phase = True\n return h, [h]\n\n def get_config(self):\n config = {'units': self.units,\n 'activation': activations.serialize(self.activation),\n 'recurrent_activation': activations.serialize(self.recurrent_activation),\n 'use_bias': self.use_bias,\n 'kernel_initializer': initializers.serialize(self.kernel_initializer),\n 'recurrent_initializer': initializers.serialize(self.recurrent_initializer),\n 'bias_initializer': initializers.serialize(self.bias_initializer),\n 'kernel_regularizer': regularizers.serialize(self.kernel_regularizer),\n 'recurrent_regularizer': regularizers.serialize(self.recurrent_regularizer),\n 'bias_regularizer': regularizers.serialize(self.bias_regularizer),\n 'kernel_constraint': constraints.serialize(self.kernel_constraint),\n 'recurrent_constraint': constraints.serialize(self.recurrent_constraint),\n 'bias_constraint': constraints.serialize(self.bias_constraint),\n 'dropout': self.dropout,\n 'recurrent_dropout': self.recurrent_dropout,\n 'implementation': self.implementation}\n base_config = super(GRUCell, self).get_config()\n return dict(list(base_config.items()) + list(config.items()))\n\n\nclass GRU(RNN):\n \"\"\"Gated Recurrent Unit - Cho et al. 2014.\n\n # Arguments\n units: Positive integer, dimensionality of the output space.\n activation: Activation function to use\n (see [activations](../activations.md)).\n If you pass None, no activation is applied\n (ie. \"linear\" activation: `a(x) = x`).\n recurrent_activation: Activation function to use\n for the recurrent step\n (see [activations](../activations.md)).\n use_bias: Boolean, whether the layer uses a bias vector.\n kernel_initializer: Initializer for the `kernel` weights matrix,\n used for the linear transformation of the inputs\n (see [initializers](../initializers.md)).\n recurrent_initializer: Initializer for the `recurrent_kernel`\n weights matrix,\n used for the linear transformation of the recurrent state\n (see [initializers](../initializers.md)).\n bias_initializer: Initializer for the bias vector\n (see [initializers](../initializers.md)).\n kernel_regularizer: Regularizer function applied to\n the `kernel` weights matrix\n (see [regularizer](../regularizers.md)).\n recurrent_regularizer: Regularizer function applied to\n the `recurrent_kernel` weights matrix\n (see [regularizer](../regularizers.md)).\n bias_regularizer: Regularizer function applied to the bias vector\n (see [regularizer](../regularizers.md)).\n activity_regularizer: Regularizer function applied to\n the output of the layer (its \"activation\").\n (see [regularizer](../regularizers.md)).\n kernel_constraint: Constraint function applied to\n the `kernel` weights matrix\n (see [constraints](../constraints.md)).\n recurrent_constraint: Constraint function applied to\n the `recurrent_kernel` weights matrix\n (see [constraints](../constraints.md)).\n bias_constraint: Constraint function applied to the bias vector\n (see [constraints](../constraints.md)).\n dropout: Float between 0 and 1.\n Fraction of the units to drop for\n the linear transformation of the inputs.\n recurrent_dropout: Float between 0 and 1.\n Fraction of the units to drop for\n the linear transformation of the recurrent state.\n implementation: Implementation mode, either 1 or 2.\n Mode 1 will structure its operations as a larger number of\n smaller dot products and additions, whereas mode 2 will\n batch them into fewer, larger operations. These modes will\n have different performance profiles on different hardware and\n for different applications.\n return_sequences: Boolean. Whether to return the last output.\n in the output sequence, or the full sequence.\n return_state: Boolean. Whether to return the last state\n in addition to the output.\n go_backwards: Boolean (default False).\n If True, process the input sequence backwards and return the\n reversed sequence.\n stateful: Boolean (default False). If True, the last state\n for each sample at index i in a batch will be used as initial\n state for the sample of index i in the following batch.\n unroll: Boolean (default False).\n If True, the network will be unrolled,\n else a symbolic loop will be used.\n Unrolling can speed-up a RNN,\n although it tends to be more memory-intensive.\n Unrolling is only suitable for short sequences.\n\n # References\n - [On the Properties of Neural Machine Translation: Encoder-Decoder Approaches](https://arxiv.org/abs/1409.1259)\n - [Empirical Evaluation of Gated Recurrent Neural Networks on Sequence Modeling](http://arxiv.org/abs/1412.3555v1)\n - [A Theoretically Grounded Application of Dropout in Recurrent Neural Networks](http://arxiv.org/abs/1512.05287)\n \"\"\"\n\n @interfaces.legacy_recurrent_support\n def __init__(self, units,\n activation='tanh',\n recurrent_activation='hard_sigmoid',\n use_bias=True,\n kernel_initializer='glorot_uniform',\n recurrent_initializer='orthogonal',\n bias_initializer='zeros',\n kernel_regularizer=None,\n recurrent_regularizer=None,\n bias_regularizer=None,\n activity_regularizer=None,\n kernel_constraint=None,\n recurrent_constraint=None,\n bias_constraint=None,\n dropout=0.,\n recurrent_dropout=0.,\n implementation=1,\n return_sequences=False,\n return_state=False,\n go_backwards=False,\n stateful=False,\n unroll=False,\n **kwargs):\n if implementation == 0:\n warnings.warn('`implementation=0` has been deprecated, '\n 'and now defaults to `implementation=1`.'\n 'Please update your layer call.')\n if K.backend() == 'theano':\n warnings.warn(\n 'RNN dropout is no longer supported with the Theano backend '\n 'due to technical limitations. '\n 'You can either set `dropout` and `recurrent_dropout` to 0, '\n 'or use the TensorFlow backend.')\n dropout = 0.\n recurrent_dropout = 0.\n\n cell = GRUCell(units,\n activation=activation,\n recurrent_activation=recurrent_activation,\n use_bias=use_bias,\n kernel_initializer=kernel_initializer,\n recurrent_initializer=recurrent_initializer,\n bias_initializer=bias_initializer,\n kernel_regularizer=kernel_regularizer,\n recurrent_regularizer=recurrent_regularizer,\n bias_regularizer=bias_regularizer,\n kernel_constraint=kernel_constraint,\n recurrent_constraint=recurrent_constraint,\n bias_constraint=bias_constraint,\n dropout=dropout,\n recurrent_dropout=recurrent_dropout,\n implementation=implementation)\n super(GRU, self).__init__(cell,\n return_sequences=return_sequences,\n return_state=return_state,\n go_backwards=go_backwards,\n stateful=stateful,\n unroll=unroll,\n **kwargs)\n self.activity_regularizer = regularizers.get(activity_regularizer)\n\n def call(self, inputs, mask=None, training=None, initial_state=None):\n return super(GRU, self).call(inputs,\n mask=mask,\n training=training,\n initial_state=initial_state)\n\n @property\n def units(self):\n return self.cell.units\n\n @property\n def activation(self):\n return self.cell.activation\n\n @property\n def recurrent_activation(self):\n return self.cell.recurrent_activation\n\n @property\n def use_bias(self):\n return self.cell.use_bias\n\n @property\n def kernel_initializer(self):\n return self.cell.kernel_initializer\n\n @property\n def recurrent_initializer(self):\n return self.cell.recurrent_initializer\n\n @property\n def bias_initializer(self):\n return self.cell.bias_initializer\n\n @property\n def kernel_regularizer(self):\n return self.cell.kernel_regularizer\n\n @property\n def recurrent_regularizer(self):\n return self.cell.recurrent_regularizer\n\n @property\n def bias_regularizer(self):\n return self.cell.bias_regularizer\n\n @property\n def kernel_constraint(self):\n return self.cell.kernel_constraint\n\n @property\n def recurrent_constraint(self):\n return self.cell.recurrent_constraint\n\n @property\n def bias_constraint(self):\n return self.cell.bias_constraint\n\n @property\n def dropout(self):\n return self.cell.dropout\n\n @property\n def recurrent_dropout(self):\n return self.cell.recurrent_dropout\n\n @property\n def implementation(self):\n return self.cell.implementation\n\n def get_config(self):\n config = {'units': self.units,\n 'activation': activations.serialize(self.activation),\n 'recurrent_activation': activations.serialize(self.recurrent_activation),\n 'use_bias': self.use_bias,\n 'kernel_initializer': initializers.serialize(self.kernel_initializer),\n 'recurrent_initializer': initializers.serialize(self.recurrent_initializer),\n 'bias_initializer': initializers.serialize(self.bias_initializer),\n 'kernel_regularizer': regularizers.serialize(self.kernel_regularizer),\n 'recurrent_regularizer': regularizers.serialize(self.recurrent_regularizer),\n 'bias_regularizer': regularizers.serialize(self.bias_regularizer),\n 'activity_regularizer': regularizers.serialize(self.activity_regularizer),\n 'kernel_constraint': constraints.serialize(self.kernel_constraint),\n 'recurrent_constraint': constraints.serialize(self.recurrent_constraint),\n 'bias_constraint': constraints.serialize(self.bias_constraint),\n 'dropout': self.dropout,\n 'recurrent_dropout': self.recurrent_dropout,\n 'implementation': self.implementation}\n base_config = super(GRU, self).get_config()\n del base_config['cell']\n return dict(list(base_config.items()) + list(config.items()))\n\n @classmethod\n def from_config(cls, config):\n if 'implementation' in config and config['implementation'] == 0:\n config['implementation'] = 1\n return cls(**config)\n\n\nclass LSTMCell(Layer):\n \"\"\"Cell class for the LSTM layer.\n\n # Arguments\n units: Positive integer, dimensionality of the output space.\n activation: Activation function to use\n (see [activations](../activations.md)).\n If you pass None, no activation is applied\n (ie. \"linear\" activation: `a(x) = x`).\n recurrent_activation: Activation function to use\n for the recurrent step\n (see [activations](../activations.md)).\n use_bias: Boolean, whether the layer uses a bias vector.\n kernel_initializer: Initializer for the `kernel` weights matrix,\n used for the linear transformation of the inputs\n (see [initializers](../initializers.md)).\n recurrent_initializer: Initializer for the `recurrent_kernel`\n weights matrix,\n used for the linear transformation of the recurrent state\n (see [initializers](../initializers.md)).\n bias_initializer: Initializer for the bias vector\n (see [initializers](../initializers.md)).\n unit_forget_bias: Boolean.\n If True, add 1 to the bias of the forget gate at initialization.\n Setting it to true will also force `bias_initializer=\"zeros\"`.\n This is recommended in [Jozefowicz et al.](http://www.jmlr.org/proceedings/papers/v37/jozefowicz15.pdf)\n kernel_regularizer: Regularizer function applied to\n the `kernel` weights matrix\n (see [regularizer](../regularizers.md)).\n recurrent_regularizer: Regularizer function applied to\n the `recurrent_kernel` weights matrix\n (see [regularizer](../regularizers.md)).\n bias_regularizer: Regularizer function applied to the bias vector\n (see [regularizer](../regularizers.md)).\n kernel_constraint: Constraint function applied to\n the `kernel` weights matrix\n (see [constraints](../constraints.md)).\n recurrent_constraint: Constraint function applied to\n the `recurrent_kernel` weights matrix\n (see [constraints](../constraints.md)).\n bias_constraint: Constraint function applied to the bias vector\n (see [constraints](../constraints.md)).\n dropout: Float between 0 and 1.\n Fraction of the units to drop for\n the linear transformation of the inputs.\n recurrent_dropout: Float between 0 and 1.\n Fraction of the units to drop for\n the linear transformation of the recurrent state.\n implementation: Implementation mode, either 1 or 2.\n Mode 1 will structure its operations as a larger number of\n smaller dot products and additions, whereas mode 2 will\n batch them into fewer, larger operations. These modes will\n have different performance profiles on different hardware and\n for different applications.\n \"\"\"\n\n def __init__(self, units,\n activation='tanh',\n recurrent_activation='hard_sigmoid',\n use_bias=True,\n kernel_initializer='glorot_uniform',\n recurrent_initializer='orthogonal',\n bias_initializer='zeros',\n unit_forget_bias=True,\n kernel_regularizer=None,\n recurrent_regularizer=None,\n bias_regularizer=None,\n kernel_constraint=None,\n recurrent_constraint=None,\n bias_constraint=None,\n dropout=0.,\n recurrent_dropout=0.,\n implementation=1,\n **kwargs):\n super(LSTMCell, self).__init__(**kwargs)\n self.units = units\n self.activation = activations.get(activation)\n self.recurrent_activation = activations.get(recurrent_activation)\n self.use_bias = use_bias\n\n self.kernel_initializer = initializers.get(kernel_initializer)\n self.recurrent_initializer = initializers.get(recurrent_initializer)\n self.bias_initializer = initializers.get(bias_initializer)\n self.unit_forget_bias = unit_forget_bias\n\n self.kernel_regularizer = regularizers.get(kernel_regularizer)\n self.recurrent_regularizer = regularizers.get(recurrent_regularizer)\n self.bias_regularizer = regularizers.get(bias_regularizer)\n\n self.kernel_constraint = constraints.get(kernel_constraint)\n self.recurrent_constraint = constraints.get(recurrent_constraint)\n self.bias_constraint = constraints.get(bias_constraint)\n\n self.dropout = min(1., max(0., dropout))\n self.recurrent_dropout = min(1., max(0., recurrent_dropout))\n self.implementation = implementation\n self.state_size = (self.units, self.units)\n self._dropout_mask = None\n self._recurrent_dropout_mask = None\n\n def build(self, input_shape):\n input_dim = input_shape[-1]\n self.kernel = self.add_weight(shape=(input_dim, self.units * 4),\n name='kernel',\n initializer=self.kernel_initializer,\n regularizer=self.kernel_regularizer,\n constraint=self.kernel_constraint)\n self.recurrent_kernel = self.add_weight(\n shape=(self.units, self.units * 4),\n name='recurrent_kernel',\n initializer=self.recurrent_initializer,\n regularizer=self.recurrent_regularizer,\n constraint=self.recurrent_constraint)\n\n if self.use_bias:\n if self.unit_forget_bias:\n def bias_initializer(_, *args, **kwargs):\n return K.concatenate([\n self.bias_initializer((self.units,), *args, **kwargs),\n initializers.Ones()((self.units,), *args, **kwargs),\n self.bias_initializer((self.units * 2,), *args, **kwargs),\n ])\n else:\n bias_initializer = self.bias_initializer\n self.bias = self.add_weight(shape=(self.units * 4,),\n name='bias',\n initializer=bias_initializer,\n regularizer=self.bias_regularizer,\n constraint=self.bias_constraint)\n else:\n self.bias = None\n\n self.kernel_i = self.kernel[:, :self.units]\n self.kernel_f = self.kernel[:, self.units: self.units * 2]\n self.kernel_c = self.kernel[:, self.units * 2: self.units * 3]\n self.kernel_o = self.kernel[:, self.units * 3:]\n\n self.recurrent_kernel_i = self.recurrent_kernel[:, :self.units]\n self.recurrent_kernel_f = self.recurrent_kernel[:, self.units: self.units * 2]\n self.recurrent_kernel_c = self.recurrent_kernel[:, self.units * 2: self.units * 3]\n self.recurrent_kernel_o = self.recurrent_kernel[:, self.units * 3:]\n\n if self.use_bias:\n self.bias_i = self.bias[:self.units]\n self.bias_f = self.bias[self.units: self.units * 2]\n self.bias_c = self.bias[self.units * 2: self.units * 3]\n self.bias_o = self.bias[self.units * 3:]\n else:\n self.bias_i = None\n self.bias_f = None\n self.bias_c = None\n self.bias_o = None\n self.built = True\n\n def call(self, inputs, states, training=None):\n if 0 < self.dropout < 1 and self._dropout_mask is None:\n self._dropout_mask = _generate_dropout_mask(\n _generate_dropout_ones(inputs, K.shape(inputs)[-1]),\n self.dropout,\n training=training,\n count=4)\n if (0 < self.recurrent_dropout < 1 and\n self._recurrent_dropout_mask is None):\n self._recurrent_dropout_mask = _generate_dropout_mask(\n _generate_dropout_ones(inputs, self.units),\n self.recurrent_dropout,\n training=training,\n count=4)\n\n # dropout matrices for input units\n dp_mask = self._dropout_mask\n # dropout matrices for recurrent units\n rec_dp_mask = self._recurrent_dropout_mask\n\n h_tm1 = states[0] # previous memory state\n c_tm1 = states[1] # previous carry state\n\n if self.implementation == 1:\n if 0 < self.dropout < 1.:\n inputs_i = inputs * dp_mask[0]\n inputs_f = inputs * dp_mask[1]\n inputs_c = inputs * dp_mask[2]\n inputs_o = inputs * dp_mask[3]\n else:\n inputs_i = inputs\n inputs_f = inputs\n inputs_c = inputs\n inputs_o = inputs\n x_i = K.dot(inputs_i, self.kernel_i)\n x_f = K.dot(inputs_f, self.kernel_f)\n x_c = K.dot(inputs_c, self.kernel_c)\n x_o = K.dot(inputs_o, self.kernel_o)\n if self.use_bias:\n x_i = K.bias_add(x_i, self.bias_i)\n x_f = K.bias_add(x_f, self.bias_f)\n x_c = K.bias_add(x_c, self.bias_c)\n x_o = K.bias_add(x_o, self.bias_o)\n\n if 0 < self.recurrent_dropout < 1.:\n h_tm1_i = h_tm1 * rec_dp_mask[0]\n h_tm1_f = h_tm1 * rec_dp_mask[1]\n h_tm1_c = h_tm1 * rec_dp_mask[2]\n h_tm1_o = h_tm1 * rec_dp_mask[3]\n else:\n h_tm1_i = h_tm1\n h_tm1_f = h_tm1\n h_tm1_c = h_tm1\n h_tm1_o = h_tm1\n i = self.recurrent_activation(x_i + K.dot(h_tm1_i,\n self.recurrent_kernel_i))\n f = self.recurrent_activation(x_f + K.dot(h_tm1_f,\n self.recurrent_kernel_f))\n c = f * c_tm1 + i * self.activation(x_c + K.dot(h_tm1_c,\n self.recurrent_kernel_c))\n o = self.recurrent_activation(x_o + K.dot(h_tm1_o,\n self.recurrent_kernel_o))\n else:\n if 0. < self.dropout < 1.:\n inputs *= dp_mask[0]\n z = K.dot(inputs, self.kernel)\n if 0. < self.recurrent_dropout < 1.:\n h_tm1 *= rec_dp_mask[0]\n z += K.dot(h_tm1, self.recurrent_kernel)\n if self.use_bias:\n z = K.bias_add(z, self.bias)\n\n z0 = z[:, :self.units]\n z1 = z[:, self.units: 2 * self.units]\n z2 = z[:, 2 * self.units: 3 * self.units]\n z3 = z[:, 3 * self.units:]\n\n i = self.recurrent_activation(z0)\n f = self.recurrent_activation(z1)\n c = f * c_tm1 + i * self.activation(z2)\n o = self.recurrent_activation(z3)\n\n h = o * self.activation(c)\n if 0 < self.dropout + self.recurrent_dropout:\n if training is None:\n h._uses_learning_phase = True\n return h, [h, c]\n\n def get_config(self):\n config = {'units': self.units,\n 'activation': activations.serialize(self.activation),\n 'recurrent_activation': activations.serialize(self.recurrent_activation),\n 'use_bias': self.use_bias,\n 'kernel_initializer': initializers.serialize(self.kernel_initializer),\n 'recurrent_initializer': initializers.serialize(self.recurrent_initializer),\n 'bias_initializer': initializers.serialize(self.bias_initializer),\n 'unit_forget_bias': self.unit_forget_bias,\n 'kernel_regularizer': regularizers.serialize(self.kernel_regularizer),\n 'recurrent_regularizer': regularizers.serialize(self.recurrent_regularizer),\n 'bias_regularizer': regularizers.serialize(self.bias_regularizer),\n 'kernel_constraint': constraints.serialize(self.kernel_constraint),\n 'recurrent_constraint': constraints.serialize(self.recurrent_constraint),\n 'bias_constraint': constraints.serialize(self.bias_constraint),\n 'dropout': self.dropout,\n 'recurrent_dropout': self.recurrent_dropout,\n 'implementation': self.implementation}\n base_config = super(LSTMCell, self).get_config()\n return dict(list(base_config.items()) + list(config.items()))\n\n\nclass LSTM(RNN):\n \"\"\"Long-Short Term Memory layer - Hochreiter 1997.\n\n # Arguments\n units: Positive integer, dimensionality of the output space.\n activation: Activation function to use\n (see [activations](../activations.md)).\n If you pass None, no activation is applied\n (ie. \"linear\" activation: `a(x) = x`).\n recurrent_activation: Activation function to use\n for the recurrent step\n (see [activations](../activations.md)).\n use_bias: Boolean, whether the layer uses a bias vector.\n kernel_initializer: Initializer for the `kernel` weights matrix,\n used for the linear transformation of the inputs.\n (see [initializers](../initializers.md)).\n recurrent_initializer: Initializer for the `recurrent_kernel`\n weights matrix,\n used for the linear transformation of the recurrent state.\n (see [initializers](../initializers.md)).\n bias_initializer: Initializer for the bias vector\n (see [initializers](../initializers.md)).\n unit_forget_bias: Boolean.\n If True, add 1 to the bias of the forget gate at initialization.\n Setting it to true will also force `bias_initializer=\"zeros\"`.\n This is recommended in [Jozefowicz et al.](http://www.jmlr.org/proceedings/papers/v37/jozefowicz15.pdf)\n kernel_regularizer: Regularizer function applied to\n the `kernel` weights matrix\n (see [regularizer](../regularizers.md)).\n recurrent_regularizer: Regularizer function applied to\n the `recurrent_kernel` weights matrix\n (see [regularizer](../regularizers.md)).\n bias_regularizer: Regularizer function applied to the bias vector\n (see [regularizer](../regularizers.md)).\n activity_regularizer: Regularizer function applied to\n the output of the layer (its \"activation\").\n (see [regularizer](../regularizers.md)).\n kernel_constraint: Constraint function applied to\n the `kernel` weights matrix\n (see [constraints](../constraints.md)).\n recurrent_constraint: Constraint function applied to\n the `recurrent_kernel` weights matrix\n (see [constraints](../constraints.md)).\n bias_constraint: Constraint function applied to the bias vector\n (see [constraints](../constraints.md)).\n dropout: Float between 0 and 1.\n Fraction of the units to drop for\n the linear transformation of the inputs.\n recurrent_dropout: Float between 0 and 1.\n Fraction of the units to drop for\n the linear transformation of the recurrent state.\n implementation: Implementation mode, either 1 or 2.\n Mode 1 will structure its operations as a larger number of\n smaller dot products and additions, whereas mode 2 will\n batch them into fewer, larger operations. These modes will\n have different performance profiles on different hardware and\n for different applications.\n return_sequences: Boolean. Whether to return the last output.\n in the output sequence, or the full sequence.\n return_state: Boolean. Whether to return the last state\n in addition to the output.\n go_backwards: Boolean (default False).\n If True, process the input sequence backwards and return the\n reversed sequence.\n stateful: Boolean (default False). If True, the last state\n for each sample at index i in a batch will be used as initial\n state for the sample of index i in the following batch.\n unroll: Boolean (default False).\n If True, the network will be unrolled,\n else a symbolic loop will be used.\n Unrolling can speed-up a RNN,\n although it tends to be more memory-intensive.\n Unrolling is only suitable for short sequences.\n\n # References\n - [Long short-term memory](http://www.bioinf.jku.at/publications/older/2604.pdf) (original 1997 paper)\n - [Learning to forget: Continual prediction with LSTM](http://www.mitpressjournals.org/doi/pdf/10.1162/089976600300015015)\n - [Supervised sequence labeling with recurrent neural networks](http://www.cs.toronto.edu/~graves/preprint.pdf)\n - [A Theoretically Grounded Application of Dropout in Recurrent Neural Networks](http://arxiv.org/abs/1512.05287)\n \"\"\"\n\n @interfaces.legacy_recurrent_support\n def __init__(self, units,\n activation='tanh',\n recurrent_activation='hard_sigmoid',\n use_bias=True,\n kernel_initializer='glorot_uniform',\n recurrent_initializer='orthogonal',\n bias_initializer='zeros',\n unit_forget_bias=True,\n kernel_regularizer=None,\n recurrent_regularizer=None,\n bias_regularizer=None,\n activity_regularizer=None,\n kernel_constraint=None,\n recurrent_constraint=None,\n bias_constraint=None,\n dropout=0.,\n recurrent_dropout=0.,\n implementation=1,\n return_sequences=False,\n return_state=False,\n go_backwards=False,\n stateful=False,\n unroll=False,\n **kwargs):\n if implementation == 0:\n warnings.warn('`implementation=0` has been deprecated, '\n 'and now defaults to `implementation=1`.'\n 'Please update your layer call.')\n if K.backend() == 'theano':\n warnings.warn(\n 'RNN dropout is no longer supported with the Theano backend '\n 'due to technical limitations. '\n 'You can either set `dropout` and `recurrent_dropout` to 0, '\n 'or use the TensorFlow backend.')\n dropout = 0.\n recurrent_dropout = 0.\n\n cell = LSTMCell(units,\n activation=activation,\n recurrent_activation=recurrent_activation,\n use_bias=use_bias,\n kernel_initializer=kernel_initializer,\n recurrent_initializer=recurrent_initializer,\n unit_forget_bias=unit_forget_bias,\n bias_initializer=bias_initializer,\n kernel_regularizer=kernel_regularizer,\n recurrent_regularizer=recurrent_regularizer,\n bias_regularizer=bias_regularizer,\n kernel_constraint=kernel_constraint,\n recurrent_constraint=recurrent_constraint,\n bias_constraint=bias_constraint,\n dropout=dropout,\n recurrent_dropout=recurrent_dropout,\n implementation=implementation)\n super(LSTM, self).__init__(cell,\n return_sequences=return_sequences,\n return_state=return_state,\n go_backwards=go_backwards,\n stateful=stateful,\n unroll=unroll,\n **kwargs)\n self.activity_regularizer = regularizers.get(activity_regularizer)\n\n def call(self, inputs, mask=None, training=None, initial_state=None):\n return super(LSTM, self).call(inputs,\n mask=mask,\n training=training,\n initial_state=initial_state)\n\n @property\n def units(self):\n return self.cell.units\n\n @property\n def activation(self):\n return self.cell.activation\n\n @property\n def recurrent_activation(self):\n return self.cell.recurrent_activation\n\n @property\n def use_bias(self):\n return self.cell.use_bias\n\n @property\n def kernel_initializer(self):\n return self.cell.kernel_initializer\n\n @property\n def recurrent_initializer(self):\n return self.cell.recurrent_initializer\n\n @property\n def bias_initializer(self):\n return self.cell.bias_initializer\n\n @property\n def unit_forget_bias(self):\n return self.cell.unit_forget_bias\n\n @property\n def kernel_regularizer(self):\n return self.cell.kernel_regularizer\n\n @property\n def recurrent_regularizer(self):\n return self.cell.recurrent_regularizer\n\n @property\n def bias_regularizer(self):\n return self.cell.bias_regularizer\n\n @property\n def kernel_constraint(self):\n return self.cell.kernel_constraint\n\n @property\n def recurrent_constraint(self):\n return self.cell.recurrent_constraint\n\n @property\n def bias_constraint(self):\n return self.cell.bias_constraint\n\n @property\n def dropout(self):\n return self.cell.dropout\n\n @property\n def recurrent_dropout(self):\n return self.cell.recurrent_dropout\n\n @property\n def implementation(self):\n return self.cell.implementation\n\n def get_config(self):\n config = {'units': self.units,\n 'activation': activations.serialize(self.activation),\n 'recurrent_activation': activations.serialize(self.recurrent_activation),\n 'use_bias': self.use_bias,\n 'kernel_initializer': initializers.serialize(self.kernel_initializer),\n 'recurrent_initializer': initializers.serialize(self.recurrent_initializer),\n 'bias_initializer': initializers.serialize(self.bias_initializer),\n 'unit_forget_bias': self.unit_forget_bias,\n 'kernel_regularizer': regularizers.serialize(self.kernel_regularizer),\n 'recurrent_regularizer': regularizers.serialize(self.recurrent_regularizer),\n 'bias_regularizer': regularizers.serialize(self.bias_regularizer),\n 'activity_regularizer': regularizers.serialize(self.activity_regularizer),\n 'kernel_constraint': constraints.serialize(self.kernel_constraint),\n 'recurrent_constraint': constraints.serialize(self.recurrent_constraint),\n 'bias_constraint': constraints.serialize(self.bias_constraint),\n 'dropout': self.dropout,\n 'recurrent_dropout': self.recurrent_dropout,\n 'implementation': self.implementation}\n base_config = super(LSTM, self).get_config()\n del base_config['cell']\n return dict(list(base_config.items()) + list(config.items()))\n\n @classmethod\n def from_config(cls, config):\n if 'implementation' in config and config['implementation'] == 0:\n config['implementation'] = 1\n return cls(**config)\n\n\ndef _generate_dropout_ones(inputs, dims):\n # Currently, CTNK can't instantiate `ones` with symbolic shapes.\n # Will update workaround once CTNK supports it.\n if K.backend() == 'cntk':\n ones = K.ones_like(K.reshape(inputs[:, 0], (-1, 1)))\n return K.tile(ones, (1, dims))\n else:\n return K.ones((K.shape(inputs)[0], dims))\n\n\ndef _generate_dropout_mask(ones, rate, training=None, count=1):\n def dropped_inputs():\n return K.dropout(ones, rate)\n\n if count > 1:\n return [K.in_train_phase(\n dropped_inputs,\n ones,\n training=training) for _ in range(count)]\n return K.in_train_phase(\n dropped_inputs,\n ones,\n training=training)\n"
] | [
[
"numpy.zeros"
]
] |
Msegade/pyNastran | [
"ae36548579c6bb2ee3a4fff207f7211c1986a5ab",
"ae36548579c6bb2ee3a4fff207f7211c1986a5ab",
"ae36548579c6bb2ee3a4fff207f7211c1986a5ab",
"ae36548579c6bb2ee3a4fff207f7211c1986a5ab"
] | [
"pyNastran/dev/bdf_vectorized/cards/dynamic.py",
"pyNastran/bdf/cards/dmig.py",
"pyNastran/dev/bdf_vectorized/cards/elements/shell/pcomp_helper.py",
"pyNastran/op2/tables/oes_stressStrain/real/oes_bush1d.py"
] | [
"# pylint: disable=C0103,R0902,R0904,R0914\n\"\"\"\nAll dynamic control cards are defined in this file. This includes:\n\n * FREQ\n * FREQ1\n * FREQ2 (not implemented)\n * FREQ3\n * FREQ4\n * FREQ5 (not implemented)\n * NLPCI\n * NLPARM\n * TSTEP\n * TSTEPNL\n\nAll cards are BaseCard objects.\n\n\"\"\"\nfrom math import log, exp, ceil\nimport numpy as np\nfrom numpy import unique, hstack\n\nfrom pyNastran.utils.numpy_utils import integer_types\nfrom pyNastran.bdf.field_writer_8 import set_blank_if_default\nfrom pyNastran.bdf.cards.base_card import BaseCard\nfrom pyNastran.bdf.bdf_interface.assign_type import (\n integer, integer_or_blank, double, double_or_blank,\n string_or_blank, blank, fields, components_or_blank\n)\nfrom pyNastran.bdf.field_writer_8 import print_card_8\nfrom pyNastran.bdf.field_writer_16 import print_card_16\nif TYPE_CHECKING: # pragma: no cover\n from pyNastran.bdf.bdf import BDF\n\n\nclass DELAY(BaseCard):\n type = 'DELAY'\n\n def __init__(self, sid, nodes, components, delays, comment=''):\n \"\"\"\n +-------+-----+-----------+-----+--------+------+-----+--------+-----+\n | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |\n +=======+=====+===========+=====+========+======+=====+========+=====+\n | DELAY | SID | POINT ID1 | C1 | T1 | P2 | C2 | T2 | |\n +-------+-----+-----------+-----+--------+------+-----+--------+-----+\n \"\"\"\n if comment:\n self.comment = comment\n\n #: Identification number of DELAY entry. (Integer > 0)\n self.sid = sid\n #: Grid, extra, or scalar point identification number. (Integer > 0)\n self.nodes = nodes\n #: Component number. (Integers 1 through 6 for grid points; zero or blank for extra\n #: or scalar points)\n self.components = components\n #: Time delay (tau) for designated point Pi and component Ci. (Real)\n self.delays = delays\n\n @classmethod\n def add_card(cls, card, comment=''):\n \"\"\"\n Adds a DELAY card from ``BDF.add_card(...)``\n\n Parameters\n ----------\n card : BDFCard()\n a BDFCard object\n comment : str; default=''\n a comment for the card\n \"\"\"\n sid = integer(card, 1, 'sid')\n nodes = [integer(card, 2, 'node')]\n components = [integer(card, 3, 'components')]\n delays = [double_or_blank(card, 4, 'delay')]\n assert components[0] in [0, 1, 2, 3, 4, 5, 6], components\n if card.field(5):\n nodes.append(integer(card, 5, 'node'))\n components.append(integer(card, 6, 'components'))\n delays.append(double_or_blank(card, 7, 'delay'))\n assert components[1] in [0, 1, 2, 3, 4, 5, 6], components\n return DELAY(sid, nodes, components, delays, comment=comment)\n\n def add(self, delay):\n assert self.sid == delay.sid, 'sid=%s delay.sid=%s' % (self.sid, delay.sid)\n if delay.comment:\n if hasattr('_comment'):\n self._comment += delay.comment\n else:\n self._comment = delay.comment\n self.nodes += delay.nodes\n self.components += delay.components\n self.delays += delay.delays\n\n def get_delay_at_freq(self, freq):\n return self.nodes, self.components, self.delays\n\n #def cross_reference(self, model: BDF) -> None:\n #\"\"\"\n #Cross links the card so referenced cards can be extracted directly\n\n #Parameters\n #----------\n #model : BDF()\n #the BDF object\n #\"\"\"\n #msg = ', which is required by DELAY sid=%s' % self.sid\n #self.nodes_ref = model.Node(self.node_ids, msg=msg)\n\n #@property\n #def node_id1(self):\n #if isinstance(self.nodes[0], integer_types):\n #return self.nodes[0]\n #return self.nodes_ref[0].nid\n\n #@property\n #def node_id2(self):\n #if isinstance(self.nodes[1], integer_types):\n #return self.nodes[1]\n #return self.nodes_ref[1].nid\n\n @property\n def node_ids(self):\n node_ids = [self.node_id1]\n if len(self.components) == 2:\n node_ids.append(self.node_id2)\n return node_ids\n\n def raw_fields(self):\n list_fields = ['DELAY', self.sid]\n for nid, comp, delay in zip(self.node_ids, self.components, self.delays):\n if isinstance(nid, integer_types):\n nidi = nid\n else:\n nidi = nid.nid\n list_fields += [nidi, comp, delay]\n return list_fields\n\n def write_card(self, size: int=8, is_double: bool=False) -> str:\n msg = self.comment\n node_ids = self.node_ids\n if size == 8:\n for nid, comp, delay in zip(node_ids, self.components, self.delays):\n msg += print_card_8(['DELAY', self.sid, nid, comp, delay])\n else:\n for nid, comp, delay in zip(node_ids, self.components, self.delays):\n msg += print_card_16(['DELAY', self.sid, nid, comp, delay])\n return msg\n\n\nclass DPHASE(BaseCard):\n type = 'DPHASE'\n\n def __init__(self, sid, nodes, components, phase_leads, comment=''):\n \"\"\"\n +--------+-----+-----------+-----+------+------+-----+-----+-----+\n | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |\n +========+=====+===========+=====+======+======+=====+=====+=====+\n | DPHASE | SID | POINT ID1 | C1 | TH1 | P2 | C2 | TH2 | |\n +--------+-----+-----------+-----+------+------+-----+-----+-----+\n \"\"\"\n if comment:\n self.comment = comment\n self.sid = sid\n self.nodes = nodes\n self.components = components\n self.phase_leads = phase_leads\n\n @classmethod\n def add_card(cls, card, comment=''):\n \"\"\"\n Adds a DPHASE card from ``BDF.add_card(...)``\n\n Parameters\n ----------\n card : BDFCard()\n a BDFCard object\n comment : str; default=''\n a comment for the card\n \"\"\"\n sid = integer(card, 1, 'sid')\n nodes = [integer(card, 2, 'node')]\n components = [integer(card, 3, 'components')]\n phase_leads = [double_or_blank(card, 4, 'phase_lead')]\n assert components[0] in [0, 1, 2, 3, 4, 5, 6], components\n if card.field(5):\n nodes.append(integer(card, 5, 'node'))\n components.append(integer(card, 6, 'components'))\n phase_leads.append(double_or_blank(card, 7, 'phase_lead'))\n assert components[1] in [0, 1, 2, 3, 4, 5, 6], components\n return DPHASE(sid, nodes, components, phase_leads, comment=comment)\n\n def add(self, dphase):\n assert self.sid == dphase.sid, 'sid=%s dphase.sid=%s' % (self.sid, dphase.sid)\n if dphase.comment:\n if hasattr('_comment'):\n self._comment += dphase.comment\n else:\n self._comment = dphase.comment\n self.nodes += dphase.nodes\n self.components += dphase.components\n self.phase_leads += dphase.phase_leads\n\n #def cross_reference(self, model: BDF) -> None:\n #\"\"\"\n #Cross links the card so referenced cards can be extracted directly\n\n #Parameters\n #----------\n #model : BDF()\n #the BDF object\n #\"\"\"\n #msg = ', which is required by DPHASE sid=%s' % self.sid\n #self.nodes_ref = model.Nodes(self.node_ids, msg=msg)\n\n #@property\n #def node_id1(self):\n #if isinstance(self.nodes[0], integer_types):\n #return self.nodes[0]\n #return self.nodes_ref[0].nid\n\n #@property\n #def node_id2(self):\n #if isinstance(self.nodes[1], integer_types):\n #return self.nodes[1]\n #return self.nodes_ref[1].nid\n\n @property\n def node_ids(self):\n node_ids = [self.node_id1]\n if len(self.components) == 2:\n node_ids.append(self.node_id2)\n return node_ids\n\n def raw_fields(self):\n list_fields = ['DPHASE', self.sid]\n for nid, comp, delay in zip(self.nodes, self.components, self.phase_leads):\n if isinstance(nid, integer_types):\n nidi = nid\n else:\n nidi = nid.nid\n list_fields += [nidi, comp, delay]\n return list_fields\n\n def write_card(self, size: int=8, is_double: bool=False) -> str:\n msg = self.comment\n node_ids = self.node_ids\n if size == 8:\n for nid, comp, delay in zip(node_ids, self.components, self.phase_leads):\n msg += print_card_8(['DPHASE', self.sid, nid, comp, delay])\n else:\n for nid, comp, delay in zip(node_ids, self.components, self.phase_leads):\n msg += print_card_16(['DPHASE', self.sid, nid, comp, delay])\n return msg\n\n\nclass FREQ(BaseCard):\n \"\"\"\n Defines a set of frequencies to be used in the solution of frequency\n response problems.\n\n +------+-----+-----+-----+------+-----+-----+-----+-----+\n | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |\n +======+=====+=====+=====+======+=====+=====+=====+=====+\n | FREQ | SID | F1 | F2 | etc. | | | | |\n +------+-----+-----+-----+------+-----+-----+-----+-----+\n \"\"\"\n type = 'FREQ'\n\n def __init__(self, sid, freqs, comment=''):\n if comment:\n self.comment = comment\n self.sid = sid\n self.freqs = np.unique(freqs)\n\n @classmethod\n def add_card(cls, card, comment=''):\n \"\"\"\n Adds a FREQ card from ``BDF.add_card(...)``\n\n Parameters\n ----------\n card : BDFCard()\n a BDFCard object\n comment : str; default=''\n a comment for the card\n \"\"\"\n sid = integer(card, 1, 'sid')\n freqs = fields(double, card, 'freq', i=2, j=len(card))\n return FREQ(sid, freqs, comment=comment)\n\n def get_freqs(self):\n return self.freqs\n\n def add_frequencies(self, freqs):\n \"\"\"\n Combines the frequencies from 1 FREQx object with another.\n All FREQi entries with the same frequency set identification numbers\n will be used. Duplicate frequencies will be ignored.\n\n Parameters\n ----------\n freqs : ???\n the frequencies for a FREQx object\n \"\"\"\n #print(\"self.freqs = \",self.freqs)\n #print(\"freqs = \",freqs)\n self.freqs = unique(hstack([self.freqs, freqs]))\n\n def add_frequency_object(self, freq):\n \"\"\"\n :param freq: a FREQx object\n\n .. seealso:: :func:`addFrequencies`\n \"\"\"\n self.add_frequencies(freq.freqs)\n\n def raw_fields(self):\n list_fields = ['FREQ', self.sid] + list(self.freqs)\n return list_fields\n\n def write_card(self, size: int=8, is_double: bool=False) -> str:\n card = self.repr_fields()\n if size == 8:\n return self.comment + print_card_8(card)\n return self.comment + print_card_16(card)\n\n\nclass FREQ1(FREQ):\n \"\"\"\n Defines a set of frequencies to be used in the solution of frequency\n response problems by specification of a starting frequency, frequency\n increment, and the number of increments desired.\n\n +-------+-----+-----+-----+-----+-----+-----+-----+-----+\n | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |\n +=======+=====+=====+=====+=====+=====+=====+=====+=====+\n | FREQ1 | SID | F1 | DF | NDF | | | | |\n +-------+-----+-----+-----+-----+-----+-----+-----+-----+\n\n .. note:: this card rewrites as a FREQ card\n \"\"\"\n type = 'FREQ1'\n\n def __init__(self, sid, f1, df, ndf, comment=''):\n if comment:\n self.comment = comment\n self.sid = sid\n self.f1 = f1\n self.df = df\n self.ndf = ndf\n\n freqs = []\n for i in range(ndf):\n freqs.append(f1 + i * df)\n self.freqs = unique(freqs)\n\n @classmethod\n def add_card(cls, card, comment=''):\n \"\"\"\n Adds a FREQ1 card from ``BDF.add_card(...)``\n\n Parameters\n ----------\n card : BDFCard()\n a BDFCard object\n comment : str; default=''\n a comment for the card\n \"\"\"\n sid = integer(card, 1, 'sid')\n f1 = double_or_blank(card, 2, 'f1', 0.0)\n df = double(card, 3, 'df')\n ndf = integer_or_blank(card, 4, 'ndf', 1)\n assert len(card) <= 5, 'len(FREQ card) = %i\\ncard=%s' % (len(card), card)\n return FREQ1(sid, f1, df, ndf, comment=comment)\n\n def write_card(self, size: int=8, is_double: bool=False) -> str:\n card = self.repr_fields()\n if size == 8:\n return self.comment + print_card_8(card)\n return self.comment + print_card_16(card)\n\n\nclass FREQ2(FREQ):\n \"\"\"\n Defines a set of frequencies to be used in the solution of frequency\n response problems by specification of a starting frequency, final\n frequency, and the number of logarithmic increments desired.\n\n +-------+-----+-----+-----+-----+-----+-----+-----+-----+\n | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |\n +=======+=====+=====+=====+=====+=====+=====+=====+=====+\n | FREQ2 | SID | F1 | F2 | NDF | | | | |\n +-------+-----+-----+-----+-----+-----+-----+-----+-----+\n\n .. note:: this card rewrites as a FREQ card\n \"\"\"\n type = 'FREQ2'\n\n def __init__(self, sid, f1, f2, ndf=1, comment=''):\n if comment:\n self.comment = comment\n self.sid = sid\n self.f1 = f1\n self.f2 = f2\n self.ndf = ndf\n\n d = 1. / ndf * log(f2 / f1)\n freqs = []\n for i in range(ndf):\n freqs.append(f1 * exp(i * d)) # 0 based index\n self.freqs = np.unique(freqs)\n\n @classmethod\n def add_card(cls, card, comment=''):\n \"\"\"\n Adds a FREQ2 card from ``BDF.add_card(...)``\n\n Parameters\n ----------\n card : BDFCard()\n a BDFCard object\n comment : str; default=''\n a comment for the card\n \"\"\"\n sid = integer(card, 1, 'sid')\n f1 = double(card, 2, 'f1') # default=0.0 ?\n f2 = double(card, 3, 'f2')\n ndf = integer_or_blank(card, 4, 'nf', 1)\n assert len(card) <= 5, 'len(FREQ2 card) = %i\\ncard=%s' % (len(card), card)\n return FREQ2(sid, f1, f2, ndf, comment=comment)\n #return FREQ(sid, freqs, comment=comment)\n\n\nclass FREQ3(FREQ):\n \"\"\"\n +-------+-----+------+-------+--------+-----+---------+\n | 1 | 2 | 3 | 4 | 5 | 6 | 7 |\n +=======+=====+======+=======+========+=====+=========+\n | FREQ3 | SID | F1 | F2 | TYPE | NEF | CLUSTER |\n +-------+-----+------+-------+--------+-----+---------+\n | FREQ3 | 6 | 20.0 | 200.0 | LINEAR | 10 | 2.0 |\n +-------+-----+------+-------+--------+-----+---------+\n \"\"\"\n type = 'FREQ3'\n\n def __init__(self, f1, f2=None, Type='LINEAR', nef=10, cluster=1.0, comment=''):\n if comment:\n self.comment = comment\n if f2 is None:\n f2 = f1\n self.sid = sid\n self.f1 = f1\n self.f2 = f2\n self.Type = Type\n self.nef = nef\n self.cluster = cluster\n\n @classmethod\n def add_card(cls, card, comment=''):\n sid = integer(card, 1, 'sid')\n f1 = double(card, 1, 'f1')\n f2 = integer_or_blank(card, 1, 'f2', f1)\n Type = string_or_blank(card, 1, 'Type', 'LINEAR')\n nef = integer_or_blank(card, 1, 'nef', 10)\n cluster = double_or_blank(card, 1, 'cluster', 1.0)\n\n return FREQ3(sid, f1, f2, Type, nef, cluster, comment='')\n\n def raw_fields(self):\n return ['FREQ3', self.sid, self.f1, self.f2, self.Type, self.nef, self.cluster]\n\n def write_card(self, size: int=8, is_double: bool=False) -> str:\n card = self.repr_fields()\n if size == 8:\n return self.comment + print_card_8(card)\n return self.comment + print_card_16(card)\n\n\nclass FREQ4(FREQ):\n \"\"\"\n Defines a set of frequencies used in the solution of modal frequency\n response problems by specifying the amount of 'spread' around each natural\n frequency and the number of equally spaced excitation frequencies within\n the spread.\n\n +-------+-----+-----+-----+------+-----+-----+-----+-----+\n | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |\n +=======+=====+=====+=====+======+=====+=====+=====+=====+\n | FREQ4 | SID | F1 | F2 | FSPD | NFM | | | |\n +-------+-----+-----+-----+------+-----+-----+-----+-----+\n\n .. note:: this card rewrites as a FREQ card\n .. todo:: not done...\n \"\"\"\n type = 'FREQ4'\n\n def __init__(self, sid, f1, f2, fspread, nfm, comment=''):\n if comment:\n self.comment = comment\n self.sid = sid\n self.f1 = f1\n self.f2 = f2\n self.fspread = fspread\n self.nfm = nfm\n\n @classmethod\n def add_card(cls, card, comment=''):\n \"\"\"\n Adds a FREQ4 card from ``BDF.add_card(...)``\n\n Parameters\n ----------\n card : BDFCard()\n a BDFCard object\n comment : str; default=''\n a comment for the card\n \"\"\"\n sid = integer(card, 1, 'sid')\n f1 = double_or_blank(card, 2, 'f1', 0.0)\n f2 = double_or_blank(card, 3, 'f2', 1.e20)\n fspread = double_or_blank(card, 4, 'fspd', 0.1)\n nfm = integer_or_blank(card, 5, 'nfm', 3)\n assert len(card) <= 6, 'len(FREQ card) = %i\\ncard=%s' % (len(card), card)\n return FREQ4(sid, f1, f2, fspread, nfm, comment=comment)\n\n def raw_fields(self):\n list_fields = ['FREQ4', self.sid, self.f1, self.f2, self.fspread,\n self.nfm]\n return list_fields\n\n def repr_fields(self):\n return self.raw_fields()\n\n def write_card(self, size: int=8, is_double: bool=False) -> str:\n card = self.repr_fields()\n if size == 8:\n return self.comment + print_card_8(card)\n return self.comment + print_card_16(card)\n\n\n#class FREQ5(FREQ):\n #type = 'FREQ5'\n\n #def __init__(self, card=None, data=None, comment=''):\n #if comment:\n # self.comment = comment\n #raise NotImplementedError()\n\n #def write_card(self, size: int=8, is_double: bool=False) -> str:\n #card = self.repr_fields()\n #if size == 8:\n #return self.comment + print_card_8(card)\n #return self.comment + print_card_16(card)\n\n\nclass NLPARM(BaseCard):\n \"\"\"\n Defines a set of parameters for nonlinear static analysis iteration\n strategy.\n\n +--------+--------+------+------+---------+-------+---------+---------+--------+\n | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |\n +========+========+======+======+=========+=======+=========+=========+========+\n | NLPARM | ID | NINC | DT | KMETHOD | KSTEP | MAXITER | CONV | INTOUT |\n +--------+--------+------+------+---------+-------+---------+---------+--------+\n | | ESPU | EPSP | EPSW | MAXDIV | MAXQN | MAXLS | FSTRESS | LSTOL |\n +--------+--------+------+------+---------+-------+---------+---------+--------+\n | | MAXBIS | | | | MAXR | | RTOLB | CONV |\n +--------+--------+------+------+---------+-------+---------+---------+--------+\n \"\"\"\n type = 'NLPARM'\n\n def __init__(self, nlparm_id, ninc=10, dt=0.0, kmethod='AUTO', kstep=5,\n max_iter=25, conv='PW', int_out='NO',\n eps_u=0.01, eps_p=0.01, eps_w=0.01, max_div=3, max_qn=None, max_ls=4,\n fstress=0.2, ls_tol=0.5, max_bisect=5, max_r=20., rtol_b=20., comment=''):\n if comment:\n self.comment = comment\n self.nlparm_id = nlparm_id\n self.ninc = ninc\n self.dt = dt\n self.kmethod = kmethod\n self.kstep = kstep\n self.max_iter = max_iter\n self.conv = conv\n self.int_out = int_out\n\n # line 2\n self.eps_p = eps_p\n self.eps_u = eps_u\n self.eps_w = eps_w\n self.max_div = max_div\n self.max_qn = max_qn\n self.max_ls = max_ls\n self.fstress = fstress\n self.ls_tol = ls_tol\n\n # line 3\n self.max_bisect = max_bisect\n self.max_r = max_r\n self.rtol_b = rtol_b\n\n if self.max_qn is None:\n if kmethod == 'PFNT':\n self.max_qn = 0\n else:\n self.max_qn = max_iter\n\n @classmethod\n def add_card(cls, card, comment=''):\n \"\"\"\n Adds a NLPARM card from ``BDF.add_card(...)``\n\n Parameters\n ----------\n card : BDFCard()\n a BDFCard object\n comment : str; default=''\n a comment for the card\n \"\"\"\n nlparm_id = integer(card, 1, 'nlparm_id')\n ninc = integer_or_blank(card, 2, 'ninc', 10)\n dt = double_or_blank(card, 3, 'dt', 0.0)\n kmethod = string_or_blank(card, 4, 'kmethod', 'AUTO')\n kstep = integer_or_blank(card, 5, 'kstep', 5)\n max_iter = integer_or_blank(card, 6, 'max_iter', 25)\n conv = string_or_blank(card, 7, 'conv', 'PW')\n int_out = string_or_blank(card, 8, 'intOut', 'NO')\n\n # line 2\n eps_u = double_or_blank(card, 9, 'eps_u', 0.01)\n eps_p = double_or_blank(card, 10, 'eps_p', 0.01)\n eps_w = double_or_blank(card, 11, 'eps_w', 0.01)\n max_div = integer_or_blank(card, 12, 'max_div', 3)\n\n if kmethod == 'PFNT':\n max_qn = integer_or_blank(card, 13, 'max_qn', 0)\n else:\n max_qn = integer_or_blank(card, 13, 'max_qn', max_iter)\n\n max_ls = integer_or_blank(card, 14, 'max_ls', 4)\n fstress = double_or_blank(card, 15, 'fstress', 0.2)\n ls_tol = double_or_blank(card, 16, 'ls_tol', 0.5)\n\n # line 3\n max_bisect = integer_or_blank(card, 17, 'max_bisect', 5)\n max_r = double_or_blank(card, 21, 'max_r', 20.)\n rtol_b = double_or_blank(card, 23, 'rtol_b', 20.)\n assert len(card) <= 24, 'len(NLPARM card) = %i\\ncard=%s' % (len(card), card)\n return NLPARM(nlparm_id, ninc, dt, kmethod, kstep, max_iter, conv,\n int_out, eps_u, eps_p, eps_w, max_div,\n max_qn, max_ls, fstress,\n ls_tol, max_bisect, max_r,\n rtol_b, comment=comment)\n\n @classmethod\n def add_op2_data(cls, data, comment=''):\n \"\"\"\n Adds a NLPARM card from the OP2\n\n Parameters\n ----------\n data : List[varies]\n a list of fields defined in OP2 format\n comment : str; default=''\n a comment for the card\n \"\"\"\n (nlparm_id, ninc, dt, kmethod, kstep, max_iter, conv, int_out, eps_u, eps_p,\n eps_w, max_div, max_qn, max_ls, fstress, ls_tol, max_bisect, max_r,\n rtol_b) = data\n\n if kmethod == 1:\n kmethod = 'AUTO'\n elif kmethod == 2:\n kmethod = 'ITER'\n elif kmethod == 4:\n kmethod = 'SEMI'\n elif kmethod == 3:\n kmethod = 'ADAPT'\n else:\n msg = 'nlparm_id=%s kmethod=%r data=%s' % (nlparm_id, kmethod, data)\n raise NotImplementedError(msg)\n\n if conv == 1:\n conv = 'W'\n elif conv == 2:\n conv = 'P'\n elif conv == 3:\n conv = 'PW'\n elif conv == 4:\n conv = 'U'\n elif conv == 5:\n conv = 'UW'\n elif conv == 6:\n conv = 'UP'\n elif conv == 7:\n conv = 'UPW'\n else:\n msg = 'nlparm_id=%s conv=%r data=%s' % (nlparm_id, conv, data)\n raise NotImplementedError(msg)\n\n if int_out == 0:\n int_out = 'NO'\n elif int_out == 1:\n int_out = 'YES'\n elif int_out == 2:\n int_out = 'ALL'\n else:\n msg = 'nlparm_id=%s int_out=%r data=%s' % (nlparm_id, int_out, data)\n raise NotImplementedError(msg)\n return NLPARM(nlparm_id, ninc, dt, kmethod, kstep, max_iter, conv,\n int_out, eps_u, eps_p, eps_w, max_div,\n max_qn, max_ls, fstress,\n ls_tol, max_bisect, max_r,\n rtol_b, comment=comment)\n\n def raw_fields(self):\n list_fields = ['NLPARM', self.nlparm_id, self.ninc, self.dt, self.kmethod,\n self.kstep, self.max_iter, self.conv, self.int_out, self.eps_u,\n self.eps_p, self.eps_w, self.max_div, self.max_qn, self.max_ls,\n self.fstress, self.ls_tol, self.max_bisect, None, None, None,\n self.max_r, None, self.rtol_b]\n return list_fields\n\n def repr_fields(self):\n ninc = set_blank_if_default(self.ninc, 10)\n dt = set_blank_if_default(self.dt, 0.0)\n kmethod = set_blank_if_default(self.kmethod, 'AUTO')\n kstep = set_blank_if_default(self.kstep, 5)\n max_iter = set_blank_if_default(self.max_iter, 25)\n conv = set_blank_if_default(self.conv, 'PW')\n int_out = set_blank_if_default(self.int_out, 'NO')\n eps_u = set_blank_if_default(self.eps_u, 0.01)\n eps_p = set_blank_if_default(self.eps_p, 0.01)\n eps_w = set_blank_if_default(self.eps_w, 0.01)\n max_div = set_blank_if_default(self.max_div, 3)\n max_qn = set_blank_if_default(self.max_qn, self.max_iter)\n max_ls = set_blank_if_default(self.max_ls, 4)\n fstress = set_blank_if_default(self.fstress, 0.2)\n ls_tol = set_blank_if_default(self.ls_tol, 0.5)\n max_bisect = set_blank_if_default(self.max_bisect, 5)\n max_r = set_blank_if_default(self.max_r, 20.)\n rtol_b = set_blank_if_default(self.rtol_b, 20.)\n\n list_fields = ['NLPARM', self.nlparm_id, ninc, dt, kmethod, kstep, max_iter,\n conv, int_out, eps_u, eps_p, eps_w, max_div, max_qn, max_ls,\n fstress, ls_tol, max_bisect, None, None, None, max_r, None,\n rtol_b]\n return list_fields\n\n def write_card(self, size: int=8, is_double: bool=False) -> str:\n card = self.repr_fields()\n if size == 8:\n return self.comment + print_card_8(card) # having trouble with double precision...\n return self.comment + print_card_16(card)\n\n\nclass NLPCI(BaseCard):\n type = 'NLPCI'\n\n def __init__(self, nlpci_id, Type='CRIS', minalr=0.25, maxalr=4.,\n scale=0., desiter=12, mxinc=20, comment=''):\n if comment:\n self.comment = comment\n self.nlpci_id = nlpci_id\n self.Type = Type\n self.minalr = minalr\n self.maxalr = maxalr\n self.scale = scale\n self.desiter = desiter\n self.mxinc = mxinc\n\n @classmethod\n def add_card(cls, card, comment=''):\n \"\"\"\n Adds a NLPCI card from ``BDF.add_card(...)``\n\n Parameters\n ----------\n card : BDFCard()\n a BDFCard object\n comment : str; default=''\n a comment for the card\n \"\"\"\n nlpci_id = integer(card, 1, 'nlpci_id')\n Type = string_or_blank(card, 2, 'Type', 'CRIS')\n minalr = double_or_blank(card, 3, 'minalr', 0.25)\n maxalr = double_or_blank(card, 4, 'maxalr', 4.0)\n scale = double_or_blank(card, 5, 'scale', 0.0)\n blank(card, 6, 'blank')\n desiter = integer_or_blank(card, 7, 'desiter', 12)\n mxinc = integer_or_blank(card, 8, 'mxinc', 20)\n return NLPCI(nlpci_id, Type=Type, minalr=minalr, maxalr=maxalr,\n scale=scale, desiter=desiter, mxinc=mxinc, comment=comment)\n\n def raw_fields(self):\n list_fields = ['NLPCI', self.nlpci_id, self.Type, self.minalr,\n self.maxalr, self.scale, None, self.desiter, self.mxinc]\n return list_fields\n\n def repr_fields(self):\n #minalr = set_blank_if_default(self.minalr, 0.25)\n return self.raw_fields()\n\n def write_card(self, size: int=8, is_double: bool=False) -> str:\n card = self.repr_fields()\n if size == 8:\n return self.comment + print_card_8(card)\n return self.comment + print_card_16(card)\n\n\nclass TF(BaseCard):\n \"\"\"\n Defines a dynamic transfer function of the form:\n (B0 + B1 p + B2 *p2)*ud sum(A0_i + A1_i*p + A2_i*p2)*ui = 0\n\n +----+-----+-----+------+------+------+--------+----+----+\n | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |\n +====+=====+=====+======+======+======+========+====+====+\n | TF | SID | GD | CD | B0 | B1 | B2 | | |\n +----+-----+-----+------+------+------+--------+----+----+\n | | G_1 | C_1 | A0_1 | A1_1 | A2_1 | etc. | | |\n +----+-----+-----+------+------+------+--------+----+----+\n\n \"\"\"\n type = 'TF'\n def __init__(self, sid, nid0, c, b0, b1, b2, nids, components, a, comment=''):\n if comment:\n self.comment = comment\n self.sid = sid\n self.nid0 = nid0\n self.c = c\n self.b0 = b0\n self.b1 = b1\n self.b2 = b2\n self.nids = nids\n self.components = components\n self.a = a\n\n def validate(self):\n pass\n #assert len(self.grids1) > 0, 'ngrids1=%s\\n%s' % (len(self.grids1), str(self))\n\n #def cross_reference(self, model: BDF) -> None:\n #pass\n\n @classmethod\n def add_card(cls, card, comment=''):\n \"\"\"\n Adds a TF card from ``BDF.add_card(...)``\n\n Parameters\n ----------\n card : BDFCard()\n a BDFCard object\n comment : str; default=''\n a comment for the card\n \"\"\"\n sid = integer(card, 1, 'sid')\n nid0 = integer(card, 2, 'nid0')\n # component 0 means an SPOINT/EPOINT\n c = components_or_blank(card, 3, 'components_0', 0)\n b0 = double_or_blank(card, 4, 'b0', 0.)\n b1 = double_or_blank(card, 5, 'b1', 0.)\n b2 = double_or_blank(card, 6, 'b2', 0.)\n\n nfields = len(card) - 9\n nrows = nfields // 8\n if nfields % 8 > 0:\n nrows += 1\n\n nids = []\n components = []\n a = []\n for irow in range(nrows):\n j = irow * 8 + 9\n #ifield = irow + 1\n nid = integer(card, j, 'grid_%i' % (irow + 1))\n component = components_or_blank(card, j + 1, 'components_%i' % (irow + 1), 0)\n a0 = double_or_blank(card, j + 2, 'a0_%i' % (irow + 1), 0.)\n a1 = double_or_blank(card, j + 3, 'a1_%i' % (irow + 1), 0.)\n a2 = double_or_blank(card, j + 4, 'a2_%i' % (irow + 1), 0.)\n nids.append(nid)\n components.append(component)\n a.append([a0, a1, a2])\n return TF(sid, nid0, c, b0, b1, b2, nids, components, a,\n comment=comment)\n\n def raw_fields(self):\n list_fields = ['TF', self.sid, self.nid0, self.c, self.b0, self.b1, self.b2, None, None]\n for grid, c, (a0, a1, a2) in zip(self.nids, self.components, self.a):\n list_fields += [grid, c, a0, a1, a2, None, None, None]\n return list_fields\n\n def write_card(self, size: int=8, is_double: bool=False) -> str:\n # double precision?\n card = self.repr_fields()\n if size == 8:\n return self.comment + print_card_8(card)\n return self.comment + print_card_16(card)\n\n\nclass TSTEP(BaseCard):\n \"\"\"\n Transient Time Step\n Defines time step intervals at which a solution will be generated and\n output in transient analysis.\n\n +-------+------+------+------+------+-----+-----+-----+-----+\n | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |\n +=======+======+======+======+======+=====+=====+=====+=====+\n | TSTEP | SID | N1 | DT1 | NO1 | | | | |\n +-------+------+------+------+------+-----+-----+-----+-----+\n | | | N2 | DT2 | NO2 | | | | |\n +-------+------+------+------+------+-----+-----+-----+-----+\n | | | etc. | | | | | | |\n +-------+------+------+------+------+-----+-----+-----+-----+\n\n +-------+------+------+------+------+-----+-----+-----+-----+\n | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |\n +=======+======+======+======+======+=====+=====+=====+=====+\n | TSTEP | 101 | 9000 | .001 | 9000 | | | | |\n +-------+------+------+------+------+-----+-----+-----+-----+\n | | | 1000 | .001 | 1 | | | | |\n +-------+------+------+------+------+-----+-----+-----+-----+\n \"\"\"\n type = 'TSTEP'\n\n def __init__(self, sid, N, DT, NO, comment=''):\n \"\"\"\n Creates a TSTEP card\n\n Parameters\n ----------\n sid : int\n the time step id\n N : List[int/None]\n ???\n DT : List[float/None]\n ???\n NO : List[int/None]\n ???\n comment : str; default=''\n a comment for the card\n \"\"\"\n if comment:\n self.comment = comment\n self.sid = sid\n #: Number of time steps of value DTi. (Integer > 1)\n self.N = N\n #: Time increment (float)\n self.DT = DT\n #: Skip factor for output. Every NOi-th step will be saved for output (default=1)\n self.NO = NO\n\n def validate(self):\n assert len(self.N) == len(self.DT), 'N=%s DT=%s' % (self.N, self.DT)\n assert len(self.N) == len(self.NO), 'N=%s NO=%s' % (self.N, self.NO)\n\n @classmethod\n def add_card(cls, card, comment=''):\n \"\"\"\n Adds a TSTEP card from ``BDF.add_card(...)``\n\n Parameters\n ----------\n card : BDFCard()\n a BDFCard object\n comment : str; default=''\n a comment for the card\n \"\"\"\n sid = integer(card, 1, 'sid')\n N = []\n DT = []\n NO = []\n\n nrows = int(ceil((len(card) - 1.) / 8.))\n for i in range(nrows):\n n = 8 * i + 1\n ni = integer_or_blank(card, n + 1, 'N' + str(i), 1)\n dt = double_or_blank(card, n + 2, 'dt' + str(i), 0.)\n no = integer_or_blank(card, n + 3, 'NO' + str(i), 1)\n N.append(ni)\n DT.append(dt)\n NO.append(no)\n return TSTEP(sid, N, DT, NO, comment=comment)\n\n def raw_fields(self):\n list_fields = ['TSTEP', self.sid]\n for (N, dt, no) in zip(self.N, self.DT, self.NO):\n list_fields += [N, dt, no, None, None, None, None, None]\n return list_fields\n\n def repr_fields(self):\n return self.raw_fields()\n\n def write_card(self, size: int=8, is_double: bool=False) -> str:\n card = self.repr_fields()\n if size == 8:\n return self.comment + print_card_8(card)\n return self.comment + print_card_16(card)\n\n\nclass TSTEPNL(BaseCard):\n \"\"\"\n Defines parametric controls and data for nonlinear transient structural or\n heat transfer analysis. TSTEPNL is intended for SOLs 129, 159, and 600.\n Parameters for Nonlinear Transient Analysis.\n\n +---------+--------+--------+-------+--------+--------+-------+---------+------+\n | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |\n +=========+========+========+=======+========+========+=======+=========+======+\n | TSTEPNL | ID | NDT | DT | NO | METHOD | KSTEP | MAXITER | CONV |\n +---------+--------+--------+-------+--------+--------+-------+---------+------+\n | | ESPU | EPSP | EPSW | MAXDIV | MAXQN | MAXLS | FSTRESS | |\n +---------+--------+--------+-------+--------+--------+-------+---------+------+\n | | MAXBIS | ADJUST | MSTEP | RB | MAXR | UTOL | RTOLB | |\n +---------+--------+--------+-------+--------+--------+-------+---------+------+\n\n method = None for NX, but apparently TSTEP as well, which is not in the QRG\n \"\"\"\n type = 'TSTEPNL'\n allowed_methods = ['AUTO', 'ITER', 'ADAPT', 'SEMI', 'FNT', 'PFNT', # MSC\n 'TSTEP'] # NX\n\n def __init__(self, sid, ndt, dt, no, method='ADAPT', kstep=None,\n max_iter=10, conv='PW', eps_u=1.e-2, eps_p=1.e-3,\n eps_w=1.e-6, max_div=2, max_qn=10, max_ls=2,\n fstress=0.2, max_bisect=5, adjust=5, mstep=None,\n rb=0.6, max_r=32., utol=0.1, rtol_b=20.,\n min_iter=None, comment=''):\n \"\"\"\n Creates a TSTEPNL card\n\n Parameters\n ----------\n sid : int\n the time step id\n ndt : ???\n ???\n dt : ???\n ???\n no : ???\n ???\n eps_u : float; default=1.e-2\n ???\n eps_p : float; default=1.e-3\n ???\n eps_w : float; default=1.e-6\n ???\n max_div : int; default=2\n ???\n max_qn : int; default=10\n ???\n max_ls : int; default=2\n ???\n fstress : float; default=0.2\n ???\n max_bisect : int; default=5\n ???\n adjust : int; default=5\n ???\n mstep : int; default=None\n ???\n rb : float; default=0.6\n ???\n max_r = float; default=32.\n ???\n utol = float; default=0.1\n ???\n rtol_b = float; default=20.\n ???\n min_iter : int; default=None\n not listed in all QRGs\n comment : str; default=''\n a comment for the card\n \"\"\"\n if comment:\n self.comment = comment\n\n # line 1\n self.sid = sid\n self.ndt = ndt\n self.dt = dt\n self.no = no\n self.method = method\n self.kstep = kstep\n self.max_iter = max_iter\n self.conv = conv\n\n self.eps_u = eps_u\n self.eps_p = eps_p\n self.eps_w = eps_w\n self.max_div = max_div\n self.max_qn = max_qn\n self.max_ls = max_ls\n self.fstress = fstress\n\n # line 3\n self.max_bisect = max_bisect\n self.adjust = adjust\n self.mstep = mstep\n self.rb = rb\n self.max_r = max_r\n self.utol = utol\n self.rtol_b = rtol_b\n self.min_iter = min_iter\n assert self.ndt >= 3\n assert self.dt > 0.\n\n def validate(self):\n if self.method not in self.allowed_methods:\n msg = 'method=%r allowed_methods=[%s]' % (\n self.method, ', '.join(self.allowed_methods))\n raise ValueError(msg)\n\n @classmethod\n def add_card(cls, card, comment=''):\n \"\"\"\n Adds a TSTEPNL card from ``BDF.add_card(...)``\n\n Parameters\n ----------\n card : BDFCard()\n a BDFCard object\n comment : str; default=''\n a comment for the card\n \"\"\"\n sid = integer(card, 1, 'sid')\n ndt = integer(card, 2, 'ndt')\n dt = double(card, 3, 'dt')\n no = integer_or_blank(card, 4, 'no', 1)\n\n #: .. note:: not listed in all QRGs\n method = string_or_blank(card, 5, 'method', 'ADAPT')\n if method == 'ADAPT':\n kstep = integer_or_blank(card, 6, 'kStep', 2)\n elif method == 'ITER':\n kstep = integer_or_blank(card, 6, 'kStep', 10)\n elif method in ['AUTO', 'TSTEP', 'SEMI']:\n kstep = None\n #kstep = blank(card, 6, 'kStep') #: .. todo:: not blank\n else:\n msg = 'invalid TSTEPNL Method. method=%r; allowed_methods=[%s]' % (\n method, ', '.join(cls.allowed_methods))\n raise RuntimeError(msg)\n max_iter = integer_or_blank(card, 7, 'maxIter', 10)\n conv = string_or_blank(card, 8, 'conv', 'PW')\n\n # line 2\n eps_u = double_or_blank(card, 9, 'epsU', 1.E-2)\n eps_p = double_or_blank(card, 10, 'epsP', 1.E-3)\n eps_w = double_or_blank(card, 11, 'epsW', 1.E-6)\n max_div = integer_or_blank(card, 12, 'maxDiv', 2)\n max_qn = integer_or_blank(card, 13, 'maxQn', 10)\n max_ls = integer_or_blank(card, 14, 'MaxLs', 2)\n fstress = double_or_blank(card, 15, 'fStress', 0.2)\n\n # line 3\n max_bisect = integer_or_blank(card, 17, 'maxBisect', 5)\n adjust = integer_or_blank(card, 18, 'adjust', 5)\n mstep = integer_or_blank(card, 19, 'mStep')\n rb = double_or_blank(card, 20, 'rb', 0.6)\n max_r = double_or_blank(card, 21, 'maxR', 32.)\n utol = double_or_blank(card, 22, 'uTol', 0.1)\n rtol_b = double_or_blank(card, 23, 'rTolB', 20.)\n\n # not listed in all QRGs\n min_iter = integer_or_blank(card, 24, 'minIter')\n assert len(card) <= 25, 'len(TSTEPNL card) = %i\\ncard=%s' % (len(card), card)\n return TSTEPNL(\n sid, ndt, dt, no, method, kstep, max_iter, conv,\n eps_u, eps_p, eps_w, max_div, max_qn, max_ls, fstress,\n max_bisect, adjust, mstep, rb, max_r, utol, rtol_b, min_iter,\n comment=comment)\n\n @classmethod\n def add_op2_data(cls, data, comment=''):\n \"\"\"\n Adds a TSTEPNL card from the OP2\n\n Parameters\n ----------\n data : List[varies]\n a list of fields defined in OP2 format\n comment : str; default=''\n a comment for the card\n \"\"\"\n (sid, ndt, dt, no, method, kstep, max_iter, conv, eps_u, eps_p, eps_w,\n max_div, max_qn, max_ls, fstress, max_bisect,\n adjust, mstep, rb, max_r, utol, rtol_b) = data\n\n if method == 1:\n method = 'AUTO'\n elif method == 3:\n method = 'ADAPT'\n else:\n raise NotImplementedError('tstepnl=%s method=%r data=%s' % (sid, method, data))\n\n if conv == 3:\n conv = 'PW'\n elif conv == 4:\n conv = 'U'\n #elif conv == 3:\n #conv = 'ADAPT'\n else:\n raise NotImplementedError('tstepnl=%s conv=%r data=%s' % (sid, conv, data))\n\n min_iter = None # not listed in DMAP 2005\n return TSTEPNL(\n sid, ndt, dt, no, method, kstep, max_iter, conv,\n eps_u, eps_p, eps_w, max_div, max_qn, max_ls, fstress,\n max_bisect, adjust, mstep, rb, max_r, utol, rtol_b, min_iter,\n comment=comment)\n #self.sid = sid\n #self.ndt = ndt\n #self.dt = dt\n #self.no = no\n #self.method = method\n #self.kStep = kStep\n #self.maxIter = maxIter\n #self.conv = conv\n\n ## line 2\n #self.epsU = epsU\n #self.epsP = epsP\n #self.epsW = epsW\n #self.maxDiv = maxDiv\n #self.maxQn = maxQn\n #self.MaxLs = maxLs\n #self.fStress = fStress\n\n ## line 3\n #self.maxBisect = maxBisect\n #self.adjust = adjust\n #self.mStep = mStep\n #self.rb = rb\n #self.maxR = maxR\n #self.uTol = uTol\n #self.rTolB = rTolB\n\n def raw_fields(self):\n list_fields = ['TSTEPNL', self.sid, self.ndt, self.dt, self.no,\n self.method, self.kstep, self.max_iter, self.conv, self.eps_u,\n self.eps_p, self.eps_w, self.max_div, self.max_qn, self.max_ls,\n self.fstress, None, self.max_bisect, self.adjust, self.mstep,\n self.rb, self.max_r, self.utol, self.rtol_b, self.min_iter]\n return list_fields\n\n def repr_fields(self):\n #no = set_blank_if_default(self.no,1)\n no = self.no\n method = set_blank_if_default(self.method, 'ADAPT')\n\n kstep = self.kstep\n #if self.method == 'ADAPT':\n #kStep = set_blank_if_default(self.kStep, 2)\n #elif self.method == 'ITER':\n #kStep = set_blank_if_default(self.kStep, 10)\n #else:\n #msg = 'invalid TSTEPNL Method. method=|%s|' %(self.method)\n #raise RuntimeError(msg)\n\n #maxIter = set_blank_if_default(self.maxIter, 10)\n conv = set_blank_if_default(self.conv, 'PW')\n\n eps_u = set_blank_if_default(self.eps_u, 1e-2)\n eps_p = set_blank_if_default(self.eps_p, 1e-3)\n eps_w = set_blank_if_default(self.eps_w, 1e-6)\n max_div = set_blank_if_default(self.max_div, 2)\n max_qn = set_blank_if_default(self.max_qn, 10)\n max_ls = set_blank_if_default(self.max_ls, 2)\n fstress = set_blank_if_default(self.fstress, 0.2)\n\n max_bisect = set_blank_if_default(self.max_bisect, 5)\n adjust = set_blank_if_default(self.adjust, 5)\n rb = set_blank_if_default(self.rb, 0.6)\n max_r = set_blank_if_default(self.max_r, 32.)\n utol = set_blank_if_default(self.utol, 0.1)\n rtol_b = set_blank_if_default(self.rtol_b, 20.)\n\n list_fields = ['TSTEPNL', self.sid, self.ndt, self.dt, no, method,\n kstep, self.max_iter, conv, eps_u, eps_p, eps_w, max_div, max_qn,\n max_ls, fstress, None, max_bisect, adjust, self.mstep, rb,\n max_r, utol, rtol_b, self.min_iter]\n return list_fields\n\n def write_card(self, size: int=8, is_double: bool=False) -> str:\n card = self.repr_fields()\n if size == 8:\n return self.comment + print_card_8(card)\n return self.comment + print_card_16(card)\n",
"# pylint: disable=R0902,R0904,R0914\nfrom math import sin, cos, radians, atan2, sqrt, degrees\nfrom itertools import count\nfrom typing import Tuple # , TYPE_CHECKING\n\nimport numpy as np\nfrom numpy import array, zeros\nfrom scipy.sparse import coo_matrix # type: ignore\n\nfrom pyNastran.utils.numpy_utils import integer_types\nfrom pyNastran.bdf.cards.base_card import BaseCard\nfrom pyNastran.bdf.field_writer_8 import print_card_8\nfrom pyNastran.bdf.field_writer_16 import print_card_16\nfrom pyNastran.bdf.field_writer_double import print_card_double\n\nfrom pyNastran.bdf.bdf_interface.assign_type import (\n integer, integer_or_blank, double, string, string_or_blank,\n parse_components, interpret_value, integer_double_string_or_blank)\n\n\nclass DTI(BaseCard):\n \"\"\"\n +-----+-------+-----+------+-------+--------+------+-------------+\n | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |\n +=====+=======+=====+======+=======+========+======+=============+\n | DTI | UNITS | \"1\" | MASS | FORCE | LENGTH | TIME | STRESS |\n +-----+-------+-----+------+-------+--------+------+-------------+\n\n MSC\n\n +-----+-------+-----+------+-------+--------+------+-------------+\n | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |\n +=====+=======+=====+======+=======+========+======+=============+\n | DTI | UNITS | \"1\" | MASS | FORCE | LENGTH | TIME | TEMPERATURE |\n +-----+-------+-----+------+-------+--------+------+-------------+\n\n NX\n \"\"\"\n type = 'DTI'\n #_properties = ['shape', 'ifo', 'is_real', 'is_complex', 'is_polar', 'matrix_type', 'tin_dtype', 'tout_dtype']\n\n @classmethod\n def _init_from_empty(cls):\n name = 'name'\n fields = []\n return DTI(name, fields, comment='')\n\n def _finalize_hdf5(self, encoding):\n \"\"\"hdf5 helper function\"\"\"\n keys, values = self.fields\n\n # nan != nan\n values = [value if value == value else None for value in values]\n values_str = [value.decode(encoding) if isinstance(value, bytes) else value\n for value in values]\n #values = [valuei.decode(encoding) if isinstance(valuei, bytes) else (\n # None if np.isnan(valuei) else valuei)\n # for valuei in values]\n self.fields = {key : value for key, value in zip(keys, values_str)}\n\n @classmethod\n def export_to_hdf5(cls, h5_file, model, encoding):\n \"\"\"exports the elements in a vectorized way\"\"\"\n from pyNastran.bdf.bdf_interface.hdf5_exporter import _export_list\n for name, dti in sorted(model.dti.items()):\n if name == 'UNITS':\n i = 0\n for key, value in sorted(dti.fields.items()):\n #print(key, value)\n h5_group = h5_file.create_group(str(key))\n if value is None:\n h5_group.create_dataset(str(i), data=np.nan)\n else:\n h5_group.create_dataset(str(i), data=value)\n i += 1\n #fields = {\n #'mass' : mass,\n #'force' : force,\n #'length' : length,\n #'time' : time,\n #'temp_stress' : temp_stress\n #}\n else:\n for irecord, fields in sorted(dti.fields.items()):\n #h5_group = h5_file.create_group(str(irecord))\n attr = 'irecord=%s' % irecord\n namei = str(irecord)\n values = fields\n _export_list(h5_file, attr, namei, values, encoding)\n #print(h5_group)\n #print(irecord, fields)\n\n def __init__(self, name, fields, comment=''):\n \"\"\"\n Creates a DTI card\n\n Parameters\n ----------\n name : str\n UNITS\n fields : List[varies]\n the fields\n comment : str; default=''\n a comment for the card\n \"\"\"\n if comment:\n self.comment = comment\n self.name = name\n self.fields = fields\n assert len(fields) > 0, fields\n\n @classmethod\n def add_card(cls, card, comment):\n \"\"\"\n Adds a DTI card from ``BDF.add_card(...)``\n\n Parameters\n ----------\n card : BDFCard()\n a BDFCard object\n comment : str; default=''\n a comment for the card\n\n \"\"\"\n name = string(card, 1, 'name')\n if name == 'UNITS':\n integer(card, 2, '1')\n mass = string(card, 3, 'mass')\n force = string(card, 4, 'force')\n length = string(card, 5, 'length')\n time = string(card, 6, 'time')\n temp_stress = string_or_blank(card, 7, 'stress/temperature')\n fields = {\n 'mass' : mass,\n 'force' : force,\n 'length' : length,\n 'time' : time,\n 'temp_stress' : temp_stress\n }\n else:\n fields = []\n #field2 = card[2]\n\n list_fields = []\n irecord = integer(card, 2, 'record')\n if irecord == 0:\n for i in range(3, len(card)):\n val = integer_double_string_or_blank(\n card, i, 'T%i' % (i-1), default=32767)\n list_fields.append(val)\n else:\n for i in range(3, len(card)):\n val = integer_double_string_or_blank(\n card, i, 'T%i' % (i-1), default=None)\n list_fields.append(val)\n fields = {irecord: list_fields,}\n return DTI(name, fields, comment=comment)\n\n def raw_fields(self):\n if self.name == 'UNITS':\n mass = self.fields['mass']\n force = self.fields['force']\n length = self.fields['length']\n time = self.fields['time']\n temp_stress = self.fields['temp_stress']\n list_fields = ['DTI', self.name, '1', mass, force, length, time, temp_stress]\n else:\n list_fields = []\n for irecord, fields in sorted(self.fields.items()):\n nfields = len(fields)\n list_fields += ['DTI', self.name] + fields\n nleftover = nfields % 8\n if nleftover:\n list_fields += [None] * nleftover\n return list_fields\n\n def write_card(self, size: int=8, is_double: bool=False) -> str:\n if self.name == 'UNITS':\n card = self.repr_fields()\n return self.comment + print_card_8(card)\n\n msg = self.comment\n for irecord, fields in sorted(self.fields.items()):\n list_fields = ['DTI', self.name, irecord, ] + fields\n msg += print_card_8(list_fields)\n return msg\n\n\nclass NastranMatrix(BaseCard):\n \"\"\"\n Base class for the DMIG, DMIJ, DMIJI, DMIK matrices\n \"\"\"\n def _finalize_hdf5(self, encoding):\n \"\"\"hdf5 helper function\"\"\"\n self.finalize()\n\n def __init__(self, name, matrix_form, tin, tout, polar, ncols,\n GCj, GCi, Real, Complex=None, comment='', finalize=True):\n \"\"\"\n Creates a NastranMatrix\n\n Parameters\n ----------\n name : str\n the name of the matrix\n matrix_form : int\n matrix shape\n 4=Lower Triangular\n 5=Upper Triangular\n 6=Symmetric\n 8=Identity (m=nRows, n=m)\n tin : int\n matrix input precision\n 1=Real, Single Precision\n 2=Real, Double Precision\n 3=Complex, Single Precision\n 4=Complex, Double Precision\n tout : int\n matrix output precision\n 0=same as tin\n 1=Real, Single Precision\n 2=Real, Double Precision\n 3=Complex, Single Precision\n 4=Complex, Double Precision\n polar : int; default=0\n Input format of Ai, Bi\n Integer=blank or 0 indicates real, imaginary format\n Integer > 0 indicates amplitude, phase format\n ncols : int\n ???\n GCj : List[(node, dof)]\n the jnode, jDOFs\n GCi : List[(node, dof)]\n the inode, iDOFs\n Real : List[float]\n The real values\n Complex : List[float]; default=None\n The complex values (if the matrix is complex)\n comment : str; default=''\n a comment for the card\n\n \"\"\"\n if comment:\n self.comment = comment\n if Complex is None:\n Complex = []\n if tout is None:\n tout = 0\n\n polar = _set_polar(polar)\n\n if matrix_form not in [1, 2, 4, 5, 6, 8, 9]:\n msg = (\n 'matrix_form=%r must be [1, 2, 4, 5, 6, 8, 9]\\n'\n ' 1: Square\\n'\n ' 2: Rectangular\\n'\n #' 4: Lower Triangular\\n'\n #' 5: Upper Triangular\\n'\n ' 6: Symmetric\\n'\n #' 8: Identity (m=nRows, n=m)\\n'\n ' 9: Rectangular\\n' % matrix_form)\n raise ValueError(msg)\n self.name = name\n\n #: 4-Lower Triangular; 5=Upper Triangular; 6=Symmetric; 8=Identity (m=nRows, n=m)\n self.matrix_form = matrix_form\n\n #: 1-Real, Single Precision; 2=Real,Double Precision;\n # 3=Complex, Single; 4=Complex, Double\n self.tin = tin\n\n #: 0-Set by cell precision\n self.tout = tout\n\n #: Input format of Ai, Bi. (Integer=blank or 0 indicates real, imaginary format;\n #: Integer > 0 indicates amplitude, phase format.)\n self.polar = polar\n\n self.ncols = ncols\n self.GCj = GCj\n self.GCi = GCi\n\n self.Real = Real\n if len(Complex) or self.is_complex:\n self.Complex = Complex\n assert self.tin in [3, 4], 'tin=%r and must 3 or 4 to be complex' % self.tin\n assert self.tout in [0, 3, 4], 'tin=%r and must 0, 3 or 4 to be complex' % self.tout\n assert isinstance(matrix_form, integer_types), 'matrix_form=%r type=%s' % (matrix_form, type(matrix_form))\n assert not isinstance(matrix_form, bool), 'matrix_form=%r type=%s' % (matrix_form, type(matrix_form))\n if finalize:\n self.finalize()\n\n @classmethod\n def add_card(cls, card, comment=''):\n \"\"\"\n Adds a NastranMatrix (DMIG, DMIJ, DMIK, DMIJI) card from ``BDF.add_card(...)``\n\n Parameters\n ----------\n card : BDFCard()\n a BDFCard object\n comment : str; default=''\n a comment for the card\n\n \"\"\"\n name = string(card, 1, 'name')\n #zero\n\n matrix_form = integer(card, 3, 'ifo')\n tin = integer(card, 4, 'tin')\n tout = integer_or_blank(card, 5, 'tout', 0)\n polar = integer_or_blank(card, 6, 'polar', 0)\n if matrix_form == 1: # square\n ncols = integer_or_blank(card, 8, 'matrix_form=%s; ncol' % matrix_form)\n elif matrix_form == 6: # symmetric\n ncols = integer_or_blank(card, 8, 'matrix_form=%s; ncol' % matrix_form)\n elif matrix_form in [2, 9]: # rectangular\n ncols = integer(card, 8, 'matrix_form=%s; ncol' % (matrix_form))\n else:\n # technically right, but nulling this will fix bad decks\n #self.ncols = blank(card, 8, 'matrix_form=%s; ncol' % self.matrix_form)\n\n msg = (\n '%s name=%r matrix_form=%r is not supported. Valid forms:\\n'\n ' 4=Lower Triangular\\n'\n ' 5=Upper Triangular\\n'\n ' 6=Symmetric\\n'\n ' 8=Identity (m=nRows, n=m)\\n' % (cls.type, name, matrix_form)\n )\n raise NotImplementedError(msg)\n\n GCj = []\n GCi = []\n Real = []\n Complex = []\n return cls(name, matrix_form, tin, tout, polar, ncols,\n GCj, GCi, Real, Complex, comment=comment, finalize=False)\n\n @property\n def matrix_type(self):\n \"\"\"gets the matrix type\"\"\"\n if not isinstance(self.matrix_form, integer_types):\n msg = 'ifo must be an integer; matrix_form=%r type=%s name=%s' % (\n self.matrix_form, type(self.matrix_form), self.name)\n raise TypeError(msg)\n if isinstance(self.matrix_form, bool):\n msg = 'matrix_form must not be a boolean; matrix_form=%r type=%s name=%s' % (\n self.matrix_form, type(self.matrix_form), self.name)\n raise TypeError(msg)\n\n if self.matrix_form == 1:\n matrix_type = 'square'\n elif self.matrix_form == 6:\n matrix_type = 'symmetric'\n elif self.matrix_form in [2, 9]:\n matrix_type = 'rectangular'\n else:\n # technically right, but nulling this will fix bad decks\n #self.ncols = blank(card, 8, 'matrix_form=%s; ncol' % self.matrix_form)\n raise NotImplementedError('%s matrix_form=%r is not supported' % (\n self.type, self.matrix_form))\n return matrix_type\n\n def finalize(self):\n \"\"\"converts the lists into numpy arrays\"\"\"\n self.GCi = np.asarray(self.GCi)\n self.GCj = np.asarray(self.GCj)\n self.Real = np.asarray(self.Real)\n if self.is_complex:\n self.Complex = np.asarray(self.Complex)\n\n @property\n def shape(self):\n \"\"\"gets the matrix shape\"\"\"\n if self.matrix_form in [1, 6]: # square, symmetric\n if self.ncols is not None:\n shape = (self.ncols, self.ncols)\n else:\n nrows, ncols = get_row_col_map(\n self, self.GCi, self.GCj, self.matrix_form)[:2]\n shape = (nrows, ncols)\n elif self.matrix_form in [2, 9]:\n raise NotImplementedError('need to pull the nrows after reading in everything')\n #shape = (self.ncols, self.ncols)\n else:\n raise NotImplementedError('matrix_form=%s' % self.matrix_form)\n return shape\n\n def _add_column(self, card, comment=''):\n \"\"\"adds an additional column entry to the matrix\"\"\"\n if comment:\n if hasattr(self, '_comment'):\n self.comment += comment\n else:\n self.comment = comment\n\n name = string(card, 1, 'name')\n if name == 'UACCEL':\n self._add_column_uaccel()\n return\n\n Gj = integer(card, 2, 'Gj')\n # Cj = integer(card, 3, 'Cj')\n Cj = integer_or_blank(card, 3, 'Cj', 0)\n #Cj = parse_components(card, 3, 'Cj')\n assert 0 <= Cj <= 6, 'C%i must be between [0, 6]; Cj=%s' % (0, Cj)\n\n nfields = len(card)\n #print(\"nfields = %i\" % nfields)\n #print(\"card[5:] =\", card[5:])\n #print(\"(nfields - 5) %% 4 = %i\" % ((nfields - 5) % 4))\n\n nloops = (nfields - 5) // 4\n if (nfields - 5) % 4 in [2, 3]: # real/complex\n nloops += 1\n #assert nfields <= 8,'nfields=%s' % nfields\n #print(\"nloops = %i\" % nloops)\n assert nloops > 0, 'nloops=%s' % nloops\n\n for i in range(nloops):\n self.GCj.append((Gj, Cj))\n\n if self.is_complex:\n if self.is_polar:\n for i in range(nloops):\n n = 5 + 4 * i\n Gi = integer(card, n, 'Gi')\n # Ci = integer(card, n + 1, 'Ci')\n Ci = integer_or_blank(card, n + 1, 'Ci', 0)\n #Ci = parse_components(card, n + 1, 'Ci')\n assert 0 <= Ci <= 6, 'C%i must be between [0, 6]; Ci=%s' % (i + 1, Ci)\n self.GCi.append((Gi, Ci))\n magi = double(card, n + 2, 'ai')\n phasei = double(card, n + 3, 'bi')\n reali = magi * cos(radians(phasei))\n complexi = magi * sin(radians(phasei))\n self.Real.append(reali)\n self.Complex.append(complexi)\n else:\n for i in range(nloops):\n n = 5 + 4 * i\n Gi = integer(card, n, 'Gi')\n # Ci = integer(card, n + 1, 'Ci')\n Ci = integer_or_blank(card, n + 1, 'Ci', 0)\n #Ci = parse_components(card, n + 1, 'Ci')\n assert 0 <= Ci <= 6, 'C%i must be between [0, 6]; Ci=%s' % (i + 1, Ci)\n self.GCi.append((Gi, Ci))\n reali = double(card, n + 2, 'real')\n complexi = double(card, n + 3, 'complex')\n self.Real.append(reali)\n self.Complex.append(complexi)\n else:\n # real\n for i in range(nloops):\n n = 5 + 4 * i\n Gi = integer(card, n, 'Gi')\n # Ci = integer(card, n + 1, 'Ci')\n Ci = integer_or_blank(card, n + 1, 'Ci', 0)\n #Ci = parse_components(card, n + 1, 'Ci')\n assert 0 <= Ci <= 6, 'C%i must be between [0, 6]; Ci=%s' % (i + 1, Ci)\n reali = double(card, n + 2, 'real')\n self.GCi.append((Gi, Ci))\n self.Real.append(reali)\n #print(\"GC=%s,%s real=%s\" % (Gi, Ci, reali))\n\n msg = '(len(GCj)=%s len(GCi)=%s' % (len(self.GCj), len(self.GCi))\n assert len(self.GCj) == len(self.GCi), msg\n #if self.is_complex:\n #self.Complex(double(card, v, 'complex')\n\n def get_matrix(self, is_sparse=False, apply_symmetry=True):\n \"\"\"\n Builds the Matrix\n\n Parameters\n ----------\n is_sparse : bool; default=False\n should the matrix be returned as a sparse matrix.\n Slower for dense matrices.\n apply_symmetry : bool; default=True\n If the matrix is symmetric (ifo=6), returns a symmetric matrix.\n Supported as there are symmetric matrix routines.\n\n Returns\n -------\n M : numpy.ndarray or scipy.coomatrix\n the matrix\n rows : dict[int] = [int, int]\n dictionary of keys=rowID, values=(Grid,Component) for the matrix\n cols: dict[int] = [int, int]\n dictionary of keys=columnID, values=(Grid,Component) for the matrix\n\n .. warning:: is_sparse=True WILL fail\n\n \"\"\"\n return get_matrix(self, is_sparse=is_sparse, apply_symmetry=apply_symmetry)\n\n @property\n def is_real(self):\n \"\"\"real vs. complex attribute\"\"\"\n return not self.is_complex\n\n @property\n def is_complex(self):\n \"\"\"real vs. complex attribute\"\"\"\n if self.tin in [1, 2]: # real\n return False\n elif self.tin in [3, 4]: # complex\n return True\n msg = ('Matrix %r must have a value of TIN = [1, 2, 3, 4].\\n'\n 'TIN defines the type (real, complex) '\n 'of the matrix. TIN=%r.\\n'\n ' TIN=1,2 -> real\\n'\n ' TIN=3,4 -> complex' % (self.name, self.tin))\n raise ValueError(msg)\n\n @property\n def is_polar(self):\n \"\"\"\n Used by:\n - DMIG\n - DMIJ\n - DMIJI\n - DMIK\n\n Not used by:\n - DMI\n - DMIAX\n - DMIG, UACCEL\n - DMIGOUT\n - DMIGROT\n\n \"\"\"\n if self.polar == 0: # real, imag\n return False\n elif self.polar == 1: # mag, phase\n return True\n elif self.polar is None:\n return False\n msg = ('Matrix %r must have a value of POLAR = [0, 1].\\n'\n 'POLAR defines the type (real/imag or mag/phase) complex) '\n 'of the matrix. POLAR=%r.' % (self.name, self.polar))\n raise ValueError(msg)\n\n @property\n def tin_dtype(self):\n \"\"\"gets the input dtype\"\"\"\n return _get_dtype(self.is_complex, self.tin)\n\n @property\n def tout_dtype(self):\n \"\"\"gets the output dtype\"\"\"\n return _get_dtype(self.is_complex, self.tout)\n\n def __repr__(self):\n return self.write_card(size=8, is_double=False)\n\n def fill_in_default_components(self, model):\n for i, (Gi, Ci) in enumerate(self.GCi):\n if Ci is None:\n node = model.nodes[Gi]\n if node.type == 'GRID':\n msg = ('Ci on DMIG card must be 1, 2, 3, 4, 5, or 6; '\n 'Node=%i (GRID); Ci=%s' % (Gi, Ci))\n raise RuntimeError(msg)\n elif node.type in ['SPOINT', 'EPOINT']:\n Ci = 0\n else:\n raise NotImplementedError(node)\n self.GCi[i] = [Gi, Ci]\n\n for i, (Gj, Cj) in enumerate(self.GCj):\n if Cj is None:\n node = model.nodes[Gj]\n if node.type == 'GRID':\n msg = ('Cj on DMIG card must be 1, 2, 3, 4, 5, or 6; '\n 'Node=%i (GRID); Cj=%s' % (Gj, Cj))\n raise RuntimeError(msg)\n elif node.type in ['SPOINT', 'EPOINT']:\n Cj = 0\n else:\n raise NotImplementedError(node)\n self.GCj[i] = [Gj, Cj]\n return\n\n def write_card(self, size: int=8, is_double: bool=False) -> str:\n if self.tin in [1, 3]:\n is_double = False\n elif self.tin in [2, 4]:\n is_double = True\n size = 16\n else:\n raise RuntimeError('tin=%r must be 1, 2, 3, or 4' % self.tin)\n\n assert isinstance(self.GCi, (list, np.ndarray)), 'type(GCi)=%s' % type(self.GCi)\n assert isinstance(self.GCj, (list, np.ndarray)), 'type(GCj)=%s' % type(self.GCj)\n assert isinstance(self.Real, (list, np.ndarray)), 'type(Real)=%s' % type(self.Real)\n #assert isinstance(self.GCi[0], (list, np.ndarray)), 'type(GCi[0])=%s' % type(self.GCi[0])\n #assert isinstance(self.GCj[0], (list, np.ndarray)), 'type(GCj[0])=%s' % type(self.GCj[0])\n\n msg = '\\n$' + '-' * 80\n msg += '\\n$ %s Matrix %s\\n' % (self.type, self.name)\n list_fields = [self.type, self.name, 0, self.matrix_form, self.tin,\n self.tout, self.polar, None, self.ncols]\n if size == 8:\n msg += print_card_8(list_fields)\n else:\n msg += print_card_16(list_fields)\n\n if self.is_complex:\n if self.is_polar:\n for (GCi, GCj, reali, complexi) in zip(self.GCi, self.GCj, self.Real, self.Complex):\n magi = sqrt(reali**2 + complexi**2)\n if reali == 0.0:\n phasei = 0.0\n else:\n phasei = degrees(atan2(complexi, reali))\n list_fields = [self.type, self.name, GCj[0], GCj[1],\n None, GCi[0], GCi[1], magi, phasei]\n if size == 8:\n msg += print_card_8(list_fields)\n elif is_double:\n msg += print_card_double(list_fields)\n else:\n msg += print_card_16(list_fields)\n else:\n for (GCi, GCj, reali, complexi) in zip(self.GCi, self.GCj, self.Real, self.Complex):\n list_fields = [self.type, self.name, GCj[0], GCj[1],\n None, GCi[0], GCi[1], reali, complexi]\n if size == 8:\n msg += print_card_8(list_fields)\n elif is_double:\n msg += print_card_double(list_fields)\n else:\n msg += print_card_16(list_fields)\n else:\n for (GCi, GCj, reali) in zip(self.GCi, self.GCj, self.Real):\n list_fields = [self.type, self.name, GCj[0], GCj[1],\n None, GCi[0], GCi[1], reali, None]\n if size == 8:\n msg += print_card_8(list_fields)\n elif is_double:\n msg += print_card_double(list_fields)\n else:\n msg += print_card_16(list_fields)\n\n #msg += '\\n\\nGCi[0]=%s\\n' % self.GCi[0]\n #msg += 'GCj[0]=%s\\n' % self.GCj[0]\n #msg += 'Real[0]=%s\\n' % self.Real[0]\n #assert isinstance(self.GCi[0], (list, np.ndarray)), msg\n #assert isinstance(self.GCj[0], (list, np.ndarray)), msg\n #assert isinstance(self.Real[0], (list, np.ndarray)), msg\n\n return msg\n\n\nclass DMIG_UACCEL(BaseCard):\n \"\"\"\n Direct Matrix Input of Enforced Static Acceleration\n Defines rigid body accelerations in the basic coordinate system.\n\n +------+--------+-----+-----+-----+-----+-----+-------+-------+\n | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | |\n +======+========+=====+=====+=====+=====+=====+=======+=======+\n | DMIG | UACCEL | \"0\" | \"9\" | TIN | | | | NCOL |\n +------+--------+-----+-----+-----+-----+-----+-------+-------+\n | DMIG | UACCEL | L | | | G1 | C1 | X1 | |\n +------+--------+-----+-----+-----+-----+-----+-------+-------+\n | | G2 | C2 | X2 | | G3 | C3 | X3 | |\n +------+--------+-----+-----+-----+-----+-----+-------+-------+\n\n +------+--------+-----+-----+-----+-----+-----+-------+-------+\n | DMIG | UACCEL | 0 | 9 | 1 | | | | 4 |\n +------+--------+-----+-----+-----+-----+-----+-------+-------+\n | DMIG | UACCEL | 2 | | | 2 | 3 | 386.4 | |\n +------+--------+-----+-----+-----+-----+-----+-------+-------+\n | DMIG | UACCEL | 3 | | | 2 | 4 | 3.0 | |\n +------+--------+-----+-----+-----+-----+-----+-------+-------+\n | DMIG | UACCEL | 4 | | | 2 | 6 | 1.0 | |\n +------+--------+-----+-----+-----+-----+-----+-------+-------+\n \"\"\"\n type = 'DMIG'\n name = 'UACCEL'\n def __init__(self, tin, ncol, load_sequences, comment=''):\n if comment:\n self.comment = comment\n self.tin = tin\n self.ncol = ncol\n self.load_sequences = load_sequences\n #print(str(self))\n\n @classmethod\n def export_to_hdf5(cls, h5_file, model, encoding):\n _export_dmig_to_hdf5(h5_file, model, model.dmig, encoding)\n\n @classmethod\n def add_card(cls, card, comment=''):\n \"\"\"\n Adds a DMIG,UACCEL card from ``BDF.add_card(...)``\n\n Parameters\n ----------\n card : BDFCard()\n a BDFCard object\n comment : str; default=''\n a comment for the card\n\n \"\"\"\n tin = integer(card, 4, 'tin')\n ncol = integer_or_blank(card, 8, 'ncol')\n return DMIG_UACCEL(tin, ncol, load_sequences={}, comment=comment)\n\n def _add_column(self, card, comment=''):\n if comment:\n if hasattr(self, '_comment'):\n self.comment += comment\n else:\n self.comment = comment\n load_seq = integer(card, 2, 'load_seq')\n\n i = 0\n ifield = 5\n self.load_sequences[load_seq] = []\n assert len(card) >= 8, 'len=%s card=%s' % (len(card), card)\n while ifield < len(card):\n g1 = integer(card, ifield, 'nid%d' % i)\n c1 = parse_components(card, ifield+1, 'c%d' % i)\n x1 = double(card, ifield+2, 'x%d' % i)\n #assert len(card) <= 8, 'len=%s card=%s' % (len(card), card)\n gcx = [g1, c1, x1]\n self.load_sequences[load_seq].append(gcx)\n ifield += 4\n i += 1\n\n\n @staticmethod\n def finalize():\n \"\"\"a passer method\"\"\"\n pass\n\n def raw_fields(self):\n list_fields = [\n 'DMIG', 'UACCEL', 0, 9, self.tin, None, None, None, self.ncol\n ]\n for lseq, ncx in sorted(self.load_sequences.items()):\n list_fields += [lseq, None, None]\n for ncxi in ncx:\n list_fields += ncxi\n #for (nid, comp, xi) in ncx:\n #print('list_fields= %s' % list_fields)\n self.write_card()\n return list_fields\n\n def write_card(self, size: int=8, is_double: bool=False) -> str:\n if self.tin in [1, 3]:\n is_double = False\n msg = self.write_card_8()\n elif self.tin in [2, 4]:\n is_double = True\n size = 16\n msg = self.write_card_16()\n else:\n raise RuntimeError('tin=%r must be 1, 2, 3, or 4' % self.tin)\n return msg\n\n def write_card_8(self):\n \"\"\"writes the card in small field format\"\"\"\n return self._write_card(print_card_8)\n\n def write_card_16(self):\n \"\"\"writes the card in small large format\"\"\"\n return self._write_card(print_card_16)\n\n def _write_card(self, func):\n \"\"\"writes the card\"\"\"\n msg = '\\n$' + '-' * 80\n msg += '\\n$ DMIG Matrix UACCEL\\n'\n list_fields = [\n 'DMIG', 'UACCEL', 0, 9, self.tin, None, None, None, self.ncol,\n ]\n msg += func(list_fields)\n\n for lseq, ncx in sorted(self.load_sequences.items()):\n list_fields = ['DMIG', 'UACCEL']\n list_fields += [lseq, None, None]\n for ncxi in ncx:\n list_fields += ncxi + [None]\n list_fields.pop()\n msg += func(list_fields)\n #print(msg)\n #if self.is_complex:\n #msg += self._get_complex_fields(func)\n #else:\n #msg += self._get_real_fields(func)\n return msg\n\n def __repr__(self):\n return self.write_card(size=8)\n\nclass DMIG(NastranMatrix):\n \"\"\"\n Defines direct input matrices related to grid, extra, and/or scalar points.\n The matrix is defined by a single header entry and one or more column\n entries. A column entry is required for each column with nonzero elements.\n\n +------+------+----+-----+-----+------+-------+----+------+\n | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |\n +======+======+====+=====+=====+======+=======+====+======+\n | DMIG | NAME | 0 | IFO | TIN | TOUT | POLAR | | NCOL |\n +------+------+----+-----+-----+------+-------+----+------+\n | DMIG | NAME | GJ | CJ | | G1 | C1 | A1 | B1 |\n +------+------+----+-----+-----+------+-------+----+------+\n | | G2 | C2 | A2 | B2 | | | | |\n +------+------+----+-----+-----+------+-------+----+------+\n \"\"\"\n type = 'DMIG'\n _properties = ['is_real', 'is_complex', 'is_polar', 'matrix_type', 'shape',\n 'tin_dtype', 'tout_dtype']\n\n #@classmethod\n #def _init_from_empty(cls):\n #name = 'name'\n #ifo = 1\n #tin = 1\n #tout = 1\n #polar = 0\n #ncols = 1\n #GCj = []\n #GCi = []\n #Real = []\n #return DMIG(name, ifo, tin, tout, polar, ncols, GCj, GCi, Real,\n #Complex=None, comment='', finalize=True)\n\n @classmethod\n def export_to_hdf5(cls, h5_file, model, encoding):\n _export_dmig_to_hdf5(h5_file, model, model.dmig, encoding)\n\n def __init__(self, name, ifo, tin, tout, polar, ncols,\n GCj, GCi, Real, Complex=None, comment='', finalize=True):\n \"\"\"\n Creates a DMIG card\n\n Parameters\n ----------\n name : str\n the name of the matrix\n ifo : int\n matrix shape\n 4=Lower Triangular\n 5=Upper Triangular\n 6=Symmetric\n 8=Identity (m=nRows, n=m)\n tin : int\n matrix input precision\n 1=Real, Single Precision\n 2=Real, Double Precision\n 3=Complex, Single Precision\n 4=Complex, Double Precision\n tout : int\n matrix output precision\n 0=same as tin\n 1=Real, Single Precision\n 2=Real, Double Precision\n 3=Complex, Single Precision\n 4=Complex, Double Precision\n polar : int; default=0\n Input format of Ai, Bi\n Integer=blank or 0 indicates real, imaginary format\n Integer > 0 indicates amplitude, phase format\n ncols : int\n ???\n GCj : List[(node, dof)]\n the [jnode, jDOFs]\n GCi : List[(node, dof)]\n the inode, iDOFs\n Real : List[float]\n The real values\n Complex : List[float]; default=None\n The complex values (if the matrix is complex)\n comment : str; default=''\n a comment for the card\n\n \"\"\"\n NastranMatrix.__init__(self, name, ifo, tin, tout, polar, ncols,\n GCj, GCi, Real, Complex, comment=comment,\n finalize=finalize)\n\n\nclass DMIAX(BaseCard):\n \"\"\"\n Direct Matrix Input for Axisymmetric Analysis\n\n Defines axisymmetric (fluid or structure) related direct input matrix\n terms. The matrix is defined by a single header entry and one or\n more column entries. Only one header entry is required. A column\n entry is required for each column with nonzero elements.\n\n +-------+------+----+--------+------+--------+-------+----+------+\n | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |\n +=======+======+====+========+======+========+=======+====+======+\n | DMIAX | NAME | 0 | IFO | TIN | TOUT | | | |\n +-------+------+----+--------+------+--------+-------+----+------+\n\n +-------+------+----+--------+------+--------+-------+----+------+\n | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |\n +=======+======+====+========+======+========+=======+====+======+\n | DMIAX | NAME | GJ | CJ | NJ | | | | |\n +-------+------+----+--------+------+--------+-------+----+------+\n | | G1 | C1 | N1 | A1 | B1 | | | |\n +-------+------+----+--------+------+--------+-------+----+------+\n | | G2 | C2 | etc. | | | | | |\n +-------+------+----+--------+------+--------+-------+----+------+\n\n +-------+------+----+--------+------+--------+-------+----+------+\n | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |\n +=======+======+====+========+======+========+=======+====+======+\n | DMIAX | B2PP | 0 | 1 | 3 | | | | |\n +-------+------+----+--------+------+--------+-------+----+------+\n | DMIAX | B2PP | 32 | | | | | | |\n +-------+------+----+--------+------+--------+-------+----+------+\n | | 1027 | 3 | 4.25+6 | | 2.27+3 | | | |\n +-------+------+----+--------+------+--------+-------+----+------+\n\n \"\"\"\n type = 'DMIAX'\n\n def __init__(self, name, matrix_form, tin, tout, ncols,\n GCNj, GCNi, Real, Complex=None, comment=''):\n \"\"\"\n Creates a DMIAX card\n\n Parameters\n ----------\n name : str\n the name of the matrix\n matrix_form : int\n matrix shape\n 1=Square\n 2=General Rectangular\n 6=Symmetric\n tin : int\n matrix input precision\n 1=Real, Single Precision\n 3=Complex, Single Precision\n tout : int\n matrix output precision\n 1=Real, Single Precision\n 2=Real, Double Precision\n 3=Complex, Single Precision\n 4=Complex, Double Precision\n GCNj : List[(node, dof, harmonic_number)]???\n the jnode, jDOFs\n GCNi : List[(node, dof, harmonic_number)]???\n the inode, iDOFs\n Real : List[float]???\n The real values\n Complex : List[float]???; default=None\n The complex values (if the matrix is complex)\n comment : str; default=''\n a comment for the card\n\n \"\"\"\n ncols = None\n\n if comment:\n self.comment = comment\n\n if Complex is None:\n Complex = []\n\n if tout is None:\n tout = 0\n\n self.name = name\n\n #: ifo/4-Lower Triangular; 5=Upper Triangular; 6=Symmetric; 8=Identity (m=nRows, n=m)\n self.matrix_form = matrix_form\n\n #: 1-Real, Single Precision; 2=Real,Double Precision;\n # 3=Complex, Single; 4=Complex, Double\n self.tin = tin\n\n #: 0-Set by cell precision\n self.tout = tout\n\n self.ncols = ncols\n self.GCNj = GCNj\n self.GCNi = GCNi\n\n self.Real = Real\n if len(Complex) or self.is_complex:\n self.Complex = Complex\n if matrix_form not in [1]: #4, 5, 6, 8\n msg = (\n f'{self.type} name={name!r} matrix_form={matrix_form!r} '\n 'must be [1, 2, 6]\\n'\n ' 1: Square\\n'\n ' 2: General Rectangular\\n'\n ' 4: Lower Triangular\\n'\n ' 5: Upper Triangular\\n'\n ' 6: Symmetric\\n'\n ' 8: Identity (m=nRows, n=m)\\n')\n raise ValueError(msg)\n\n assert isinstance(matrix_form, integer_types), 'matrix_form=%r type=%s' % (matrix_form, type(matrix_form))\n assert not isinstance(matrix_form, bool), 'matrix_form=%r type=%s' % (matrix_form, type(matrix_form))\n\n def finalize(self):\n \"\"\"converts the lists into numpy arrays\"\"\"\n return\n #self.GCi = np.asarray(self.GCi)\n #self.GCj = np.asarray(self.GCj)\n self.Real = np.asarray(self.Real)\n if self.is_complex:\n self.Complex = np.asarray(self.Complex)\n\n @classmethod\n def export_to_hdf5(cls, h5_file, model, encoding):\n _export_dmiax_to_hdf5(h5_file, model, model.dmiax, encoding)\n\n @property\n def is_real(self):\n \"\"\"is the matrix real?\"\"\"\n if self.tin in [1, 2]:\n return True\n return False\n\n @property\n def is_complex(self):\n \"\"\"is the matrix complex\"\"\"\n return not self.is_real\n\n @property\n def is_polar(self):\n \"\"\"is the matrix polar (vs real/imag)?\"\"\"\n return False\n\n @property\n def tin_dtype(self):\n \"\"\"gets the input dtype\"\"\"\n return _get_dtype(self.is_complex, self.tin)\n\n @property\n def tout_dtype(self):\n \"\"\"gets the output dtype\"\"\"\n return _get_dtype(self.is_complex, self.tout)\n\n @property\n def matrix_type(self):\n \"\"\"gets the matrix type\"\"\"\n if not isinstance(self.matrix_form, integer_types):\n msg = 'ifo must be an integer; matrix_form=%r type=%s name=%s' % (\n self.matrix_form, type(self.matrix_form), self.name)\n raise TypeError(msg)\n if isinstance(self.matrix_form, bool):\n msg = 'matrix_form must not be a boolean; matrix_form=%r type=%s name=%s' % (\n self.matrix_form, type(self.matrix_form), self.name)\n raise TypeError(msg)\n\n if self.matrix_form == 1:\n matrix_type = 'square'\n #elif self.matrix_form == 6:\n #matrix_type = 'symmetric'\n #elif self.matrix_form in [2, 9]:\n #matrix_type = 'rectangular'\n else:\n # technically right, but nulling this will fix bad decks\n #self.ncols = blank(card, 8, 'matrix_form=%s; ncol' % self.matrix_form)\n raise NotImplementedError(f'{self.type} matrix_form={self.matrix_form} '\n 'is not supported')\n return matrix_type\n\n @classmethod\n def add_card(cls, card, comment=''):\n \"\"\"\n Adds a NastranMatrix (DMIAX) card from ``BDF.add_card(...)``\n\n Parameters\n ----------\n card : BDFCard()\n a BDFCard object\n comment : str; default=''\n a comment for the card\n\n \"\"\"\n name = string(card, 1, 'name')\n #zero\n\n matrix_form = integer(card, 3, 'ifo')\n tin = integer(card, 4, 'tin')\n tout = integer_or_blank(card, 5, 'tout', 0)\n if matrix_form == 1: # square\n ncols = integer_or_blank(card, 8, 'matrix_form=%s; ncol' % matrix_form)\n elif matrix_form == 6: # symmetric\n ncols = integer_or_blank(card, 8, 'matrix_form=%s; ncol' % matrix_form)\n elif matrix_form in [2, 9]: # rectangular\n ncols = integer(card, 8, 'matrix_form=%s; ncol' % matrix_form)\n else:\n # technically right, but nulling this will fix bad decks\n #self.ncols = blank(card, 8, 'matrix_form=%s; ncol' % self.matrix_form)\n raise NotImplementedError('matrix_form=%s is not supported' % matrix_form)\n\n GCj = []\n GCi = []\n Real = []\n Complex = []\n return DMIAX(name, matrix_form, tin, tout, ncols,\n GCj, GCi, Real, Complex, comment=comment)\n\n def _add_column(self, card, comment=''):\n if comment:\n if hasattr(self, '_comment'):\n self.comment += comment\n else:\n self.comment = comment\n\n unused_name = string(card, 1, 'name')\n\n Gj = integer(card, 2, 'Gj')\n # Cj = integer(card, 3, 'Cj')\n Cj = integer_or_blank(card, 3, 'Cj', 0)\n #Cj = parse_components(card, 3, 'Cj')\n Nj = integer_or_blank(card, 4, 'Nj')\n\n assert 0 <= Cj <= 6, 'C%i must be between [0, 6]; Cj=%s' % (0, Cj)\n\n nfields = len(card)\n #print(\"nfields = %i\" % nfields)\n #print(\"card[5:] =\", card[5:])\n #print(\"(nfields - 5) %% 4 = %i\" % ((nfields - 5) % 4))\n\n nloops = (nfields - 8) // 8\n if nfields - 8 % 8:\n nloops += 1\n #assert nfields <= 8,'nfields=%s' % nfields\n #print(\"nloops = %i\" % nloops)\n assert nloops > 0, 'nloops=%s' % nloops\n\n self.GCNj.append((Gj, Cj, Nj))\n GCNi = []\n self.GCNi.append(GCNi)\n if self.is_complex:\n for i in range(nloops):\n #print(dir(card))\n n = 9 + 8 * i\n Gi = integer(card, n, f'Gi{i}')\n # Ci = integer(card, n + 1, 'Ci')\n Ci = integer_or_blank(card, n + 1, f'Ci{i}', 0)\n #Ci = parse_components(card, n + 1, 'Ci')\n Ni = integer_or_blank(card, n + 2, f'Ni{i}')\n\n assert 0 <= Ci <= 6, 'C%i must be between [0, 6]; Ci=%s' % (i + 1, Ci)\n GCNi.append((Gi, Ci, Ni))\n reali = double(card, n + 3, 'real')\n complexi = double(card, n + 4, 'complex')\n self.Real.append(reali)\n self.Complex.append(complexi)\n else:\n # real\n for i in range(nloops):\n n = 9 + 9 * i\n Gi = integer(card, n, 'Gi')\n # Ci = integer(card, n + 1, 'Ci')\n Ci = integer_or_blank(card, n + 1, 'Ci', 0)\n #Ci = parse_components(card, n + 1, 'Ci')\n Ni = integer(card, n + 2, 'Ni')\n\n assert 0 <= Ci <= 6, 'C%i must be between [0, 6]; Ci=%s' % (i + 1, Ci)\n reali = double(card, n + 3, 'real')\n GCNi.append((Gi, Ci, Ni))\n self.Real.append(reali)\n #print(\"GC=%s,%s real=%s\" % (Gi, Ci, reali))\n\n msg = '(len(GCNj)=%s len(GCNi)=%s' % (len(self.GCNj), len(self.GCNi))\n assert len(self.GCNj) == len(self.GCNi), msg\n #if self.is_complex:\n #self.Complex(double(card, v, 'complex')\n\n def raw_fields(self):\n list_fields = [\n 'DMIAX', self.name, 0, self.matrix_form, self.tin, None, None, None, self.ncols,\n ]\n k = 0\n if self.is_real:\n for i, GCNj in enumerate(self.GCNj):\n gj, cj, nj = GCNj\n list_fields += ['DMIAX', self.name, gj, cj, nj, None, None, None, None]\n for unused_j, GCNi in enumerate(self.GCNi[i]):\n gi, ci, ni = GCNi\n reali = self.Real[k]\n list_fields += [gi, ci, ni, reali, None, None, None, None]\n k += 1\n else:\n for i, GCNj in enumerate(self.GCNj):\n gj, cj, nj = GCNj\n list_fields += ['DMIAX', self.name, gj, cj, nj, None, None, None, None]\n for unused_j, GCNi in enumerate(self.GCNi[i]):\n gi, ci, ni = GCNi\n reali = self.Real[k]\n imagi = self.Complex[k]\n list_fields += [gi, ci, ni, reali, imagi, None, None, None, None]\n k += 1\n\n self.write_card()\n return list_fields\n\n def write_card(self, size: int=8, is_double: bool=False) -> str:\n if self.tin in [1, 3]:\n is_double = False\n msg = self.write_card_8()\n elif self.tin in [2, 4]:\n is_double = True\n size = 16\n msg = self.write_card_16()\n else:\n raise RuntimeError('tin=%r must be 1, 2, 3, or 4' % self.tin)\n return msg\n\n def write_card_8(self):\n \"\"\"writes the card in small field format\"\"\"\n return self._write_card(print_card_8)\n\n def write_card_16(self):\n \"\"\"writes the card in small large format\"\"\"\n return self._write_card(print_card_16)\n\n def _write_card(self, func):\n \"\"\"writes the card\"\"\"\n msg = '\\n$' + '-' * 80\n msg += f'\\n$ DMIAX Matrix {self.name}\\n'\n list_fields = [\n 'DMIAX', self.name, 0, self.matrix_form, self.tin, None, None, None, self.ncols,\n ]\n msg += func(list_fields)\n k = 0\n assert len(self.GCNj) > 0, self.get_stats()\n assert len(self.GCNi) > 0, self.get_stats()\n if self.is_real:\n for i, GCNj in enumerate(self.GCNj):\n gj, cj, nj = GCNj\n list_fields = ['DMIAX', self.name, gj, cj, nj, None, None, None, None]\n for unused_j, GCNi in enumerate(self.GCNi[i]):\n gi, ci, ni = GCNi\n reali = self.Real[k]\n list_fields += [gi, ci, ni, reali, None, None, None, None]\n k += 1\n msg += func(list_fields)\n else:\n for i, GCNj in enumerate(self.GCNj):\n gj, cj, nj = GCNj\n list_fields = ['DMIAX', self.name, gj, cj, nj, None, None, None, None]\n for unused_j, GCNi in enumerate(self.GCNi[i]):\n gi, ci, ni = GCNi\n reali = self.Real[k]\n imagi = self.Complex[k]\n list_fields += [gi, ci, ni, reali, imagi, None, None, None]\n k += 1\n msg += func(list_fields)\n return msg\n\n def __repr__(self):\n return self.write_card(size=8)\n\nclass DMIJ(NastranMatrix):\n \"\"\"\n Direct Matrix Input at js-Set of the Aerodynamic Mesh\n Defines direct input matrices related to collation degrees-of-freedom\n (js-set) of aerodynamic mesh points for CAERO1, CAERO3, CAERO4 and CAERO5\n and for the slender body elements of CAERO2. These include W2GJ, FA2J and\n input pressures and downwashes associated with AEPRESS and AEDW entries.\n The matrix is described by a single header entry and one or more column\n entries. A column entry is required for each column with nonzero elements.\n For entering data for the interference elements of a CAERO2, use DMIJI\n or DMI.\n\n \"\"\"\n type = 'DMIJ'\n _properties = ['shape', 'ifo', 'is_real', 'is_complex', 'is_polar', 'matrix_type',\n 'tin_dtype', 'tout_dtype']\n\n @classmethod\n def _init_from_empty(cls):\n name = 'name'\n ifo = 1\n tin = 1\n tout = 1\n polar = 0\n ncols = 1\n GCj = []\n GCi = []\n Real = []\n return DMIJ(name, ifo, tin, tout, polar, ncols, GCj, GCi, Real,\n Complex=None, comment='', finalize=True)\n\n @classmethod\n def export_to_hdf5(cls, h5_file, model, encoding):\n _export_dmig_to_hdf5(h5_file, model, model.dmij, encoding)\n\n def __init__(self, name, matrix_form, tin, tout, polar, ncols,\n GCj, GCi, Real, Complex=None, comment='',\n finalize=True):\n \"\"\"\n Creates a DMIJ card\n\n Parameters\n ----------\n name : str\n the name of the matrix\n matrix_form : int\n matrix shape\n 4=Lower Triangular\n 5=Upper Triangular\n 6=Symmetric\n 8=Identity (m=nRows, n=m)\n tin : int\n matrix input precision\n 1=Real, Single Precision\n 2=Real, Double Precision\n 3=Complex, Single Precision\n 4=Complex, Double Precision\n tout : int\n matrix output precision\n 0=same as tin\n 1=Real, Single Precision\n 2=Real, Double Precision\n 3=Complex, Single Precision\n 4=Complex, Double Precision\n polar : int; default=0\n Input format of Ai, Bi\n Integer=blank or 0 indicates real, imaginary format\n Integer > 0 indicates amplitude, phase format\n ncols : int\n ???\n GCj : List[(node, dof)]???\n the jnode, jDOFs\n GCi : List[(node, dof)]???\n the inode, iDOFs\n Real : List[float]???\n The real values\n Complex : List[float]???; default=None\n The complex values (if the matrix is complex)\n comment : str; default=''\n a comment for the card\n\n \"\"\"\n NastranMatrix.__init__(self, name, matrix_form, tin, tout, polar, ncols,\n GCj, GCi, Real, Complex, comment=comment,\n finalize=finalize)\n\n\nclass DMIJI(NastranMatrix):\n \"\"\"\n Direct Matrix Input at js-Set of the Interference Body\n Defines direct input matrices related to collation degrees-of-freedom\n (js-set) of aerodynamic mesh points for the interference elements of CAERO2.\n These include W2GJ, FA2J and input pressures and downwashes associated with\n AEPRESS and AEDW entries. The matrix is described by a single header entry\n and one or more column entries. A column entry is required for each column\n with nonzero elements. For entering data for the slender elements of a\n CAERO2, or a CAERO1, 3, 4 or 5 use DMIJ or DMI.\n\n \"\"\"\n type = 'DMIJI'\n _properties = ['shape', 'ifo', 'is_real', 'is_complex', 'is_polar', 'matrix_type',\n 'tin_dtype', 'tout_dtype']\n\n #@classmethod\n #def _init_from_empty(cls):\n #name = 'name'\n #ifo = 1\n #tin = 1\n #tout = 1\n #polar = 0\n #ncols = 1\n #GCj = []\n #GCi = []\n #Real = []\n #return DMIJI(name, ifo, tin, tout, polar, ncols, GCj, GCi, Real,\n #Complex=None, comment='', finalize=True)\n\n @classmethod\n def export_to_hdf5(cls, h5_file, model, encoding):\n _export_dmig_to_hdf5(h5_file, model, model.dmiji, encoding)\n\n def __init__(self, name, ifo, tin, tout, polar, ncols,\n GCj, GCi, Real, Complex=None, comment='', finalize=True):\n \"\"\"\n Creates a DMIJI card\n\n Parameters\n ----------\n name : str\n the name of the matrix\n ifo : int\n matrix shape\n 4=Lower Triangular\n 5=Upper Triangular\n 6=Symmetric\n 8=Identity (m=nRows, n=m)\n tin : int\n matrix input precision\n 1=Real, Single Precision\n 2=Real, Double Precision\n 3=Complex, Single Precision\n 4=Complex, Double Precision\n tout : int\n matrix output precision\n 0=same as tin\n 1=Real, Single Precision\n 2=Real, Double Precision\n 3=Complex, Single Precision\n 4=Complex, Double Precision\n polar : int; default=0\n Input format of Ai, Bi\n Integer=blank or 0 indicates real, imaginary format\n Integer > 0 indicates amplitude, phase format\n ncols : int\n ???\n GCj : List[(node, dof)]???\n the jnode, jDOFs\n GCi : List[(node, dof)]???\n the inode, iDOFs\n Real : List[float]???\n The real values\n Complex : List[float]???; default=None\n The complex values (if the matrix is complex)\n comment : str; default=''\n a comment for the card\n\n \"\"\"\n NastranMatrix.__init__(self, name, ifo, tin, tout, polar, ncols,\n GCj, GCi, Real, Complex, comment=comment,\n finalize=finalize)\n\n\nclass DMIK(NastranMatrix):\n \"\"\"\n Direct Matrix Input at ks-Set of the Aerodynamic Mesh\n Defines direct input matrices related to physical (displacement)\n degrees-of-freedom (ks-set) of aerodynamic grid points. These include WKK,\n WTFACT and input forces associated with AEFORCE entries. The matrix is\n described by a single header entry and one or more column entries. A column\n entry is required for each column with nonzero elements.\n\n +------+-------+----+-----+-----+------+-------+----+------+\n | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |\n +======+=======+====+=====+=====+======+=======+====+======+\n | DMIK | NAME | 0 | IFO | TIN | TOUT | POLAR | | NCOL |\n +------+-------+----+-----+-----+------+-------+----+------+\n | DMIK | NAME | GJ | CJ | | G1 | C1 | A1 | B1 |\n +------+-------+----+-----+-----+------+-------+----+------+\n | | G2 | C2 | A2 | B2 | | | | |\n +------+-------+----+-----+-----+------+-------+----+------+\n | DMIK | ALPH1 | 0 | 9 | 2 | 0 | 1 | | |\n +------+-------+----+-----+-----+------+-------+----+------+\n | DMIK | ALPH1 | 1 | 1 | 1 | 1 | 1.0 | | |\n +------+-------+----+-----+-----+------+-------+----+------+\n | | 2 | 1 | 1.0 | | | | | |\n +------+-------+----+-----+-----+------+-------+----+------+\n \"\"\"\n type = 'DMIK'\n _properties = ['shape', 'ifo', 'is_real', 'is_complex', 'is_polar', 'matrix_type',\n 'tin_dtype', 'tout_dtype']\n\n #@classmethod\n #def _init_from_empty(cls):\n #name = 'name'\n #ifo = 1\n #tin = 1\n #tout = 1\n #polar = 0\n #ncols = 1\n #GCj = []\n #GCi = []\n #Real = []\n #return DMIK(name, ifo, tin, tout, polar, ncols, GCj, GCi, Real,\n #Complex=None, comment='', finalize=True)\n\n @classmethod\n def export_to_hdf5(cls, h5_file, model, encoding):\n _export_dmig_to_hdf5(h5_file, model, model.dmik, encoding)\n\n def __init__(self, name, ifo, tin, tout, polar, ncols,\n GCj, GCi, Real, Complex=None, comment='', finalize=True):\n \"\"\"\n Creates a DMIK card\n\n Parameters\n ----------\n name : str\n the name of the matrix\n ifo : int\n matrix shape\n 4=Lower Triangular\n 5=Upper Triangular\n 6=Symmetric\n 8=Identity (m=nRows, n=m)\n tin : int\n matrix input precision\n 1=Real, Single Precision\n 2=Real, Double Precision\n 3=Complex, Single Precision\n 4=Complex, Double Precision\n tout : int\n matrix output precision\n 0=same as tin\n 1=Real, Single Precision\n 2=Real, Double Precision\n 3=Complex, Single Precision\n 4=Complex, Double Precision\n polar : int; default=0\n Input format of Ai, Bi\n Integer=blank or 0 indicates real, imaginary format\n Integer > 0 indicates amplitude, phase format\n ncols : int\n ???\n GCj : List[(node, dof)]\n the jnode, jDOFs\n GCi : List[(node, dof)]\n the inode, iDOFs\n Real : List[float]\n The real values\n Complex : List[float]; default=None\n The complex values (if the matrix is complex)\n comment : str; default=''\n a comment for the card\n\n \"\"\"\n NastranMatrix.__init__(self, name, ifo, tin, tout, polar, ncols,\n GCj, GCi, Real, Complex, comment=comment,\n finalize=finalize)\n\n\nclass DMI(NastranMatrix):\n \"\"\"\n +------+-------+------+------+---------+----------+-----------+-----------+------+\n | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |\n +======+=======+======+======+=========+==========+===========+===========+======+\n | DMI | NAME | 0 | FORM | TIN | TOUT | | M | N |\n +------+-------+------+------+---------+----------+-----------+-----------+------+\n | DMI | NAME | J | I1 | A(I1,J) | A(I1,J) | A(I1+1,J) | A(I1+2,J) | etc. |\n +------+-------+------+------+---------+----------+-----------+-----------+------+\n | | I2 | etc. | | | | | | |\n +------+-------+------+------+---------+----------+-----------+-----------+------+\n \"\"\"\n type = 'DMI'\n _properties = ['shape', 'ifo', 'is_real', 'is_complex', 'is_polar', 'matrix_type',\n 'tin_dtype', 'tout_dtype']\n\n @classmethod\n def _init_from_empty(cls):\n name = 'name'\n matrix_form = 8\n tin = 1\n tout = 1\n nrows = 5\n ncols = 5\n GCj = []\n GCi = []\n Real = []\n return DMI(name, matrix_form, tin, tout, nrows, ncols, GCj, GCi, Real,\n Complex=None, comment='', finalize=False)\n\n @classmethod\n def export_to_hdf5(cls, h5_file, model, encoding):\n _export_dmig_to_hdf5(h5_file, model, model.dmi, encoding)\n\n def __init__(self, name, matrix_form, tin, tout, nrows, ncols,\n GCj, GCi, Real, Complex=None, comment='', finalize=True):\n #NastranMatrix.__init__(self, name, ifo, tin, tout, polar, ncols,\n #GCj, GCi, Real, Complex, comment='')\n if comment:\n self.comment = comment\n\n if Complex is None:\n Complex = []\n\n if tout is None:\n tout = 0\n\n if matrix_form not in [1, 2, 3, 4, 5, 6, 8]:\n msg = (\n '%s name=%r matrix_form=%r must be [1, 2, 3, 4, 5, 6, 8]\\n'\n ' 1: Square\\n'\n ' 2: Rectangular\\n'\n ' 3: Diagonal matrix (M=number of rows, N=1)\\n'\n ' 4: Lower Triangular\\n'\n ' 5: Upper Triangular\\n'\n ' 6: Symmetric\\n'\n ' 8: Identity (m=nRows, n=m)\\n'\n #' 9: Rectangular\\n'\n % (self.type, name, matrix_form))\n raise ValueError(msg)\n\n self.name = name\n self.matrix_form = matrix_form\n self.tin = tin\n self.tout = tout\n self.nrows = nrows\n self.ncols = ncols\n self.GCi = GCi\n self.GCj = GCj\n self.Real = Real\n if len(Complex) or self.is_complex:\n self.Complex = Complex\n if finalize:\n self.finalize()\n\n #@property\n #def form(self):\n #\"\"\"gets the matrix_form\"\"\"\n #self.deprecated('form', 'matrix_form', '1.1')\n #return self.matrix_form\n\n #@form.setter\n #def form(self, matrix_form):\n #\"\"\"sets the matrix_form\"\"\"\n #self.deprecated('form', 'matrix_form', '1.1')\n #self.matrix_form = matrix_form\n\n @classmethod\n def add_card(cls, card, comment=''):\n \"\"\"\n Adds a DMI card from ``BDF.add_card(...)``\n\n Parameters\n ----------\n card : BDFCard()\n a BDFCard object\n comment : str; default=''\n a comment for the card\n\n \"\"\"\n name = string(card, 1, 'name')\n #zero\n\n #: Form of the matrix: 1=Square (not symmetric); 2=Rectangular;\n #: 3=Diagonal (m=nRows,n=1); 4=Lower Triangular; 5=Upper Triangular;\n #: 6=Symmetric; 8=Identity (m=nRows, n=m)\n matrix_form = integer(card, 3, 'form')\n\n #: 1-Real, Single Precision; 2=Real,Double Precision;\n #: 3=Complex, Single; 4=Complex, Double\n tin = integer(card, 4, 'tin')\n\n #: 0-Set by cell precision\n tout = integer_or_blank(card, 5, 'tout', 0)\n\n nrows = integer(card, 7, 'nrows')\n ncols = integer(card, 8, 'ncols')\n\n assert len(card) == 9, 'len(DMI card) = %i\\ncard=%s' % (len(card), card)\n\n GCj = []\n GCi = []\n Real = []\n Complex = []\n return DMI(name, matrix_form, tin, tout, nrows, ncols,\n GCj, GCi, Real, Complex, comment=comment, finalize=False)\n\n def finalize(self):\n self.GCi = np.asarray(self.GCi)\n self.GCj = np.asarray(self.GCj)\n self.Real = np.asarray(self.Real)\n if self.is_complex:\n self.Complex = np.asarray(self.Complex)\n\n @property\n def matrix_type(self):\n \"\"\"\n gets the matrix type\n\n 1 Square matrix (not symmetric)\n 2 General rectangular matrix\n 3 Diagonal matrix (M=number of rows, N = 1)\n #4 Lower triangular factor\n #5 Upper triangular factor\n 6 Symmetric matrix\n 8 Identity matrix (M=number of rows, N = M)\n \"\"\"\n if not isinstance(self.matrix_form, integer_types):\n msg = 'ifo must be an integer; matrix_form=%r type=%s name=%s' % (\n self.matrix_form, type(self.matrix_form), self.name)\n raise TypeError(msg)\n if isinstance(self.matrix_form, bool):\n msg = 'matrix_form must not be a boolean; matrix_form=%r type=%s name=%s' % (\n self.matrix_form, type(self.matrix_form), self.name)\n raise TypeError(msg)\n\n if self.matrix_form == 1:\n matrix_type = 'square'\n elif self.matrix_form == 2: # 9 ???\n matrix_type = 'rectangular'\n elif self.matrix_form == 3:\n matrix_type = 'diagonal'\n elif self.matrix_form == 6:\n matrix_type = 'symmetric'\n elif self.matrix_form == 9:\n matrix_type = 'identity'\n else:\n raise NotImplementedError('%s matrix_form=%r is not supported' % (\n self.type, self.matrix_form))\n return matrix_type\n\n @property\n def is_polar(self):\n if self.tin in [1, 2]:\n is_polar = False\n elif self.tin in [3, 4]:\n is_polar = False # TODO: could be wrong...\n else:\n raise NotImplementedError('nrows=%s ncols=%s' % (self.nrows, self.ncols))\n return is_polar\n\n @property\n def shape(self):\n return (self.nrows, self.ncols)\n\n @property\n def ifo(self):\n \"\"\"\n ifo\n #: 4-Lower Triangular; 5=Upper Triangular; 6=Symmetric; 8=Identity (m=nRows, n=m)\n\n #: Form of the matrix: 1=Square (not symmetric); 2=Rectangular;\n #: 3=Diagonal (m=nRows,n=1); 4=Lower Triangular; 5=Upper Triangular;\n #: 6=Symmetric; 8=Identity (m=nRows, n=m)\n self.matrix_form = integer(card, 3, 'matrix_form')\n\n \"\"\"\n return self.matrix_form\n #if self.nrows == self.ncols:\n ## symmetric\n #ifo = 6\n ##elif self.nrows > 1 and self.ncols > 1:\n ##ifo = 2\n #else:\n #raise NotImplementedError('matrix_form=%r nrows=%s ncols=%s' % (\n #self.matrix_form, self.nrows, self.ncols))\n #return ifo\n\n def _add_column(self, card, comment=''):\n \"\"\"\n .. todo:: support comment\n \"\"\"\n if self.is_complex:\n self._read_complex(card)\n else:\n self._read_real(card)\n\n def _read_real(self, card):\n \"\"\"reads a real DMI column\"\"\"\n # column number\n j = integer(card, 2, 'icol')\n\n # counter\n i = 0\n fields = [interpret_value(field, card) for field in card[3:]]\n\n # Real, starts at A(i1,j), goes to A(i2,j) in a column\n while i < len(fields):\n i1 = fields[i]\n if isinstance(i1, integer_types):\n i += 1\n is_done_reading_floats = False\n while not is_done_reading_floats and i < len(fields):\n real_value = fields[i]\n if isinstance(real_value, integer_types):\n is_done_reading_floats = True\n elif isinstance(real_value, float):\n #print('adding j=%s i1=%s val=%s' % (j, i1, real_value))\n self.GCj.append(j)\n self.GCi.append(i1)\n self.Real.append(real_value)\n i += 1\n i1 += 1\n else:\n real_value = self.Real[-1]\n end_i = fields[i + 1]\n for ii in range(i1, end_i + 1):\n #print('adding j=%s i1=%s val=%s' % (j, ii, real_value))\n self.GCj.append(j)\n self.GCi.append(ii)\n self.Real.append(real_value)\n i += 1\n is_done_reading_floats = True\n\n def _read_complex(self, card):\n \"\"\"reads a complex DMI column\"\"\"\n #msg = 'complex matrices not supported in the DMI reader...'\n #raise NotImplementedError(msg)\n # column number\n j = integer(card, 2, 'icol')\n # counter\n i = 0\n fields = [interpret_value(field, card) for field in card[3:]]\n # Complex, starts at A(i1,j)+imag*A(i1,j), goes to A(i2,j) in a column\n if 0: # pragma: no cover\n is_real = True\n gci = None\n for field in fields:\n if isinstance(field, integer_types):\n gci = field\n elif isinstance(field, float):\n if is_real:\n real = field\n else:\n self.GCj.append(j)\n self.GCi.append(gci)\n self.Real.append(real)\n self.Complex.append(field)\n is_real = not is_real\n\n while i < len(fields):\n i1 = fields[i]\n assert isinstance(i1, int), card\n i += 1\n is_done_reading_floats = False\n while not is_done_reading_floats and i < len(fields):\n value = fields[i]\n #print(\"i=%s len(fields)=%s value=%s\" % (\n #i, len(fields), value))\n if isinstance(value, integer_types):\n is_done_reading_floats = True\n elif isinstance(value, float):\n complex_value = fields[i + 1]\n assert isinstance(complex_value, float), card\n self.GCj.append(j)\n self.GCi.append(i1)\n self.Real.append(value)\n self.Complex.append(complex_value)\n i += 2\n else:\n raise NotImplementedError()\n\n @property\n def is_real(self):\n \"\"\"real vs. complex attribute\"\"\"\n return not self.is_complex\n\n @property\n def is_complex(self):\n \"\"\"real vs. complex attribute\"\"\"\n if self.tin in [3, 4]:\n return True\n return False\n\n def raw_fields(self):\n \"\"\"\n .. warning:: All the writers are bad because Nastran insists on\n making columns a single DMI card. This makes\n writing a card much harder, so there are a lot of\n NotImplementedErrors floating about.\n\n This is an invalid method, but is not disabled\n because it's currently needed for checking results\n\n \"\"\"\n list_fields = ['DMI', self.name, 0, self.matrix_form, self.tin,\n self.tout, None, self.nrows, self.ncols]\n\n if self.is_complex:\n for (gci, gcj, reali, imagi) in zip(self.GCi, self.GCj, self.Real, self.Complex):\n list_fields += ['DMI', self.name, gcj, gci, reali, imagi]\n else:\n for (gci, gcj, reali) in zip(self.GCi, self.GCj, self.Real):\n list_fields += ['DMI', self.name, gcj, gci, reali]\n return list_fields\n\n def write_card_8(self):\n \"\"\"writes the card in single precision\"\"\"\n return self._write_card(print_card_8)\n\n def _get_real_fields(self, func):\n msg = ''\n uGCj = np.unique(self.GCj)\n for gcj in uGCj:\n i = np.where(gcj == self.GCj)[0]\n gcis = self.GCi[i]\n reals = self.Real[i]\n isort = np.argsort(gcis)\n list_fields = ['DMI', self.name, gcj]\n\n # will always write the first one\n gci_last = -1\n for gci, real in zip(gcis[isort], reals[isort]):\n if gci == gci_last + 1:\n pass\n else:\n list_fields.append(gci)\n list_fields.append(real)\n gci_last = gci\n msg += func(list_fields)\n return msg\n\n def _get_complex_fields(self, func):\n msg = ''\n uGCj = np.unique(self.GCj)\n for gcj in uGCj:\n i = np.where(gcj == self.GCj)[0]\n gcis = self.GCi[i]\n reals = self.Real[i]\n complexs = self.Complex[i]\n isort = np.argsort(gcis)\n list_fields = ['DMI', self.name, gcj]\n\n # will always write the first one\n gci_last = -10\n #print('gcis=%s \\nreals=%s \\ncomplexs=%s' % (\n #gcis[isort], reals[isort], complexs[isort]))\n if max(gcis) == min(gcis):\n list_fields += [gcis[0]]\n for reali, complexi in zip(reals, complexs):\n list_fields.extend([reali, complexi])\n msg += func(list_fields)\n else:\n #print(f'list_fields0 = {list_fields}')\n for i, gci, reali, complexi in zip(count(), gcis[isort], reals[isort], complexs[isort]):\n #print('B', gci, reali, complexi, gci_last)\n if gci != gci_last + 1 and i != 0:\n pass\n else:\n list_fields.append(gci)\n list_fields.append(reali)\n list_fields.append(complexi)\n gci_last = gci\n #print(f'list_fields = {list_fields}')\n msg += func(list_fields)\n return msg\n\n def get_matrix(self, is_sparse=False, apply_symmetry=True):\n \"\"\"\n Builds the Matrix\n\n Parameters\n ----------\n is_sparse : bool; default=False\n should the matrix be returned as a sparse matrix.\n Slower for dense matrices.\n apply_symmetry : bool; default=True\n If the matrix is symmetric (ifo=6), returns a symmetric matrix.\n Supported as there are symmetric matrix routines.\n\n Returns\n -------\n M : numpy.ndarray or scipy.coomatrix\n the matrix\n rows : dict[int] = [int, int]\n dictionary of keys=rowID, values=(Grid,Component) for the matrix\n cols: dict[int] = [int, int]\n dictionary of keys=columnID, values=(Grid,Component) for the matrix\n\n .. warning:: is_sparse=True WILL fail\n\n \"\"\"\n return get_dmi_matrix(self, is_sparse=is_sparse, apply_symmetry=apply_symmetry)\n\n def write_card_16(self):\n \"\"\"writes the card in single precision\"\"\"\n return self._write_card(print_card_16)\n\n def write_card_double(self):\n \"\"\"writes the card in double precision\"\"\"\n return self._write_card(print_card_16)\n\n def _write_card(self, func):\n \"\"\"writes the card in single/double precision\"\"\"\n msg = '\\n$' + '-' * 80\n msg += '\\n$ %s Matrix %s\\n' % ('DMI', self.name)\n list_fields = ['DMI', self.name, 0, self.matrix_form, self.tin,\n self.tout, None, self.nrows, self.ncols]\n msg += print_card_8(list_fields)\n\n if self.is_complex:\n msg += self._get_complex_fields(func)\n else:\n msg += self._get_real_fields(func)\n return msg\n\n def write_card(self, size: int=8, is_double: bool=False) -> str:\n if size == 8:\n return self.write_card_8()\n if is_double:\n return self.write_card_double()\n return self.write_card_16()\n\n def __repr__(self):\n \"\"\"\n .. todo:: support shortened output format. There's a very low 1000\n DMI cap, I assume this is entries and not matrices.\n\n \"\"\"\n return self.write_card(size=8, is_double=False)\n\n\ndef get_row_col_map(matrix, GCi, GCj, ifo):\n ndim = len(GCi.shape)\n #print('ndim=%s' % ndim)\n #print('GCj=%s' % GCj)\n #print('GCi=%s' % GCi)\n if ndim == 1:\n rows, cols, rows_reversed, cols_reversed = _get_row_col_map_1d(matrix, GCi, GCj, ifo)\n else:\n rows, cols, rows_reversed, cols_reversed = _get_row_col_map_2d(matrix, GCi, GCj, ifo)\n\n nrows = len(rows)\n ncols = len(cols)\n assert nrows > 0, 'nrows=%s' % nrows\n assert ncols > 0, 'ncols=%s' % ncols\n return nrows, ncols, ndim, rows, cols, rows_reversed, cols_reversed\n\ndef _get_row_col_map_1d(matrix, GCi, GCj, ifo):\n \"\"\"helper for ``get_row_col_map``\"\"\"\n rows = {}\n rows_reversed = {}\n\n cols = {}\n cols_reversed = {}\n i = 0\n #nrows = np.unique(GCi)\n #ncols = np.unique(GCj)\n for gci in GCi:\n if gci not in rows:\n rows[gci] = i\n rows_reversed[i] = gci\n i += 1\n\n if ifo == 6:\n # symmetric\n #print(GCj)\n for gcj in GCj:\n if gcj not in rows:\n #print('row.gcj = %s' % str(gcj))\n rows[gcj] = i\n rows_reversed[i] = gcj\n i += 1\n cols = rows\n cols_reversed = rows_reversed\n else:\n j = 0\n for gcj in GCj:\n if gcj not in cols:\n cols[gcj] = j\n cols_reversed[j] = gcj\n j += 1\n return rows, cols, rows_reversed, cols_reversed\n\ndef _get_row_col_map_2d(matrix, GCi, GCj, ifo):\n \"\"\"helper for ``get_row_col_map``\"\"\"\n rows = {}\n rows_reversed = {}\n\n cols = {}\n cols_reversed = {}\n #print('i0=%s j0=%s' % (i, j))\n #nrows = len(GCi)\n #ncols = len(GCj)\n #rows_array = np.zeros((nrows, 2), dtype='int32')\n #cols_array = np.zeros((ncols, 2), dtype='int32')\n #for i, (nid, comp) in enumerate(GCi):\n ##print('i=%s nid=%s comp=%s nrows=%s rows_array.shape=%s' % (\n ##i, nid, comp, nrows, str(rows_array.shape)))\n #rows_array[i, :] = [nid, comp]\n #print('rows_array = \\n%s' % rows_array)\n\n #for j, (nid, comp) in enumerate(GCj):\n #cols_array[j, :] = [nid, comp]\n #print('cols_array = \\n%s' % cols_array)\n\n #print(GCi)\n #print(GCj)\n i = 0\n for (nid, comp) in GCi:\n gci = (nid, comp)\n if gci not in rows:\n #print('row.gci = %s' % str(gci))\n rows[gci] = i\n rows_reversed[i] = gci\n i += 1\n if ifo == 6:\n # symmetric\n for (nid, comp) in GCj:\n gcj = (nid, comp)\n if gcj not in rows:\n #print('row.gcj = %s' % str(gcj))\n rows[gcj] = i\n rows_reversed[i] = gcj\n i += 1\n cols = rows\n cols_reversed = rows_reversed\n else:\n j = 0\n for (nid, comp) in GCj:\n gcj = (nid, comp)\n if gcj not in cols:\n #print('col.gcj = %s' % str(gcj))\n cols[gcj] = j\n cols_reversed[j] = gcj\n j += 1\n return rows, cols, rows_reversed, cols_reversed\n\ndef _fill_sparse_matrix(matrix, nrows, ncols):\n \"\"\"helper method for get_matrix\"\"\"\n GCj = array(matrix.GCj, dtype='int32') - 1\n GCi = array(matrix.GCi, dtype='int32') - 1\n reals = array(matrix.Real, dtype='float32')\n\n # TODO: matrix size: is this correct?\n nrows = max(GCi) + 1\n ncols = max(GCj) + 1\n\n dtype = _get_dtype(matrix.is_complex, matrix.tin)\n # TODO: no check for symmetry\n # TODO: no check for dtype\n if matrix.is_complex:\n complexs = array(matrix.Complex, dtype='float32')\n data = array([reals, complexs]).astype(complex)\n else:\n data = reals\n\n if matrix.matrix_form in [1, 6]:\n nrows = max(nrows, ncols)\n ncols = nrows\n\n #A = coo_matrix( (entries,(rows,cols)),shape=(nrows,ncols),dtype=dtype) # test\n sparse_matrix = coo_matrix((data, (matrix.GCi, matrix.GCj)),\n shape=(nrows, ncols), dtype=dtype)\n #sparse_matrix = coo_matrix( (data,(matrix.GCi,matrix.GCj)),shape=(i,j)) # old\n #sparse_matrix = coo_matrix( (data,(matrix.GCi,matrix.GCj)),shape=(nrows,ncols))\n #print(sparse_matrix.toarray())\n #print(sparse_matrix)\n return sparse_matrix\n\n\ndef _fill_dense_rectangular_matrix(self, nrows, ncols, ndim, rows, cols, apply_symmetry):\n \"\"\"helper method for get_matrix\"\"\"\n is_sparse = False\n if self.is_complex:\n dense_mat = zeros((nrows, ncols), dtype='complex128')\n if self.matrix_form == 6 and apply_symmetry: # symmetric\n for (gcj, gci, reali, complexi) in zip(self.GCj, self.GCi,\n self.Real, self.Complex):\n i = rows[(gci[0], gci[1])]\n j = cols[(gcj[0], gcj[1])]\n dense_mat[i, j] = complex(reali, complexi)\n dense_mat[j, i] = complex(reali, complexi)\n else:\n for (gcj, gci, reali, complexi) in zip(self.GCj, self.GCi,\n self.Real, self.Complex):\n i = rows[(gci[0], gci[1])]\n j = cols[(gcj[0], gcj[1])]\n dense_mat[i, j] = complex(reali, complexi)\n else:\n dense_mat = zeros((nrows, ncols), dtype='float64')\n if self.matrix_form == 6 and apply_symmetry: # symmetric\n try:\n for (gcj, gci, reali) in zip(self.GCj, self.GCi, self.Real):\n i = rows[(gci[0], gci[1])]\n j = cols[(gcj[0], gcj[1])]\n dense_mat[i, j] = reali\n dense_mat[j, i] = reali\n except IndexError:\n msg = ('name=%s ndim=%s i=%s j=%s matrix_type=%s '\n 'is_polar=%s ncols=%s M.shape=%s\\n' % (\n self.name, ndim, i, j, self.matrix_type,\n self.is_polar, self.ncols, dense_mat.shape))\n msg += 'Rows:\\n'\n for i, row in enumerate(rows):\n msg += 'i=%s row=%s\\n' % (i, row)\n raise RuntimeError(msg)\n else:\n try:\n for (gcj, gci, reali) in zip(self.GCj, self.GCi, self.Real):\n i = rows[(gci[0], gci[1])]\n j = cols[(gcj[0], gcj[1])]\n dense_mat[i, j] = reali\n except KeyError:\n msg = ('name=%s ndim=%s gci=%s gcj=%s matrix_type=%s '\n 'is_polar=%s is_sparse=%s ncols=%s M.shape=%s\\n\\n' % (\n self.name, ndim, str(gci), str(gcj), self.matrix_type,\n self.is_polar, is_sparse, self.ncols, dense_mat.shape))\n\n gci2 = (gci[0], gci[1])\n gcj2 = (gcj[0], gcj[1])\n if gci2 in rows:\n msg += 'gci/row_key=%s found\\n' % str(gci2)\n else:\n msg += 'gci/row_key=%s not found\\n' % str(gci2)\n msg += 'Rows:\\n'\n for i, row in enumerate(rows):\n msg += ' i=%s row=%s\\n' % (i, row)\n\n if gcj2 in cols:\n msg += '\\ngcj/col_key=%s found\\n' % str(gcj2)\n else:\n msg += '\\ngcj/col_key=%s not found\\n' % str(gcj2)\n msg += 'Cols:\\n'\n for j, col in enumerate(cols):\n msg += ' j=%s row=%s\\n' % (j, col)\n\n msg += '\\n'\n print(msg)\n raise KeyError(msg)\n except IndexError:\n msg = ('name=%s ndim=%s i=%s j=%s matrix_type=%s '\n 'is_polar=%s is_sparse=%s ncols=%s M.shape=%s\\n' % (\n self.name, ndim, i, j, self.matrix_type,\n self.is_polar, is_sparse, self.ncols, dense_mat.shape))\n msg += 'Rows:\\n'\n for i, row in enumerate(rows):\n msg += ' i=%s row=%s\\n' % (i, row)\n\n msg += '\\nCols:\\n'\n for j, row in enumerate(cols):\n msg += ' j=%s row=%s\\n' % (j, col)\n raise RuntimeError(msg)\n return dense_mat\n\n\ndef _fill_dense_column_matrix(self, nrows, ncols, ndim, rows, cols, apply_symmetry):\n \"\"\"helper method for get_matrix\"\"\"\n is_sparse = False\n if self.is_complex:\n dense_mat = zeros((nrows, ncols), dtype='complex128')\n if self.matrix_form == 6 and apply_symmetry: # symmetric\n assert nrows == ncols, 'nrows=%s ncols=%s' % (nrows, ncols)\n for (gcj, gci, reali, complexi) in zip(self.GCj, self.GCi,\n self.Real, self.Complex):\n i = rows[gci]\n j = cols[gcj]\n dense_mat[i, j] = complex(reali, complexi)\n dense_mat[j, i] = complex(reali, complexi)\n elif self.matrix_form == 2: # rectangular\n assert nrows == ncols, 'nrows=%s ncols=%s' % (nrows, ncols)\n for (gcj, gci, reali, complexi) in zip(self.GCj, self.GCi,\n self.Real, self.Complex):\n i = rows[gci]\n j = cols[gcj]\n dense_mat[i, j] = complex(reali, complexi)\n else:\n for (gcj, gci, reali, complexi) in zip(self.GCj, self.GCi,\n self.Real, self.Complex):\n i = rows[gci]\n j = cols[gcj]\n else:\n #print('nrows=%s ncols=%s' % (nrows, ncols))\n dense_mat = zeros((nrows, ncols), dtype='float64')\n if self.matrix_form == 6 and apply_symmetry: # symmetric\n assert nrows == ncols, 'nrows=%s ncols=%s' % (nrows, ncols)\n for (gcj, gci, reali) in zip(self.GCj, self.GCi, self.Real):\n i = rows[gci]\n j = cols[gcj]\n dense_mat[i, j] = reali\n dense_mat[j, i] = reali\n else:\n try:\n for (gcj, gci, reali) in zip(self.GCj, self.GCi, self.Real):\n i = rows[gci]\n j = cols[gcj]\n dense_mat[i, j] = reali\n except IndexError:\n msg = ('name=%s ndim=%s i=%s j=%s matrix_type=%s '\n 'is_polar=%s is_sparse=%s ncols=%s M.shape=%s\\n' % (\n self.name, ndim, i, j, self.matrix_type,\n self.is_polar, is_sparse, self.ncols, dense_mat.shape))\n msg += 'Rows:\\n'\n for i, row in enumerate(rows):\n msg += ' i=%s row=%s\\n' % (i, row)\n raise RuntimeError(msg)\n return dense_mat\n\ndef get_dmi_matrix(matrix: DMI, is_sparse: bool=False,\n apply_symmetry: bool=True) -> Tuple[np.array, None, None]:\n \"\"\"\n Builds the Matrix\n\n Parameters\n ----------\n is_sparse : bool\n should the matrix be returned as a sparse matrix (default=True).\n Slower for dense matrices.\n apply_symmetry: bool\n If the matrix is symmetric (matrix_form=6), returns a symmetric matrix.\n Supported as there are symmetric matrix routines.\n TODO: unused...\n\n Returns\n -------\n M : ndarray\n the matrix\n rows : None\n unused\n cols : None\n unused\n\n .. warning:: is_sparse=True WILL fail\n\n \"\"\"\n ifo = matrix.ifo\n GCj = array(matrix.GCj, dtype='int32') - 1\n GCi = array(matrix.GCi, dtype='int32') - 1\n\n dtype = matrix.tin_dtype\n\n if matrix.is_complex:\n data = matrix.Real + matrix.Complex * 1j\n else:\n data = matrix.Real\n\n if ifo == 2:\n # rectangular\n nrows = matrix.nrows\n ncols = matrix.ncols\n\n M = coo_matrix((data, (GCi, GCj)),\n shape=(nrows, ncols), dtype=dtype)\n if not is_sparse:\n M = M.toarray()\n\n else:\n nrows = matrix.nrows\n ncols = matrix.ncols\n if ifo == 6:\n nrows = max(nrows, ncols)\n ncols = nrows\n M = coo_matrix((data, (GCi, GCj)),\n shape=(nrows, ncols), dtype=dtype)\n if not is_sparse:\n M = M.toarray()\n #else:\n #ifo : int\n # matrix shape\n # 4=Lower Triangular\n # 5=Upper Triangular\n # 6=Symmetric\n # 8=Identity (m=nRows, n=m)\n #raise RuntimeError(matrix.get_stats())\n return M, None, None\n\ndef get_matrix(self, is_sparse=False, apply_symmetry=True):\n \"\"\"\n Builds the Matrix\n\n Parameters\n ----------\n is_sparse : bool\n should the matrix be returned as a sparse matrix (default=True).\n Slower for dense matrices.\n apply_symmetry: bool\n If the matrix is symmetric (matrix_form=6), returns a symmetric matrix.\n Supported as there are symmetric matrix routines.\n TODO: unused...\n\n Returns\n -------\n M : ndarray\n the matrix\n rows : Dict[(nid, nid)] = float\n dictionary of keys=rowID, values=(Grid,Component) for the matrix\n cols : Dict[](int, int)] = float\n dictionary of keys=columnID, values=(Grid,Component) for the matrix\n\n .. warning:: is_sparse=True WILL fail\n\n \"\"\"\n nrows, ncols, ndim, rows, cols, rows_reversed, cols_reversed = get_row_col_map(\n self, self.GCi, self.GCj, self.matrix_form)\n #print('rows = ', rows)\n #print('cols = ', cols)\n #print('i=%s j=%s' % (i, j))\n #nrows = len(rows2)\n #ncols = len(cols2)\n\n #A = ss.lil_matrix((3,3), dtype='d') # double precision\n #rows = []\n #cols = []\n #data = []\n #for i in range(3):\n #for j in range(3):\n #k = float((i+1)*(j+1))\n #rows.append(i)\n #cols.append(j)\n #data.append(k)\n #A[i,j] = k\n\n #is_sparse = False\n if is_sparse:\n M = _fill_sparse_matrix(self, nrows, ncols)\n return M\n else:\n if ndim == 1:\n M = _fill_dense_column_matrix(self, nrows, ncols, ndim, rows, cols, apply_symmetry)\n else:\n M = _fill_dense_rectangular_matrix(self, nrows, ncols, ndim, rows, cols, apply_symmetry)\n\n #print(M)\n return (M, rows_reversed, cols_reversed)\n\n\ndef _export_dmig_to_hdf5(h5_file, model, dict_obj, encoding):\n \"\"\"export dmigs, dmij, dmiji, dmik, dmi\"\"\"\n for name, dmig in dict_obj.items():\n dmig_group = h5_file.create_group(name)\n dmig_group.create_dataset('tin', data=dmig.tin)\n\n if hasattr(dmig, 'tout'):\n dmig_group.create_dataset('tout', data=dmig.tout)\n\n if dmig.type == 'DMIG' and name == 'UACCEL':\n if dmig.ncol is not None:\n dmig_group.create_dataset('ncol', data=dmig.ncol)\n #load_seq_group = dmig_group.create_group('load_sequences')\n\n nids = []\n dofs = []\n values = []\n for lseq, ncx in sorted(dmig.load_sequences.items()):\n lseq_group = dmig_group.create_group(str(lseq))\n #list_fields += [lseq, None, None]\n for (nid, dof, value) in ncx:\n nids.append(nid)\n dofs.append(int(dof))\n values.append(value)\n\n #print('nids =', nids)\n #print('dofs =', dofs)\n #print('values =', values)\n lseq_group.create_dataset('nids', data=nids)\n lseq_group.create_dataset('dofs', data=dofs)\n lseq_group.create_dataset('values', data=values)\n else:\n if hasattr(dmig, 'nrows') and dmig.nrows is not None:\n dmig_group.create_dataset('nrows', data=dmig.nrows)\n if dmig.ncols is not None:\n dmig_group.create_dataset('ncols', data=dmig.ncols)\n if hasattr(dmig, 'polar'):\n dmig_group.create_dataset('polar', data=dmig.polar)\n\n dmig_group.create_dataset('matrix_form', data=dmig.matrix_form)\n dmig_group.create_dataset('tin_dtype', data=dmig.tin_dtype)\n dmig_group.create_dataset('tout_dtype', data=dmig.tout_dtype)\n\n dmig_group.create_dataset('matrix_type', data=dmig.matrix_type)\n dmig_group.create_dataset('is_complex', data=dmig.is_complex)\n dmig_group.create_dataset('is_real', data=dmig.is_real)\n dmig_group.create_dataset('is_polar', data=dmig.is_polar)\n\n dmig_group.create_dataset('GCi', data=dmig.GCi)\n dmig_group.create_dataset('GCj', data=dmig.GCj)\n dmig_group.create_dataset('Real', data=dmig.Real)\n if hasattr(dmig, 'Complex') and dmig.Complex is not None:\n dmig_group.create_dataset('Complex', data=dmig.Complex)\n\n\ndef _export_dmiax_to_hdf5(h5_file, model, dict_obj, encoding):\n \"\"\"export dmiax\"\"\"\n for name, dmiax in dict_obj.items():\n #print(f'exporting {dmiax.type} name={name!r}')\n dmiax_group = h5_file.create_group(name)\n dmiax_group.create_dataset('tin', data=dmiax.tin)\n\n if hasattr(dmiax, 'tout'):\n dmiax_group.create_dataset('tout', data=dmiax.tout)\n\n if hasattr(dmiax, 'nrows') and dmiax.nrows is not None:\n dmiax_group.create_dataset('nrows', data=dmiax.nrows)\n if dmiax.ncols is not None:\n dmiax_group.create_dataset('ncols', data=dmiax.ncols)\n if hasattr(dmiax, 'polar'):\n dmiax_group.create_dataset('polar', data=dmiax.polar)\n\n dmiax_group.create_dataset('matrix_form', data=dmiax.matrix_form)\n dmiax_group.create_dataset('tin_dtype', data=dmiax.tin_dtype)\n dmiax_group.create_dataset('tout_dtype', data=dmiax.tout_dtype)\n\n dmiax_group.create_dataset('matrix_type', data=dmiax.matrix_type)\n dmiax_group.create_dataset('is_complex', data=dmiax.is_complex)\n dmiax_group.create_dataset('is_real', data=dmiax.is_real)\n dmiax_group.create_dataset('is_polar', data=dmiax.is_polar)\n\n gcnj = []\n j_none_flags = []\n\n gcni = []\n i_none_flags = []\n for j, GCNj in enumerate(dmiax.GCNj):\n gj, cj, nj = GCNj\n is_none_flag_j = False\n if nj is None:\n nj = 0\n is_none_flag_j = True\n j_none_flags.append(is_none_flag_j)\n gcnj.append((gj, cj, nj))\n for unused_i, GCNi in enumerate(dmiax.GCNi[j]):\n gi, ci, ni = GCNi\n is_none_flag_i = False\n if ni is None:\n ni = 0\n is_none_flag_i = True\n i_none_flags.append(is_none_flag_i)\n gcni.append((gi, ci, ni, j))\n\n dmiax_group.create_dataset('GCNi_j', data=gcni)\n dmiax_group.create_dataset('GCNj', data=gcnj)\n dmiax_group.create_dataset('i_none_flags', data=i_none_flags)\n dmiax_group.create_dataset('j_none_flags', data=j_none_flags)\n\n dmiax_group.create_dataset('Real', data=dmiax.Real)\n if hasattr(dmiax, 'Complex') and dmiax.Complex is not None:\n dmiax_group.create_dataset('Complex', data=dmiax.Complex)\n\ndef _set_polar(polar):\n if polar in [None, 0, False]:\n polar = 0\n elif polar in [1, True]:\n polar = 1\n else:\n raise ValueError('polar=%r and must be 0 or 1' % polar)\n return polar\n\ndef _get_dtype(is_complex, type_flag):\n if type_flag == 1:\n dtype = 'float32'\n elif type_flag == 2:\n dtype = 'float64'\n elif type_flag == 3:\n dtype = 'complex64'\n elif type_flag == 4:\n dtype = 'complex128'\n elif type_flag == 0:\n if is_complex:\n dtype = 'complex128'\n else:\n dtype = 'float64'\n else:\n raise RuntimeError(\"invalid option for matrix format\")\n return dtype\n\n",
"from __future__ import annotations\nfrom typing import TYPE_CHECKING\nfrom numpy import array\n\nfrom pyNastran.utils.numpy_utils import integer_types\n#from pyNastran.bdf.bdf_interface.assign_type import (integer, integer_or_blank,\n #double_or_blank, integer_double_or_blank, blank, string_or_blank)\nfrom pyNastran.bdf.bdf_interface.assign_type import integer, double_or_blank, string_or_blank, integer_or_blank\nfrom pyNastran.bdf.field_writer_8 import set_blank_if_default, print_card_8\nfrom pyNastran.bdf.field_writer import print_card\nfrom pyNastran.bdf.cards.base_card import _format_comment\nif TYPE_CHECKING: # pragma: no cover\n from pyNastran.bdf.bdf import BDF\n\n\nclass BaseCard:\n def __init__(self):\n pass\n\n @property\n def comment(self):\n if hasattr(self, '_comment'):\n return '%s' % self._comment\n return ''\n\n @comment.setter\n def comment(self, new_comment):\n \"\"\"sets a comment\"\"\"\n #comment = new_comment.rstrip()\n #self._comment = comment + '\\n' if comment else ''\n self._comment = _format_comment(new_comment)\n\n def print_card(self, size=8):\n list_fields = self.repr_fields()\n return self.comment + print_card(list_fields, size=size)\n\n\n def __repr__(self):\n \"\"\"\n Prints a card in the simplest way possible\n (default values are left blank).\n \"\"\"\n try:\n return self.print_card()\n except:\n print('problem printing %s card' % self.type)\n fields = self.repr_fields()\n print(\"fields = \", fields)\n raise\n\n\nclass Property_i(BaseCard):\n def __init__(self):\n pass\n\n def Pid(self):\n \"\"\"\n returns the property ID of an property\n\n Returns\n -------\n pid : int\n the Property ID\n \"\"\"\n return self.pid\n\n def Mid(self):\n \"\"\"\n returns the material ID of an element\n\n Returns\n -------\n mid : int\n the Material ID\n \"\"\"\n if isinstance(self.mid, integer_types):\n return self.mid\n else:\n return self.mid_ref.mid\n\n def cross_reference(self, model: BDF) -> None:\n \"\"\"\n Cross links the card so referenced cards can be extracted directly\n\n Parameters\n ----------\n model : BDF()\n the BDF object\n \"\"\"\n msg = ' which is required by %s pid=%s' % (self.type, self.pid)\n self.mid = model.Material(self.mid, msg)\n self.mid_ref = self.mid\n\n def uncross_reference(self) -> None:\n self.mid = self.Mid()\n del self.mid_ref\n\n\nclass ShellProperty(Property_i):\n def __init__(self):\n Property_i.__init__(self)\n\nclass DeprecatedCompositeShellProperty:\n def MassPerArea(self, iply='all', method='nplies'):\n return self.get_mass_per_area(iply, method)\n\n def Thickness(self, iply='all'):\n return self.get_thickness(iply)\n\n def nPlies(self):\n return self.nplies\n\n def Nsm(self):\n return self.get_nonstructural_mass()\n\n def Rho(self, iply):\n return self.get_density(iply)\n\n def Theta(self, iply):\n return self.get_theta(iply)\n\n def sout(self, iply):\n return self.get_sout(iply)\n\n\nclass CompositeShellProperty(ShellProperty, DeprecatedCompositeShellProperty):\n def __init__(self):\n ShellProperty.__init__(self)\n self.nsm = 0.0\n\n def is_symmetrical(self):\n \"\"\"\n Is the laminate symmetrical?\n\n :returns; True or False\n \"\"\"\n if self.lam == 'SYM':\n return True\n return False\n\n def _adjust_ply_id(self, iply):\n \"\"\"\n Gets the ply ID that's stored in **self.plies**.\n\n When a ply is not symmetric, this function returns the input iply.\n When a ply is symmetrical and the iply value is greater than the\n number of plies, we return the mirrored ply. For the case of a\n symmetrical ply, the element will always have an even number of\n layers.\n\n Parameters\n ----------\n iply : int\n the ply ID\n\n Raises\n ------\n - IndexError if iply is invalid\n\n ::\n\n Case 1 (nplies=6, len(plies)=3, lam='SYM'):\n ply 2\n ply 1\n ply 0\n ------- sym\n ply 0 / 3\n ply 1 / 4\n ply 2 / 5\n Ask for ply 3, return ply 0\n Ask for ply 4, return ply 1\n Ask for ply 5, return ply 2\n\n Case 2 (nplies=5, len(plies)=5, lam='NO'):\n ply 5\n ply 4\n ply 3\n ply 1\n ply 0\n Ask for ply 3, return ply 1\n Ask for ply 4, return ply 2\n \"\"\"\n if iply == 'all':\n return iply\n\n nplies = len(self.plies)\n if iply >= nplies:\n if iply < self.nplies:\n iply = iply - nplies\n else:\n raise IndexError('invalid value for iply=%r' % iply)\n elif iply < 0:\n raise IndexError('invalid value for iply=%r' % iply)\n return iply\n\n def get_thickness(self, iply='all'):\n \"\"\"\n Gets the thickness of the :math:`i^{th}` ply.\n\n Parameters\n ----------\n iply : int/str; default='all'\n the string **'all'** (default) or the mass per area of\n the :math:`i^{th}` ply\n\n Returns\n -------\n thickness : float\n the thickness of the ply or plies\n \"\"\"\n nplies = len(self.plies)\n if iply == 'all': # get all layers\n t = 0.\n for iply in range(nplies):\n t += self.get_thickness(iply)\n\n if self.is_symmetrical:\n return t * 2.\n return t\n else:\n iply = self._adjust_ply_id(iply)\n t = self.plies[iply][1]\n return t\n\n @property\n def nplies(self):\n r\"\"\"\n Gets the number of plies including the core.\n\n ::\n\n if Lam=SYM:\n returns nplies*2 (even)\n else:\n returns nplies\n \"\"\"\n nplies = len(self.plies)\n if self.is_symmetrical:\n return nplies * 2\n return nplies\n\n def get_nonstructural_mass(self):\n \"\"\"\n Gets the non-structural mass :math:`i^{th}` ply\n \"\"\"\n return self.nsm\n\n def Mid(self, iply):\n \"\"\"\n Gets the Material ID of the :math:`i^{th}` ply.\n\n Parameters\n ----------\n iply : int\n the ply ID (starts from 0)\n\n Returns\n -------\n material_id : int\n the material id of the ith ply\n \"\"\"\n iply = self._adjust_ply_id(iply)\n Mid = self.Material(iply)\n if isinstance(Mid, integer_types):\n return Mid\n return Mid.mid\n\n def get_material_ids(self):\n return self.Mids()\n\n def Mids(self):\n \"\"\"\n Gets the material IDs of all the plies\n\n Returns\n -------\n mids : MATx\n the material IDs\n \"\"\"\n mids = []\n for iply in range(self.nplies):\n mids.append(self.Mid(iply))\n #theta = self.get_theta(iply)\n #sout = self.get_sout(iply)\n return mids\n\n def get_density(self, iply):\n \"\"\"\n Gets the density of the :math:`i^{th}` ply\n\n Parameters\n ----------\n iply : int\n the ply ID (starts from 0)\n \"\"\"\n iply = self._adjust_ply_id(iply)\n mid = self.Material(iply)\n #print(\"rho =\", mid.rho)\n return mid.rho\n\n def Material(self, iply):\n \"\"\"\n Gets the material of the :math:`i^{th}` ply (not the ID unless\n it is not cross-referenced).\n\n Parameters\n ----------\n iply : int\n the ply ID (starts from 0)\n \"\"\"\n iply = self._adjust_ply_id(iply)\n Mid = self.plies[iply][0]\n return Mid\n\n def get_theta(self, iply):\n \"\"\"\n Gets the ply angle of the :math:`i^{th}` ply (not the ID)\n\n Parameters\n ----------\n iply : int\n the ply ID (starts from 0)\n \"\"\"\n iply = self._adjust_ply_id(iply)\n Theta = self.plies[iply][2]\n return Theta\n\n def get_sout(self, iply):\n \"\"\"\n Gets the the flag identifying stress/strain outpur of the\n :math:`i^{th}` ply (not the ID). default='NO'.\n\n Parameters\n ----------\n iply : int\n the ply ID (starts from 0)\n \"\"\"\n iply = self._adjust_ply_id(iply)\n sout = self.plies[iply][3]\n return sout\n\n def get_z_locations(self):\n \"\"\"\n Gets the z locations for the various plies.\n\n Parameters\n ----------\n iply : int\n the ply ID (starts from 0)\n\n Assume there are 2 plies, each of 1.0 thick, starting from :math:`z=0`.\n\n >>> pcomp.get_z_locations()\n [0., 1., 2.]\n \"\"\"\n zi = self.z0\n z = [zi]\n for i in range(self.nplies):\n t = self.get_thickness(i)\n zi += t\n z.append(zi)\n return array(z)\n\n def get_mass_per_area(self, iply='all', method='nplies'):\n r\"\"\"\n Gets the Mass/Area for the property.\n\n .. math:: \\frac{m}{A} = \\sum(\\rho t) + nsm\n\n or\n\n .. math:: \\frac{m}{A} - nsm = \\sum(\\rho t)\n\n and\n\n .. math:: \\frac{m_i}{A} = rho_i t_i + nsm_i\n\n where :math:`nsm_i` is the non-structural mass of the\n :math:`i^{th}` ply\n\n :param iply: the string 'all' (default) or the mass per area of\n the :math:`i^{th}` ply\n :param method: the method to compute MassPerArea\n\n * **Case 1 (iply = all)**\n\n method has no effect because the total nsm is defined\n\n * **Case 2 (iply != all)**\n\n method **'nplies'** smear the nsm based on :math:`n_{plies}` (default)\n\n :math:`nsm_i = nsm / n_{plies}` # smear based on nplies\n\n * **Case 3 (iply != all)**\n\n method **'rho*t'** smear the nsm based on the mass distribution\n\n .. math:: nsm_i = \\rho_i t_i \\frac{nsm}{\\sum(\\rho_i t_i)}\n\n .. math:: nsm_i = \\rho_i t_i \\frac{nsm}{\\frac{m}{A} - nsm}\n\n * **Case 4 (iply != all)**\n\n method **'t'** smear the nsm based on the thickness distribution\n\n .. math:: nsm_i = t_i \\frac{nsm}{\\sum(t_i)}\n\n .. note:: final mass calculation will be done later\n \"\"\"\n rhos = [ply[0].get_density() for ply in self.plies]\n return self.get_mass_per_area_rho(rhos, iply, method)\n\n def get_mass_per_area_rho(self, rhos, iply='all', method='nplies'):\n r\"\"\"\n Gets the Mass/Area for the property.\n\n .. math:: \\frac{m}{A} = \\sum(\\rho t) + nsm\n\n or\n\n .. math:: \\frac{m}{A} - nsm = \\sum(\\rho t)\n\n and\n\n .. math:: \\frac{m_i}{A} = rho_i t_i + nsm_i\n\n where :math:`nsm_i` is the non-structural mass of the\n :math:`i^{th}` ply\n\n :param iply: the string 'all' (default) or the mass per area of\n the :math:`i^{th}` ply\n :param method: the method to compute MassPerArea\n\n * **Case 1 (iply = all)**\n\n method has no effect because the total nsm is defined\n\n * **Case 2 (iply != all)**\n\n method **'nplies'** smear the nsm based on :math:`n_{plies}` (default)\n\n :math:`nsm_i = nsm / n_{plies}` # smear based on nplies\n\n * **Case 3 (iply != all)**\n\n method **'rho*t'** smear the nsm based on the mass distribution\n\n .. math:: nsm_i = \\rho_i t_i \\frac{nsm}{\\sum(\\rho_i t_i)}\n\n .. math:: nsm_i = \\rho_i t_i \\frac{nsm}{\\frac{m}{A} - nsm}\n\n * **Case 4 (iply != all)**\n\n method **'t'** smear the nsm based on the thickness distribution\n\n .. math:: nsm_i = t_i \\frac{nsm}{\\sum(t_i)}\n\n .. note:: final mass calculation will be done later\n \"\"\"\n assert method in ['nplies', 'rho*t', 't'], 'method=%r is invalid' % method\n nplies = len(self.plies)\n iply = self._adjust_ply_id(iply)\n if iply == 'all': # get all layers\n #mass_per_area_total = m/A = sum(rho*t) + nsm\n #mass_per_area_total = mpa-nsm = sum(rho*t)\n #(m/A)i = rho*t + nsmi\n # where nsmi has two methods\n mass_per_area = 0.\n nplies = len(self.plies)\n for iply in range(nplies):\n #rho = self.get_density(iply)\n rho = rhos[iply]\n t = self.plies[iply][1]\n mass_per_area += rho * t\n\n if self.is_symmetrical:\n return 2. * mass_per_area + self.nsm\n return mass_per_area + self.nsm\n else:\n assert isinstance(iply, int), 'iply must be an integer; iply=%r' % iply\n #rho = self.get_density(iply)\n rho = rhos[iply]\n t = self.plies[iply][1]\n\n if method == 'nplies':\n # we divide by nplies b/c it's nsm per area and\n # we're working on a per ply basis\n # nsmi = nsmi/n # smear based on nplies\n mass_per_area = rho * t + self.nsm / self.nplies\n elif method == 'rho*t':\n # assume you smear the nsm mass based on rho*t distribution\n #nsmi = rho*t / sum(rho*t) * nsm\n #rho*t + nsmi = rho*t + rho*t/(sum(rho*t) + nsm - nsm) * nsm\n #rho*t + nsmi = rho*t + rho*t/(mass_per_area_total - nsm) * nsm\n # = rho*t * (1 + nsm/(mass_per_area_total-nsm))\n mass_per_area_total = self.get_mass_per_area_rho(rhos, iply='all', method='nplies')\n mass_per_area = rho * t * (1.0 + self.nsm / (mass_per_area_total - self.nsm))\n elif method == 't':\n # assume you smear the nsm mass based on t distribution\n #nsmi = t / sum(t) * nsm\n #rho*t + nsmi = rho*t + t/sum(t) * nsm\n #rho*t + nsmi = rho*t + t/thickness_total * nsm\n # = t * (rho + nsm/thickness_total)\n thickness_total = self.get_thickness()\n mass_per_area = t * (rho + self.nsm / thickness_total)\n else:\n raise NotImplementedError('method=%r is not supported' % method)\n return mass_per_area\n\n\nclass PCOMPi(CompositeShellProperty):\n \"\"\"\n +-------+--------+--------+---------+------+--------+--------+-------+------+\n | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |\n +=======+========+========+=========+======+========+========+=======+======+\n | PCOMP | PID | Z0 | NSM | SB | FT | TREF | GE | LAM |\n +-------+--------+--------+---------+------+--------+--------+-------+------+\n | MID1 | T1 | THETA1 | SOUT1 | MID2 | T2 | THETA2 | SOUT2 | |\n +-------+--------+--------+---------+------+--------+--------+-------+------+\n | MID3 | T3 | THETA3 | SOUT3 | etc. | | | | |\n +-------+--------+--------+---------+------+--------+--------+-------+------+\n\n +-------+--------+--------+---------+------+--------+--------+-------+------+\n | PCOMP | 701512 | 0.0+0 | 1.549-2 | | | 0.0+0 | 0.0+0 | SYM |\n +-------+--------+--------+---------+------+--------+--------+-------+------+\n | | 300704 | 3.7-2 | 0.0+0 | YES | 300704 | 3.7-2 | 45. | YES |\n +-------+--------+--------+---------+------+--------+--------+-------+------+\n | | 300704 | 3.7-2 | -45. | YES | 300704 | 3.7-2 | 90. | YES |\n +-------+--------+--------+---------+------+--------+--------+-------+------+\n | | 300705 | .5 | 0.0+0 | YES | | | | |\n +-------+--------+--------+---------+------+--------+--------+-------+------+\n \"\"\"\n type = 'PCOMP'\n\n def __init__(self, card=None, data=None, comment=''): # not done, cleanup\n ShellProperty.__init__(self, card, data)\n\n @property\n def plies(self):\n plies = []\n for mid, t, theta, sout in zip(self.mids, self.thicknesses, self.thetas, self.souts):\n plies.append([mid, t, theta, sout])\n return plies\n\n def __init__(self, pid,\n mids, thicknesses, thetas, souts,\n nsm, sb, ft, tref, ge, lam, z0, comment=''):\n CompositeShellProperty.__init__(self)\n if comment:\n self.comment = comment\n\n #: Property ID\n self.pid = pid\n\n #: Non-Structural Mass per unit Area\n self.nsm = nsm\n self.sb = sb\n\n #: Failure Theory\n #:\n #: ['HILL', 'HOFF', 'TSAI', 'STRN', None]\n self.ft = ft\n\n #: Reference Temperature (default=0.0)\n self.tref = tref\n self.ge = ge\n\n #: symmetric flag - default = No Symmetry (NO)\n #if lam is None: # TODO: is NO an option?\n #lam = 'NO'\n self.lam = lam\n self.mids = mids\n self.thicknesses = thicknesses\n self.thetas = thetas\n self.souts = souts\n if z0 is None:\n z0 = -0.5 * self.Thickness()\n self.z0 = z0\n\n assert self.ft in ['HILL', 'HOFF', 'TSAI', 'STRN', 0.0, None], 'ft=%r' % self.ft\n # TODO: is NO an option?\n assert self.lam in [None, 'SYM', 'MEM', 'BEND', 'SMEAR', 'SMCORE'], 'lam=%r is invalid' % self.lam\n\n @classmethod\n def add_card(cls, card, comment=''):\n pid = integer(card, 1, 'pid')\n\n # z0 is field 2 and is calculated at the end because we need the\n # thickness first\n #self.z0 = double_or_blank(card, 1, 'pid')\n\n nsm = double_or_blank(card, 3, 'nsm', 0.0)\n sb = double_or_blank(card, 4, 'sb', 0.0)\n ft = string_or_blank(card, 5, 'ft')\n tref = double_or_blank(card, 6, 'tref', 0.0)\n ge = double_or_blank(card, 7, 'ge', 0.0)\n lam = string_or_blank(card, 8, 'lam') # default=blank -> nothing\n\n # -8 for the first 8 fields (1st line)\n nply_fields = card.nfields - 9\n\n # counting plies\n nmajor = nply_fields // 4\n nleftover = nply_fields % 4\n if nleftover:\n nmajor += 1\n nplies = nmajor\n\n mid_last = None\n thick_last = None\n ply = None\n iply = 1\n\n # supports single ply per line\n mids = []\n thicknesses = []\n thetas = []\n souts = []\n for i in range(9, 9 + nplies * 4, 4):\n actual = card.fields(i, i + 4)\n mid = integer_or_blank(card, i, 'mid', mid_last)\n t = double_or_blank(card, i + 1, 't', thick_last)\n theta = double_or_blank(card, i + 2, 'theta', 0.0)\n sout = string_or_blank(card, i + 3, 'sout', 'NO')\n\n if t <= 0.:\n msg = ('thickness of PCOMP layer is invalid pid=%s'\n ' iLayer=%s t=%s ply=[mid,t,theta,'\n 'sout]=%s' % (pid, iply, t, ply))\n raise RuntimeError(msg)\n\n # if this card has 2 plies on the line\n if actual != [None, None, None, None]:\n mids.append(mid)\n thicknesses.append(t)\n thetas.append(theta)\n souts.append(sout)\n iply += 1\n mid_last = mid\n thick_last = t\n #print(\"nplies = \",nplies)\n\n #self.plies = []\n #if self.lam == 'SYM':\n # if nplies%2 == 1: # 0th layer is the core layer\n # # cut the thickness in half to make the ply have an\n # # even number of plies, is there a better way???\n # plies[0][1] = plies[0][1]/2.\n #\n # pliesLower = plies.reverse()\n # self.plies = pliesLower+plies\n # #print str(self)\n z0 = double_or_blank(card, 2, 'z0')\n return PCOMPi(pid, mids, thicknesses, thetas, souts, nsm, sb, ft, tref, ge,\n lam, z0, comment=comment)\n\n def update(self, pid_map, mid_map):\n \"\"\"\n maps = {\n 'node' : nid_map,\n 'property' : pid_map,\n }\n \"\"\"\n pid2 = pid_map[self.pid]\n mids2 = [mid_map[mid] if mid != 0 else 0 for mid in self.mids]\n self.pid = pid2\n self.mids = mids2\n\n @classmethod\n def add_op2_data(cls, data, comment=''):\n #data_in = [\n #pid, z0, nsm, sb, ft, Tref, ge,\n #is_symmetrical, Mid, T, Theta, Sout]\n pid = data[0]\n z0 = data[1]\n nsm = data[2]\n sb = data[3]\n ft = data[4]\n tref = data[5]\n ge = data[6]\n lam = data[7]\n Mid = data[8]\n T = data[9]\n Theta = data[10]\n Sout = data[11]\n\n if lam == 'NO':\n lam = None\n\n #ply = [mid,t,theta,sout]\n mids = []\n thicknesses = []\n thetas = []\n souts = []\n for (mid, t, theta, sout) in zip(Mid, T, Theta, Sout):\n if sout == 0:\n sout = 'NO'\n elif sout == 1:\n sout = 'YES'\n #elif sout == 2: #: .. todo:: what?!!\n #sout = 'YES'\n #elif sout == 3: #: .. todo:: what?!!\n #sout = 'YES'\n else:\n raise RuntimeError('unsupported sout. sout=%r and must be 0 or 1.'\n '\\nPCOMP = %s' % (sout, data))\n mids.append(mid)\n thicknesses.append(t)\n thetas.append(theta)\n souts.append(sout)\n if ft == 0:\n ft = None\n elif ft == 1:\n ft = 'HILL'\n elif ft == 2:\n ft = 'HOFF'\n elif ft == 3:\n ft = 'TSAI'\n elif ft == 4:\n ft = 'STRN'\n else:\n raise RuntimeError('unsupported ft. pid=%s ft=%r.'\n '\\nPCOMP = %s' % (pid, ft, data))\n return PCOMPi(pid, mids, thicknesses, thetas, souts,\n nsm, sb, ft, tref, ge, lam, z0, comment=comment)\n\n def raw_fields(self):\n list_fields = ['PCOMP', self.pid, self.z0, self.nsm, self.sb, self.ft,\n self.tref, self.ge, self.lam, ]\n for (iply, ply) in enumerate(self.plies):\n (_mid, t, theta, sout) = ply\n mid = self.Mid(iply)\n list_fields += [mid, t, theta, sout]\n return list_fields\n\n def repr_fields(self):\n nsm = set_blank_if_default(self.nsm, 0.0)\n sb = set_blank_if_default(self.sb, 0.0)\n tref = set_blank_if_default(self.tref, 0.0)\n ge = set_blank_if_default(self.ge, 0.0)\n z0 = set_blank_if_default(self.z0, -0.5 * self.get_thickness())\n\n list_fields = ['PCOMP', self.pid, z0, nsm, sb, self.ft, tref, ge, self.lam]\n for (iply, ply) in enumerate(self.plies):\n (_mid, t, theta, sout) = ply\n mid = self.Mid(iply)\n #theta = set_blank_if_default(theta,0.0)\n sout = set_blank_if_default(sout, 'NO')\n list_fields += [mid, t, theta, sout]\n return list_fields\n\n def write_card(self, size: int=8, is_double: bool=False) -> str:\n card = self.repr_fields()\n return self.comment + print_card_8(card)\n\n\n",
"from itertools import count\nfrom typing import List\n\nimport numpy as np\nfrom numpy import zeros, searchsorted, ravel\n\nfrom pyNastran.utils.numpy_utils import integer_types\nfrom pyNastran.op2.tables.oes_stressStrain.real.oes_objects import OES_Object\nfrom pyNastran.f06.f06_formatting import write_floats_13e, _eigenvalue_header\n\n\nclass RealBush1DStressArray(OES_Object):\n def __init__(self, data_code, is_sort1, isubcase, dt):\n OES_Object.__init__(self, data_code, isubcase, apply_data_code=True)\n #self.code = [self.format_code, self.sort_code, self.s_code]\n #self.ntimes = 0 # or frequency/mode\n #self.ntotal = 0\n self.ielement = 0\n self.nelements = 0 # result specific\n\n @property\n def is_stress(self) -> bool:\n return True\n\n @property\n def is_real(self) -> bool:\n return True\n\n @property\n def is_complex(self) -> bool:\n return False\n\n @property\n def nnodes_per_elements(self) -> int:\n if self.element_type == 40:\n nnodes_per_element = 1\n else:\n raise NotImplementedError(self.element_type)\n return nnodes_per_element\n\n def _reset_indices(self):\n self.itotal = 0\n self.ielement = 0\n\n def _get_msgs(self):\n words = [\n #' ELEMENT-ID = 104'\n ' S T R E S S E S ( F O R C E S ) I N B U S H 1 D E L E M E N T S ( C B U S H 1 D )\\n',\n ' \\n',\n ' AXIAL AXIAL AXIAL AXIAL AXIAL PLASTIC\\n',\n ' TIME FORCE DISPLACEMENT VELOCITY STRESS STRAIN STRAIN STATUS\\n',\n #' 2.000000E-02 1.960396E+01 1.960396E-04 1.940792E-02 1.960396E+01 1.960396E-04 0.000000E+00 \\n',\n ]\n return words\n # raise NotImplementedError('%s needs to implement _get_msgs' % self.__class__.__name__)\n\n def get_headers(self) -> List[str]:\n headers = ['element_force', 'axial_displacement', 'axial_velocity',\n 'axial_stress', 'axial_strain', 'plastic_strain']\n return headers\n\n def build(self):\n \"\"\"sizes the vectorized attributes of the RealBush1DStressArray\"\"\"\n #print(\"self.ielement =\", self.ielement)\n #print('ntimes=%s nelements=%s ntotal=%s' % (self.ntimes, self.nelements, self.ntotal))\n\n assert self.ntimes > 0, 'ntimes=%s' % self.ntimes\n assert self.nelements > 0, 'nelements=%s' % self.nelements\n assert self.ntotal > 0, 'ntotal=%s' % self.ntotal\n\n self.itime = 0\n self.ielement = 0\n self.itotal = 0\n #self.ntimes = 0\n #self.nelements = 0\n self.is_built = True\n\n #print(\"***name=%s type=%s nnodes_per_element=%s ntimes=%s nelements=%s ntotal=%s\" % (\n #self.element_name, self.element_type, nnodes_per_element, self.ntimes, self.nelements,\n #self.ntotal))\n dtype = 'float32'\n if isinstance(self.nonlinear_factor, integer_types):\n dtype = 'int32'\n self._times = zeros(self.ntimes, dtype=dtype)\n self.element = zeros(self.ntotal, dtype='int32')\n self.is_failed = zeros((self.ntimes, self.ntotal, 1), dtype='int32')\n\n # [element_force, axial_displacement, axial_velocity, axial_stress, axial_strain, plastic_strain, is_failed]\n self.data = zeros((self.ntimes, self.ntotal, 6), dtype='float32')\n\n def build_dataframe(self):\n \"\"\"creates a pandas dataframe\"\"\"\n import pandas as pd\n headers = self.get_headers()\n if self.nonlinear_factor not in (None, np.nan):\n # Time 0.02 0.04 0.06\n # ElementID Item\n #104 element_force 38.633198 113.462921 220.903046\n # axial_displacement 0.000194 0.000761 0.001673\n # axial_velocity 0.019220 0.037323 0.053638\n # axial_stress NaN NaN NaN\n # axial_strain NaN NaN NaN\n # plastic_strain 0.000000 0.000000 0.000000\n column_names, column_values = self._build_dataframe_transient_header()\n data_frame = self._build_pandas_transient_elements(\n column_values, column_names,\n headers, self.element, self.data)\n else:\n #Static element_force axial_displacement axial_velocity axial_stress axial_strain plastic_strain\n #ElementID\n #17801 1.0 0.1 0.0 0.0 0.0 0.0\n #17807 1.0 0.1 0.0 0.0 0.0 0.0\n data_frame = pd.DataFrame(self.data[0], columns=headers, index=self.element)\n data_frame.index.name = 'ElementID'\n data_frame.columns.names = ['Static']\n self.data_frame = data_frame\n\n def __eq__(self, table): # pragma: no cover\n assert self.is_sort1 == table.is_sort1\n self._eq_header(table)\n\n i = 0\n if not np.array_equal(self.data, table.data):\n msg = 'table_name=%r class_name=%s\\n' % (self.table_name, self.__class__.__name__)\n msg += '%s\\n' % str(self.code_information())\n ntimes = self.data.shape[0]\n\n if self.is_sort1:\n for itime in range(ntimes):\n for ieid, eid, in enumerate(self.element):\n t1 = self.data[itime, ieid, :]\n t2 = table.data[itime, ieid, :]\n #i_not_nan = np.isnp.where(t1 != np.nan)[0]\n i_not_nan = np.isfinite(t1)\n (axial_stress1, equiv_stress1, total_strain1, eff_plastic_creep_strain1, eff_creep_strain1, linear_torsional_stress1) = t1\n (axial_stress2, equiv_stress2, total_strain2, eff_plastic_creep_strain2, eff_creep_strain2, linear_torsional_stress2) = t2\n if not np.allclose(t1[i_not_nan], t2[i_not_nan]):\n #if not np.array_equal(t1, t2):\n msg += '%s\\n (%s, %s, %s, %s, %s, %s)\\n (%s, %s, %s, %s, %s, %s)\\n' % (\n eid,\n axial_stress1, equiv_stress1, total_strain1, eff_plastic_creep_strain1, eff_creep_strain1, linear_torsional_stress1,\n axial_stress2, equiv_stress2, total_strain2, eff_plastic_creep_strain2, eff_creep_strain2, linear_torsional_stress2)\n i += 1\n if i > 10:\n print(msg)\n raise ValueError(msg)\n else:\n raise NotImplementedError(self.is_sort2)\n if i > 0:\n print(msg)\n raise ValueError(msg)\n return True\n\n def add_sort1(self, dt, eid, element_force, axial_displacement, axial_velocity,\n axial_stress, axial_strain, plastic_strain, is_failed):\n \"\"\"unvectorized method for adding SORT1 transient data\"\"\"\n assert isinstance(eid, integer_types) and eid > 0, 'dt=%s eid=%s' % (dt, eid)\n # pyNastran_examples\\move_tpl\\ar29scb1.op2\n #print('dt=%s eid=%s force=%s' % (dt, eid, element_force))\n #print('element.shape=%s' % self.element.shape)\n #print('data.shape=%s' % str(self.data.shape))\n #print('times.shape=%s' % self._times.shape)\n #print('itime=%s ielement=%s itotal=%s' % (self.itime, self.itotal, self.ielement))\n self._times[self.itime] = dt\n self.element[self.itotal] = eid\n self.is_failed[self.itime, self.itotal, 0] = is_failed\n self.data[self.itime, self.itotal, :] = [\n element_force, axial_displacement, axial_velocity,\n axial_stress, axial_strain, plastic_strain]\n self.itotal += 1\n self.ielement += 1\n\n def get_stats(self, short=False) -> List[str]:\n if not self.is_built:\n return ['<%s>\\n' % self.__class__.__name__,\n ' ntimes: %i\\n' % self.ntimes,\n ' ntotal: %i\\n' % self.ntotal,\n ]\n\n nelements = self.ntotal\n ntimes = self.ntimes\n #ntotal = self.ntotal\n nelements = self.ntotal\n\n msg = []\n if self.nonlinear_factor not in (None, np.nan): # transient\n msg.append(' type=%s ntimes=%i nelements=%i\\n'\n % (self.__class__.__name__, ntimes, nelements))\n ntimes_word = 'ntimes'\n else:\n msg.append(' type=%s nelements=%i\\n'\n % (self.__class__.__name__, nelements))\n ntimes_word = '1'\n headers = self.get_headers()\n\n n = len(headers)\n assert n == self.data.shape[2], 'nheaders=%s shape=%s' % (n, str(self.data.shape))\n msg.append(' data: [%s, ntotal, %i] where %i=[%s]\\n' % (ntimes_word, n, n, str(', '.join(headers))))\n msg.append(' element.shape = %s\\n' % str(self.element.shape).replace('L', ''))\n msg.append(' is_failed.shape = %s\\n' % str(self.is_failed.shape).replace('L', ''))\n msg.append(' data.shape = %s\\n' % str(self.data.shape).replace('L', ''))\n msg.append(' element type: %s\\n' % self.element_name)\n msg += self.get_data_code()\n return msg\n\n def get_element_index(self, eids):\n # elements are always sorted; nodes are not\n itot = searchsorted(eids, self.element) #[0]\n return itot\n\n def eid_to_element_node_index(self, eids):\n ind = ravel([searchsorted(self.element == eid) for eid in eids])\n return ind\n\n def write_f06(self, f06_file, header=None, page_stamp='PAGE %s',\n page_num=1, is_mag_phase=False, is_sort1=True):\n if header is None:\n header = []\n msg = self._get_msgs()\n ntimes = self.data.shape[0]\n eids = self.element\n for itime in range(ntimes):\n dt = self._times[itime]\n header = _eigenvalue_header(self, header, itime, ntimes, dt)\n f06_file.write(''.join(header + msg))\n\n #[element_force, axial_displacement, axial_velocity, axial_stress, axial_strain, plastic_strain, is_failed]\n element_force = self.data[itime, :, 0]\n axial_displacement = self.data[itime, :, 1]\n axial_velocity = self.data[itime, :, 2]\n axial_stress = self.data[itime, :, 3]\n axial_strain = self.data[itime, :, 4]\n plastic_strain = self.data[itime, :, 5]\n is_failed = self.is_failed[itime, :, 0]\n\n for (i, eid, element_forcei, axial_displacementi, axial_velocityi, axial_stressi,\n axial_straini, plastic_straini, is_failedi) in zip(\n count(), eids, element_force, axial_displacement, axial_velocity,\n axial_stress, axial_strain, plastic_strain, is_failed):\n\n vals = [element_forcei, axial_displacementi, axial_velocityi, axial_stressi,\n axial_straini, plastic_straini, is_failedi]\n vals2 = write_floats_13e(vals)\n [element_forcei, axial_displacementi, axial_velocityi, axial_stressi,\n axial_straini, plastic_straini, is_failedi] = vals2\n f06_file.write(\n '0%8i %-13s %-13s %-13s %-13s %-13s %-13s %s\\n'\n % (eid, element_forcei, axial_displacementi, axial_velocityi, axial_stressi,\n axial_straini, plastic_straini, is_failedi))\n f06_file.write(page_stamp % page_num)\n page_num += 1\n if self.nonlinear_factor in (None, np.nan):\n page_num -= 1\n return page_num\n"
] | [
[
"numpy.hstack",
"numpy.unique"
],
[
"scipy.sparse.coo_matrix",
"numpy.array",
"numpy.asarray",
"numpy.zeros",
"numpy.where",
"numpy.argsort",
"numpy.unique"
],
[
"numpy.array"
],
[
"numpy.array_equal",
"numpy.zeros",
"pandas.DataFrame",
"numpy.allclose",
"numpy.isfinite",
"numpy.searchsorted"
]
] |
hengwei-chan/molecular_attention_transformer | [
"29193d4155df528e3a6a0c1e0da39111d0b8db93"
] | [
"soltrannet/__init__.py"
] | [
"from .predict import predict \nimport argparse\nimport sys, multiprocessing\nimport torch\n\ndef _parse_args():\n parser=argparse.ArgumentParser(description=\"Run SolTranNet aqueous solubility predictor\")\n parser.add_argument('input',nargs='?',type=argparse.FileType('r'),default=sys.stdin,help='PATH to the file containing the SMILES you wish to use. Assumes the content is 1 SMILE per line.')\n parser.add_argument('output',nargs='?',type=argparse.FileType('w'),default=sys.stdout,help='Name of the output file. Defaults to stdout.')\n parser.add_argument('--batchsize',default=32,type=int,help='Batch size for the data loader. Defaults to 32.')\n parser.add_argument('--cpus',default=multiprocessing.cpu_count(),type=int,help='Number of CPU cores to use for the data loader. Defaults to use all available cores. Pass 0 to only run on 1 CPU.')\n parser.add_argument('--cpu_predict',action='store_true',help='Flag to force the predictions to be made on only the CPU. Default behavior is to use GPU if available.')\n\n args=parser.parse_args()\n\n return args\n\ndef _run(args):\n\n smiles=[x.rstrip() for x in args.input]\n if args.cpu_predict:\n predictions=predict(smiles,batch_size=args.batchsize,num_workers=args.cpus,device=torch.device('cpu'))\n else:\n predictions=predict(smiles,batch_size=args.batchsize,num_workers=args.cpus)\n for pred, smi, warn in predictions:\n args.output.write(f'{smi},{pred:.3f},{warn}\\n')\n\n"
] | [
[
"torch.device"
]
] |
adibellathur/garage | [
"482a26a07d46091f878c41b582f1478588e397ff"
] | [
"src/garage/torch/algos/_utils.py"
] | [
"\"\"\"Utility functions used by PyTorch algorithms.\"\"\"\nimport torch\nimport torch.nn.functional as F\n\n\nclass _Default: # pylint: disable=too-few-public-methods\n \"\"\"A wrapper class to represent default arguments.\n\n Args:\n val (object): Argument value.\n\n \"\"\"\n\n def __init__(self, val):\n self.val = val\n\n\ndef make_optimizer(optimizer_type, module, **kwargs):\n \"\"\"Create an optimizer for PyTorch algos.\n\n Args:\n optimizer_type (Union[type, tuple[type, dict]]): Type of optimizer.\n This can be an optimizer type such as 'torch.optim.Adam' or a\n tuple of type and dictionary, where dictionary contains arguments\n to initialize the optimizer e.g. (torch.optim.Adam, {'lr' = 1e-3})\n module (torch.nn.Module): The module whose parameters needs to be\n optimized.\n kwargs (dict): Other keyword arguments to initialize optimizer. This\n is not used when `optimizer_type` is tuple.\n\n Returns:\n torch.optim.Optimizer: Constructed optimizer.\n\n Raises:\n ValueError: Raises value error when `optimizer_type` is tuple, and\n non-default argument is passed in `kwargs`.\n\n \"\"\"\n if isinstance(optimizer_type, tuple):\n opt_type, opt_args = optimizer_type\n for name, arg in kwargs.items():\n if not isinstance(arg, _Default):\n raise ValueError('Should not specify {} and explicit \\\n optimizer args at the same time'.format(name))\n return opt_type(module.parameters(), **opt_args)\n\n opt_args = {}\n for name, arg in kwargs.items():\n if isinstance(arg, _Default):\n opt_args[name] = arg.val\n else:\n opt_args[name] = arg\n return optimizer_type(module.parameters(), **opt_args)\n\n\ndef compute_advantages(discount, gae_lambda, max_path_length, baselines,\n rewards):\n \"\"\"Calculate advantages.\n\n Advantages are a discounted cumulative sum.\n\n Calculate advantages using a baseline (value function) according to\n Generalized Advantage Estimation (GAE)\n\n The discounted cumulative sum can be computed using conv2d with filter.\n filter:\n [1, (discount * gae_lambda), (discount * gae_lambda) ^ 2, ...]\n where the length is same with max_path_length.\n\n baselines and rewards are also has same shape.\n baselines:\n [ [b_11, b_12, b_13, ... b_1n],\n [b_21, b_22, b_23, ... b_2n],\n ...\n [b_m1, b_m2, b_m3, ... b_mn] ]\n rewards:\n [ [r_11, r_12, r_13, ... r_1n],\n [r_21, r_22, r_23, ... r_2n],\n ...\n [r_m1, r_m2, r_m3, ... r_mn] ]\n\n Args:\n discount (float): RL discount factor (i.e. gamma).\n gae_lambda (float): Lambda, as used for Generalized Advantage\n Estimation (GAE).\n max_path_length (int): Maximum length of a single rollout.\n baselines (torch.Tensor): A 2D vector of value function estimates with\n shape (N, T), where N is the batch dimension (number of episodes)\n and T is the maximum path length experienced by the agent. If an\n episode terminates in fewer than T time steps, the remaining\n elements in that episode should be set to 0.\n rewards (torch.Tensor): A 2D vector of per-step rewards with shape\n (N, T), where N is the batch dimension (number of episodes) and T\n is the maximum path length experienced by the agent. If an episode\n terminates in fewer than T time steps, the remaining elements in\n that episode should be set to 0.\n\n Returns:\n torch.Tensor: A 2D vector of calculated advantage values with shape\n (N, T), where N is the batch dimension (number of episodes) and T\n is the maximum path length experienced by the agent. If an episode\n terminates in fewer than T time steps, the remaining values in that\n episode should be set to 0.\n\n \"\"\"\n adv_filter = torch.full((1, 1, 1, max_path_length - 1),\n discount * gae_lambda)\n adv_filter = torch.cumprod(F.pad(adv_filter, (1, 0), value=1), dim=-1)\n\n deltas = (rewards + discount * F.pad(baselines, (0, 1))[:, 1:] - baselines)\n deltas = F.pad(deltas, (0, max_path_length - 1)).unsqueeze(0).unsqueeze(0)\n\n advantages = F.conv2d(deltas, adv_filter, stride=1).squeeze()\n return advantages\n\n\ndef pad_to_last(nums, total_length, axis=-1, val=0):\n \"\"\"Pad val to last in nums in given axis.\n\n length of the result in given axis should be total_length.\n\n Raises:\n IndexError: If the input axis value is out of range of the nums array\n\n Args:\n nums (numpy.ndarray): The array to pad.\n total_length (int): The final width of the Array.\n axis (int): Axis along which a sum is performed.\n val (int): The value to set the padded value.\n\n Returns:\n torch.Tensor: Padded array\n\n \"\"\"\n tensor = torch.Tensor(nums)\n axis = (axis + len(tensor.shape)) if axis < 0 else axis\n\n if len(tensor.shape) <= axis:\n raise IndexError('axis {} is out of range {}'.format(\n axis, tensor.shape))\n\n padding_config = [0, 0] * len(tensor.shape)\n padding_idx = abs(axis - len(tensor.shape)) * 2 - 1\n padding_config[padding_idx] = max(total_length - tensor.shape[axis], val)\n return F.pad(tensor, padding_config)\n\n\ndef filter_valids(tensor, valids):\n \"\"\"Filter out tensor using valids (last index of valid tensors).\n\n valids contains last indices of each rows.\n\n Args:\n tensor (torch.Tensor): The tensor to filter\n valids (list[int]): Array of length of the valid values\n\n Returns:\n torch.Tensor: Filtered Tensor\n\n \"\"\"\n return [tensor[i][:valids[i]] for i in range(len(valids))]\n"
] | [
[
"torch.nn.functional.pad",
"torch.full",
"torch.Tensor",
"torch.nn.functional.conv2d"
]
] |
amuamushu/wavedata | [
"1745c646ff3a76b38a81c439a0edd900c986c9f7"
] | [
"wavedata/tools/core/voxel_grid_2d.py"
] | [
"import numpy as np\n\nfrom wavedata.wavedata.tools.core import geometry_utils\n\n\nclass VoxelGrid2D(object):\n \"\"\"\n Voxel grids represent occupancy info. The voxelize_2d method projects a point cloud\n onto a plane, while saving height and point density information for each voxel.\n \"\"\"\n\n # Class Constants\n VOXEL_EMPTY = -1\n VOXEL_FILLED = 0\n\n def __init__(self):\n\n # Quantization size of the voxel grid\n self.voxel_size = 0.0\n\n # Voxels at the most negative/positive xyz\n self.min_voxel_coord = np.array([])\n self.max_voxel_coord = np.array([])\n\n # Size of the voxel grid along each axis\n self.num_divisions = np.array([0, 0, 0])\n\n # Points in sorted order, to match the order of the voxels\n self.points = []\n\n # Indices of filled voxels\n self.voxel_indices = []\n\n # Max point height in projected voxel\n self.heights = []\n\n # Number of points corresponding to projected voxel\n self.num_pts_in_voxel = []\n\n # Full occupancy grid, VOXEL_EMPTY or VOXEL_FILLED\n self.leaf_layout_2d = []\n\n def voxelize_2d(self, pts, voxel_size, extents=None,\n ground_plane=None, create_leaf_layout=True):\n \"\"\"Voxelizes the point cloud into a 2D voxel grid by\n projecting it down into a flat plane, and stores the maximum\n point height, and number of points corresponding to the voxel\n\n :param pts: Point cloud as N x [x, y, z]\n :param voxel_size: Quantization size for the grid\n :param extents: Optional, specifies the full extents of the point cloud.\n Used for creating same sized voxel grids.\n :param ground_plane: Plane coefficients (a, b, c, d), xz plane used if\n not specified\n :param create_leaf_layout: Set this to False to create an empty\n leaf_layout, which will save computation\n time.\n \"\"\"\n # Check if points are 3D, otherwise early exit\n if pts.shape[1] != 3:\n raise ValueError(\"Points have the wrong shape: {}\".format(\n pts.shape))\n\n self.voxel_size = voxel_size\n\n # Discretize voxel coordinates to given quantization size\n discrete_pts = np.floor(pts / voxel_size).astype(np.int32)\n\n # Use Lex Sort, sort by x, then z, then y (\n x_col = discrete_pts[:, 0]\n y_col = discrete_pts[:, 1]\n z_col = discrete_pts[:, 2]\n sorted_order = np.lexsort((y_col, z_col, x_col))\n\n # Save original points in sorted order\n self.points = pts[sorted_order]\n\n # Save discrete points in sorted order\n discrete_pts = discrete_pts[sorted_order]\n\n # Project all points to a 2D plane\n discrete_pts_2d = discrete_pts.copy()\n discrete_pts_2d[:, 1] = 0\n\n # Format the array to c-contiguous array for unique function\n contiguous_array = np.ascontiguousarray(discrete_pts_2d).view(\n np.dtype((np.void, discrete_pts_2d.dtype.itemsize *\n discrete_pts_2d.shape[1])))\n\n # The new coordinates are the discretized array with its unique indexes\n _, unique_indices = np.unique(contiguous_array, return_index=True)\n\n # Sort unique indices to preserve order\n unique_indices.sort()\n\n voxel_coords = discrete_pts_2d[unique_indices]\n\n # Number of points per voxel, last voxel calculated separately\n num_points_in_voxel = np.diff(unique_indices)\n num_points_in_voxel = np.append(num_points_in_voxel,\n discrete_pts_2d.shape[0] -\n unique_indices[-1])\n\n if ground_plane is None:\n # Use first point in voxel as highest point\n height_in_voxel = self.points[unique_indices, 1]\n else:\n # Ground plane provided\n height_in_voxel = geometry_utils.dist_to_plane(\n ground_plane, self.points[unique_indices])\n\n # Set the height and number of points for each voxel\n self.heights = height_in_voxel\n self.num_pts_in_voxel = num_points_in_voxel\n\n # Find the minimum and maximum voxel coordinates\n if extents is not None:\n # Check provided extents\n extents_transpose = np.array(extents).transpose()\n if extents_transpose.shape != (2, 3):\n raise ValueError(\"Extents are the wrong shape {}\".format(\n extents.shape))\n\n # Set voxel grid extents\n self.min_voxel_coord = np.floor(extents_transpose[0] / voxel_size)\n self.max_voxel_coord = \\\n np.ceil((extents_transpose[1] / voxel_size) - 1)\n\n self.min_voxel_coord[1] = 0\n self.max_voxel_coord[1] = 0\n\n # Check that points are bounded by new extents\n if not (self.min_voxel_coord <= np.amin(voxel_coords,\n axis=0)).all():\n raise ValueError(\"Extents are smaller than min_voxel_coord\")\n if not (self.max_voxel_coord >= np.amax(voxel_coords,\n axis=0)).all():\n raise ValueError(\"Extents are smaller than max_voxel_coord\")\n\n else:\n # Automatically calculate extents\n self.min_voxel_coord = np.amin(voxel_coords, axis=0)\n self.max_voxel_coord = np.amax(voxel_coords, axis=0)\n\n # Get the voxel grid dimensions\n self.num_divisions = ((self.max_voxel_coord - self.min_voxel_coord)\n + 1).astype(np.int32)\n\n # Bring the min voxel to the origin\n self.voxel_indices = (voxel_coords - self.min_voxel_coord).astype(int)\n\n if create_leaf_layout:\n # Create Voxel Object with -1 as empty/occluded, 0 as occupied\n self.leaf_layout_2d = self.VOXEL_EMPTY * \\\n np.ones(self.num_divisions.astype(int))\n\n # Fill out the leaf layout\n self.leaf_layout_2d[self.voxel_indices[:, 0], 0,\n self.voxel_indices[:, 2]] = \\\n self.VOXEL_FILLED\n\n def map_to_index(self, map_index):\n \"\"\"Converts map coordinate values to 1-based discretized grid index\n coordinate. Note: Any values outside the extent of the grid will be\n forced to be the maximum grid coordinate.\n\n :param map_index: N x 2 points\n\n :return: N x length(dim) (grid coordinate)\n [] if min_voxel_coord or voxel_size or grid_index or dim is not set\n \"\"\"\n if self.voxel_size == 0 \\\n or len(self.min_voxel_coord) == 0 \\\n or len(map_index) == 0:\n return []\n\n num_divisions_2d = self.num_divisions[[0, 2]]\n min_voxel_coord_2d = self.min_voxel_coord[[0, 2]]\n\n # Truncate index (same as np.floor for positive values) and clip\n # to valid voxel index range\n indices = np.int32(map_index / self.voxel_size) - min_voxel_coord_2d\n indices[:, 0] = np.clip(indices[:, 0], 0, num_divisions_2d[0])\n indices[:, 1] = np.clip(indices[:, 1], 0, num_divisions_2d[1])\n\n return indices\n"
] | [
[
"numpy.array",
"numpy.clip",
"numpy.ceil",
"numpy.lexsort",
"numpy.ascontiguousarray",
"numpy.diff",
"numpy.amin",
"numpy.amax",
"numpy.append",
"numpy.int32",
"numpy.dtype",
"numpy.unique",
"numpy.floor"
]
] |
zmcx16/ReclassifyAnimeCG | [
"f5f95b229447564502564d9ffc7edf6215fec83d"
] | [
"src/data/dataset.py"
] | [
"import torch\nfrom torch.utils.data import Dataset, DataLoader\nimport numpy as np\nfrom PIL import Image\nImage.MAX_IMAGE_PIXELS = None\n\nfrom data import get_train_transform, get_test_transform\n\n\nclass CustomDataset(Dataset):\n img_aug = True\n imgs = []\n transform = None\n\n def __init__(self, label_file, image_set, input_size):\n with open(label_file, 'r', encoding=\"utf-8\") as f:\n self.imgs = list(map(lambda line: line.strip().split('|'), f))\n\n if image_set == 'train':\n self.transform = get_train_transform(size=input_size)\n else:\n self.transform = get_test_transform(size=input_size)\n self.input_size = input_size\n\n def __getitem__(self, index):\n # print(self.imgs)\n # print(index)\n # print(len(self.imgs[index]))\n img_path, label = self.imgs[index]\n # print(img_path)\n img = Image.open(img_path).convert('RGB')\n if self.img_aug:\n img = self.transform(img)\n else:\n img = np.array(img)\n img = torch.from_numpy(img)\n\n return img, torch.from_numpy(np.array(int(label)))\n \n def __len__(self):\n return len(self.imgs)\n\n\ndef get_datasets_and_dataloader(label_path, image_set, batch_size, input_size):\n _dataset = CustomDataset(label_path, image_set=image_set, input_size=input_size)\n _dataloader = DataLoader(_dataset, batch_size=batch_size, shuffle=True, num_workers=2)\n return _dataset, _dataloader\n"
] | [
[
"numpy.array",
"torch.utils.data.DataLoader",
"torch.from_numpy"
]
] |
stormymcstorm/condensa | [
"c7321e0a362f73eca9349769b341a7dd688ee1b9"
] | [
"test/schemes/test_qz.py"
] | [
"# Copyright 2019 NVIDIA Corporation\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 torch\n\nimport condensa\nfrom condensa import schemes\n\ndef test_float16(device):\n scheme = schemes.Quantize(condensa.float16)\n fc = torch.nn.Linear(100, 10).float().to(device)\n\n scheme.pi(fc)\n assert fc.weight.dtype == torch.float16\n scheme.delta(fc)\n assert fc.weight.dtype == torch.float32\n\nif __name__ == '__main__':\n test_float16('cpu')\n if torch.cuda.is_available():\n test_float16('cpu')\n"
] | [
[
"torch.nn.Linear",
"torch.cuda.is_available"
]
] |
mathischeap/mifem | [
"3242e253fb01ca205a76568eaac7bbdb99e3f059",
"3242e253fb01ca205a76568eaac7bbdb99e3f059"
] | [
"objects/CSCG/_3d/forms/standard/base/export/field.py",
"objects/CSCG/_3d/forms/trace/_2tr/discretize/scalar/boundary_wise.py"
] | [
"\"\"\"We want to export the field to some data files.\n\"\"\"\n\nfrom root.config.main import *\nfrom screws.freeze.main import FrozenOnly\nfrom screws.miscellaneous.timer import check_filename, check_no_splcharacter\nfrom scipy.io import savemat\n\n\n\nclass _3dCSC_SF_Export_Field(FrozenOnly):\n \"\"\"\"\"\"\n\n def __init__(self, sf):\n \"\"\"\"\"\"\n assert '3dCSCG_standard_form' in sf.standard_properties.tags\n self._sf_ = sf\n self._freeze_self_()\n\n\n def to_file(self, filename, numOfSamples=1e6, regions=None):\n \"\"\"\"\"\"\n filename, extension = check_filename(filename)\n if extension is None: extension = 'txt'\n\n supported_formats = ('txt', 'mat')\n assert extension in supported_formats, \\\n f\"format={extension} is not among the supported formats {supported_formats}.\"\n\n if isinstance(numOfSamples, (int, float)):\n assert numOfSamples > 0, f\"numOfSamples={numOfSamples} is wrong.\"\n numOfSamples = [numOfSamples, numOfSamples, numOfSamples]\n else:\n assert isinstance(numOfSamples, (tuple, list)) and len(numOfSamples) == 3, \\\n f\"numOfSamples={numOfSamples} wrong.\"\n for nos in numOfSamples:\n assert isinstance(nos, (int, float)) and nos > 0, f\"numOfSamples={numOfSamples} wrong.\"\n\n mesh = self._sf_.mesh\n\n if regions is None:\n regions = mesh.domain.regions.names\n elif isinstance(regions, str):\n regions = [regions,]\n else:\n pass\n assert isinstance(regions, (list, tuple)), f\"regions={regions} is wrong.\"\n assert len(set(regions)) == len(regions), f\"regions={regions} has repeated regions.\"\n for i, r in enumerate(regions):\n assert r in mesh.domain.regions, f\"regions[{i}]={r} is wrong.\"\n\n rst = list()\n for i in range(3):\n density = int((numOfSamples[i] / mesh.elements.GLOBAL_num) ** (1/3)) + 1\n interval = 2 / density\n rst.append(np.linspace(-1 + interval/2, 1-interval/2, density))\n\n xyz, v = self._sf_.reconstruct(*rst, regions=regions)\n\n # Now, we gather xyz & v from all cores into Master Core, store in XYZ & V --- BELOW ---\n if rAnk == mAster_rank:\n X = [None for _ in range(mesh.elements.GLOBAL_num)]\n Y = [None for _ in range(mesh.elements.GLOBAL_num)]\n Z = [None for _ in range(mesh.elements.GLOBAL_num)]\n Vx = [None for _ in range(mesh.elements.GLOBAL_num)]\n if self._sf_.k in (1, 2):\n Vy = [None for _ in range(mesh.elements.GLOBAL_num)]\n Vz = [None for _ in range(mesh.elements.GLOBAL_num)]\n for j in mesh.elements.indices:\n X[j] = xyz[j][0]\n Y[j] = xyz[j][1]\n Z[j] = xyz[j][2]\n Vx[j] = v[j][0]\n if self._sf_.k in (1, 2):\n # noinspection PyUnboundLocalVariable\n Vy[j] = v[j][1]\n # noinspection PyUnboundLocalVariable\n Vz[j] = v[j][2]\n for i in sLave_ranks:\n xyz, v = cOmm.recv(source=i, tag=0)\n for j in xyz:\n X[j] = xyz[j][0]\n Y[j] = xyz[j][1]\n Z[j] = xyz[j][2]\n Vx[j] = v[j][0]\n if self._sf_.k in (1, 2):\n Vy[j] = v[j][1]\n Vz[j] = v[j][2]\n del xyz, v\n else:\n cOmm.send([xyz, v], dest=mAster_rank, tag=0)\n del xyz, v\n\n # Now, we reshape the XYZ and V for export in the master core. -------- BELOW ----------\n if rAnk == mAster_rank:\n if self._sf_.k in (1, 2):\n # noinspection PyUnboundLocalVariable\n X, Y, Z, Vx, Vy, Vz = mesh.do.regionwsie_stack(X, Y, Z, Vx, Vy, Vz)\n else:\n # noinspection PyUnboundLocalVariable\n X, Y, Z, V = mesh.do.regionwsie_stack(X, Y, Z, Vx)\n\n for rn in regions:\n assert rn in X and rn in Y and rn in Z, \"Data not full!\"\n\n x, y, z = X[rn], Y[rn], Z[rn]\n if self._sf_.k in (1, 2):\n vx, vy, vz = Vx[rn], Vy[rn], Vz[rn]\n else:\n # noinspection PyUnboundLocalVariable\n vx = V[rn]\n\n # we take care of the file names ------------------ BELOW -----------------------\n RN = rn[2:] # if regions name is R:center, we select\n assert check_no_splcharacter(RN), f\"region name={RN} wrong.\"\n\n FILE_NAME = filename + '__InRegion_' + RN\n if self._sf_.k in (1, 2):\n FILE_NAME += '__x_y_z_vx_vy_vz'\n else:\n FILE_NAME += '__x_y_z_v'\n FILE_NAME = FILE_NAME + '.' + extension\n\n\n # It's time to do the save or writing ------------------- BELOW -----------------\n\n if extension == 'txt':\n # for .txt, we have to flat the data =====================\n x = x.ravel(order='F')[:,np.newaxis]\n y = y.ravel(order='F')[:,np.newaxis]\n z = z.ravel(order='F')[:,np.newaxis]\n if self._sf_.k in (1, 2):\n vx = vx.ravel(order='F')[:,np.newaxis]\n # noinspection PyUnboundLocalVariable\n vy = vy.ravel(order='F')[:,np.newaxis]\n # noinspection PyUnboundLocalVariable\n vz = vz.ravel(order='F')[:,np.newaxis]\n else:\n vx = vx.ravel(order='F')[:,np.newaxis]\n if self._sf_.k in (1, 2):\n # noinspection PyUnboundLocalVariable\n TO_BE_WRITTEN = np.hstack((x, y, z, vx, vy, vz))\n else:\n TO_BE_WRITTEN = np.hstack((x, y, z, vx))\n # noinspection PyTypeChecker\n np.savetxt(FILE_NAME, TO_BE_WRITTEN)\n\n elif extension == 'mat':\n # for .mat, we save 3-d arrays. ==========================\n m_dic = dict()\n m_dic['x'] = x\n m_dic['y'] = y\n m_dic['z'] = z\n if self._sf_.k in (1, 2):\n m_dic['vx'] = vx\n m_dic['vy'] = vy\n m_dic['vz'] = vz\n else:\n m_dic['v'] = vx\n\n savemat(FILE_NAME, m_dic)\n\n else:\n raise Exception(f\"Format=.{extension} is not supported.\")",
"\nimport sys\nif './' not in sys.path: sys.path.append('./')\n\n\nfrom screws.freeze.base import FrozenOnly\nimport numpy as np\nfrom screws.quadrature import Quadrature\n\n\n\nclass _3dCSCG_2Trace_Discretize_BoundaryWiseScalar(FrozenOnly):\n \"\"\"\"\"\"\n def __init__(self, tf):\n self._tf_ = tf\n self.___cache_DISCRETIZE_STANDARD___ = None\n self._freeze_self_()\n\n def __call__(self, quad_degree=None):\n \"\"\"\n 'locally full local TEW cochain' means the cochain is a dict whose keys are trace-element\n numbers and values are trace-element-wise local cochains.\n \"\"\"\n SELF = self._tf_\n\n if self.___cache_DISCRETIZE_STANDARD___ is None or \\\n self.___cache_DISCRETIZE_STANDARD___['quadDegree'] != quad_degree:\n p = [SELF.dqp[i] + 1 for i in range(SELF.ndim)] if quad_degree is None else quad_degree\n quad_nodes, quad_weights = Quadrature(p, category='Gauss').quad\n nodes = SELF.space.nodes\n num_edges = [len(nodes[i])-1 for i in range(SELF.ndim)]\n lens = [nodes[i][1:]-nodes[i][0:-1] for i in range(SELF.ndim)]\n qnodes = []\n for i in range(SELF.ndim):\n qnodes_i = ((np.array(quad_nodes[i])+1)/2)[np.newaxis,:].repeat(num_edges[i],\n axis=0)*lens[i][:,np.newaxis]\n qnodes_i += np.array(nodes[i][:-1])[:,np.newaxis].repeat(p[i]+1, axis=1)\n qnodes.append(qnodes_i)\n # NS sides\n qn_NS_y = []\n qn_NS_z = []\n for k in range(SELF.p[2]):\n for j in range(SELF.p[1]):\n qn_NS_y.append(qnodes[1][j][:,np.newaxis].repeat(p[2]+1, axis=1))\n qn_NS_z.append(qnodes[2][k][np.newaxis,:].repeat(p[1]+1, axis=0))\n qn_NS_y, qn_NS_z = np.array(qn_NS_y), np.array(qn_NS_z)\n area_NS = np.kron(lens[2], lens[1]) * 0.25\n # WE sides\n qn_WE_x = []\n qn_WE_z = []\n for k in range(SELF.p[2]):\n for i in range(SELF.p[0]):\n qn_WE_x.append(qnodes[0][i][:,np.newaxis].repeat(p[2]+1, axis=1))\n qn_WE_z.append(qnodes[2][k][np.newaxis,:].repeat(p[0]+1, axis=0))\n qn_WE_x, qn_WE_z = np.array(qn_WE_x), np.array(qn_WE_z)\n area_WE = np.kron(lens[2], lens[0]) * 0.25\n # BF sides\n qn_BF_x = []\n qn_BF_y = []\n for j in range(SELF.p[1]):\n for i in range(SELF.p[0]):\n qn_BF_x.append(qnodes[0][i][:,np.newaxis].repeat(p[1]+1, axis=1))\n qn_BF_y.append(qnodes[1][j][np.newaxis,:].repeat(p[0]+1, axis=0))\n qn_BF_x, qn_BF_y = np.array(qn_BF_x), np.array(qn_BF_y)\n area_BF = np.kron(lens[1], lens[0]) * 0.25\n\n cd = dict()\n cd['quadDegree'] = quad_degree\n cd['qn_NS_y'] = qn_NS_y\n cd['qn_NS_z'] = qn_NS_z\n cd['area_NS'] = area_NS\n cd['qn_WE_x'] = qn_WE_x\n cd['qn_WE_z'] = qn_WE_z\n cd['area_WE'] = area_WE\n cd['qn_BF_x'] = qn_BF_x\n cd['qn_BF_y'] = qn_BF_y\n cd['area_BF'] = area_BF\n cd['quad_weights'] = quad_weights\n self.___cache_DISCRETIZE_STANDARD___ = cd\n else:\n qn_NS_y = self.___cache_DISCRETIZE_STANDARD___['qn_NS_y']\n qn_NS_z = self.___cache_DISCRETIZE_STANDARD___['qn_NS_z']\n area_NS = self.___cache_DISCRETIZE_STANDARD___['area_NS']\n qn_WE_x = self.___cache_DISCRETIZE_STANDARD___['qn_WE_x']\n qn_WE_z = self.___cache_DISCRETIZE_STANDARD___['qn_WE_z']\n area_WE = self.___cache_DISCRETIZE_STANDARD___['area_WE']\n qn_BF_x = self.___cache_DISCRETIZE_STANDARD___['qn_BF_x']\n qn_BF_y = self.___cache_DISCRETIZE_STANDARD___['qn_BF_y']\n area_BF = self.___cache_DISCRETIZE_STANDARD___['area_BF']\n quad_weights = self.___cache_DISCRETIZE_STANDARD___['quad_weights']\n\n assert SELF.BC.body is not None, f\"No BC.body!\"\n FUNC = SELF.BC.body\n RANGE_trace_elements = SELF.mesh.boundaries.range_of_trace_elements\n local_TEW = dict()\n for bn in FUNC:\n func_bn = FUNC[bn]\n trace_elements = RANGE_trace_elements[bn]\n _lf_ = func_bn[0]\n for i in trace_elements:\n te = SELF.mesh.trace.elements[i]\n ele = te.CHARACTERISTIC_element\n ele_side = te.CHARACTERISTIC_side\n if ele_side in 'NS':\n qn0, qn1 = qn_NS_y, qn_NS_z\n qw0, qw1 = quad_weights[1], quad_weights[2]\n area = area_NS\n x, y, z = te.coordinate_transformation.mapping(qn0, qn1, from_element=ele, side=ele_side)\n g = te.coordinate_transformation.metric(qn0, qn1)\n elif ele_side in 'WE':\n qn0, qn1 = qn_WE_x, qn_WE_z\n qw0, qw1 = quad_weights[0], quad_weights[2]\n area = area_WE\n x, y, z = te.coordinate_transformation.mapping(qn0, qn1, from_element=ele, side=ele_side)\n g = te.coordinate_transformation.metric(qn0, qn1)\n elif ele_side in 'BF':\n qn0, qn1 = qn_BF_x, qn_BF_y\n qw0, qw1 = quad_weights[0], quad_weights[1]\n area = area_BF\n x, y, z = te.coordinate_transformation.mapping(qn0, qn1, from_element=ele, side=ele_side)\n g = te.coordinate_transformation.metric(qn0, qn1)\n else:\n raise Exception()\n\n f = _lf_(x, y, z)\n sqrt_g = np.sqrt(g)\n te_primal_local = np.einsum('mij, i, j, m -> m', f * sqrt_g,\n qw0, qw1, area,\n optimize='greedy')\n if not SELF.space.IS_Kronecker: raise NotImplementedError()\n assert i not in local_TEW, f\"Trace element #{i} can only appear once (be on one mesh boundary).\"\n local_TEW[i] = te_primal_local\n\n # 'locally full local TEW cochain': provide cochain.local_TEW and for all dofs on the trace element.\n return 'locally full local TEW cochain', local_TEW\n\n\n\n\n\nif __name__ == '__main__':\n # mpiexec -n 5 python _3dCSCG\\forms\\trace\\_2_trace\\discretize\\scalar\\boundary_wise.py\n\n from objects.CSCG._3d.master import MeshGenerator, SpaceInvoker, FormCaller\n\n mesh = MeshGenerator('crazy', c=0.)([2,2,2])\n space = SpaceInvoker('polynomials')([('Lobatto',5), ('Lobatto',5), ('Lobatto',5)])\n FC = FormCaller(mesh, space)"
] | [
[
"scipy.io.savemat"
],
[
"numpy.array",
"numpy.sqrt",
"numpy.kron",
"numpy.einsum"
]
] |
LongKt7/Face_Recognize_Pytorch | [
"baa02e633d379abe1001c8b8acb942617177329c",
"baa02e633d379abe1001c8b8acb942617177329c"
] | [
"config.py",
"Face_Alignt/predict_m.py"
] | [
"from easydict import EasyDict as edict\n# from pathlib import Path\nimport torch\nimport os\nfrom torchvision import transforms as trans\nfrom utils.constants import *\nlist_model = ['wget https://www.dropbox.com/s/akktsgxp0n8cwn2/model_mobilefacenet.pth?dl=0 -O model_mobilefacenet.pth',\n'wget https://www.dropbox.com/s/kzo52d9neybjxsb/model_ir_se50.pth?dl=0 -O model_ir_se50.pth',\n'wget https://www.dropbox.com/s/rxavczg9dlxy3a8/model_ir50.pth?dl=0 -O model_ir50.pth']\ndef get_config(mode = 'app', net_size = 'large', net_mode = 'ir_se', use_mtcnn = 1, threshold = 1.25):\n conf = edict()\n conf.device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n conf.input_size = [112, 112]\n conf.face_limit = 5 \n conf.min_face_size = 30\n conf.mode = mode\n conf.net_size = net_size\n if mode =='app':\n assert net_size in ['mobi', 'large', None], 'net_size should be mobi or large, please change in cogfig.py'\n conf.use_tensor = True\n conf.work_path = WORK_PATH\n conf.model_path = '%s/models'%WORK_PATH\n conf.log_path = '%s/log'%WORK_PATH\n conf.save_path = '%s/save'%WORK_PATH\n conf.facebank_path = '%s/Face_bank'%WORK_PATH\n conf.threshold = threshold\n if use_mtcnn:\n conf.use_mtcnn = True\n else:\n conf.use_mtcnn = False\n #when inference, at maximum detect 10 faces in one image, my laptop is slow\n conf.test_transform = trans.Compose([\n trans.ToTensor(),\n trans.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])\n ])\n if net_size == 'large':\n conf.use_mobilfacenet = False\n if net_mode == 'ir_se':\n conf.net_mode = 'ir_se' # or 'ir'\n conf.weight_path = '%s/weights/model_ir_se50.pth'%WORK_PATH\n conf.url = list_model[1]\n else:\n conf.net_mode = 'ir' # or 'ir'\n conf.weight_path = '%s/weights/model_ir50.pth'%WORK_PATH\n conf.url = list_model[2]\n if net_size =='mobi':\n conf.use_mobilfacenet = True\n conf.weight_path = '%s/weights/model_mobilefacenet.pth'%WORK_PATH\n conf.url = list_model[0]\n conf.video_source = 0\n\n if mode =='training_eval':\n conf.lr = 1e-3\n conf.milestones = [18,30,42]\n conf.momentum = 0.9\n conf.pin_memory = True\n# conf.num_workers = 4 # when batchsize is 200\n conf.num_workers = 3\n conf.train_root = \"/mnt/01D4A1D481139570/Dataset/Face/casia\"\n conf.file_list = '/mnt/01D4A1D481139570/Dataset/Face/casia_train.txt' \n conf.batch_size = 4\n conf.lfw_root = '/mnt/01D4A1D481139570/Dataset/Face/data/LFW/lfw_align_112'\n conf.lfw_file_list = '/mnt/01D4A1D481139570/Dataset/Face/data/LFW/pairs.txt'\n conf.agedb_root = '/mnt/01D4A1D481139570/Dataset/Face/data/AgeDB-30/agedb30_align_112'\n conf.agedb_file_list = '/mnt/01D4A1D481139570/Dataset/Face/data/AgeDB-30/agedb_30_pair.txt'\n conf.cfp_root = '/mnt/01D4A1D481139570/Dataset/Face/data/CFP-FP/CFP_FP_aligned_112'\n conf.cfp_file_list = '/mnt/01D4A1D481139570/Dataset/Face/data/CFP-FP/cfp_fp_pair.txt'\n return conf",
"from network import PNet,ONet\r\nimport torch,cv2,itertools\r\nfrom torch.autograd import Variable\r\nimport torch.nn.functional as F\r\nimport numpy as np\r\nimport time\r\nfrom matlab_cp2tform import get_similarity_transform_for_cv2\r\n\r\nimport math\r\ndef alignment(src_img,src_pts, crop_size = (112, 112)):\r\n ref_pts = np.array([ [30.2946, 51.6963],\r\n [65.5318, 51.5014],\r\n [48.0252, 71.7366],\r\n [33.5493, 92.3655],\r\n [62.7299, 92.2041] ])\r\n \r\n if crop_size[1]==112:\r\n ref_pts[:,0] += 8.0\r\n src_pts = np.array(src_pts).reshape(5,2)\r\n \r\n s = np.array(src_pts).astype(np.float32)\r\n r = np.array(ref_pts).astype(np.float32)\r\n\r\n tfm = get_similarity_transform_for_cv2(s, r)\r\n face_img = cv2.warpAffine(src_img, tfm, crop_size)\r\n return face_img\r\ndef resize_square(img, height=128, color=(0, 0, 0)): # resize a rectangular image to a padded square\r\n shape = img.shape[:2] # shape = [height, width]\r\n ratio = float(height) / max(shape) # ratio = old / new\r\n new_shape = [round(shape[0] * ratio), round(shape[1] * ratio)]\r\n dw = height - new_shape[1] # width padding\r\n dh = height - new_shape[0] # height padding\r\n top, bottom = dh // 2, dh - (dh // 2)\r\n left, right = dw // 2, dw - (dw // 2)\r\n img = cv2.resize(img, (new_shape[1], new_shape[0]), interpolation=cv2.INTER_AREA) # resized, no border\r\n return cv2.copyMakeBorder(img, top, bottom, left, right, cv2.BORDER_CONSTANT, value=color), ratio, dw // 2, dh // 2\r\n\r\ndef dotproduct(v1, v2):\r\n return sum((a*b) for a, b in zip(v1, v2))\r\n\r\ndef length(v):\r\n return math.sqrt(dotproduct(v, v))\r\n\r\ndef angle(v1, v2):\r\n return math.acos(dotproduct(v1, v2) / (length(v1) * length(v2)))\r\ndef get_anchors(scale=64):\r\n '''\r\n compute anchors\r\n return:\r\n u_boxes:tensor([anchor_num,4]) (cx,cy,w,h): real anchors\r\n boxes:tensor([anchor_num,4]) (x1,y1,x2,y2): crop box for ONet,each with size 80\r\n '''\r\n sizes = [float(s) / scale for s in [32]]\r\n \r\n aspect_ratios = [(1.,)]\r\n feature_map_sizes = [int(scale/16)]\r\n \r\n num_layers = len(feature_map_sizes)\r\n u_boxes,boxes = [],[]\r\n for i in range(num_layers):\r\n fmsize = feature_map_sizes[i]\r\n for h,w in itertools.product(range(fmsize),repeat=2):\r\n cx = float(w)/feature_map_sizes[i]\r\n cy = float(h)/feature_map_sizes[i]\r\n \r\n s = sizes[i]\r\n for j,ar in enumerate(aspect_ratios[i]):\r\n u_boxes.append((cx,cy,float(s)*ar,float(s)*ar))\r\n boxes.append((w*16-32,h*16-32,w*16+32,h*16+32)) \r\n return torch.Tensor(u_boxes),torch.Tensor(boxes).long()\r\n\r\ndef nms(bboxes,scores,threshold=0.35):\r\n '''\r\n bboxes(tensor) [N,4]\r\n scores(tensor) [N,]\r\n '''\r\n x1 = bboxes[:,0]\r\n y1 = bboxes[:,1]\r\n x2 = bboxes[:,2]\r\n y2 = bboxes[:,3]\r\n areas = (x2-x1) * (y2-y1)\r\n\r\n _,order = scores.sort(0,descending=True)\r\n keep = []\r\n while order.numel() > 0:\r\n if order.numel() == 1:\r\n i = order.item()\r\n else:\r\n i = order[0].item()\r\n keep.append(i) \r\n\r\n if order.numel() == 1:\r\n break \r\n\r\n xx1 = x1[order[1:]].clamp(min=x1[i]) \r\n yy1 = y1[order[1:]].clamp(min=y1[i])\r\n xx2 = x2[order[1:]].clamp(max=x2[i])\r\n yy2 = y2[order[1:]].clamp(max=y2[i])\r\n\r\n w = (xx2-xx1).clamp(min=0)\r\n h = (yy2-yy1).clamp(min=0)\r\n inter = w*h\r\n\r\n ovr = inter / (areas[i] + areas[order[1:]] - inter) \r\n ids = (ovr<=threshold).nonzero().squeeze()\r\n if ids.numel() == 0:\r\n break\r\n order = order[ids+1] \r\n return torch.LongTensor(keep)\r\n \r\ndef decode_box(loc, size=64):\r\n variances = [0.1,0.2]\r\n anchor,crop = get_anchors(scale=size)\r\n cxcy = loc[:,:2] * variances[0] * anchor[:,2:] + anchor[:,:2]\r\n wh = torch.exp(loc[:,2:] * variances[1]) * anchor[:,2:]\r\n boxes = torch.cat([cxcy-wh/2,cxcy+wh/2],1)\r\n \r\n return boxes,anchor,crop\r\n \r\ndef decode_ldmk(ldmk,anchor):\r\n variances = [0.1,0.2]\r\n index_x = torch.Tensor([0,2,4,6,8]).long()\r\n index_y = torch.Tensor([1,3,5,7,9]).long()\r\n ldmk[:,index_x] = ldmk[:,index_x] * variances[0] * anchor[:,2].view(-1,1) + anchor[:,0].view(-1,1)\r\n ldmk[:,index_y] = ldmk[:,index_y] * variances[0] * anchor[:,3].view(-1,1) + anchor[:,1].view(-1,1)\r\n return ldmk\r\n \r\nimport os\r\n# list_per = []\r\ndef detect(file, pic = None):\r\n def change(boxes,ldmks, h, w, pad1):\r\n index_x = torch.LongTensor([0,2,4,6,8])\r\n index_y = torch.LongTensor([1,3,5,7,9])\r\n if h <= w:\r\n boxes[:,1] = boxes[:,1]*w-pad1\r\n boxes[:,3] = boxes[:,3]*w-pad1\r\n boxes[:,0] = boxes[:,0]*w\r\n boxes[:,2] = boxes[:,2]*w \r\n ldmks[:,index_x] = ldmks[:,index_x] * w\r\n ldmks[:,index_y] = ldmks[:,index_y] * w - torch.Tensor([pad1])\r\n else:\r\n boxes[:,1] = boxes[:,1]*h\r\n boxes[:,3] = boxes[:,3]*h\r\n boxes[:,0] = boxes[:,0]*h-pad1\r\n boxes[:,2] = boxes[:,2]*h-pad1\r\n ldmks[:,index_x] = ldmks[:,index_x] * h - torch.Tensor([pad1])\r\n ldmks[:,index_y] = ldmks[:,index_y] * h \r\n return boxes,ldmks\r\n if not isinstance(file, np.ndarray):\r\n im = cv2.imread(file)\r\n else:\r\n im = file\r\n if im is None:\r\n print(\"can not open image:\", file)\r\n return\r\n\r\n # pad img to square\r\n h, w,_ = im.shape\r\n\r\n dim_diff = np.abs(h - w)\r\n pad1, pad2 = dim_diff //2, dim_diff - dim_diff // 2\r\n pad = ((pad1,pad2),(0,0),(0,0)) if h<=w else ((0,0),(pad1, pad2),(0,0))\r\n img = np.pad(im, pad,'constant', constant_values=128)\r\n \r\n #get img_pyramid\r\n img_scale, img_size = 0,int((img.shape[0]-1)/32)\r\n while img_size > 0:\r\n img_scale += 1\r\n img_size /= 2\r\n if img_scale == 6:\r\n break\r\n img_size = 64\r\n img_pyramid = []\r\n t_boxes,t_probs, t_anchors, t_crops, t_which = None, None, None, None, None\r\n \r\n for scale in range(4):\r\n # print('scale:{0} img_size:{1}'.format(scale, img_size))\r\n input_img = cv2.resize(img,(img_size, img_size))\r\n img_pyramid.append(input_img.transpose(2,0,1))\r\n im_tensor = torch.from_numpy(input_img.transpose(2,0,1)).float()\r\n if use_gpu:\r\n im_tensor = im_tensor.cuda()\r\n #get conf and loc(box)\r\n if use_gpu:\r\n torch.cuda.synchronize()\r\n loc,conf = pnet(torch.unsqueeze(im_tensor,0))\r\n if use_gpu:\r\n torch.cuda.synchronize()\r\n \r\n # print('forward time:{}s'.format(e_t-s_t)) \r\n loc, conf = loc.detach().cpu(),conf.detach().cpu()\r\n loc, conf = loc.data.squeeze(0),F.softmax(conf.squeeze(0))\r\n boxes, anchor, crop = decode_box(loc,size=img_size)\r\n which_img = torch.tensor([scale]).long().expand((crop.shape[0],))\r\n \r\n #add box into stack\r\n if scale == 0:\r\n t_boxes, t_confs, t_anchors, t_crops, t_which = boxes, conf, anchor, crop, which_img\r\n else:\r\n t_boxes = torch.cat((t_boxes, boxes),0)\r\n t_confs = torch.cat((t_confs, conf),0)\r\n t_anchors = torch.cat((t_anchors, anchor),0)\r\n t_crops = torch.cat((t_crops, crop),0)\r\n t_which = torch.cat((t_which, which_img),0)\r\n img_size *= 2\r\n\r\n #get right boxes and nms\r\n t_confs[:,0] = 0.6\r\n max_conf, labels = t_confs.max(1)\r\n if labels.long().sum().item() is 0:\r\n return None\r\n ids = labels.nonzero().squeeze(1)\r\n t_boxes, t_confs, t_anchors, t_crops, t_which = t_boxes[ids], t_confs[ids], t_anchors[ids], t_crops[ids], t_which[ids]\r\n max_conf = max_conf[ids]\r\n \r\n keep = nms(t_boxes, max_conf)\r\n t_boxes, max_conf, t_anchors, t_crops, t_which = t_boxes[keep], max_conf[keep], t_anchors[keep], t_crops[keep], t_which[keep]\r\n\r\n t_boxes = t_boxes.detach().numpy()\r\n max_conf = max_conf.detach().numpy()\r\n \r\n #get crop and ldmks\r\n crop_imgs = []\r\n for i in range(t_boxes.shape[0]):\r\n img = img_pyramid[t_which[i]]\r\n crop = t_crops[i].numpy()\r\n _,h_,w_ = img.shape\r\n o_x1,o_y1,o_x2,o_y2 = max(crop[0],0),max(crop[1],0),min(crop[2],w_),min(crop[3],h_)\r\n c_x1 = 0 if crop[0] >=0 else -crop[0]\r\n c_y1 = 0 if crop[1] >=0 else -crop[1]\r\n c_x2 = 64 if crop[2] <= w_ else 64 - (crop[2] - w_)\r\n c_y2 = 64 if crop[3] <= h_ else 64 - (crop[3] - h_)\r\n crop_img = np.ones((3,64,64))*128\r\n np.copyto(crop_img[:,c_y1:c_y2,c_x1:c_x2],img[:,o_y1:o_y2,o_x1:o_x2])\r\n crop_imgs.append(crop_img)\r\n crop_imgs = torch.from_numpy(np.array(crop_imgs)).float()\r\n if use_gpu:\r\n crop_imgs = crop_imgs.cuda()\r\n t_ldmks = onet(crop_imgs).detach().cpu()[:,10,:].squeeze(1)\r\n t_ldmks = decode_ldmk(t_ldmks, t_anchors)\r\n t_boxes, t_ldmks = change(t_boxes,t_ldmks, h, w, pad1)\r\n t_faces = []\r\n for i in range(len(t_boxes)):\r\n box, prob, ldmk = t_boxes[i], max_conf[i], t_ldmks[i]\r\n if prob <= 0.7:\r\n continue\r\n ldmk_fn = ldmk.reshape(5,2)\r\n x1 = min(int(box[0])-5, 0)\r\n x2 = min(int(box[2]) -5, 0)\r\n y1 = max(int(box[1])+5, im.shape[1])\r\n y2 = max(int(box[3])+5, im.shape[2])\r\n face = alignment(im, ldmk_fn)\r\n cv2.rectangle(im, (x1,y1),(x2,y2), (255,0,0), 1)\r\n cv2.imwrite('a.png',im) \r\n t_faces.append(face)\r\n return t_boxes, t_faces\r\nimport glob, tqdm\r\nclass Face_Alignt():\r\n def __init__(self, use_gpu = True):\r\n pnet,onet = PNet(),ONet() \r\n pnet.load_state_dict(torch.load('weight/msos_pnet_rotate.pt',map_location=lambda storage, loc:storage), strict=False) \r\n onet.load_state_dict(torch.load('weight/msos_onet_rotate.pt',map_location=lambda storage, loc:storage), strict=False)\r\n onet.float()\r\n pnet.eval()\r\n onet.eval()\r\n if use_gpu:\r\n torch.cuda.set_device(0)\r\n pnet.cuda()\r\n onet.cuda()\r\n else:\r\n torch.set_num_threads(1)\r\n def align_multi(img, limit=None, min_face_size=30.0):\r\n return detect(img)"
] | [
[
"torch.cuda.is_available"
],
[
"numpy.pad",
"numpy.array",
"torch.cat",
"numpy.copyto",
"torch.cuda.synchronize",
"numpy.ones",
"torch.unsqueeze",
"torch.cuda.set_device",
"torch.LongTensor",
"torch.tensor",
"numpy.abs",
"torch.load",
"torch.Tensor",
"torch.exp",
"torch.set_num_threads"
]
] |
Splendon/examples | [
"ed4a8a01857b6ddca49559141acf5d0986eb01e1",
"ed4a8a01857b6ddca49559141acf5d0986eb01e1",
"ed4a8a01857b6ddca49559141acf5d0986eb01e1"
] | [
"utils/tests/test_util.py",
"code_examples/tensorflow/kernel_benchmarks/dense.py",
"applications/tensorflow/cnns/inference/data.py"
] | [
"# Copyright 2019 Graphcore Ltd.\nfrom statistics import mean\nimport numpy as np\nimport os\nimport re\nimport subprocess\nimport sys\nimport time\n\n\n\"\"\"Library of utility functions common between frameworks\"\"\"\n\n\ndef parse_results_for_speed(output, iter_tolerance, speed_tolerance):\n \"\"\"Look for <iter number> sec/itr. <speed number> {other stuff}\"\"\"\n found_a_result = False\n\n for line in output.split(\"\\n\"):\n matches = re.match(r\"([\\d.]+) +sec/itr. +([\\d.]+)\", line)\n if matches:\n found_a_result = True\n iterations, speed = matches.groups()\n iterations = float(iterations)\n speed = float(speed)\n _verify_model_numbers(\n iter_tolerance, iterations, speed_tolerance, speed, line\n )\n\n if not found_a_result:\n raise AssertionError(\"No results detected in this run\")\n\n\ndef parse_results_for_accuracy(output, expected_accuracies, acc_tolerance):\n \"\"\"Look for Accuracy=<accuracy>%\"\"\"\n\n accuracies = []\n for line in output.split(\"\\n\"):\n if re.match(r\" + Accuracy=+([\\d.]+)%\", line):\n accuracy = float(re.match(r\" + Accuracy=+([\\d.]+)%\", line).groups()[0])\n accuracies.append(accuracy)\n elif re.search(r\"Validation accuracy\", line):\n accuracy_str = re.search(r\"accuracy:\\s(.*)\", line).group(1)\n accuracy = float(accuracy_str[:accuracy_str.rfind(\"%\")])\n accuracies.append(accuracy)\n\n if len(accuracies) == 0:\n raise AssertionError(\"No results detected in this run\")\n elif len(accuracies) != len(expected_accuracies):\n raise AssertionError(\"Expected accuracies and parsed accuracies have\"\n \" different lengths\")\n\n _verify_model_accuracies(accuracies, expected_accuracies, acc_tolerance)\n\n\ndef _verify_model_numbers(iter_tolerance, iterations,\n speed_tolerance, speed, line):\n iter_error = \"\"\n speed_error = \"\"\n\n # Verify iteration speed\n if iterations > iter_tolerance[1]:\n iter_error = (\"The time per iteration has regressed above\"\n \" the tolerance maximum: \" +\n str(iter_tolerance[1]))\n elif iterations < iter_tolerance[0]:\n iter_error = (\"Time taken to compete an iteration was \"\n \"suspiciously fast. Please verify the model\"\n \" is operating correctly and tune tolerances\"\n \" accordingly.\")\n\n # Verify item processing speed\n if speed < speed_tolerance[0]:\n speed_error = (\"The number of items processed per second\"\n \" has regressed below the tolerance: \" +\n str(speed_tolerance[0]))\n elif speed > speed_tolerance[1]:\n speed_error = (\"The number of items processed per second\"\n \" was suspiciously high. Please verify the\"\n \" model is behaving correctly and tune\"\n \" tolerances accordingly.\")\n\n if iter_error and speed_error:\n sys.stderr.write(\"\\n\".join([line, iter_error, speed_error]))\n raise AssertionError(\"Timings out of tolerance range\")\n elif iter_error or speed_error:\n sys.stderr.write(line)\n raise AssertionError(iter_error + speed_error)\n\n\ndef _verify_model_accuracies(accuracies, expected_accuracy, acc_tolerance):\n \"\"\"Asserts a list of accuracies is within a list of expected accuracies\n with a tolerance applied.\n\n Args:\n accuracies: A list of floats representing the accuracies (%) produced\n by the model at each step.\n expected_accuracy: A list of floats representing the expected\n accuracies (%) produced by the model at each step.\n acc_tolerance: A float representing a percentage tolerance applied on\n top of the expected accuracies that the accuracies produced by\n the model should sit within.\n\n Raises:\n Assertion Error: Accuracy produced by the model are not within\n the expected limits.\n \"\"\"\n\n for iter_num in range(len(accuracies)):\n exp_acc = expected_accuracy[iter_num]\n exp_acc_str = (\n \"{0} = {1} +- {2} = [{3:.{5}f}, {4:.{5}f}]\".format(\n \"Expected accuracy (%)\".ljust(22),\n exp_acc,\n acc_tolerance,\n exp_acc - acc_tolerance,\n exp_acc + acc_tolerance,\n 2\n )\n )\n acc = accuracies[iter_num]\n acc_str = \"{} = {:.{}f}\".format(\n \"Accuracy (%)\".ljust(22),\n acc,\n 2\n )\n full_acc_str = \"{}\\n{}\".format(acc_str, exp_acc_str)\n if acc < exp_acc - acc_tolerance:\n raise AssertionError(\n \"After iteration {}, the model is less accurate\"\n \" than expected.\\n\"\n \"{}\".format(iter_num + 1, full_acc_str)\n )\n elif acc > exp_acc + acc_tolerance:\n raise AssertionError(\n \"After iteration {}, the model is producing an accuracy\"\n \" that is suspiciously high and should be reviewed.\\n\"\n \"{}\".format(iter_num + 1, full_acc_str)\n )\n\n\ndef assert_result_equals_tensor_value(output, tensor):\n \"\"\"Searches for a single tensor result in the first line of the output\n\n\n Searches the first line of the string output for a line with format\n '[array([3., 8.], dtype=float32)]' and asserts its equal to the numpy\n tensor argument\n\n Args:\n output: String containing the string representation of a numpy\n tensor\n tensor: numpy tensor representing the expected result\n\n Returns:\n None\n\n Raises:\n Assertion Error: Output is not in correct format\n Assertion Error: Output does not contain a string representation\n of a numpy array\n Assertion Error: Output numpy array does not equal the expected\n numpy array\n \"\"\"\n # TODO - np representation over multiple lines\n # TODO - large np array output\n # TODO - multiple dimension np output\n list_regex = r\"^\\[.*?\\]$\"\n np_array_str_regex = r\"array\\(.*?, dtype=.*?\\)$\"\n first_line = output.split(\"\\n\")[0]\n if not re.match(list_regex, first_line):\n raise AssertionError(\n \"Result not in expected string format.\"\n \" Expecting stringified list \"\n \" eg. [array([3., 8.], dtype=float32)]\"\n )\n\n contents = first_line[1:-1]\n if not re.match(np_array_str_regex, contents):\n raise AssertionError(\n \"Expecting numpy representation \"\n \"array with dtype \"\n \"eg. array([3., 8.], dtype=float32)\"\n )\n\n assert contents == np.array_repr(tensor), (\n \"Output value {} does not \"\n \"equal expected value {}\".format(np.array_repr(contents), tensor)\n )\n\n\ndef parse_results_for_ipus_used(output):\n \"\"\"Finds the number of IPUs used in the model by looking for\n string with format ' On 2 IPUs.' in output\"\"\"\n shards_regex = r\" On ([\\d.]+) IPUs.\"\n for line in output.split(\"\\n\"):\n matches = re.match(shards_regex, line)\n if matches:\n shards = matches.group(1)\n return int(shards)\n raise AssertionError(\"Expecting line detailing IPU usage \"\n \"eg. ' On 2 IPUs.'\")\n\n\ndef assert_shards(output, expected_shards):\n \"\"\"Verify the expected number of shards used were actually\n used\"\"\"\n actual_shards = parse_results_for_ipus_used(output)\n assert actual_shards == expected_shards\n\n\ndef get_final_accuracy(output):\n \"\"\"Find and return the accuracy reported in a test's output.\"\"\"\n result_regex = r\"Accuracy=([\\d.]+)\\%\"\n result_list = parse_results_with_regex(output, result_regex)\n result = result_list[0]\n return result[-1]\n\n\ndef get_final_loss(output):\n \"\"\"Find and return the loss reported in a test's output.\"\"\"\n result_regex = r\"Loss=([\\d.]+)\"\n result_list = parse_results_with_regex(output, result_regex)\n result = result_list[0]\n return result[-1]\n\n\ndef get_average_speeds(output):\n \"\"\"Finds the average seconds/iteration and tokens/second\n\n Args:\n output: String representing the output of a test.\n\n Returns:\n A tuple where the first element is a float representing\n the average iterations per second and the second the\n average tokens processed per second\n \"\"\"\n\n result_regex = r\"([\\d.]+) +sec/itr. +([\\d.]+)\"\n results = parse_results_with_regex(output, result_regex)\n\n itr_sec_list = results[0]\n tokens_sec_list = results[1]\n\n return mean(itr_sec_list), mean(tokens_sec_list)\n\n\ndef parse_results_with_regex(output, regex):\n \"\"\"Find and returns the regex matching results in output\n\n Looks through the output line by line looking for a matching regex.\n The function assembles a list of lists where each parent list is\n the results for that position in the regex string and each item in\n the child lists represents an order of the results found in the output\n\n Args:\n output: String representing the output of a test.\n regex: Regex of result to find.\n\n Returns:\n A list of lists of floats. Parent list represents the result at each\n position in the regex. Child list contains results received in the\n order they were output.\n\n Raises:\n AssertionError: a line matching the regex could not be found in the\n output\n \"\"\"\n\n results = []\n\n for line in output.split(\"\\n\"):\n matches = re.search(regex, line)\n if matches:\n number_of_results = matches.lastindex\n if results == []:\n results = [None] * number_of_results\n for match_index in range(0, number_of_results):\n result = float(matches.group(match_index + 1))\n if results[match_index]:\n results[match_index].append(result)\n continue\n results[match_index] = [result]\n\n if results == []:\n raise AssertionError(\"Regex {} not found in result\".format(regex))\n\n return results\n\n\ndef get_total_epochs(output):\n \"\"\"Finds the number of epochs model has run through by looking for\n string with format 'Epoch #3' in the models raw output\"\"\"\n epochs = None\n for line in output.split(\"\\n\"):\n epoch_match = re.search(r\"Epoch #([\\d.]+)\", line)\n if epoch_match:\n epochs = int(epoch_match.group(1))\n if not epochs:\n raise AssertionError(\"Epochs not found in output, eg. \"\n \"Epoch #3\")\n return epochs\n\n\ndef assert_total_run_time(total_time, time_range):\n \"\"\"Checks total run time is within the required range\n\n Args:\n total_time: float representing number of seconds the test took to\n run\n time_range: a tuple of floats where the first element is the minimum\n time the test should run in in seconds and the second the\n maximum\n\n Raises:\n AssertionError: if the total_time is not between the minimum time\n and maximum time\n \"\"\"\n minimum_time = time_range[0]\n maximum_time = time_range[1]\n assert total_time >= minimum_time\n assert total_time <= maximum_time\n\n\ndef assert_final_accuracy(output, minimum, maximum):\n \"\"\"Gets the final accuracy given a raw model output and checks its value\n is between the minimum and maximum\n\n Args:\n output: String representing the raw output of a model\n minimum: a float representing a percentage (between 0.0% and 100%)\n that is the minimum accuracy for the model after running\n maximum: a float representing a percentage (between 0.0% and 100%)\n that is the maximum accuracy for the model after running\n\n Raises:\n AssertionError: if the final accuracy is not between the maximum and\n minimum percentages\n \"\"\"\n accuracy = get_final_accuracy(output)\n assert accuracy >= minimum\n assert accuracy <= maximum\n\n\ndef run_python_script_helper(cwd, script, **kwargs):\n \"\"\"A function that given a path and python script name, runs the script\n with kwargs as the command line arguments\n\n Args:\n cwd: string representing the directory of the python script\n script: string representing the full name of the python script\n kwargs: dictionary of string key and values that form the command\n line arguments when the script is run.\n\n Returns:\n A string representing the raw output of the python script run\n\n Raises:\n AssertionError: if the final accuracy is not between the maximum and\n minimum percentages\n \"\"\"\n py_version = \"python{}\".format(sys.version_info[0])\n cmd = [py_version, script]\n if kwargs:\n args = [\n str(item) for sublist in kwargs.items() for item in sublist if item != \"\"\n ]\n cmd.extend(args)\n out = subprocess.check_output(cmd, cwd=cwd, universal_newlines=True)\n print(out)\n return out\n\n\ndef run_test_helper(subprocess_function, total_run_time=None,\n total_run_time_tolerance=0.1, **kwargs):\n \"\"\"Helper function for running tests\n\n Takes in testable parameters, runs the test and checks the relevant\n parameters against test results\n\n Args:\n subprocess_function: the function that runs a subprocess of\n the model in question\n total_run_time_range: tuple float representing the expected\n upper and lower bounds for the total time taken to run\n the test\n\n Returns:\n A String representing the raw output of the models subprocess\n\n Raises:\n AssertionError: If the accuracy, time taken etc. are not within\n the expected bounds\n \"\"\"\n\n start_time = time.time()\n\n out = subprocess_function(**kwargs)\n\n total_time = time.time() - start_time\n\n if total_run_time:\n total_run_time_range = range_from_tolerances(\n total_run_time, total_run_time_tolerance\n )\n assert_total_run_time(total_time, total_run_time_range)\n\n return out\n\n\ndef range_from_tolerances(value, tolerance):\n \"\"\"Helper function that takes a value and applies the tolerance\n\n Args:\n value: a float representing the mean value to which the tolerance\n will be applied\n tolerance: a float representing a percentage (between 0.0 and 1.0)\n which is applied symmetrically across the value argument\n\n Returns:\n A tuple of floats, the first element representing the tolerance\n applied below the value (minimum) and the second above (maximum)\n \"\"\"\n return (\n get_minimum_with_tolerance(value, tolerance),\n get_maximum_with_tolerance(value, tolerance),\n )\n\n\ndef get_minimum_with_tolerance(value, tolerance):\n \"\"\"Helper function that takes a value and applies the tolerance\n below the value\n\n Args:\n value: a float representing the mean value to which the tolerance\n will be applied\n tolerance: a float representing a percentage (between 0.0 and 1.0)\n which is applied to the value argument\n\n Returns:\n A float representing the tolerance applied below the value (maximum)\n \"\"\"\n return value * (1 - tolerance)\n\n\ndef get_maximum_with_tolerance(value, tolerance):\n \"\"\"Helper function that takes a value and applies the tolerance\n above the value\n\n Args:\n value: a float representing the mean value to which the tolerance\n will be applied\n tolerance: a float representing a percentage (between 0.0 and 1.0)\n which is applied to the value argument\n\n Returns:\n A float representing the tolerance applied above the value (minimum)\n \"\"\"\n return value * (1 + tolerance)\n\n\ndef check_data_exists(data_path, expected_files_list):\n \"\"\"Helper function that checks the expected data exists in a directory\n\n Args:\n data_path: A string representing the directory of where the\n data is expected to be\n expected_files_list: a list of strings representing the expected\n file names in the data_path directory\n\n Returns:\n A boolean which represents whether the expected files are found in\n the data_path directory\n \"\"\"\n\n if os.path.exists(data_path):\n for filename in expected_files_list:\n if not os.path.isfile(os.path.join(data_path, filename)):\n return False\n return True\n\n return False\n",
"#!/usr/bin/env python\n\"\"\"\nBenchmark a single Dense layer with no host/device data transfers.\n\nThe Items/sec reported at the end of the benchmark is based on wall time.\n\nRun with -h or --help for options.\n\"\"\"\nimport inspect\nimport os\nimport sys\nimport tensorflow as tf\nfrom tensorflow.python.ipu import utils\n\n\ndef dense(opts, inputs):\n # Add ReLU activation function if appropriate option is set\n if opts.activation:\n return tf.layers.dense(units=opts.size, inputs=inputs, activation=tf.nn.relu)\n\n else:\n return tf.layers.dense(units=opts.size, inputs=inputs)\n\n\ndef inputs(opts, index):\n value = tf.cast(index, tf.float16)\n return {\n \"inputs\": tf.broadcast_to(value, [opts.batch_size, opts.size]),\n }\n\n\ndef graph_builder(opts, inputs):\n output = dense(opts, inputs[\"inputs\"])\n\n if opts.train:\n # Loss is the mean across output matrix:\n loss = tf.reduce_mean(output)\n optimiser = tf.train.GradientDescentOptimizer(0.01)\n with tf.variable_scope(\"train\", reuse=tf.AUTO_REUSE):\n # We need to ensure that the train op is executed as part of\n # the benchmarking loop by maintaining a step variable and\n # forcing a control dependency between it and the train op:\n global_step = tf.get_variable(\n \"step_control\", dtype=tf.int32, shape=[])\n grads_and_vars = optimiser.compute_gradients(\n loss, tf.trainable_variables())\n train = optimiser.apply_gradients(grads_and_vars, global_step)\n with tf.control_dependencies([train]):\n global_step = tf.identity(global_step)\n return global_step\n return output\n\n\ndef initializer():\n utils.move_variable_initialization_to_cpu()\n return tf.global_variables_initializer()\n\n\ndef add_args(parser):\n parser.add_argument(\"--batch-size\", default=32, type=int,\n help=\"Number of inputs in a mini-batch\")\n parser.add_argument(\"--size\", default=1024, type=int,\n help=\"Dense layer size\")\n parser.add_argument(\"--train\", action='store_true', dest='train',\n help=\"Compute loss and optimization pass\")\n parser.add_argument(\"--include-activation\", action='store_true', dest='activation',\n help=\"Include ReLU activation (otherwise linear/no activation\")\n\n parser.set_defaults(train=False, batches_per_step=5000, steps=5)\n return parser\n\n\ndef iteration_report(opts, time):\n return \"{:5f} items/sec\".format(opts.batch_size * opts.batches_per_step / time)\n\n\nif __name__ == '__main__':\n # Add benchmark module to path\n cwd = os.path.dirname(os.path.abspath(inspect.stack()[0][1]))\n sys.path.insert(1, os.path.join(cwd, '..', '..', '..', 'utils',\n 'benchmarks', 'tensorflow'))\n import benchmark\n\n module = benchmark.Benchmark(\n graph_builder,\n inputs,\n initializer,\n add_args,\n iteration_report\n )\n\n options = benchmark.parse_opts(module, False)\n\n if options.shards > 0:\n raise NotImplementedError(\n \"--shards option has not been implemented with this example\")\n\n # Log Benchmark Message\n print(\" Dense layer {} Synthetic benchmark.\\n\"\n \" Batch size {}.\\n\"\n \" Batches per Step {}.\\n\"\n \" Dense size {}.\\n\"\n .format(\n \"Training\" if options.train else \"Inference\",\n options.batch_size,\n options.batches_per_step if not options.cycle_report else \"n/a\",\n options.size))\n\n benchmark.run(module, options)\n",
"# Copyright 2019 Graphcore Ltd.\nfrom functools import partial\nfrom typing import Callable, Tuple\n\nimport tensorflow as tf\n\n\ndef load_and_preprocess_data(img_path: str, img_width: int, img_height: int,\n preprocess_fn: Callable, dtype: tf.DType) -> tf.Tensor:\n \"\"\"Read and pre-process image.\n\n Args:\n img_path: Path to image\n img_width: Target width\n img_height: Target height\n preprocess_fn: Function that scales the input to the correct range.\n\n Returns: tf.Tensor representing pre-processed image in fp16.\n\n \"\"\"\n image = tf.read_file(img_path)\n image = tf.image.decode_jpeg(image, channels=3)\n image = tf.image.resize(image, [img_height, img_width])\n image = preprocess_fn(image, data_format='channels_last')\n return tf.cast(image, dtype)\n\n\ndef get_dataset(image_filenames: Tuple, batch_size: int, preprocess_fn: Callable, img_width: int, img_height: int,\n loop: bool, dtype: tf.DType) -> tf.data.Dataset:\n \"\"\"Creates an `Iterator` for enumerating the elements of this dataset.\n\n Note: The returned iterator will be in an uninitialized state,\n and you must run the `iterator.initializer` operation before using it:\n\n ```python\n dataset = ...\n iterator = dataset.make_initializable_iterator()\n # ...\n sess.run(iterator.initializer)\n ```\n\n Args:\n image_filenames: Tuple of image filenames, with each filename corresponding to the label of the image.\n batch_size: Number of images per batch\n preprocess_fn: Pre-processing to apply\n img_width: Expected width of image\n img_height: Expected height of image\n loop: Repeatedly loop through images.\n dtype: Input data type.\n\n\n Returns:\n Iterator over images and labels.\n\n \"\"\"\n\n image_ds = tf.data.Dataset.from_tensor_slices(tf.constant([str(item) for item in image_filenames]))\n if loop:\n image_ds = image_ds.repeat()\n input_preprocess = partial(load_and_preprocess_data, img_width=img_width, img_height=img_height,\n preprocess_fn=preprocess_fn, dtype=dtype)\n image_ds = image_ds.map(map_func=input_preprocess, num_parallel_calls=100)\n image_ds = image_ds.batch(batch_size, drop_remainder=True)\n image_ds = image_ds.prefetch(buffer_size=100)\n return image_ds\n"
] | [
[
"numpy.array_repr"
],
[
"tensorflow.control_dependencies",
"tensorflow.trainable_variables",
"tensorflow.variable_scope",
"tensorflow.broadcast_to",
"tensorflow.get_variable",
"tensorflow.layers.dense",
"tensorflow.train.GradientDescentOptimizer",
"tensorflow.global_variables_initializer",
"tensorflow.python.ipu.utils.move_variable_initialization_to_cpu",
"tensorflow.identity",
"tensorflow.cast",
"tensorflow.reduce_mean"
],
[
"tensorflow.read_file",
"tensorflow.image.resize",
"tensorflow.image.decode_jpeg",
"tensorflow.cast"
]
] |
MasterScott/Formasaurus | [
"d7d916237a6d2ca4c80c4c8ae5d66999c8beebed"
] | [
"tests/test_fieldtype_model.py"
] | [
"# -*- coding: utf-8 -*-\nfrom __future__ import absolute_import, division\nimport itertools\n\nimport numpy as np\nfrom sklearn_crfsuite.metrics import flat_accuracy_score\n\nfrom formasaurus.fieldtype_model import (\n train,\n _PRECISE_C1_C2,\n _REALISTIC_C1_C2,\n get_Xy,\n)\n\n\ndef test_training(storage, capsys):\n annotations = (a for a in storage.iter_annotations(\n simplify_form_types=True,\n simplify_field_types=True,\n ) if a.fields_annotated)\n annotations = list(itertools.islice(annotations, 0, 300))\n\n crf = train(\n annotations=annotations,\n use_precise_form_types=False,\n optimize_hyperparameters_iters=2,\n optimize_hyperparameters_folds=2,\n optimize_hyperparameters_jobs=-1,\n full_form_type_names=False,\n full_field_type_names=False\n )\n\n out, err = capsys.readouterr()\n\n assert 'Training on 300 forms' in out\n assert 'realistic form types' in out\n assert 'Best hyperparameters' in out\n\n assert 0.0 < crf.c1 < 2.5\n assert 0.0 < crf.c2 < 0.9\n assert crf.c1, crf.c2 != _REALISTIC_C1_C2\n assert crf.c1, crf.c2 != _PRECISE_C1_C2\n\n form_types = np.asarray([a.type for a in annotations])\n X, y = get_Xy(annotations, form_types, full_type_names=False)\n y_pred = crf.predict(X)\n score = flat_accuracy_score(y, y_pred)\n assert 0.9 < score < 1.0 # overfitting FTW!\n\n field_schema = storage.get_field_schema()\n short_names = set(field_schema.types_inv.keys())\n assert set(crf.classes_).issubset(short_names)\n"
] | [
[
"numpy.asarray"
]
] |
Wentaobi/Udacity | [
"00af9c36b42d6bca5f2d42d2744efed2ddb51587"
] | [
"Self_Driving_Car/P1/LaneLines-P1/P1.py"
] | [
"#importing some useful packages\nimport matplotlib.pyplot as plt\nimport matplotlib.image as mpimg\nimport numpy as np\nimport cv2\n\n\n#reading in an image\nimage = mpimg.imread('test_images/solidWhiteRight.jpg');\n#printing out some stats and plotting\nprint('This image is:', type(image), 'with dimesions:', image.shape)\nplt.imshow(image); #call as plt.imshow(gray, cmap='gray') to show a grayscaled image\n\nimport math\n\ndef grayscale(img):\n \"\"\"Applies the Grayscale transform\n This will return an image with only one color channel\n but NOTE: to see the returned image as grayscale\n you should call plt.imshow(gray, cmap='gray')\"\"\"\n return cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)\n # Or use BGR2GRAY if you read an image with cv2.imread()\n # return cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n\ndef hsv(img):\n return cv2.cvtColor(img, cv2.COLOR_RGB2HSV)\n\ndef canny(img, low_threshold, high_threshold):\n \"\"\"Applies the Canny transform\"\"\"\n return cv2.Canny(img, low_threshold, high_threshold)\n\ndef gaussian_blur(img, kernel_size):\n \"\"\"Applies a Gaussian Noise kernel\"\"\"\n return cv2.GaussianBlur(img, (kernel_size, kernel_size), 0)\n\ndef region_of_interest(img, vertices):\n \"\"\"\n Applies an image mask.\n\n Only keeps the region of the image defined by the polygon\n formed from `vertices`. The rest of the image is set to black.\n \"\"\"\n #defining a blank mask to start with\n mask = np.zeros_like(img)\n\n #defining a 3 channel or 1 channel color to fill the mask with depending on the input image\n if len(img.shape) > 2:\n channel_count = img.shape[2] # i.e. 3 or 4 depending on your image\n ignore_mask_color = (255,) * channel_count\n else:\n ignore_mask_color = 255\n\n #filling pixels inside the polygon defined by \"vertices\" with the fill color\n cv2.fillPoly(mask, vertices, ignore_mask_color)\n\n #returning the image only where mask pixels are nonzero\n masked_image = cv2.bitwise_and(img, mask)\n return masked_image\n\n\ndef draw_lines(img, lines, color=[255, 0, 0], thickness=13):\n \"\"\"\n NOTE: this is the function you might want to use as a starting point once you want to\n average/extrapolate the line segments you detect to map out the full\n extent of the lane (going from the result shown in raw-lines-example.mp4\n to that shown in P1_example.mp4).\n\n Think about things like separating line segments by their\n slope ((y2-y1)/(x2-x1)) to decide which segments are part of the left\n line vs. the right line. Then, you can average the position of each of\n the lines and extrapolate to the top and bottom of the lane.\n\n This function draws `lines` with `color` and `thickness`.\n Lines are drawn on the image inplace (mutates the image).\n If you want to make the lines semi-transparent, think about combining\n this function with the weighted_img() function below\n \"\"\"\n x_size = img.shape[1]\n y_size = img.shape[0]\n lines_slope_intercept = np.zeros(shape=(len(lines),2))\n for index,line in enumerate(lines):\n for x1,y1,x2,y2 in line:\n slope = (y2-y1)/(x2-x1)\n intercept = y1 - x1 * slope\n lines_slope_intercept[index]=[slope,intercept]\n max_slope_line = lines_slope_intercept[lines_slope_intercept.argmax(axis=0)[0]]\n min_slope_line = lines_slope_intercept[lines_slope_intercept.argmin(axis=0)[0]]\n left_slopes = []\n left_intercepts = []\n right_slopes = []\n right_intercepts = []\n # this gets slopes and intercepts of lines similar to the lines with the max (immediate left) and min\n # (immediate right) slopes (i.e. slope and intercept within x%)\n for line in lines_slope_intercept:\n if abs(line[0] - max_slope_line[0]) < 0.15 and abs(line[1] - max_slope_line[1]) < (0.15 * x_size):\n left_slopes.append(line[0])\n left_intercepts.append(line[1])\n elif abs(line[0] - min_slope_line[0]) < 0.15 and abs(line[1] - min_slope_line[1]) < (0.15 * x_size):\n right_slopes.append(line[0])\n right_intercepts.append(line[1])\n # left and right lines are averages of these slopes and intercepts, extrapolate lines to edges and center*\n # *roughly\n new_lines = np.zeros(shape=(1,2,4), dtype=np.int32)\n if len(left_slopes) > 0:\n left_line = [sum(left_slopes)/len(left_slopes),sum(left_intercepts)/len(left_intercepts)]\n left_bottom_x = (y_size - left_line[1])/left_line[0]\n left_top_x = (y_size*.575 - left_line[1])/left_line[0]\n if (left_bottom_x >= 0):\n new_lines[0][0] =[left_bottom_x,y_size,left_top_x,y_size*.575]\n if len(right_slopes) > 0:\n right_line = [sum(right_slopes)/len(right_slopes),sum(right_intercepts)/len(right_intercepts)]\n right_bottom_x = (y_size - right_line[1])/right_line[0]\n right_top_x = (y_size*.575 - right_line[1])/right_line[0]\n if (right_bottom_x <= x_size):\n new_lines[0][1]=[right_bottom_x,y_size,right_top_x,y_size*.575]\n for line in new_lines:\n for x1,y1,x2,y2 in line:\n cv2.line(img, (x1, y1), (x2, y2), color, thickness)\n\ndef hough_lines(img, rho, theta, threshold, min_line_len, max_line_gap):\n \"\"\"\n `img` should be the output of a Canny transform.\n\n Returns an image with hough lines drawn.\n \"\"\"\n lines = cv2.HoughLinesP(img, rho, theta, threshold, np.array([]), minLineLength=min_line_len, maxLineGap=max_line_gap)\n line_img = np.zeros((img.shape[0], img.shape[1], 3), dtype=np.uint8)\n draw_lines(line_img, lines)\n return line_img\n\n# Python 3 has support for cool math symbols.\n\ndef weighted_img(img, initial_img, α=0.8, β=1., λ=0.):\n \"\"\"\n `img` is the output of the hough_lines(), An image with lines drawn on it.\n Should be a blank image (all black) with lines drawn on it.\n\n `initial_img` should be the image before any processing.\n\n The result image is computed as follows:\n\n initial_img * α + img * β + λ\n NOTE: initial_img and img must be the same shape!\n \"\"\"\n return cv2.addWeighted(initial_img, α, img, β, λ)\n\nimport os\nos.listdir(\"test_images/\")\n\n#reading in an image\nfor index, img in enumerate(os.listdir(\"test_images/\")):\n image = mpimg.imread('test_images/' + img)\n\n gray_img = grayscale(image)\n\n hsv_img = hsv(image)\n\n # define range of color in HSV\n lower_yel = np.array([20,100,100])\n upper_yel = np.array([30,255,255])\n lower_wht = np.array([0,0,235])\n upper_wht = np.array([255,255,255])\n\n # Threshold the HSV image to get only yellow/white\n yellow_mask = cv2.inRange(hsv_img, lower_yel, upper_yel)\n white_mask = cv2.inRange(hsv_img, lower_wht, upper_wht)\n # Bitwise-AND mask and original image\n full_mask = cv2.bitwise_or(yellow_mask, white_mask)\n\n subdued_gray = (gray_img / 2).astype('uint8')\n\n boosted_lanes = cv2.bitwise_or(subdued_gray, full_mask)\n\n kernel_size = 5\n blurred_img = gaussian_blur(boosted_lanes,kernel_size)\n\n canny_low_threshold = 60\n canny_high_threshold = 150\n edges_img = canny(blurred_img,canny_low_threshold,canny_high_threshold)\n\n x = edges_img.shape[1]\n y = edges_img.shape[0]\n vertices = np.array([[(x*0.,y),(x*.475, y*.575), (x*.525, y*.575), (x,y)]], dtype=np.int32)\n masked_img = region_of_interest(edges_img, vertices)\n\n hough_rho = 3\n hough_theta = np.pi/180\n hough_threshold = 70\n hough_min_line_length = 70\n hough_max_line_gap = 250\n hough_img = hough_lines(masked_img,hough_rho,hough_theta,hough_threshold,hough_min_line_length,hough_max_line_gap)\n\n result = weighted_img(hough_img,image)\n\n fig = plt.figure(figsize=(6,10))\n plt.imshow(result, cmap=\"gray\") #call as plt.imshow(gray, cmap='gray') to show a grayscaled image\n\n#reading in an image\nfor index, img in enumerate(os.listdir(\"test_images2/\")):\n image = mpimg.imread('test_images2/' + img)\n\n gray_img = grayscale(image)\n\n hsv_img = hsv(image)\n\n # define range of color in HSV\n lower_yel = np.array([20,100,100])\n upper_yel = np.array([30,255,255])\n lower_wht = np.array([0,0,235])\n upper_wht = np.array([255,255,255])\n\n # Threshold the HSV image to get only yellow/white\n yellow_mask = cv2.inRange(hsv_img, lower_yel, upper_yel)\n white_mask = cv2.inRange(hsv_img, lower_wht, upper_wht)\n # Bitwise-AND mask and original image\n full_mask = cv2.bitwise_or(yellow_mask, white_mask)\n\n subdued_gray = (gray_img / 2).astype('uint8')\n\n boosted_lanes = cv2.bitwise_or(subdued_gray, full_mask)\n\n kernel_size = 5\n blurred_img = gaussian_blur(boosted_lanes,kernel_size)\n\n canny_low_threshold = 60\n canny_high_threshold = 150\n edges_img = canny(blurred_img,canny_low_threshold,canny_high_threshold)\n\n x = edges_img.shape[1]\n y = edges_img.shape[0]\n vertices = np.array([[(x*0.,y),(x*.475, y*.575), (x*.525, y*.575), (x,y)]], dtype=np.int32)\n masked_img = region_of_interest(edges_img, vertices)\n\n hough_rho = 3\n hough_theta = np.pi/180\n hough_threshold = 70\n hough_min_line_length = 70\n hough_max_line_gap = 250\n hough_img = hough_lines(masked_img,hough_rho,hough_theta,hough_threshold,hough_min_line_length,hough_max_line_gap)\n\n result = weighted_img(hough_img,image)\n\n fig = plt.figure(figsize=(8,10))\n plt.imshow(result, cmap=\"gray\") #call as plt.imshow(gray, cmap='gray') to show a grayscaled image\n\n# Import everything needed to edit/save/watch video clips\nfrom moviepy.editor import VideoFileClip\n# from IPython.display import HTML\n\ndef process_image(image):\n # NOTE: The output you return should be a color image (3 channel) for processing video below\n # TODO: put your pipeline here,\n # you should return the final output (image with lines are drawn on lanes)\n\n gray_img = grayscale(image)\n\n hsv_img = hsv(image)\n\n # define range of color in HSV\n lower_yel = np.array([20,100,100])\n upper_yel = np.array([30,255,255])\n lower_wht = np.array([0,0,235])\n upper_wht = np.array([255,255,255])\n\n # Threshold the HSV image to get only yellow/white\n yellow_mask = cv2.inRange(hsv_img, lower_yel, upper_yel)\n white_mask = cv2.inRange(hsv_img, lower_wht, upper_wht)\n # Bitwise-AND mask and original image\n full_mask = cv2.bitwise_or(yellow_mask, white_mask)\n\n subdued_gray = (gray_img / 2).astype('uint8')\n\n boosted_lanes = cv2.bitwise_or(subdued_gray, full_mask)\n\n kernel_size = 5\n blurred_img = gaussian_blur(boosted_lanes,kernel_size)\n\n canny_low_threshold = 60\n canny_high_threshold = 150\n edges_img = canny(blurred_img,canny_low_threshold,canny_high_threshold)\n\n x = edges_img.shape[1]\n y = edges_img.shape[0]\n vertices = np.array([[(x*0.,y),(x*.475, y*.575), (x*.525, y*.575), (x,y)]], dtype=np.int32)\n masked_img = region_of_interest(edges_img, vertices)\n\n hough_rho = 3\n hough_theta = np.pi/180\n hough_threshold = 70\n hough_min_line_length = 70\n hough_max_line_gap = 250\n hough_img = hough_lines(masked_img,hough_rho,hough_theta,hough_threshold,hough_min_line_length,hough_max_line_gap)\n\n result = weighted_img(hough_img,image)\n\n #return cv2.cvtColor(masked_img, cv2.COLOR_GRAY2RGB)\n return result\n\n\nwhite_output = 'white.mp4'\nclip1 = VideoFileClip(\"solidWhiteRight.mp4\")\nwhite_clip = clip1.fl_image(process_image) #NOTE: this function expects color images!!\nwhite_clip.write_videofile(white_output, audio=False)\n\n\n# HTML(\"\"\"\n# <video width=\"960\" height=\"540\" controls>\n# <source src=\"{0}\">\n# </video>\n# \"\"\".format(white_output))\n\n\nyellow_output = 'yellow.mp4'\nclip2 = VideoFileClip('solidYellowLeft.mp4')\nyellow_clip = clip2.fl_image(process_image)\nyellow_clip.write_videofile(yellow_output, audio=False)\n\n\n# HTML(\"\"\"\n# <video width=\"960\" height=\"540\" controls>\n# <source src=\"{0}\">\n# </video>\n# \"\"\".format(yellow_output))\n\n\nchallenge_output = 'extra.mp4'\nclip2 = VideoFileClip('challenge.mp4')\nchallenge_clip = clip2.fl_image(process_image)\nchallenge_clip.write_videofile(challenge_output, audio=False)\n\n#\n# HTML(\"\"\"\n# <video width=\"960\" height=\"540\" controls>\n# <source src=\"{0}\">\n# </video>\n# \"\"\".format(challenge_output))\n"
] | [
[
"numpy.array",
"numpy.zeros_like",
"numpy.zeros",
"matplotlib.image.imread",
"matplotlib.pyplot.figure",
"matplotlib.pyplot.imshow"
]
] |
adelavega/pliers | [
"dee21102689c77a56b7da48bf9a0ac10c90be0eb"
] | [
"pliers/tests/extractors/api/test_clarifai_extractors.py"
] | [
"from os.path import join\nfrom ...utils import get_test_data_path\nfrom pliers.extractors import ClarifaiAPIExtractor\nfrom pliers.stimuli import ImageStim\nfrom pliers.extractors.base import merge_results\nimport numpy as np\nimport pytest\n\n\[email protected](\"'CLARIFAI_API_KEY' not in os.environ\")\ndef test_clarifai_api_extractor():\n image_dir = join(get_test_data_path(), 'image')\n stim = ImageStim(join(image_dir, 'apple.jpg'))\n result = ClarifaiAPIExtractor().transform(stim).to_df()\n assert result['apple'][0] > 0.5\n assert result.ix[:, 5][0] > 0.0\n\n result = ClarifaiAPIExtractor(max_concepts=5).transform(stim).to_df()\n assert result.shape == (1, 9)\n\n result = ClarifaiAPIExtractor(\n min_value=0.9).transform(stim).to_df(object_id=False)\n assert all(np.isnan(d) or d > 0.9 for d in result.values[0, 3:])\n\n concepts = ['cat', 'dog']\n result = ClarifaiAPIExtractor(select_concepts=concepts).transform(stim)\n result = result.to_df()\n assert result.shape == (1, 6)\n assert 'cat' in result.columns and 'dog' in result.columns\n\n\[email protected](\"'CLARIFAI_API_KEY' not in os.environ\")\ndef test_clarifai_api_extractor_batch():\n image_dir = join(get_test_data_path(), 'image')\n stim = ImageStim(join(image_dir, 'apple.jpg'))\n stim2 = ImageStim(join(image_dir, 'obama.jpg'))\n ext = ClarifaiAPIExtractor()\n results = ext.transform([stim, stim2])\n results = merge_results(results)\n assert results['ClarifaiAPIExtractor#apple'][0] > 0.5 or \\\n results['ClarifaiAPIExtractor#apple'][1] > 0.5\n\n # This takes too long to execute\n # video = VideoStim(join(get_test_data_path(), 'video', 'small.mp4'))\n # results = ExtractorResult.merge_stims(ext.transform(video))\n # assert 'Lego' in results.columns and 'robot' in results.columns\n"
] | [
[
"numpy.isnan"
]
] |
makistsantekidis/opendr | [
"07dee3b59d3487b9c5a93d6946317178a02c9890",
"07dee3b59d3487b9c5a93d6946317178a02c9890",
"07dee3b59d3487b9c5a93d6946317178a02c9890"
] | [
"src/opendr/perception/object_tracking_2d/fair_mot/object_tracking_2d_fair_mot_learner.py",
"src/opendr/perception/facial_expression_recognition/landmark_based_facial_expression_recognition/algorithm/datasets/gen_facial_muscles_data.py",
"projects/control/single_demo_grasp/simulation_ws/src/single_demo_grasping_demo/inference/single_demo_grasp_camera_stream.py"
] | [
"# Copyright 2020-2021 OpenDR European Project\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 os\nimport json\nimport torch\nimport ntpath\nimport shutil\nimport numpy as np\nimport onnxruntime as ort\nfrom torchvision.transforms import transforms as T\nfrom opendr.engine.learners import Learner\nfrom opendr.engine.datasets import DatasetIterator, ExternalDataset, MappedDatasetIterator\nfrom opendr.perception.object_tracking_2d.logger import Logger\nfrom opendr.perception.object_tracking_2d.datasets.mot_dataset import JointDataset, RawMotDatasetIterator\nfrom opendr.perception.object_tracking_2d.fair_mot.algorithm.lib.models.model import create_model\nfrom opendr.perception.object_tracking_2d.fair_mot.algorithm.run import train, evaluate\nfrom opendr.perception.object_tracking_2d.fair_mot.algorithm.load import load_from_checkpoint\nfrom opendr.perception.object_tracking_2d.datasets.mot_dataset import letterbox, process as process_dataset\nfrom opendr.perception.object_tracking_2d.fair_mot.algorithm.lib.tracker.multitracker import JDETracker\nfrom opendr.engine.data import Image\nfrom opendr.engine.target import TrackingAnnotation, TrackingAnnotationList\nfrom opendr.engine.constants import OPENDR_SERVER_URL\nfrom urllib.request import urlretrieve\n\n\nclass ObjectTracking2DFairMotLearner(Learner):\n def __init__(\n self,\n lr=0.0001,\n iters=-1,\n batch_size=4,\n optimizer=\"adam\",\n lr_schedule=\"\",\n backbone=\"dla_34\",\n network_head=\"\",\n checkpoint_after_iter=0,\n checkpoint_load_iter=0,\n temp_path=\"\",\n device=\"cuda\",\n threshold=0.3,\n scale=1.0,\n lr_step=[20],\n head_conv=256,\n ltrb=True,\n num_classes=1,\n reg_offset=True,\n gpus=[0],\n num_workers=4,\n mse_loss=False,\n reg_loss='l1',\n dense_wh=False,\n cat_spec_wh=False,\n reid_dim=128,\n norm_wh=False,\n wh_weight=0.1,\n off_weight=1,\n id_weight=1,\n num_epochs=30,\n hm_weight=1,\n down_ratio=4,\n max_objs=500,\n track_buffer=30,\n image_mean=[0.408, 0.447, 0.47],\n image_std=[0.289, 0.274, 0.278],\n frame_rate=30,\n min_box_area=100,\n ):\n # Pass the shared parameters on super's constructor so they can get initialized as class attributes\n super(ObjectTracking2DFairMotLearner, self).__init__(\n lr=lr,\n iters=iters,\n batch_size=batch_size,\n optimizer=optimizer,\n lr_schedule=lr_schedule,\n backbone=backbone,\n network_head=network_head,\n checkpoint_after_iter=checkpoint_after_iter,\n checkpoint_load_iter=checkpoint_load_iter,\n temp_path=temp_path,\n device=device,\n threshold=threshold,\n scale=scale,\n )\n\n self.ltrb = ltrb\n self.head_conv = head_conv\n self.num_classes = num_classes\n self.reid_dim = reid_dim\n self.reg_offset = reg_offset\n self.gpus = gpus\n self.num_workers = num_workers\n self.mse_loss = mse_loss\n self.reg_loss = reg_loss\n self.dense_wh = dense_wh\n self.cat_spec_wh = cat_spec_wh\n self.reid_dim = reid_dim\n self.norm_wh = norm_wh\n self.wh_weight = wh_weight\n self.off_weight = off_weight\n self.id_weight = id_weight\n self.num_epochs = num_epochs\n self.lr_step = lr_step\n self.hm_weight = hm_weight\n self.down_ratio = down_ratio\n self.max_objs = max_objs\n self.track_buffer = track_buffer\n self.image_mean = image_mean\n self.image_mean = image_mean\n self.image_std = image_std\n self.frame_rate = frame_rate\n self.min_box_area = min_box_area\n\n main_batch_size = self.batch_size // len(self.gpus)\n rest_batch_size = (self.batch_size - main_batch_size)\n self.chunk_sizes = [main_batch_size]\n\n for i in range(len(self.gpus) - 1):\n worker_chunk_size = rest_batch_size // (len(self.gpus) - 1)\n if i < rest_batch_size % (len(self.gpus) - 1):\n worker_chunk_size += 1\n self.chunk_sizes.append(worker_chunk_size)\n\n self.__create_model()\n\n def save(self, path, verbose=False):\n \"\"\"\n This method is used to save a trained model.\n Provided with the path, absolute or relative, including a *folder* name, it creates a directory with the name\n of the *folder* provided and saves the model inside with a proper format and a .json file with metadata.\n If self.optimize was ran previously, it saves the optimized ONNX model in a similar fashion, by copying it\n from the self.temp_path it was saved previously during conversion.\n :param path: for the model to be saved, including the folder name\n :type path: str\n :param verbose: whether to print success message or not, defaults to 'False'\n :type verbose: bool, optional\n \"\"\"\n\n if self.model is None and self.ort_session is None:\n raise UserWarning(\"No model is loaded, cannot save.\")\n\n folder_name, _, tail = self.__extract_trailing(path) # Extract trailing folder name from path\n # Also extract folder name without any extension if extension is erroneously provided\n folder_name_no_ext = folder_name.split(sep='.')[0]\n\n # Extract path without folder name, by removing folder name from original path\n path_no_folder_name = ''.join(path.rsplit(folder_name, 1))\n # If tail is '', then path was a/b/c/, which leaves a trailing double '/'\n if tail == '':\n path_no_folder_name = path_no_folder_name[0:-1] # Remove one '/'\n\n # Create model directory\n new_path = path_no_folder_name + folder_name_no_ext\n os.makedirs(new_path, exist_ok=True)\n\n model_metadata = {\"model_paths\": [], \"framework\": \"pytorch\", \"format\": \"\", \"has_data\": False,\n \"inference_params\": {}, \"optimized\": None, \"optimizer_info\": {}}\n\n if self.model.ort_session is None:\n model_metadata[\"model_paths\"] = [\n folder_name_no_ext + \".pth\",\n ]\n model_metadata[\"optimized\"] = False\n model_metadata[\"format\"] = \"pth\"\n\n torch.save({\n 'state_dict': self.model.state_dict()\n }, os.path.join(path_no_folder_name, folder_name_no_ext, model_metadata[\"model_paths\"][0]))\n if verbose:\n print(\"Saved Pytorch model.\")\n else:\n model_metadata[\"model_paths\"] = [\n folder_name_no_ext + \".onnx\"\n ]\n model_metadata[\"optimized\"] = True\n model_metadata[\"format\"] = \"onnx\"\n\n shutil.copy2(\n os.path.join(self.temp_path, \"onnx_model_temp.onnx\"),\n os.path.join(path_no_folder_name, folder_name_no_ext, model_metadata[\"model_paths\"][0])\n )\n if verbose:\n print(\"Saved ONNX model.\")\n\n with open(os.path.join(new_path, folder_name_no_ext + \".json\"), 'w') as outfile:\n json.dump(model_metadata, outfile)\n\n def load(\n self,\n path,\n verbose=False,\n ):\n \"\"\"\n Loads the model from inside the path provided, based on the metadata .json file included.\n :param path: path of the directory the model was saved\n :type path: str\n :param verbose: whether to print success message or not, defaults to 'False'\n :type verbose: bool, optional\n \"\"\"\n\n model_name, _, _ = self.__extract_trailing(path) # Trailing folder name from the path provided\n\n with open(os.path.join(path, model_name + \".json\")) as metadata_file:\n metadata = json.load(metadata_file)\n\n if not metadata[\"optimized\"]:\n self.__load_from_pth(self.model, os.path.join(path, metadata[\"model_paths\"][0]))\n if verbose:\n print(\"Loaded Pytorch model.\")\n else:\n self.__load_rpn_from_onnx(os.path.join(path, metadata[\"model_paths\"][0]))\n if verbose:\n print(\"Loaded ONNX model.\")\n\n def reset(self):\n self.tracker.reset()\n\n def fit(\n self,\n dataset,\n val_dataset=None,\n val_epochs=-1,\n logging_path=None,\n silent=False,\n verbose=False,\n train_split_paths=None,\n val_split_paths=None,\n resume_optimizer=False,\n nID=None\n ):\n\n if train_split_paths is None:\n train_split_paths = {\n \"mot20\": os.path.join(\n \"perception\", \"object_tracking_2d\", \"datasets\", \"splits\", \"mot20.train\"\n )\n }\n\n if val_split_paths is None:\n val_split_paths = train_split_paths\n\n logger = Logger(silent, verbose, logging_path)\n\n (\n input_dataset_iterator,\n eval_dataset_iterator,\n ) = self._prepare_datasets(\n dataset,\n val_dataset,\n train_split_paths,\n val_split_paths,\n require_val_dataset=val_epochs > 0,\n )\n\n if nID is None:\n nID = input_dataset_iterator.nID if hasattr(input_dataset_iterator, \"nID\") else dataset.nID\n\n checkpoints_path = os.path.join(self.temp_path, \"checkpoints\")\n if self.checkpoint_after_iter != 0 or self.checkpoint_load_iter != 0:\n os.makedirs(checkpoints_path, exist_ok=True)\n\n start_epoch = 0\n\n if self.checkpoint_load_iter != 0:\n _, _, start_epoch = load_from_checkpoint(\n self.model, os.path.join(checkpoints_path, f\"checkpoint_{self.checkpoint_load_iter}.pth\"),\n self.model_optimizer, resume_optimizer, self.lr, self.lr_step, log=logger.log,\n )\n\n last_eval_result = train(\n self.model,\n self.infer,\n self.model_optimizer,\n input_dataset_iterator,\n eval_dataset_iterator,\n self.batch_size,\n self.num_workers,\n self.gpus,\n self.chunk_sizes,\n self.iters,\n \"train\", # exp_id,\n self.device,\n silent, # hide_data_time,\n 1 if verbose else (-1 if silent else 10), # print_iter,\n self.mse_loss,\n self.reg_loss,\n self.dense_wh,\n self.cat_spec_wh,\n self.reid_dim,\n nID,\n self.norm_wh,\n 1, # num_stack,\n self.wh_weight,\n self.off_weight,\n self.id_weight,\n self.num_epochs,\n self.lr_step,\n self.temp_path,\n self.lr,\n self.reg_offset,\n self.hm_weight,\n checkpoints_path,\n self.checkpoint_after_iter,\n start_epoch,\n val_epochs=val_epochs,\n log=logger.log,\n )\n\n logger.close()\n\n return last_eval_result\n\n def eval(\n self,\n dataset,\n val_split_paths=None,\n logging_path=None,\n silent=False,\n verbose=False,\n ):\n\n logger = Logger(silent, verbose, logging_path)\n\n (\n _,\n eval_dataset_iterator,\n ) = self._prepare_datasets(\n None,\n dataset,\n None,\n val_split_paths,\n require_dataset=False,\n )\n\n result = evaluate(self.infer, dataset)\n\n logger.log(Logger.LOG_WHEN_NORMAL, result)\n\n logger.close()\n\n return result\n\n def infer(self, batch, frame_ids=None, img_size=(1088, 608)):\n\n if self.model is None:\n raise ValueError(\"No model loaded or created\")\n\n self.model.eval()\n\n is_single_image = False\n\n if isinstance(batch, Image):\n batch = [batch]\n is_single_image = True\n elif not isinstance(batch, list):\n raise ValueError(\"Input batch should be an engine.Image or a list of engine.Image\")\n\n if frame_ids is None:\n frame_ids = [-1] * len(batch)\n elif is_single_image:\n frame_ids = [frame_ids]\n\n results = []\n\n for image, frame_id in zip(batch, frame_ids):\n\n img0 = image.convert(\"channels_last\", \"bgr\") # BGR\n img, _, _, _ = letterbox(img0, height=img_size[1], width=img_size[0])\n\n # Normalize RGB\n img = img[:, :, ::-1].transpose(2, 0, 1)\n img = np.ascontiguousarray(img, dtype=np.float32)\n img /= 255.0\n\n blob = torch.from_numpy(img).to(self.device).unsqueeze(0)\n\n online_targets = self.tracker.update(blob, img0)\n online_tlwhs = []\n online_ids = []\n online_scores = []\n for t in online_targets:\n tlwh = t.tlwh\n tid = t.track_id\n vertical = tlwh[2] / tlwh[3] > 1.6\n if tlwh[2] * tlwh[3] > self.min_box_area and not vertical:\n online_tlwhs.append(tlwh)\n online_ids.append(tid)\n online_scores.append(t.score)\n\n result = TrackingAnnotationList([\n TrackingAnnotation(\n name=0,\n top=tlwh[0],\n left=tlwh[1],\n width=tlwh[2],\n height=tlwh[3],\n id=id,\n score=score,\n frame=frame_id,\n ) for tlwh, id, score in zip(\n online_tlwhs,\n online_ids,\n online_scores\n )\n ])\n\n results.append(result)\n\n if is_single_image:\n results = results[0]\n\n return results\n\n def optimize(self, do_constant_folding=False, img_size=(1088, 608), optimizable_dcn_v2=False):\n \"\"\"\n Optimize method converts the model to ONNX format and saves the\n model in the parent directory defined by self.temp_path. The ONNX model is then loaded.\n :param do_constant_folding: whether to optimize constants, defaults to 'False'\n :type do_constant_folding: bool, optional\n \"\"\"\n\n if not optimizable_dcn_v2:\n raise Exception(\"Can not optimize the model while DCNv2 implementation is not optimizable\")\n\n if self.model is None:\n raise UserWarning(\"No model is loaded, cannot optimize. Load or train a model first.\")\n if self.model.ort_session is not None:\n raise UserWarning(\"Model is already optimized in ONNX.\")\n\n input_shape = [\n 1,\n 3,\n img_size[1],\n img_size[0],\n ]\n\n try:\n self.__convert_to_onnx(\n input_shape,\n os.path.join(self.temp_path, \"onnx_model_temp.onnx\"), do_constant_folding\n )\n except FileNotFoundError:\n # Create temp directory\n os.makedirs(self.temp_path, exist_ok=True)\n self.__convert_rpn_to_onnx(\n input_shape,\n os.path.join(self.temp_path, \"onnx_model_temp.onnx\"), do_constant_folding\n )\n\n self.__load_rpn_from_onnx(os.path.join(self.temp_path, \"onnx_model_rpn_temp.onnx\"))\n\n @staticmethod\n def download(model_name, path, server_url=None):\n\n if server_url is None and model_name not in [\n \"crowdhuman_dla34\",\n \"fairmot_dla34\",\n ]:\n raise ValueError(\"Unknown model_name: \" + model_name)\n\n os.makedirs(path, exist_ok=True)\n\n if server_url is None:\n server_url = os.path.join(\n OPENDR_SERVER_URL, \"perception\", \"object_tracking_2d\",\n \"fair_mot\"\n )\n\n url = os.path.join(\n server_url, model_name\n )\n\n model_dir = os.path.join(path, model_name)\n os.makedirs(model_dir, exist_ok=True)\n\n urlretrieve(os.path.join(\n url, model_name + \".json\"\n ), os.path.join(\n model_dir, model_name + \".json\"\n ))\n\n try:\n urlretrieve(os.path.join(\n url, model_name + \".pth\"\n ), os.path.join(\n model_dir, model_name + \".pth\"\n ))\n except Exception:\n urlretrieve(os.path.join(\n url, model_name + \".tckpt\"\n ), os.path.join(\n model_dir, model_name + \".pth\"\n ))\n\n print(\"Downloaded model\", model_name, \"to\", model_dir)\n\n return model_dir\n\n def __convert_to_onnx(self, input_shape, output_name, do_constant_folding=False, verbose=False):\n inp = torch.randn(input_shape).to(self.device)\n input_names = [\"data\"]\n output_names = self.heads.keys()\n\n torch.onnx.export(\n self.model, inp, output_name, verbose=verbose, enable_onnx_checker=True,\n do_constant_folding=do_constant_folding, input_names=input_names, output_names=output_names\n )\n\n def __load_from_onnx(self, path):\n \"\"\"\n This method loads an ONNX model from the path provided into an onnxruntime inference session.\n\n :param path: path to ONNX model\n :type path: str\n \"\"\"\n self.model.rpn_ort_session = ort.InferenceSession(path)\n\n # The comments below are the alternative way to use the onnx model, it might be useful in the future\n # depending on how ONNX saving/loading will be implemented across the toolkit.\n # # Load the ONNX model\n # self.model = onnx.load(path)\n #\n # # Check that the IR is well formed\n # onnx.checker.check_model(self.model)\n #\n # # Print a human readable representation of the graph\n # onnx.helper.printable_graph(self.model.graph)\n\n def __load_from_pth(self, model, path, use_original_dict=False):\n all_params = torch.load(path, map_location=self.device)\n model.load_state_dict(all_params if use_original_dict else all_params[\"state_dict\"])\n\n def _prepare_datasets(\n self,\n dataset,\n val_dataset,\n train_split_paths,\n val_split_paths,\n require_dataset=True,\n require_val_dataset=True,\n ):\n\n input_dataset_iterator = None\n eval_dataset_iterator = None\n\n if isinstance(dataset, ExternalDataset):\n\n dataset_path = dataset.path\n if dataset.dataset_type.lower() != \"mot\":\n raise ValueError(\n \"ExternalDataset (\" + str(dataset) +\n \") is given as a dataset, but it is not a MOT dataset\")\n\n transforms = T.Compose([T.ToTensor()])\n input_dataset_iterator = JointDataset(\n dataset_path,\n train_split_paths,\n down_ratio=self.down_ratio,\n max_objects=self.max_objs,\n ltrb=self.ltrb,\n mse_loss=self.mse_loss,\n augment=False, transforms=transforms,\n )\n elif isinstance(dataset, DatasetIterator):\n input_dataset_iterator = MappedDatasetIterator(\n dataset,\n lambda d: process_dataset(\n d[0], d[1], self.ltrb, self.down_ratio,\n self.max_objs, self.num_classes, self.mse_loss\n )\n )\n else:\n if require_dataset or dataset is not None:\n raise ValueError(\n \"dataset parameter should be an ExternalDataset or a DatasetIterator\"\n )\n\n if isinstance(val_dataset, ExternalDataset):\n\n val_dataset_path = val_dataset.path\n if val_dataset.dataset_type.lower() != \"mot\":\n raise ValueError(\n \"ExternalDataset (\" + str(val_dataset) +\n \") is given as a val_dataset, but it is not a MOT dataset\"\n )\n\n eval_dataset_iterator = RawMotDatasetIterator(\n val_dataset_path,\n val_split_paths,\n down_ratio=self.down_ratio,\n max_objects=self.max_objs,\n ltrb=self.ltrb,\n mse_loss=self.mse_loss,\n )\n\n elif isinstance(val_dataset, DatasetIterator):\n eval_dataset_iterator = val_dataset\n elif val_dataset is None:\n if isinstance(dataset, ExternalDataset):\n val_dataset_path = dataset.path\n if dataset.dataset_type.lower() != \"mot\":\n raise ValueError(\n \"ExternalDataset (\" + str(dataset) +\n \") is given as a dataset, but it is not a MOT dataset\"\n )\n\n eval_dataset_iterator = RawMotDatasetIterator(\n val_dataset_path,\n val_split_paths,\n down_ratio=self.down_ratio,\n max_objects=self.max_objs,\n ltrb=self.ltrb,\n mse_loss=self.mse_loss,\n )\n\n elif require_val_dataset:\n raise ValueError(\n \"val_dataset is None and can't be derived from\" +\n \" the dataset object because the dataset is not an ExternalDataset\"\n )\n else:\n eval_dataset_iterator = input_dataset_iterator\n else:\n raise ValueError(\n \"val_dataset parameter should be an ExternalDataset or a DatasetIterator or None\"\n )\n\n return input_dataset_iterator, eval_dataset_iterator\n\n def __create_model(self):\n\n heads = {\n 'hm': self.num_classes,\n 'wh': 2 if not self.ltrb else 4,\n 'id': self.reid_dim\n }\n if self.reg_offset:\n heads.update({'reg': 2})\n\n self.heads = heads\n\n self.model = create_model(self.backbone, heads, self.head_conv)\n self.model.to(self.device)\n self.model.ort_session = None\n self.model.heads_names = heads.keys()\n\n self.model_optimizer = torch.optim.Adam(self.model.parameters(), self.lr)\n\n self.tracker = JDETracker(\n self.model,\n self.threshold,\n self.track_buffer,\n self.max_objs,\n self.image_mean,\n self.image_std,\n self.down_ratio,\n self.num_classes,\n self.reg_offset,\n self.ltrb,\n self.frame_rate,\n )\n\n @staticmethod\n def __extract_trailing(path):\n \"\"\"\n Extracts the trailing folder name or filename from a path provided in an OS-generic way, also handling\n cases where the last trailing character is a separator. Returns the folder name and the split head and tail.\n :param path: the path to extract the trailing filename or folder name from\n :type path: str\n :return: the folder name, the head and tail of the path\n :rtype: tuple of three strings\n \"\"\"\n head, tail = ntpath.split(path)\n folder_name = tail or ntpath.basename(head) # handle both a/b/c and a/b/c/\n return folder_name, head, tail\n",
"# Copyright 2020-2021 OpenDR European Project\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport numpy as np\nfrom numpy.lib.format import open_memmap\nfrom scipy.spatial import Delaunay\nimport argparse\n\n\ndef find_graph_edges(x):\n points = np.transpose(x[0, :, 0, :, 0])\n print(points.shape)\n tri = Delaunay(points)\n neigh = tri.simplices\n print(neigh.shape)\n G = []\n N = neigh.shape[0]\n for i in range(N):\n G.append((neigh[i][0], neigh[i][1]))\n G.append((neigh[i][0], neigh[i][2]))\n G.append((neigh[i][1], neigh[i][2]))\n # connect the master node (nose) to all other nodes\n for i in range(51):\n G.append((i+1, 17))\n edges = G\n return edges\n\n\ndef gen_muscle_data(data, muscle_path):\n \"\"\"Generate facial muscle data from facial landmarks\"\"\"\n N, C, T, V, M = data.shape\n edges = find_graph_edges(data)\n V_muscle = len(edges)\n fp_sp = open_memmap(muscle_path, dtype='float32', mode='w+', shape=(N, C, T, V_muscle, M))\n # Copy the landmark data to muscle placeholder tensor\n fp_sp[:, :, :, :V, :] = data\n for edge_id, (source_node, target_node) in enumerate(edges):\n fp_sp[:, :, :, edge_id, :] = data[:, :, :, source_node-1, :] - data[:, :, :, target_node-1, :]\n return fp_sp\n\n\nif __name__ == '__main__':\n parser = argparse.ArgumentParser(description='Facial muscle data generator.')\n parser.add_argument('--landmark_data_folder', default='./data/CASIA_10fold/')\n parser.add_argument('--muscle_data_folder', default='./data/muscle_data/')\n parser.add_argument('--dataset_name', default='CASIA')\n arg = parser.parse_args()\n part = ['Train', 'Val']\n for p in part:\n if arg.dataset_name == 'CASIA' or arg.dataset_name == 'CK+':\n for i in range(10):\n landmark_path = arg.landmark_data_folder + '/{}/{}_{}.npy'.format(arg.dataset_name, p, i)\n landmark_data = np.load(landmark_path)\n muscle_path = arg.muscle_data_folder + '/{}/{}_muscle_{}.npy'.format(arg.dataset_name, p, i)\n muscle_data = gen_muscle_data(landmark_data, muscle_path)\n elif arg.dataset_name == 'AFEW':\n landmark_path = arg.landmark_data_folder + '/{}/{}.npy'.format(arg.dataset_name, p)\n landmark_data = np.load(landmark_path)\n muscle_path = arg.muscle_data_folder + '/{}/{}_muscle.npy'.format(arg.dataset_name, p)\n muscle_data = gen_muscle_data(landmark_data, muscle_path)\n",
"#!/usr/bin/env python\n\n# Copyright 2020-2021 OpenDR European Project\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 os\nimport sys\nimport rospy\nimport numpy as np\nfrom std_msgs.msg import Int16\nfrom sensor_msgs.msg import Image as ROS_Image\nfrom std_msgs.msg import Float32MultiArray\nfrom single_demo_inference import SingleDemoInference\nfrom opendr_bridge import ROSBridge\n\n\nclass SingleDemoGraspCameraStream(object):\n\n def __init__(self, path_to_dt_model, thresh):\n \"\"\"SingleDemoGraspCameraStream initialization\"\"\"\n self.object_locator = SingleDemoInference(path_to_dt_model, thresh)\n self.rgb_image = None\n self.command_publisher = rospy.Publisher('/commands', Float32MultiArray, queue_size=1)\n self.detection_request_sub = rospy.Subscriber(\"/request_detection\", Int16, self.request_callback)\n self.image_sub = rospy.Subscriber(\"/camera/color/raw\", ROS_Image, self.image_callback)\n self.bridge = ROSBridge()\n\n def image_callback(self, data):\n self.rgb_image = self.bridge.from_ros_image(data, encoding='rgb8')\n\n def request_callback(self, data):\n print(\"new request:\")\n print(data.data)\n self.image_analyze(data.data)\n\n def image_analyze(self, msg_id):\n analyze_img = self.rgb_image.opencv()\n flag, bbx, pred_angle, pred_kps_center = self.object_locator.predict(analyze_img)\n bbx = np.asarray(bbx)\n bbx = bbx.astype(int)\n msg = Float32MultiArray()\n\n if (flag > 0):\n print(bbx)\n ctr_X = int((bbx[0] + bbx[2]) / 2)\n ctr_Y = int((bbx[1] + bbx[3]) / 2)\n angle = pred_angle\n ref_x = 640 / 2\n ref_y = 480 / 2\n\n # distance to the center of bounding box representing the center of object\n dist = [ctr_X - ref_x, ref_y - ctr_Y]\n # distance center of keypoints representing the grasp location of the object\n dist_kps_ctr = [pred_kps_center[0] - ref_x, ref_y - pred_kps_center[1]]\n msg.data = [msg_id, dist[0], dist[1], angle, dist_kps_ctr[0], dist_kps_ctr[1]]\n self.command_publisher.publish(msg)\n\n else:\n # 1e10 as a big large enough number out of range. reciever use this number\n # to check whether a detection is available or not\n msg.data = [msg_id, 1e10, 1e10, 1e10, 1e10]\n self.command_publisher.publish(msg)\n\n\nif __name__ == '__main__':\n\n dir_temp = os.path.join(\"./\", \"sdg_temp\")\n rospy.init_node('grasp_server', anonymous=True)\n camera_streamer = SingleDemoGraspCameraStream(os.path.join(dir_temp, \"pendulum\", \"output\", \"model_final.pth\"), 0.8)\n rospy.spin()\n input()\n sys.exit()\n"
] | [
[
"numpy.ascontiguousarray",
"torch.from_numpy",
"torch.onnx.export",
"torch.load",
"torch.randn"
],
[
"numpy.load",
"numpy.transpose",
"scipy.spatial.Delaunay",
"numpy.lib.format.open_memmap"
],
[
"numpy.asarray"
]
] |
pedrob37/Phys_Seg | [
"7adc65d7b228b3a5702acfa9e6d0494d6b4c2dee"
] | [
"Phys_Seg/run.py"
] | [
"import torch\nimport numpy as np\nimport SimpleITK as sitk\nfrom Phys_Seg.data_loading import load_and_preprocess, save_segmentation_nifti, read_file, save_img\nfrom Phys_Seg.predict_case import predict_phys_seg, physics_preprocessing, image_preprocessing\nimport importlib\nfrom Phys_Seg.utils import postprocess_prediction, get_params_fname, maybe_download_parameters\nfrom network_architecture import nnUNet\nimport os\nimport Phys_Seg\n\n\ndef apply_phys_seg(img, out_fname):\n img_itk = sitk.ReadImage(img)\n img_npy = sitk.GetArrayFromImage(img_itk)\n out = sitk.GetImageFromArray(img_npy)\n out.CopyInformation(img_itk)\n sitk.WriteImage(out, out_fname)\n\n\ndef run_phys_seg(mri_fnames, output_fnames, sequence='MPRAGE', physics_params=None,\n # config_file=os.path.join(Phys_Seg.__path__[0], \"config.py\"),\n device=None, overwrite=True):\n \"\"\"\n\n :param mri_fnames: str or list/tuple of str\n :param output_fnames: str or list/tuple of str. If list: must have the same length as output_fnames\n :param sequence: MPRAGE or SPGR (for now)\n :param config_file: config.py\n :param device: either int (for device id) or 'cpu'\n :param overwrite: True or False\n :param postprocess: whether to do postprocessing or not. Postprocessing here consists of simply discarding all\n but the largest predicted connected component. Default False\n :return:\n \"\"\"\n\n physics_input_size = {'MPRAGE': 4,\n 'SPGR': 6}\n\n # Load in model weights\n maybe_download_parameters(sequence=sequence, physics_flag=True if physics_params else False)\n params_file = get_params_fname(sequence=sequence, physics_flag=True if physics_params else False)\n\n net = nnUNet(1, 4, physics_flag=True if physics_params else False,\n physics_input=physics_input_size[sequence],\n physics_output=40)\n\n if device == \"cpu\":\n net = net.cpu()\n else:\n net.cuda(device)\n\n net = torch.nn.DataParallel(net, device_ids=[device, int(1-device)])\n net.to(f'cuda:{net.device_ids[0]}')\n # net = torch.nn.DataParallel(net)\n\n if not isinstance(mri_fnames, (list, tuple)):\n mri_fnames = [mri_fnames]\n\n if not isinstance(output_fnames, (list, tuple)):\n output_fnames = [output_fnames]\n\n params = torch.load(params_file, map_location=lambda storage, loc: storage)\n\n for in_fname, out_fname in zip(mri_fnames, output_fnames):\n if overwrite or not (os.path.isfile(out_fname)):\n print(\"File:\", in_fname)\n print(\"preprocessing...\")\n try:\n data, aff = read_file(in_fname)\n except RuntimeError:\n print(\"\\nERROR\\nCould not read file\", in_fname, \"\\n\")\n continue\n except AssertionError as e:\n print(e)\n continue\n\n # Process data\n if physics_params is not None:\n physics_params = eval(physics_params)\n # Convert TR to pTD\n physics_params[1] = physics_params[1] - physics_params[0]\n print(physics_params)\n processed_physics = physics_preprocessing(np.array(physics_params), sequence)\n else:\n processed_physics = None\n data = image_preprocessing(patient_data=data)\n\n print(\"prediction (CNN id)...\")\n net.load_state_dict(params['model_state_dict'])\n net.eval()\n seg = predict_phys_seg(net=net,\n patient_data=data,\n processed_physics=processed_physics,\n main_device=device)\n\n print(\"exporting segmentation...\")\n save_segmentation_nifti(seg, aff, out_fname)\n\n # apply_phys_seg(in_fname, out_fname)\n"
] | [
[
"numpy.array",
"torch.load"
]
] |
teristam/openephys-fileIO | [
"8089e7c4aff829c13a79656b8812a3d3e68eb1eb"
] | [
"test/test_binary.py"
] | [
"import numpy as np \nfrom openephys_fileIO.fileIO import *\nfrom openephys_fileIO.Binary import *\n\ndef test_write_binary_data():\n # Test writing of binary data\n \n dataFolder = 'test/data'\n\n # Read the data in original int16 format\n data,headers = load_OpenEphysRecording4BinaryFile(dataFolder,\n num_data_channel=1,num_aux_channel=1, num_adc_channel=1)\n print(headers)\n\n # Write to binary file\n writeBinaryData(dataFolder+'/experiment1/recording1/',data)\n writeStructFile(dataFolder+'/experiment1/recording1/structure.oebin',headers)\n\n #load the data in float format (take care of the bit per volt)\n data,headers = load_OpenEphysRecording4BinaryFile(dataFolder,\n num_data_channel=1,num_aux_channel=1, num_adc_channel=1,dtype=float)\n\n # Load binary file using the offical function\n data2, rate2 = Load('test/data')\n\n np.allclose(data.T,data2['100']['0']['0'])\n\ndef test_numpy2binary():\n # test write of numpy data\n Fs = 30000\n x = np.random.randn(3*Fs,4)\n bitVolts = 0.195\n dataFolder = 'test/data2'\n channel_names = [f'CH{i}' for i in range(x.shape[1])]\n writeBinaryData(dataFolder+'/experiment1/recording1/', x, bitVolts)\n writeStructFile(dataFolder+'/experiment1/recording1/structure.oebin',samplerate=30000,\n num_channels= x.shape[1], bit_volts=bitVolts,channel_names=channel_names)\n\n # load the binary file\n data, rate = Load(dataFolder)\n\n np.allclose(x, data['100']['0']['0'])\n\n\n\n\n\n\n \n"
] | [
[
"numpy.allclose",
"numpy.random.randn"
]
] |
FlowerForAlgernon/ai_tetris | [
"7ac0d3875ad9b31fb260f7567a218e0de340c4e4"
] | [
"QLearning.py"
] | [
"\"\"\"\n这份代码使用 Q learning 算法训练并运行俄罗斯方块游戏 ai。其中简化状态空间的方法可参考论文 Adapting Reinforcement Learning to Tetris\n\"\"\"\n\nimport numpy as np\nfrom game import *\n\n\n\nsub_well = 4\nbase = 7\n\n\ndef getStateIndex(field_width, field_height, field_map):\n \"\"\"\n 因为每一列有 7 种不同的情况，所以采用七进制数来作为状态索引\n \"\"\"\n temp = [0 for _ in range(field_width)]\n convert = {}\n for i in range(-(base - 1)//2, (base - 1)//2 + 1):\n convert[i] = i + (base - 1)//2\n for x in range(field_width):\n while temp[x] < field_height and field_map[temp[x]][x] == 0:\n temp[x] += 1\n index = 0\n for i in range(field_width-1):\n if temp[i+1] - temp[i] > (base - 1)//2:\n index += base**i * convert[(base - 1)//2]\n elif temp[i+1] - temp[i] < -(base - 1)//2:\n index += base**i * convert[-(base - 1)//2]\n else:\n index += base**i * convert[temp[i+1] - temp[i]]\n return index\n\n\ndef getAllPossibleLocation(field_width, field_map, block, layout):\n all_possible_position = []\n for x in range(field_width):\n if block.isLegal(layout, (x, -4), field_map) is not State.Middle:\n all_possible_position.append(x)\n return all_possible_position\n\n\ndef findBottomPosition(field_map, block, x, layout):\n y = -4\n while block.isLegal(layout, (x, y), field_map) is not State.Bottom:\n y += 1\n return y - 1\n\n\ndef dropBlock(field_height, field_map, x0, y0, layout):\n for (x, y) in layout:\n if 0 <= y0 + y < field_height:\n field_map[y0 + y][x0 + x] = 1\n if y0 + y < 0:\n return False\n return True\n\n\ndef resetMap(field_width, field_height, field_map):\n count = 0\n for y in range(field_height):\n for x in range(field_width):\n if field_map[y][x] == 1:\n field_map[y][x] = 0\n count += 1\n if count == 4:\n return\n\n\ndef getNewMap(block, position, direction, field_map):\n while block.direction is not direction:\n block.rotate(field_map)\n while block.position[0] > position[0]:\n block.left(field_map)\n while block.position[0] < position[0]:\n block.right(field_map)\n while not block.is_stop:\n block.down(field_map)\n\n\nclass QLearning(Game):\n def __init__(self):\n super(QLearning, self).__init__(sub_well, 1000)\n self.repeat_num = 200\n self.alpha = 0.2\n self.gamma = 0.8\n self.lambda_ = 0.3\n self.epsilon = 0.01\n self.key = [((s, b), (p, d)) for s in range(base**(self.field_width-1)) for b in range(7) for p in range(self.field_width) for d in range(4)]\n self.V = [0 for _ in range(len(self.key))]\n self.Q = dict(zip(self.key, self.V))\n #self.Q = np.load('QL.npy').item()\n\n def checkEvents(self):\n for event in pygame.event.get():\n if event.type == pygame.QUIT:\n pygame.quit()\n exit(0)\n\n def getBlock(self, block):\n for x in range(len(Blocks_color)):\n if block.color == Blocks_color[x]:\n return x\n\n def getReward(self):\n temp = [0 for _ in range(self.field_width)]\n for x in range(self.field_width):\n while temp[x] < self.field_height and self.field_map[temp[x]][x] == 0:\n temp[x] += 1\n buried_holes = 0\n block = self.block_factory.cur_block\n for (x, y) in block.layout:\n i = 1\n while block.position[1]+y+i < self.field_height and self.field_map[block.position[1]+y+i][x] == 0:\n buried_holes += 1\n i += 1\n return np.var(temp)*(-2) + buried_holes*(-1)\n\n def getAllActions(self, block):\n actions = []\n for direction in range(len(block.layouts)):\n for x in getAllPossibleLocation(self.field_width, self.field_map, block, block.layouts[direction]):\n y = findBottomPosition(self.field_map, block, x, block.layouts[direction])\n if dropBlock(self.field_height, self.field_map, x, y, block.layouts[direction]):\n actions.append((x, direction))\n resetMap(self.field_width, self.field_height, self.field_map)\n return actions\n\n def getBestActionWithGreedy(self, block):\n block_type = self.getBlock(block)\n state = getStateIndex(self.field_width, self.field_height, self.field_map)\n actions = self.getAllActions(block)\n actions_value = {}\n for action in actions:\n actions_value[action] = self.Q[((state, block_type), action)]\n if actions_value == {}:\n return None\n elif random.random() > self.epsilon:\n return max(actions_value, key=actions_value.get)\n else:\n return list(actions_value.keys())[random.randint(0, len(actions_value)-1)]\n\n def getBestAction(self, block):\n block_type = self.getBlock(block)\n state = getStateIndex(self.field_width, self.field_height, self.field_map)\n actions = self.getAllActions(block)\n actions_value = {}\n for action in actions:\n actions_value[action] = self.Q[((state, block_type), action)]\n if actions_value == {}:\n return None\n return max(actions_value, key=actions_value.get)\n\n def train(self):\n record = []\n for i in range(1, self.repeat_num+1):\n self.initialize()\n while not self.block_factory.is_failed:\n cur_state = getStateIndex(self.field_width, self.field_height, self.field_map)\n cur_block = self.getBlock(self.block_factory.cur_block)\n cur_action = self.getBestActionWithGreedy(self.block_factory.cur_block)\n cur_index = ((cur_state, cur_block), cur_action)\n if cur_action == None: break\n getNewMap(self.block_factory.cur_block, cur_action, cur_action[1], self.field_map)\n next_state = getStateIndex(self.field_width, self.field_height, self.field_map)\n next_block = self.getBlock(self.block_factory.next_block)\n next_action = self.getBestAction(self.block_factory.next_block)\n next_index = ((next_state, next_block), next_action)\n if next_action == None: break\n self.Q[cur_index] += self.alpha*(self.getReward()+self.gamma*self.Q[next_index] - self.Q[cur_index])\n self.update()\n print(\"Epoch:\"+str(i)+\"/\"+str(self.repeat_num)+\" Lines:\"+ str(self.lines_num)+\" Alpha:\"+str(self.alpha))\n record.append(self.lines_num)\n if i % 100 == 0:\n self.alpha *= 0.5\n np.save('QL.npy', {\"V\": self.V})\n np.save('record_QL.npy', {\"record\": record})\n np.save('QL.npy', self.Q)\n np.save('record_QL.npy', {\"record\": record})\n\n\nclass QLGame(Game):\n def __init__(self):\n super(QLGame, self).__init__(10, 20)\n self.Q = np.load('QL.npy', allow_pickle=True).item()\n self.col = 0\n\n def checkEvents(self):\n for event in pygame.event.get():\n if event.type == pygame.QUIT:\n pygame.quit()\n exit(0)\n\n def getBlock(self, block):\n for x in range(len(Blocks_color)):\n if block.color == Blocks_color[x]:\n return x\n\n def cutFieldMap(self, position):\n new_field_map = [[0]*sub_well for _ in range(self.field_height)]\n for y in range(self.field_height):\n for x in range(sub_well):\n new_field_map[y][x] = self.field_map[y][position+x]\n return new_field_map\n\n def getAllActions(self, field_width, field_height, block, field_map, init_pos):\n actions = {}\n for direction in range(len(block.layouts)):\n for x in getAllPossibleLocation(field_width, field_map, block, block.layouts[direction]):\n y = findBottomPosition(field_map, block, x, block.layouts[direction])\n if dropBlock(field_height, field_map, x, y, block.layouts[direction]):\n block_type = self.getBlock(block)\n state = getStateIndex(field_width, field_height, field_map)\n actions[(x + init_pos, direction)] = self.Q[((state, block_type), (x, direction))]\n resetMap(field_width, field_height, field_map)\n return actions\n\n def getBestAction(self):\n actions = {}\n cur_block = Block(self.block_factory.cur_block.screen, sub_well, self.field_height, self.block_factory.cur_block.layouts, self.block_factory.cur_block.direction, self.block_factory.cur_block.color, (0, -4))\n for x in range(self.field_width - sub_well + 1):\n loc_actions = self.getAllActions(sub_well, self.field_height, cur_block, self.cutFieldMap(x), x)\n for k, v in loc_actions.items():\n if k in actions:\n actions[k].append(v)\n else:\n actions[k] = [v]\n for k, v in actions.items():\n actions[k] = max(v)\n return max(actions, key=actions.get) if actions != {} else None\n\n def start(self):\n self.initialize()\n self.initializePygame()\n while not self.block_factory.is_failed:\n self.checkEvents()\n action = self.getBestAction()\n if action == None:\n break\n getNewMap(self.block_factory.cur_block, action, action[1], self.field_map)\n self.update()\n self.draw()\n return self.lines_num\n\n\n\nif __name__ == '__main__':\n train = QLearning()\n train.train()\n \n game = QLGame()\n game.start()\n"
] | [
[
"numpy.var",
"numpy.load",
"numpy.save"
]
] |
starkworld/Python-Course-work | [
"28715f079939129b442aedcd7edb2e0838886ba0"
] | [
"source code/Data Visualization.py"
] | [
"\"\"\"\nAuthor : nkalyan🤠\nimplementing Python Scripts on reading and returning the name no of mails that sent each day in week\n and plot/display them in bar graph\n\n I wrote code In counting to count the number of emails sent by each distinct user. That code may be helpful for this assignment.\n\"\"\"\n\n\nimport matplotlib.pyplot as plt\nfrom os import getcwd\n\n\ndef file_path():\n \"\"\"Method that ask the users file name and returns it\"\"\"\n file_name = input(\"Enter the file name:\")\n return file_name\n\n\ndef pop_values(filename):\n \"\"\"Method the reads file and returning value\"\"\"\n file_name = filename\n try: # look for exception\n fp = open(file_name, \"r\")\n except FileNotFoundError: # if found exception display error\n print(\"File Does not exist, please check your file name\")\n exit()\n else: # if no exceptions thrown then performs this block\n with fp:\n for line in fp:\n line = line.strip(\"\\n\")\n offset = line.find(\"From\")\n offset1 = line.find(\"@\")\n line = line[-24:]\n offset3 = line.find(\"@\")\n if offset == 0 and offset1 > 0 and offset3 == -1:\n line = line[:-21]\n yield line\n\n\ndef main():\n \"\"\"Calls the all functions that necessary to get the output\"\"\"\n name = file_path() # calls the file path method\n dictionary = {'Sun': 0, 'Mon': 0, 'Tue': 0, 'Wed': 0, 'Thu': 0, 'Fri': 0, 'Sat': 0} # store the day val in dict\n value = pop_values(name)\n count = 0\n for i in value:\n if i in dictionary:\n dictionary[i] += 1\n count += len(i)\n val = dictionary.values()\n keys = dictionary.keys()\n zp = zip(dictionary.keys(), dictionary.values())\n for item in val:\n i = val\n j = keys\n plt.bar(j, i, align='center', alpha=0.5)\n\n plt.ylabel('Number of messages') \n plt.title('Emails per day')\n plt.show() # method that shows the bar graph of our code result\n\n\nif __name__ == '__main__':\n \"\"\"calls the main method\"\"\"\n main()\n"
] | [
[
"matplotlib.pyplot.show",
"matplotlib.pyplot.title",
"matplotlib.pyplot.bar",
"matplotlib.pyplot.ylabel"
]
] |
jasonrute/puzzle_cube | [
"7e05a21acd26cb30e729ba6a95e14e16c76c1780"
] | [
"analysis/stats.py"
] | [
"\"\"\"\nTraining Statics Tools\n\nA class for loading statistics related to a particular rutraiining session.\n\"\"\"\n\nimport numpy as np\n#from scipy import stats\nimport pandas as pd\nimport os\n\ndef str_between(s, start, end):\n return (s.split(start))[1].split(end)[0]\n\ndef is_stat_file_version(file_name, version):\n return file_name.startswith(\"stats_{}_gen\".format(version)) and file_name.endswith(\".h5\")\n\nclass TrainingStates:\n def __init__(self, versions, directory, verbose=True):\n self.stats_files = self.get_stat_files(versions, directory)\n \n if verbose:\n print(\"Loading files:\")\n for f in self.stats_files:\n print(directory + f)\n\n self.generation_stats = self.load_stats('generation_stats')\n self.game_stats = self.load_stats('game_stats')\n self.move_stats = self.load_stats('self_play_stats')\n\n def get_stat_files(self, versions, directory):\n stat_files = []\n for version in reversed(versions):\n files = [directory + f for f in os.listdir(directory) if is_stat_file_version(f, version)]\n stat_files += list(sorted(files))\n\n return stat_files\n\n def load_stats(self, key_name):\n df_list = []\n for f in self.stats_files:\n path = f\n generation = str_between(f, \"_gen\", \".h5\")\n df = pd.read_hdf(path, key=key_name)\n df['_generation'] = int(generation)\n df_list.append(df)\n\n if df_list:\n stats = pd.concat(df_list, ignore_index=True)\n else:\n return pd.DataFrame()\n \n return stats\n\n def first_move_stats(self):\n \"\"\"\n Note: There is an indexing issue (the index of first_play_stats is the orginal index\n while the index of game_stats is the game number). The easiest fix is to just use\n the values (an array) of the series and not the series itself.\n \"\"\"\n return self.move_stats[self.move_stats['_step_id'] == 0]\n\n def found_target_on_first_move(self):\n return (self.first_move_stats()['shortest_path'] >= 0).values\n\n def lost_but_found_target_on_first_move(self):\n return self.found_target_on_first_move() & ~self.game_stats['win']\n\n def win_but_did_not_find_target_on_first_move(self):\n return ~self.found_target_on_first_move() & self.game_stats['win']\n\nif __name__ == '__main__':\n from pprint import pprint\n versions = ['v0.9.3']\n save_dir = '../save/stats_v0.9.3/'\n #VERSIONS = ['v0.9.2.1', 'v0.9.2']\n #SAVE_DIR = '../save/stats_archive/'\n\n cube_stats = TrainingStates(versions, save_dir)\n\n pprint(cube_stats.generation_stats)\n\n pprint(np.mean(cube_stats.lost_but_found_target_on_first_move()))\n pprint(np.mean(cube_stats.win_but_did_not_find_target_on_first_move()))\n\n\n\n"
] | [
[
"pandas.DataFrame",
"pandas.read_hdf",
"pandas.concat"
]
] |
kufusha/cabot | [
"52a40a39a29f0bd79b6fdd8f961708e09fda9a51"
] | [
"cabot_ui/src/cabot_ui/geojson.py"
] | [
"# Copyright (c) 2020 Carnegie Mellon University\n#\n# Permission is hereby granted, free of charge, to any person obtaining a copy\n# of this software and associated documentation files (the \"Software\"), to deal\n# in the Software without restriction, including without limitation the rights\n# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n# copies of the Software, and to permit persons to whom the Software is\n# furnished to do so, subject to the following conditions:\n#\n# The above copyright notice and this permission notice shall be included in all\n# copies or substantial portions of the Software.\n#\n# THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n# SOFTWARE.\n\n\"\"\"\nMapService GeoJson mapper\n\nMapService: https://github.com/hulop/MapService\n\nAuthor: Daisuke Sato<[email protected]>\n\"\"\"\n# -*- coding: utf-8 -*-\nimport sys\nimport traceback\nimport copy\nimport math\nimport json\nimport scipy\nimport scipy.spatial\nimport numpy\nimport numpy.linalg\nimport rospy\nimport tf\nimport angles\nimport geometry_msgs.msg\nfrom cabot_ui import geoutil, i18n\n\nclass Geometry(object):\n \"\"\"Geometry class\"\"\"\n \n @classmethod\n def marshal(cls, dic):\n \"\"\"marshal Geometry subclasses object\"\"\"\n if 'type' in dic:\n if dic['type'] == \"Point\":\n cls = Point\n elif dic['type'] == \"LineString\":\n cls = LineString\n if cls == Geometry:\n return cls(**dic)\n return cls.marshal(dic)\n\n def __init__(self, **dic):\n s = super(Geometry, self)\n if self.__class__.mro()[-2] == s.__thisclass__:\n s.__init__()\n else:\n s.__init__(**dic)\n\n if 'coordinates' in dic:\n self.coordinates = dic['coordinates']\n if 'type' in dic:\n self.geometry_type = dic['type']\n\nclass Point(Geometry, geoutil.Latlng):\n \"\"\"Point class representing global point\"\"\"\n \n @classmethod\n def marshal(cls, dic):\n \"\"\"marshal Point object\"\"\"\n return cls(**dic)\n\n def __init__(self, **dic):\n c = dic['coordinates']\n super(Point, self).__init__(lat=c[1], lng=c[0], **dic)\n\nclass LineString(Geometry):\n \"\"\"Point class representing global line (start to end)\"\"\"\n @classmethod\n def marshal(cls, dic):\n \"\"\"marshal LineString object\"\"\"\n return cls(**dic)\n\n def __init__(self, **dic):\n super(LineString, self).__init__(**dic)\n self.start = geoutil.Latlng(lat=self.coordinates[0][1], lng=self.coordinates[0][0])\n self.end = geoutil.Latlng(lat=self.coordinates[1][1], lng=self.coordinates[1][0])\n\n def distance_to(self, point):\n if isinstance(point, Point):\n return self.nearest_point_on_line(point).distance_to(point)\n raise RuntimeError(\"Need to pass a Point object (%s)\"%(type(point))) \n\n def nearest_point_on_line(self, point):\n A = geoutil.latlng2mercator(self.start)\n B = geoutil.latlng2mercator(self.end)\n C = geoutil.latlng2mercator(point)\n \n # Distance between A and B\n distAB = math.sqrt(math.pow(A.x - B.x, 2) + math.pow(A.y - B.y, 2));\n \n # Direction vector from A to B\n vecABx = (B.x - A.x) / distAB;\n vecABy = (B.y - A.y) / distAB;\n \n # Time from A to C\n timeAC = max(0, min(distAB, vecABx * (C.x - A.x) + vecABy * (C.y - A.y)));\n \n # LatLng of the point\n x = timeAC * vecABx + A.x;\n y = timeAC * vecABy + A.y;\n \n return geoutil.mercator2latlng(geoutil.Point(x=x, y=y))\n\n\nclass Properties(object):\n @classmethod\n def marshal(cls, dic):\n \"\"\"marshal Properties object\"\"\"\n return cls(**dic)\n\n DEFAULT_VALUES = {\n \"hulop_building\": None,\n \"hulop_major_category\": None,\n \"hulop_sub_category\": None,\n \"hulop_minor_category\": None,\n \"hulop_heading\": 0,\n \"hulop_angle\": 180,\n \"hulop_height\": 0,\n \"hulop_long_description\": None,\n \"hulop_short_description\": None,\n \"hulop_description\": None,\n \"hulop_location_description\": None,\n \"hulop_content\": None,\n \"hulop_tags\": None,\n \"hulop_poi_external_category\": None,\n \"hulop_show_labels_zoomlevel\": None\n }\n \n def __getattr__(self, name):\n value = self.__dict__.get(name)\n if not value:\n if name in Properties.DEFAULT_VALUES:\n return Properties.DEFAULT_VALUES[name]\n\n raise AttributeError(\"%s.%s is invalid\"%(self.__class__.__name__, name))\n return value\n\n def __init__(self, **dic):\n for key in dic:\n try:\n setattr(self, key, dic[key])\n except:\n print(\"Cannot use unicode string for a property name: \\\"{}\\\"\".format(key.encode('utf8')))\n\n def __str__(self):\n return json.dumps(self.__dict__, sort_keys=True, indent=2)\n\n\nclass Object(object):\n \"\"\"Object class\"\"\"\n\n @classmethod\n def marshal_list(cls, objects):\n \"\"\"marshal list of Object subclasses objects\"\"\"\n temp = []\n for obj in objects:\n temp.append(cls.marshal(obj))\n return temp\n\n @classmethod\n def marshal_dict(cls, objects):\n \"\"\"marshal dict of Object subclasses objects\"\"\"\n temp = {}\n for key in objects.keys():\n temp[key] = cls.marshal(objects[key])\n return temp\n\n @classmethod\n def marshal(cls, dic):\n \"\"\"marshal Object subclasses object\"\"\"\n if 'node' in dic:\n cls = Landmark\n else:\n prop = dic['properties'] if 'properties' in dic else None\n if prop is not None:\n if 'node_id' in prop:\n cls = Node\n if 'link_id' in prop:\n cls = Link\n if 'facil_id' in prop:\n cls = Facility\n\n if cls == Object:\n return cls(**dic)\n return cls.marshal(dic)\n\n _id_map = {}\n _all_objects = []\n @staticmethod\n def get_object_by_id(_id, func=None):\n \"\"\"get object having id by callback function, it can be defered\"\"\"\n if _id in Object._id_map:\n if isinstance(Object._id_map[_id], list):\n Object._id_map[_id].append(func)\n else:\n if func is not None and callable(func):\n func(Object._id_map[_id])\n return None\n return Object._id_map[_id]\n else:\n Object._id_map[_id] = [func]\n return None\n\n @staticmethod\n def get_objects_by_type(_type):\n \"\"\"get objects of specified type\"\"\"\n temp = []\n for obj in Object._all_objects:\n if isinstance(obj, _type):\n temp.append(obj)\n return temp\n\n @staticmethod\n def get_all_objects():\n return Object._all_objects\n\n @staticmethod\n def _register(obj):\n \"\"\"store object with id and type\"\"\"\n # register with id\n _id = obj._id\n if _id in Object._id_map:\n if isinstance(Object._id_map[_id], list):\n for func in Object._id_map[_id]:\n if callable(func):\n func(obj)\n Object._id_map[_id] = obj\n Object._all_objects.append(obj)\n else:\n #raise RuntimeError(\"duplicate id\")\n pass\n else:\n Object._id_map[_id] = obj\n Object._all_objects.append(obj)\n\n @staticmethod\n def reset_all_objects():\n \"\"\"reset all state in the objects\"\"\"\n for obj in Object._all_objects:\n obj.reset()\n\n @staticmethod\n def _reset_link_index():\n Object._link_index = []\n Object._link_points = []\n Object._link_kdtree = None\n \n _link_index = []\n _link_points = []\n _link_kdtree = None\n @staticmethod\n def _build_link_index():\n for obj in Object.get_objects_by_type(Link):\n if obj.start_node and obj.end_node:\n sp = numpy.array([obj.start_node.local_geometry.x, obj.start_node.local_geometry.y])\n ep = numpy.array([obj.end_node.local_geometry.x, obj.end_node.local_geometry.y])\n Object._add_link_index(sp, ep, obj)\n if Object._link_points:\n Object._link_kdtree = scipy.spatial.KDTree(Object._link_points)\n\n @staticmethod\n def _add_link_index(sp, ep, obj):\n mp = (sp+ep)/2.0\n Object._link_points.append(mp)\n Object._link_index.append(obj)\n if numpy.linalg.norm(sp-ep) > 1:\n Object._add_link_index(sp, mp, obj)\n Object._add_link_index(mp, ep, obj)\n\n @staticmethod\n def get_nearest_link(node, exclude=None):\n point = node.local_geometry\n latlng = node.geometry\n _, index = Object._link_kdtree.query([point.x, point.y], 50)\n\n min_index = None\n min_dist = 1000\n for i in index:\n link = Object._link_index[i]\n if exclude is not None and exclude(link):\n continue\n \n dist = link.geometry.distance_to(latlng)\n if node.floor is not None:\n if link.start_node.floor != node.floor and \\\n link.end_node.floor != node.floor:\n dist += 1000\n if dist < min_dist:\n min_dist = dist\n min_index = i\n \n if min_index is None:\n return None\n return Object._link_index[min_index]\n\n @staticmethod\n def update_anchor_all(anchor):\n \"\"\"update anchor of all object\"\"\"\n Object._reset_link_index()\n for obj in Object._all_objects:\n obj.update_anchor(anchor)\n Object._build_link_index()\n\n\n def __init__(self, **dic):\n s = super(Object, self)\n if self.__class__.mro()[-2] == s.__thisclass__:\n s.__init__()\n else:\n s.__init__(**dic)\n \n if 'geometry' in dic:\n self.geometry = Geometry.marshal(dic['geometry'])\n if 'properties' in dic:\n self.properties = Properties.marshal(dic['properties'])\n if '_id' in dic:\n self._id = dic['_id']\n if 'no_registration' not in dic or not dic['no_registration']:\n Object._register(self)\n self.anchor = None\n self.local_geometry = None \n\n def __str__(self):\n ret = \"%s, (%s)\\n\" % (type(self), hex(id(self)))\n for key in self.__dict__:\n value = getattr(self, key)\n if isinstance(value, Object):\n ret += \"%s: %s<%s>\\n\"%(key, type(value), value._id)\n else:\n ret += \"%s: %s\\n\"%(key, str(value))\n \n import inspect\n for method in inspect.getmembers(type(self), predicate=lambda o: isinstance(o, property)):\n ret += \"%s: %s\\n\"%(method[0], method[1].__get__(self, type(self)))\n\n return ret\n\n def __repr__(self):\n return \"%s<%s>\"%(type(self), self._id)\n\n def update_anchor(self, anchor):\n self.anchor = anchor\n if anchor is not None:\n try:\n self.local_geometry = geoutil.global2local(self.geometry, anchor)\n except:\n print(\"Could not convert geometry: {}\".format(self.local_geometry))\n\n def distance_to(self, point):\n if isinstance(point, geoutil.Point):\n return self.local_geometry.distance_to(point)\n if isinstance(point, geoutil.Latlng):\n return self.geometry.distance_to(point)\n\n def reset(self):\n pass\n\nclass Link(Object):\n \"\"\"Link class\"\"\"\n ROUTE_TYPE_WALKWAY = 1\n ROUTE_TYPE_MOVING_WALKWAY = 2\n ROUTE_TYPE_RAILROAD_CROSSING = 3\n ROUTE_TYPE_ELEVATOR = 4\n ROUTE_TYPE_ESCALATOR = 5\n ROUTE_TYPE_STAIRS = 6\n ROUTE_TYPE_SLOPE = 7\n ROUTE_TYPE_UNKNOWN = 99\n\n @classmethod\n def marshal(cls, dic):\n \"\"\"marshal Link subclasses object\"\"\"\n if 'properties' in dic:\n prop = dic['properties']\n if 'sourceNode' in prop:\n cls = RouteLink\n if cls == Link:\n return cls(**dic)\n return cls.marshal(dic)\n\n def __init__(self, **dic):\n super(Link, self).__init__(**dic)\n self.start_node = None\n self.end_node = None\n self.pois = []\n self.floor = 0\n Object.get_object_by_id(self.properties.start_id, self._set_start_node)\n Object.get_object_by_id(self.properties.end_id, self._set_end_node)\n\n def _set_start_node(self, node):\n self.start_node = node\n self._update()\n\n def _set_end_node(self, node):\n self.end_node = node\n self._update()\n\n def _update(self):\n if self.start_node is not None and \\\n self.end_node is not None:\n self.floor = (self.start_node.floor + self.end_node.floor)/2.0\n\n @property\n def is_elevator(self):\n \"\"\"wheather this links is an elevator or not\"\"\"\n return self.properties.route_type == Link.ROUTE_TYPE_ELEVATOR\n\n @property\n def is_escalator(self):\n \"\"\"wheather this links is an escalator or not\"\"\"\n return self.properties.route_type == Link.ROUTE_TYPE_ESCALATOR\n\n @property\n def is_leaf(self):\n \"\"\"wheather this links is a leaf or not\"\"\"\n if self.start_node is None or self.end_node is None:\n return False\n return self.start_node.is_leaf or self.end_node.is_leaf\n\n @property\n def length(self):\n \"\"\"distance from start to end\"\"\"\n if self.start_node is None or self.end_node is None:\n return float('nan')\n return self.start_node.geometry.distance_to(self.end_node.geometry)\n\n def register_poi(self, poi):\n self.pois.append(poi)\n\n def update_anchor(self, anchor):\n self.anchor = anchor\n #TODO\n\nclass RouteLink(Link):\n \"\"\"Route Link class\"\"\"\n\n @classmethod\n def marshal(cls, dic):\n \"\"\"marshal Directed Link object\"\"\"\n return cls(**dic)\n\n def __init__(self, **dic):\n super(RouteLink, self).__init__(no_registration=True, **dic)\n self.source_node = None\n self.target_node = None\n Object.get_object_by_id(self.properties.sourceNode, self._set_source_node)\n Object.get_object_by_id(self.properties.targetNode, self._set_target_node)\n Object.get_object_by_id(self._id, self._found_link)\n\n def _set_source_node(self, node):\n self.source_node = node\n\n def _set_target_node(self, node):\n self.target_node = node\n\n def _found_link(self, link):\n self.pois = link.pois\n\n @property\n def is_temp(self):\n return self._id.startswith(\"_TEMP_LINK\")\n\n\nclass Node(Object):\n \"\"\"Node class\"\"\"\n\n @classmethod\n def marshal(cls, dic):\n \"\"\"marshal Node object\"\"\"\n return cls(**dic)\n\n def __init__(self, **dic):\n super(Node, self).__init__(**dic)\n self.links = []\n for i in range(1, 100):\n attr = \"link%d_id\"%(i)\n if hasattr(self.properties, attr):\n Object.get_object_by_id(getattr(self.properties, attr), self._add_link)\n\n if hasattr(self.properties, 'floor'):\n self.floor = self.properties.floor\n else:\n self.floor = 0\n\n self.facility = None\n Facility.get_facility_by_id(self._id, self._set_facility)\n\n def _add_link(self, link):\n self.links.append(link)\n\n def _set_facility(self, facility):\n self.facility = facility\n\n @property\n def is_leaf(self):\n \"\"\"wheather this node is the end of leaf link\"\"\"\n return len(self.links) == 1\n\n @property\n def is_elevator(self):\n \"\"\"wheather this node is connected to elevator link\"\"\"\n res = False\n for link in self.links:\n res = res or link.is_elevator\n return res\n\n\nclass Facility(Object):\n \"\"\"Facility class\"\"\"\n\n @classmethod\n def marshal(cls, dic):\n \"\"\"marshal Facility subclasses object\"\"\"\n if 'properties' in dic:\n prop = dic['properties']\n if 'hulop_major_category' in prop:\n category = prop['hulop_major_category']\n if category == '_nav_poi_':\n cls = POI\n if cls == Facility:\n return cls(**dic)\n return cls.marshal(dic)\n\n def __init__(self, **dic):\n super(Facility, self).__init__(**dic)\n self.entrances = []\n for i in range(1, 100):\n attr = \"ent%d_node\"%(i)\n if hasattr(self.properties, attr):\n Facility._id_map[getattr(self.properties, attr)] = self\n Object.get_object_by_id(getattr(self.properties, attr), self._add_facility)\n\n self.name = i18n.localized_attr(self.properties, \"name\")\n self.name_pron = i18n.localized_attr(self.properties, \"name_hira\", only_if=\"ja\") ## special case\n self.long_description = i18n.localized_attr(self.properties, \"hulop_long_description\")\n\n def _add_facility(self, node):\n self.entrances.append(node)\n\n _id_map = {}\n @staticmethod\n def get_facility_by_id(_id, func=None):\n \"\"\"get facility having id by callback function, it can be defered\"\"\"\n if _id in Facility._id_map:\n if isinstance(Facility._id_map[_id], list):\n Facility._id_map[_id].append(func)\n else:\n if func is not None and callable(func):\n func(Facility._id_map[_id])\n return None\n return Facility._id_map[_id]\n else:\n Facility._id_map[_id] = [func]\n return None\n\nclass POI(Facility, geoutil.TargetPlace):\n \"\"\"POI class\"\"\"\n\n @classmethod\n def marshal(cls, dic):\n \"\"\"marshal POI object\"\"\"\n if 'properties' in dic:\n prop = dic['properties']\n if 'hulop_sub_category' in prop:\n category = prop['hulop_sub_category']\n if category == '_nav_door_':\n cls = DoorPOI\n if category == '_nav_info_':\n cls = InfoPOI\n if category == '_cabot_speed_':\n cls = SpeedPOI\n if category == '_nav_elevator_cab_':\n cls = ElevatorCabPOI\n if category == '_nav_queue_wait_':\n cls = QueueWaitPOI\n if category == '_nav_queue_target_':\n cls = QueueTargetPOI\n\n if cls == POI:\n return cls(**dic)\n return cls.marshal(dic)\n\n def __init__(self, **dic):\n if 'properties' in dic:\n prop = dic['properties']\n get_prop = lambda prop, key: prop[key] if key in prop else Properties.DEFAULT_VALUES[key]\n r = (-get_prop(prop, 'hulop_heading') + 90) / 180.0 * math.pi\n angle = get_prop(prop, 'hulop_angle')\n self.floor = get_prop(prop, 'hulop_height')\n\n super(POI, self).__init__(r=r, x=0, y=0, angle=angle, floor=self.floor, **dic)\n\n self.sub_category = self.properties.hulop_sub_category \\\n if hasattr(self.properties, 'hulop_sub_category') else \"\"\n self.minor_category = self.properties.hulop_minor_category \\\n if hasattr(self.properties, 'hulop_minor_category') else \"\"\n\n #backward compatibility\n self.local_pose = self\n\n def approaching_statement(self):\n return None\n\n def approached_statement(self):\n return None\n\n def passed_statement(self):\n return None\n\n def update_anchor(self, anchor):\n super(POI, self).update_anchor(anchor) \n if anchor is not None:\n rad = (-self.properties.hulop_heading + 90 + anchor.rotate) / 180.0 * math.pi\n self.update_pose(self.local_geometry, rad)\n\n def reset(self):\n self.reset_target()\n\nclass DoorPOI(POI):\n \"\"\"POI class\"\"\"\n\n @classmethod\n def marshal(cls, dic):\n \"\"\"marshal Door POI object\"\"\"\n return cls(**dic)\n\n def __init__(self, **dic):\n super(DoorPOI, self).__init__(**dic)\n\n @property\n def title(self):\n if self.is_auto:\n return i18n.localized_string(\"AUTO_DOOR\")\n else:\n return i18n.localized_string(\"DOOR\")\n\n @property\n def is_auto(self):\n \"\"\"wheather this is auto door or not\"\"\"\n return self.minor_category is not None and \\\n '_flag_auto_' in self.minor_category\n\n def approaching_statement(self):\n return i18n.localized_string(\"DOOR_POI_APPROACHING\", self.title) \n\nclass InfoPOI(POI):\n \"\"\"Nav Info POI class\"\"\"\n\n @classmethod\n def marshal(cls, dic):\n \"\"\"marshal Info POI object\"\"\"\n return cls(**dic)\n\n def __init__(self, **dic):\n super(InfoPOI, self).__init__(**dic)\n\n def approached_statement(self):\n return self.name\n\nclass SpeedPOI(POI):\n \"\"\"Cabot Speed POI class\"\"\"\n\n @classmethod\n def marshal(cls, dic):\n \"\"\"marshal Speed POI object\"\"\"\n return cls(**dic)\n\n def __init__(self, **dic):\n super(SpeedPOI, self).__init__(**dic)\n self.limit = float(self.properties.hulop_content)\n\nclass ElevatorCabPOI(POI):\n \"\"\"Elevator Cab POI class\"\"\"\n\n @classmethod\n def marshal(cls, dic):\n \"\"\"marshal Elevator Cab POI object\"\"\"\n return cls(**dic)\n\n def __init__(self, **dic):\n super(ElevatorCabPOI, self).__init__(**dic)\n self.set_back = (3.0, 0.0)\n self.set_forward = (3.0, 0.0)\n self.door = (1.0, 0.0)\n if self.properties.hulop_content:\n try:\n hulop_content_json = json.loads(self.properties.hulop_content)\n if \"set_back\" in hulop_content_json:\n self.set_back = hulop_content_json[\"set_back\"]\n if \"set_forward\" in hulop_content_json:\n self.set_forward = hulop_content_json[\"set_forward\"]\n if \"door\" in hulop_content_json:\n self.door = hulop_content_json[\"door\"]\n if \"buttons\" in hulop_content_json:\n self.buttons = hulop_content_json[\"buttons\"]\n except:\n traceback.print_exc(file=sys.std_out)\n\n @property\n def door_geometry(self):\n x = self.x + math.cos(self.r) * self.door[0] - math.sin(self.r) * self.door[1]\n y = self.y + math.sin(self.r) * self.door[0] + math.cos(self.r) * self.door[1]\n return geoutil.Point(x=x, y=y)\n\n def where_is_buttons(self, pose):\n x = self.x + math.cos(self.r) * self.buttons[0] - math.sin(self.r) * self.buttons[1]\n y = self.y + math.sin(self.r) * self.buttons[0] + math.cos(self.r) * self.buttons[1]\n\n b_pos = geoutil.Point(x=x,y=y)\n b_pose = geoutil.Pose.pose_from_points(b_pos, pose)\n dir = angles.shortest_angular_distance(pose.r, b_pose.r)\n\n print(pose, b_pos, b_pose, dir)\n\n if abs(dir) > math.pi / 3 * 2:\n return \"BACK\"\n elif abs(dir) > math.pi / 3:\n if dir > 0:\n return \"LEFT\"\n elif dir < 0:\n return \"RIGHT\"\n elif abs(dir) < math.pi / 10:\n return \"FRONT\"\n elif dir > 0:\n return \"FRONT_LEFT\"\n elif dir < 0:\n return \"FRONT_RIGHT\"\n\n rospy.logerror(\"should not happen\")\n return None\n\nclass QueueWaitPOI(POI):\n \"\"\"Queue Wait POI class\"\"\"\n\n @classmethod\n def marshal(cls, dic):\n \"\"\"marshal Queue TaWaitrget POI object\"\"\"\n return cls(**dic)\n\n def __init__(self, **dic):\n super(QueueWaitPOI, self).__init__(**dic)\n self.interval = 1.0\n hulop_content_json = json.loads(self.properties.hulop_content)\n if \"interval\" in hulop_content_json:\n self.interval = float(hulop_content_json[\"interval\"])\n self.is_copied = False\n self.link_orientation = None\n\n# def approached_statement(self):\n# return \"queue wait point\"\n\n def register_link(self, link):\n end_pose = geoutil.Pose.pose_from_points(link.end_node.local_geometry, link.start_node.local_geometry)\n quat = tf.transformations.quaternion_from_euler(0, 0, end_pose.r)\n\n self.link_orientation = geometry_msgs.msg.Quaternion()\n self.link_orientation.x = quat[0]\n self.link_orientation.y = quat[1]\n self.link_orientation.z = quat[2]\n self.link_orientation.w = quat[3]\n\n def copy_to_link(self, link, local_geometry_x, local_geometry_y):\n copied_poi = copy.deepcopy(self)\n copied_poi.x = local_geometry_x\n copied_poi.y = local_geometry_y\n copied_poi.local_geometry.x = local_geometry_x\n copied_poi.local_geometry.y = local_geometry_y\n copied_poi.geometry = geoutil.local2global(copied_poi.local_geometry, copied_poi.anchor)\n \n link.register_poi(copied_poi)\n copied_poi.register_link(link)\n self.is_copied = True\n return copied_poi\n\nclass QueueTargetPOI(POI):\n \"\"\"Queue Target POI class\"\"\"\n\n @classmethod\n def marshal(cls, dic):\n \"\"\"marshal Queue Target POI object\"\"\"\n return cls(**dic)\n\n def __init__(self, **dic):\n super(QueueTargetPOI, self).__init__(**dic)\n self.enter_node = None\n self.exit_node = None\n hulop_content_json = json.loads(self.properties.hulop_content)\n Object.get_object_by_id(hulop_content_json[\"enter\"], self._set_enter_node)\n Object.get_object_by_id(hulop_content_json[\"exit\"], self._set_exit_node)\n\n def _set_enter_node(self, node):\n self.enter_node = node\n\n def _set_exit_node(self, node):\n self.exit_node = node\n\nclass Landmark(Facility):\n \"\"\"Landmark class\"\"\"\n\n @classmethod\n def marshal(cls, dic):\n \"\"\"marshal Landmark object\"\"\"\n return cls(**dic)\n\n\n def __init__(self, **dic):\n self._id = dic['node']+\"_landmark\"\n super(Landmark, self).__init__(**dic)\n"
] | [
[
"scipy.spatial.KDTree",
"numpy.array",
"numpy.linalg.norm"
]
] |
Corentin-LF/pyGPs | [
"b9d36777584cd53756bd4311c3c20ea52e945451"
] | [
"pyGPs/Core/gp.py"
] | [
"from __future__ import division\nfrom __future__ import absolute_import\nfrom builtins import str\nfrom builtins import range\nfrom builtins import object\nfrom past.utils import old_div\n#================================================================================\n# Marion Neumann [marion dot neumann at uni-bonn dot de]\n# Daniel Marthaler [dan dot marthaler at gmail dot com]\n# Shan Huang [shan dot huang at iais dot fraunhofer dot de]\n# Kristian Kersting [kristian dot kersting at cs dot tu-dortmund dot de]\n#\n# This file is part of pyGPs.\n# The software package is released under the BSD 2-Clause (FreeBSD) License.\n#\n# Copyright (c) by\n# Marion Neumann, Daniel Marthaler, Shan Huang & Kristian Kersting, 18/02/2014\n#================================================================================\n\n# MEANING OF NOTATION:\n#\n# inffunc function specifying the inference method\n# covfunc prior covariance function (see below)\n# meanfunc prior mean function\n# likfunc likelihood function\n# x n by D matrix of training inputs\n# y column vector of length n of training targets\n# xs n by D matrix of test inputs\n# ys column vector of length nn of true test targets (optional)\n# nlZ returned value of the negative log marginal likelihood\n# dnlZ column vector of partial derivatives of the negative\n# log marginal likelihood w.r.t. each hyperparameter\n# ym column vector (of length ns) of predictive output means\n# ys2 column vector (of length ns) of predictive output variances\n# fm column vector (of length ns) of predictive latent means\n# fs2 column vector (of length ns) of predictive latent variances\n# lp column vector (of length ns) of log predictive probabilities\n# post struct representation of the (approximate) posterior\n# post consists of post.alpha, post.L, post.sW\n#\n# This is a object-oriented python implementation of gpml functionality\n# (Copyright (c) by Carl Edward Rasmussen and Hannes Nickisch, 2011-02-18).\n# based on the functional-version of python implementation\n# (Copyright (c) by Marion Neumann and Daniel Marthaler, 20/05/2013)\n#\n# Copyright (c) by Marion Neumann and Shan Huang, 30/09/2013\n\nimport itertools\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom . import inf, mean, lik, cov, opt\nfrom .tools import unique, jitchol, solve_chol\nfrom copy import deepcopy\nimport pyGPs\nfrom pyGPs.Core.cov import FITCOfKernel\nimport logging\n\nSHADEDCOLOR = [0.7539, 0.89453125, 0.62890625, 1.0]\nMEANCOLOR = [ 0.2109375, 0.63385, 0.1796875, 1.0]\nDATACOLOR = [0.12109375, 0.46875, 1., 1.0]\n\nclass GP(object):\n '''\n Base class for GP model.\n '''\n def __init__(self):\n super(GP, self).__init__()\n self.usingDefaultMean = True # was using default mean function now?\n self.meanfunc = None # mean function\n self.covfunc = None # covariance function\n self.likfunc = None # likelihood function\n self.inffunc = None # inference function\n self.optimizer = None # optimizer object\n self.nlZ = None # negative log marginal likelihood\n self.dnlZ = None # column vector of partial derivatives of the negative\n # log marginal likelihood w.r.t. each hyperparameter\n self.posterior = None # struct representation of the (approximate) posterior\n self.x = None # n by D matrix of training inputs\n self.y = None # column vector of length n of training targets\n self.xs = None # n by D matrix of test inputs\n self.ys = None # column vector of length nn of true test targets (optional)\n self.ym = None # column vector (of length ns) of predictive output means\n self.ys2 = None # column vector (of length ns) of predictive output variances\n self.fm = None # column vector (of length ns) of predictive latent means\n self.fs2 = None # column vector (of length ns) of predictive latent variances\n self.lp = None # column vector (of length ns) of log predictive probabilities\n\n self.logger = logging.getLogger(__name__)\n\n\n\n def __str__(self):\n strvalue = 'To get the properties of the model use:\\n'+\\\n 'model.nlZ # negative log marginal likelihood\\n'+\\\n 'model.dnlZ.cov # derivatives of cov func of negative log marginal likelihood\\n'+\\\n 'model.dnlZ.lik # derivatives of lik func of negative log marginal likelihood\\n'+\\\n 'model.dnlZ.mean # derivatives of mean func of negative log marginal likelihood\\n'+\\\n 'model.posterior # posterior structure\\n'+\\\n 'model.covfunc.hyp # hyperparameters of cov func\\n'+\\\n 'model.meanfunc.hyp # hyperparameters of mean func\\n'+\\\n 'model.likfunc.hyp # hyperparameters of lik func\\n'+\\\n 'model.fm # latent mean\\n'+\\\n 'model.fs2 # latent variance\\n'+\\\n 'model.ym # predictive mean\\n'+\\\n 'model.ys2 # predictive variance\\n'+\\\n 'model.lp # log predictive probability'\n return strvalue\n\n\n\n def __repr__(self):\n strvalue = str(type(self))+': '+\\\n 'to get the properties of the model use:\\n'+\\\n 'model.nlZ # negative log marginal likelihood\\n'+\\\n 'model.dnlZ.cov # derivatives of cov func of negative log marginal likelihood\\n'+\\\n 'model.dnlZ.lik # derivatives of lik func of negative log marginal likelihood\\n'+\\\n 'model.dnlZ.mean # derivatives of mean func of negative log marginal likelihood\\n'+\\\n 'model.posterior # posterior structure\\n'+\\\n 'model.covfunc.hyp # hyperparameters of cov func\\n'+\\\n 'model.meanfunc.hyp # hyperparameters of mean func\\n'+\\\n 'model.likfunc.hyp # hyperparameters of lik func\\n'+\\\n 'model.fm # latent mean\\n'+\\\n 'model.fs2 # latent variance\\n'+\\\n 'model.ym # predictive mean\\n'+\\\n 'model.ys2 # predictive variance\\n'+\\\n 'model.lp # log predictive probability'\n return strvalue\n\n\n\n\n def setData(self, x, y):\n '''\n Set training inputs and traning labels to model.\n\n :param x: training inputs in shape (n,D)\n :param y: training labels in shape (n,1)\n\n Note this method will transform x, y to correct shape\n if x, y is given in 1d array.\n '''\n # check wether the number of inputs and labels match\n assert x.shape[0] == y.shape[0], \"number of inputs and labels does not match\"\n\n # check the shape of inputs\n # transform to the correct shape\n if x.ndim == 1:\n x = np.reshape(x, (x.shape[0],1))\n if y.ndim == 1:\n y = np.reshape(y, (y.shape[0],1))\n\n self.x = x\n self.y = y\n if self.usingDefaultMean:\n c = np.mean(y)\n self.meanfunc = mean.Const(c) # adapt default prior mean wrt. training labels\n\n\n\n def plotData_1d(self, axisvals=None):\n '''\n Toy Method for ploting 1d data of the model.\n\n :param list axisvals: [min_x, max_x, min_y, max_y] setting the plot range\n '''\n plt.figure()\n plt.plot(self.x, self.y, ls='None', marker='+', color=DATACOLOR, ms=12, mew=2)\n if axisvals:\n plt.axis(axisvals)\n plt.grid()\n plt.xlabel('input x')\n plt.ylabel('target y')\n plt.show()\n\n\n\n def plotData_2d(self,x1,x2,t1,t2,p1,p2,axisvals=None):\n '''\n Toy Method for ploting 2d data of the model. \\n\n For plotting, we superimpose the data points with the posterior equi-probability contour\n lines for the probability of class two given complete information about the generating mechanism.\n\n :param x1: inputs for class +1\n :param x2: inputs for class -1\n :param t1: meshgrid array for the first axis\n :param t2: meshgrid array for the second axis\n :param p1,p2: contour lines contains p2/(p1+p2)\n :param list axisvals: [min_x, max_x, min_y, max_y] setting the plot range\n\n That is to say, the contour is ploted by plt.contour(t1, t2, p2/(p1+p2) )\n Note these parameters are (only) used for our hard-coded data for classification demo.\n '''\n fig = plt.figure()\n plt.plot(x1[:,0], x1[:,1], 'b+', markersize = 12)\n plt.plot(x2[:,0], x2[:,1], 'r+', markersize = 12)\n pc = plt.contour(t1, t2, np.reshape(old_div(p2,(p1+p2)), (t1.shape[0],t1.shape[1]) ))\n fig.colorbar(pc)\n plt.grid()\n if axisvals:\n plt.axis(axisvals)\n plt.show()\n\n\n\n def setPrior(self, mean=None, kernel=None):\n '''\n Set prior mean and covariance other than the default setting of current model.\n\n :param mean: instance of mean class. (e.g. mean.Linear())\n :param kernel: instance of covariance class. (e.g. cov.RBF())\n '''\n # check the type of inputs\n # ensure they are the right class before setting prior\n if not mean is None:\n assert isinstance(mean, pyGPs.mean.Mean), \"mean function is not an instance of pyGPs.mean.Mean\"\n self.meanfunc = mean\n self.usingDefaultMean = False\n if not kernel is None:\n assert isinstance(kernel, pyGPs.cov.Kernel), \"cov function is not an instance of pyGPs.cov.Kernel\"\n self.covfunc = kernel\n if type(kernel) is cov.Pre:\n self.usingDefaultMean = False\n\n\n\n def setOptimizer(self, method, num_restarts=None, min_threshold=None, meanRange=None, covRange=None, likRange=None):\n '''\n This method is used to sepecify optimization configuration. By default, gp uses a single run \"minimize\".\n\n :param method: Optimization methods. Possible values are:\\n\n \"Minimize\" -> minimize by Carl Rasmussen (python implementation of \"minimize\" in GPML)\\n\n \"CG\" -> conjugent gradient\\n\n \"BFGS\" -> quasi-Newton method of Broyden, Fletcher, Goldfarb, and Shanno (BFGS)\\n\n \"SCG\" -> scaled conjugent gradient (faster than CG)\\n\n :param num_restarts: Set if you want to run mulitiple times of optimization with different initial guess.\n It specifys the maximum number of runs/restarts/trials.\n :param min_threshold: Set if you want to run mulitiple times of optimization with different initial guess.\n It specifys the threshold of objective function value. Stop optimization when this value is reached.\n :param meanRange: The range of initial guess for mean hyperparameters.\n e.g. meanRange = [(-2,2), (-5,5), (0,1)].\n Each tuple specifys the range (low, high) of this hyperparameter,\n This is only the range of initial guess, during optimization process, optimal hyperparameters may go out of this range.\n (-5,5) for each hyperparameter by default.\n :param covRange: The range of initial guess for kernel hyperparameters. Usage see meanRange\n :param likRange: The range of initial guess for likelihood hyperparameters. Usage see meanRange\n '''\n pass\n\n\n\n def optimize40(self, x=None, y=None, numIterations=40):\n '''\n Train optimal hyperparameters based on training data,\n adjust new hyperparameters to all mean/cov/lik functions.\n\n :param x: training inputs in shape (n,D)\n :param y: training labels in shape (n,1)\n '''\n # check wether the number of inputs and labels match\n if x is not None and y is not None:\n assert x.shape[0] == y.shape[0], \"number of inputs and labels does not match\"\n\n # check the shape of inputs\n # transform to the correct shape\n if not x is None:\n if x.ndim == 1:\n x = np.reshape(x, (x.shape[0],1))\n self.x = x\n\n if not y is None:\n if y.ndim == 1:\n y = np.reshape(y, (y.shape[0],1))\n self.y = y\n\n if self.usingDefaultMean and self.meanfunc is None:\n c = np.mean(y)\n self.meanfunc = mean.Const(c) # adapt default prior mean wrt. training labels\n\n # optimize\n optimalHyp, optimalNlZ = self.optimizer.findMin(self.x, self.y, numIters = numIterations)\n self.nlZ = optimalNlZ\n\n # apply optimal hyp to all mean/cov/lik functions here\n self.optimizer._apply_in_objects(optimalHyp)\n self.getPosterior()\n\n \n \n def optimize(self, x=None, y=None, numIterations=1000):\n '''\n Train optimal hyperparameters based on training data,\n adjust new hyperparameters to all mean/cov/lik functions.\n\n :param x: training inputs in shape (n,D)\n :param y: training labels in shape (n,1)\n '''\n # check wether the number of inputs and labels match\n if x is not None and y is not None:\n assert x.shape[0] == y.shape[0], \"number of inputs and labels does not match\"\n\n # check the shape of inputs\n # transform to the correct shape\n if not x is None:\n if x.ndim == 1:\n x = np.reshape(x, (x.shape[0],1))\n self.x = x\n\n if not y is None:\n if y.ndim == 1:\n y = np.reshape(y, (y.shape[0],1))\n self.y = y\n\n if self.usingDefaultMean and self.meanfunc is None:\n c = np.mean(y)\n self.meanfunc = mean.Const(c) # adapt default prior mean wrt. training labels\n\n # optimize\n optimalHyp, optimalNlZ = self.optimizer.findMin(self.x, self.y, numIters = numIterations)\n self.nlZ = optimalNlZ\n\n # apply optimal hyp to all mean/cov/lik functions here\n self.optimizer._apply_in_objects(optimalHyp)\n self.getPosterior()\n\n\n def getPosterior(self, x=None, y=None, der=True):\n '''\n Fit the training data. Update negative log marginal likelihood(nlZ),\n partial derivatives of nlZ w.r.t. each hyperparameter(dnlZ),\n and struct representation of the (approximate) posterior(post),\n which consists of post.alpha, post.L, post.sW.\n\n nlZ, dnlZ, post = getPosterior(x, y, der=True)\\n\n nlZ, post = getPosterior(x, y, der=False )\n\n :param x: training inputs in shape (n,D)\n :param y: training labels in shape (n,1)\n :param boolean der: flag for whether to compute derivatives\n\n :return: negative log marginal likelihood (nlZ), derivatives of nlZ (dnlZ), posterior structure(post)\n\n You can print post to see descriptions of posterior.\n or see pyGPs.Core.inf for details.\n '''\n\n # check wether the number of inputs and labels match\n if x is not None and y is not None:\n assert x.shape[0] == y.shape[0], \"number of inputs and labels does not match\"\n\n # check the shape of inputs\n # transform to the correct shape\n if not x is None:\n if x.ndim == 1:\n x = np.reshape(x, (x.shape[0],1))\n self.x = x\n\n if not y is None:\n if y.ndim == 1:\n y = np.reshape(y, (y.shape[0],1))\n self.y = y\n\n if self.usingDefaultMean and self.meanfunc is None:\n c = np.mean(y)\n self.meanfunc = mean.Const(c) # adapt default prior mean wrt. training labels\n\n # call inference method\n if isinstance(self.likfunc, lik.Erf): #or is instance(self.likfunc, lik.Logistic):\n uy = unique(self.y)\n ind = ( uy != 1 )\n if any( uy[ind] != -1):\n raise Exception('You attempt classification using labels different from {+1,-1}')\n if not der:\n post, nlZ = self.inffunc.evaluate(self.meanfunc, self.covfunc, self.likfunc, self.x, self.y, 2)\n self.nlZ = nlZ\n self.posterior = deepcopy(post)\n return nlZ, post\n else:\n post, nlZ, dnlZ = self.inffunc.evaluate(self.meanfunc, self.covfunc, self.likfunc, self.x, self.y, 3)\n self.nlZ = nlZ\n self.dnlZ = deepcopy(dnlZ)\n self.posterior = deepcopy(post)\n return nlZ, dnlZ, post\n\n\n\n def predict(self, xs, ys=None):\n '''\n Prediction of test points (given by xs) based on training data of the current model.\n This method will output the following value:\\n\n predictive output means(ym),\\n\n predictive output variances(ys2),\\n\n predictive latent means(fm),\\n\n predictive latent variances(fs2),\\n\n log predictive probabilities(lp).\\n\n Theses values can also be achieved from model's property. (e.g. model.ym)\n\n :param xs: test input in shape of nn by D\n :param ys: test target(optional) in shape of nn by 1 if given\n\n :return: ym, ys2, fm, fs2, lp\n '''\n # check the shape of inputs\n # transform to correct shape if neccessary\n if xs.ndim == 1:\n xs = np.reshape(xs, (xs.shape[0],1))\n self.xs = xs\n if not ys is None:\n if ys.ndim == 1:\n ys = np.reshape(ys, (ys.shape[0],1))\n self.ys = ys\n\n meanfunc = self.meanfunc\n covfunc = self.covfunc\n likfunc = self.likfunc\n inffunc = self.inffunc\n x = self.x\n y = self.y\n\n if self.posterior is None:\n self.getPosterior()\n alpha = self.posterior.alpha\n L = self.posterior.L\n sW = self.posterior.sW\n\n nz = list(range(len(alpha[:,0]))) # non-sparse representation\n if len(L) == 0: # in case L is not provided, we compute it\n K = covfunc.getCovMatrix(x=x[nz,:], mode='train')\n #L = np.linalg.cholesky( (np.eye(nz) + np.dot(sW,sW.T)*K).T )\n L = jitchol( (np.eye(len(nz)) + np.dot(sW,sW.T)*K).T )\n Ltril = np.all( np.tril(L,-1) == 0 ) # is L an upper triangular matrix?\n ns = xs.shape[0] # number of data points\n nperbatch = 1000 # number of data points per mini batch\n nact = 0 # number of already processed test data points\n ymu = np.zeros((ns,1))\n ys2 = np.zeros((ns,1))\n fmu = np.zeros((ns,1))\n fs2 = np.zeros((ns,1))\n lp = np.zeros((ns,1))\n while nact<=ns-1: # process minibatches of test cases to save memory\n ids = list(range(nact,min(nact+nperbatch,ns))) # data points to process\n kss = covfunc.getCovMatrix(z=xs[ids,:], mode='self_test') # self-variances\n if isinstance(covfunc, FITCOfKernel):\n Ks = covfunc.getCovMatrix(x=x, z=xs[ids,:], mode='cross') # cross-covariances\n Ks = Ks[nz,:]\n else:\n Ks = covfunc.getCovMatrix(x=x[nz,:], z=xs[ids,:], mode='cross') # cross-covariances\n ms = meanfunc.getMean(xs[ids,:])\n N = (alpha.shape)[1] # number of alphas (usually 1; more in case of sampling)\n Fmu = np.tile(ms,(1,N)) + np.dot(Ks.T,alpha[nz]) # conditional mean fs|f\n fmu[ids] = np.reshape(old_div(Fmu.sum(axis=1),N),(len(ids),1)) # predictive means\n if Ltril: # L is triangular => use Cholesky parameters (alpha,sW,L)\n V = np.linalg.solve(L.T,np.tile(sW,(1,len(ids)))*Ks)\n fs2[ids] = kss - np.array([(V*V).sum(axis=0)]).T # predictive variances\n else: # L is not triangular => use alternative parametrization\n fs2[ids] = kss + np.array([(Ks*np.dot(L,Ks)).sum(axis=0)]).T # predictive variances\n fs2[ids] = np.maximum(fs2[ids],0) # remove numerical noise i.e. negative variances\n Fs2 = np.tile(fs2[ids],(1,N)) # we have multiple values in case of sampling\n if ys is None:\n Lp, Ymu, Ys2 = likfunc.evaluate(None,Fmu[:],Fs2[:],None,None,3)\n else:\n Lp, Ymu, Ys2 = likfunc.evaluate(np.tile(ys[ids],(1,N)), Fmu[:], Fs2[:],None,None,3)\n lp[ids] = np.reshape( old_div(np.reshape(Lp,(np.prod(Lp.shape),N)).sum(axis=1),N) , (len(ids),1) ) # log probability; sample averaging\n ymu[ids] = np.reshape( old_div(np.reshape(Ymu,(np.prod(Ymu.shape),N)).sum(axis=1),N) ,(len(ids),1) ) # predictive mean ys|y and ... \n ys2[ids] = np.reshape( old_div(np.reshape(Ys2,(np.prod(Ys2.shape),N)).sum(axis=1),N) , (len(ids),1) ) # .. variance\n nact = ids[-1]+1 # set counter to index of next data point\n self.ym = ymu\n self.ys2 = ys2\n self.lp = lp\n self.fm = fmu\n self.fs2 = fs2\n if ys is None:\n return ymu, ys2, fmu, fs2, None\n else:\n return ymu, ys2, fmu, fs2, lp\n\n\n\n def predict_with_posterior(self, post, xs, ys=None):\n '''\n Prediction of test points (given by xs) based on training data\n of the current model with posterior already provided.\n (i.e. you already have the posterior and thus don't need the fitting phase.)\n This method will output the following value:\\n\n predictive output means(ym),\\n\n predictive output variances(ys2),\\n\n predictive latent means(fm),\\n\n predictive latent variances(fs2),\\n\n log predictive probabilities(lp).\\n\n Theses values can also be achieved from model's property. (e.g. model.ym)\n\n :param post: struct representation of posterior\n :param xs: test input\n :param ys: test target(optional)\n\n :return: ym, ys2, fm, fs2, lp\n '''\n # check the shape of inputs\n # transform to correct shape if neccessary\n if xs.ndim == 1:\n xs = np.reshape(xs, (xs.shape[0],1))\n self.xs = xs\n if not ys is None:\n if ys.ndim == 1:\n ys = np.reshape(ys, (ys.shape[0],1))\n self.ys = ys\n\n meanfunc = self.meanfunc\n covfunc = self.covfunc\n likfunc = self.likfunc\n inffunc = self.inffunc\n x = self.x\n y = self.y\n\n self.posterior = deepcopy(post)\n alpha = post.alpha\n L = post.L\n sW = post.sW\n\n nz = list(range(len(alpha[:,0]))) # non-sparse representation\n if len(L) == 0: # in case L is not provided, we compute it\n K = covfunc.getCovMatrix(x=x[nz,:], mode='train')\n #L = np.linalg.cholesky( (np.eye(nz) + np.dot(sW,sW.T)*K).T )\n L = jitchol( (np.eye(len(nz)) + np.dot(sW,sW.T)*K).T )\n Ltril = np.all( np.tril(L,-1) == 0 ) # is L an upper triangular matrix?\n ns = xs.shape[0] # number of data points\n nperbatch = 1000 # number of data points per mini batch\n nact = 0 # number of already processed test data points\n ymu = np.zeros((ns,1))\n ys2 = np.zeros((ns,1))\n fmu = np.zeros((ns,1))\n fs2 = np.zeros((ns,1))\n lp = np.zeros((ns,1))\n while nact<=ns-1: # process minibatches of test cases to save memory\n id = list(range(nact,min(nact+nperbatch,ns))) # data points to process\n kss = covfunc.getCovMatrix(z=xs[id,:], mode='self_test') # self-variances\n Ks = covfunc.getCovMatrix(x=x[nz,:], z=xs[id,:], mode='cross') # cross-covariances\n ms = meanfunc.getMean(xs[id,:])\n N = (alpha.shape)[1] # number of alphas (usually 1; more in case of sampling)\n Fmu = np.tile(ms,(1,N)) + np.dot(Ks.T,alpha[nz]) # conditional mean fs|f\n fmu[id] = np.reshape(old_div(Fmu.sum(axis=1),N),(len(id),1)) # predictive means\n if Ltril: # L is triangular => use Cholesky parameters (alpha,sW,L)\n V = np.linalg.solve(L.T,np.tile(sW,(1,len(id)))*Ks)\n fs2[id] = kss - np.array([(V*V).sum(axis=0)]).T # predictive variances\n else: # L is not triangular => use alternative parametrization\n fs2[id] = kss + np.array([(Ks*np.dot(L,Ks)).sum(axis=0)]).T # predictive variances\n fs2[id] = np.maximum(fs2[id],0) # remove numerical noise i.e. negative variances\n Fs2 = np.tile(fs2[id],(1,N)) # we have multiple values in case of sampling\n if ys is None:\n [Lp, Ymu, Ys2] = likfunc.evaluate(None,Fmu[:],Fs2[:],None,None,3)\n else:\n [Lp, Ymu, Ys2] = likfunc.evaluate(np.tile(ys[id],(1,N)), Fmu[:], Fs2[:],None,None,3)\n lp[id] = np.reshape( old_div(np.reshape(Lp,(np.prod(Lp.shape),N)).sum(axis=1),N) , (len(id),1) ) # log probability; sample averaging\n ymu[id] = np.reshape( old_div(np.reshape(Ymu,(np.prod(Ymu.shape),N)).sum(axis=1),N) ,(len(id),1) ) # predictive mean ys|y and ...\n ys2[id] = np.reshape( old_div(np.reshape(Ys2,(np.prod(Ys2.shape),N)).sum(axis=1),N) , (len(id),1) ) # .. variance\n nact = id[-1]+1 # set counter to index of next data point\n self.ym = ymu\n self.ys2 = ys2\n self.lp = lp\n self.fm = fmu\n self.fs2 = fs2\n if ys is None:\n return ymu, ys2, fmu, fs2, None\n else:\n return ymu, ys2, fmu, fs2, lp\n\n\n\n\n\nclass GPR(GP):\n '''\n Model for Gaussian Process Regression\n '''\n def __init__(self):\n super(GPR, self).__init__()\n self.meanfunc = mean.Zero() # default prior mean\n self.covfunc = cov.RBF() # default prior covariance\n self.likfunc = lik.Gauss() # likihood with default noise variance 0.1\n self.inffunc = inf.Exact() # inference method\n self.optimizer = opt.Minimize(self) # default optimizer\n\n\n\n def setNoise(self,log_sigma):\n '''\n Set noise other than default noise value\n\n :param log_sigma: logarithm of the noise sigma\n '''\n self.likfunc = lik.Gauss(log_sigma)\n\n\n def setOptimizer(self, method, num_restarts=None, min_threshold=None, meanRange=None, covRange=None, likRange=None):\n '''\n Overriding. Usage see base class pyGPs.gp.GP.setOptimizer\n '''\n conf = None\n if (num_restarts!=None) or (min_threshold!=None):\n conf = pyGPs.Optimization.conf.random_init_conf(self.meanfunc,self.covfunc,self.likfunc)\n conf.num_restarts = num_restarts\n conf.min_threshold = min_threshold\n if not meanRange is None:\n conf.meanRange = meanRange\n if not covRange is None:\n conf.covRange = covRange\n if not likRange is None:\n conf.likRange = likRange\n if method == \"Minimize\":\n self.optimizer = opt.Minimize(self,conf)\n elif method == \"SCG\":\n self.optimizer = opt.SCG(self,conf)\n elif method == \"CG\":\n self.optimizer = opt.CG(self,conf)\n elif method == \"BFGS\":\n self.optimizer = opt.BFGS(self,conf)\n elif method == \"Nelder-Mead\":\n self.optimizer = opt.Simplex(self, conf)\n else:\n raise Exception('Optimization method is not set correctly in setOptimizer')\n\n\n def plot(self,axisvals=None):\n '''\n Plot 1d GP regression result.\n\n :param list axisvals: [min_x, max_x, min_y, max_y] setting the plot range\n '''\n xs = self.xs # test point\n x = self.x\n y = self.y\n ym = self.ym # predictive test mean\n ys2 = self.ys2 # predictive test variance\n plt.figure()\n xss = np.reshape(xs,(xs.shape[0],))\n ymm = np.reshape(ym,(ym.shape[0],))\n ys22 = np.reshape(ys2,(ys2.shape[0],))\n plt.plot(x, y, color=DATACOLOR, ls='None', marker='+',ms=12, mew=2)\n plt.plot(xs, ym, color=MEANCOLOR, ls='-', lw=3.)\n plt.fill_between(xss,ymm + 2.*np.sqrt(ys22), ymm - 2.*np.sqrt(ys22), facecolor=SHADEDCOLOR,linewidths=0.0)\n plt.grid()\n if not axisvals is None:\n plt.axis(axisvals)\n plt.xlabel('input x')\n plt.ylabel('target y')\n plt.show()\n\n\n def useInference(self, newInf):\n '''\n Use another inference techinique other than default exact inference.\n\n :param str newInf: 'Laplace' or 'EP'\n '''\n if newInf == \"Laplace\":\n self.inffunc = inf.Laplace()\n elif newInf == \"EP\":\n self.inffunc = inf.EP()\n else:\n raise Exception('Possible inf values are \"Laplace\", \"EP\".')\n\n\n def useLikelihood(self,newLik):\n '''\n Use another likelihood function other than default Gaussian likelihood.\n\n :param str newLik: 'Laplace'\n '''\n if newLik == \"Laplace\":\n self.likfunc = lik.Laplace()\n self.inffunc = inf.EP()\n else:\n raise Exception('Possible lik values are \"Laplace\".')\n\n\n\n\n\nclass GPC(GP):\n '''\n Model for Gaussian Process Classification.\n '''\n def __init__(self):\n super(GPC, self).__init__()\n self.meanfunc = mean.Zero() # default prior mean\n self.covfunc = cov.RBF() # default prior covariance\n self.likfunc = lik.Erf() # erf likihood\n self.inffunc = inf.EP() # default inference method\n self.optimizer = opt.Minimize(self) # default optimizer\n\n\n\n def setOptimizer(self, method, num_restarts=None, min_threshold=None, meanRange=None, covRange=None, likRange=None):\n '''\n Overriding. Usage see base class pyGPs.gp.GP.setOptimizer\n '''\n conf = None\n if (num_restarts!=None) or (min_threshold!=None):\n conf = pyGPs.Optimization.conf.random_init_conf(self.meanfunc,self.covfunc,self.likfunc)\n conf.num_restarts = num_restarts\n conf.min_threshold = min_threshold\n if not meanRange is None:\n conf.meanRange = meanRange\n if not covRange is None:\n conf.covRange = covRange\n if not likRange is None:\n conf.likRange = likRange\n if method == \"Minimize\":\n self.optimizer = opt.Minimize(self,conf)\n elif method == \"SCG\":\n self.optimizer = opt.SCG(self,conf)\n elif method == \"CG\":\n self.optimizer = opt.CG(self,conf)\n elif method == \"BFGS\":\n self.optimizer = opt.BFGS(self,conf)\n\n\n\n def plot(self,x1,x2,t1,t2,axisvals=None):\n '''\n Plot 2d GP Classification result.\n\n For plotting, we superimpose the data points with the posterior equi-probability contour\n lines for the probability of class two given complete information about the generating mechanism.\n\n :param x1: inputs for class +1\n :param x2: inputs for class -1\n :param t1: meshgrid array for the first axis\n :param t2: meshgrid array for the second axis\n :param list axisvals: [min_x, max_x, min_y, max_y] setting the plot range\n\n Note these parameters are (only) used for our hard-coded data for classification demo.\n '''\n fig = plt.figure()\n plt.plot(x1[:,0], x1[:,1], 'b+', markersize = 12)\n plt.plot(x2[:,0], x2[:,1], 'r+', markersize = 12)\n pc = plt.contour(t1, t2, np.reshape(np.exp(self.lp), (t1.shape[0],t1.shape[1]) ))\n fig.colorbar(pc)\n plt.grid()\n if not axisvals is None:\n plt.axis(axisvals)\n plt.show()\n\n\n\n def useInference(self, newInf):\n '''\n Use another inference techinique other than default EP inference.\n\n :param str newInf: 'Laplace'\n '''\n if newInf == \"Laplace\":\n self.inffunc = inf.Laplace()\n else:\n raise Exception('Possible inf values are \"Laplace\".')\n\n\n\n def useLikelihood(self,newLik):\n '''\n Use another likelihood function other than default error function.\n (Not used in this version)\n\n :param str newLik: 'Logistic'\n '''\n if newLik == \"Logistic\":\n raise Exception(\"Logistic likelihood is currently not implemented.\")\n #self.likfunc = lik.Logistic()\n else:\n raise Exception('Possible lik values are \"Logistic\".')\n\n\n\n\n\nclass GPMC(object):\n '''\n This is a one vs. one classification wrapper for GP Classification\n '''\n def __init__(self, n_class):\n self.meanfunc = mean.Zero() # default prior mean\n self.covfunc = cov.RBF() # default prior covariance\n self.n_class = n_class # number of different classes\n self.x_all = None\n self.y_all = None\n self.newInf = None # new inference? -> call useInference\n self.newLik = None # new likelihood? -> call useLikelihood\n self.newPrior = False\n\n\n\n def setPrior(self, mean=None, kernel=None):\n '''\n Set prior mean and covariance other than the default setting of current model.\n\n :param mean: instance of mean class. (e.g. mean.Linear())\n :param kernel: instance of covariance class. (e.g. cov.RBF())\n '''\n # check the type of inputs\n # ensure they are the right class before setting prior\n if not mean is None:\n assert isinstance(mean, pyGPs.mean.Mean), \"mean function is not an instance of pyGPs.mean.Mean\"\n self.meanfunc = mean\n self.usingDefaultMean = False\n if not kernel is None:\n assert isinstance(kernel, pyGPs.cov.Kernel), \"cov function is not an instance of pyGPs.cov.Kernel\"\n self.covfunc = kernel\n if type(kernel) is cov.Pre:\n self.usingDefaultMean = False\n self.newPrior = True\n\n\n\n def useInference(self, newInf):\n '''\n Use another inference techinique other than default EP inference.\n\n :param str newInf: 'Laplace'\n '''\n if newInf == \"Laplace\":\n self.inffunc = inf.Laplace()\n else:\n raise Exception('Possible inf values are \"Laplace\".')\n\n\n\n def useLikelihood(self,newLik):\n '''\n Use another likelihood function other than default error function.\n (Not used in this version)\n\n :param str newLik: 'Logistic'\n '''\n if newLik == \"Logistic\":\n raise Exception(\"Logistic likelihood is currently not implemented.\")\n #self.likfunc = lik.Logistic()\n else:\n raise Exception('Possible lik values are \"Logistic\".')\n\n\n\n def setData(self,x,y):\n '''\n Set training inputs and traning labels to model.\n\n :param x: training inputs in shape (n,D)\n :param y: training labels in shape (n,1)\n\n Note this method will transform x, y to correct shape\n if x, y is given in 1d array.\n '''\n # check wether the number of inputs and labels match\n assert x.shape[0] == y.shape[0], \"number of inputs and labels does not match\"\n\n # check the shape of inputs\n # transform to the correct shape\n if x.ndim == 1:\n x = np.reshape(x, (x.shape[0],1))\n if y.ndim == 1:\n y = np.reshape(y, (y.shape[0],1))\n\n self.x_all = x\n self.y_all = y\n\n\n\n def fitAndPredict(self, xs):\n '''\n Fit the model with given training data and predict for test points (given by xs).\n predictive_vote is a matrix where row i is each test point i,\n and column j is the probability for being class j\n\n :param xs: test inputs in shape of nn by D\n :return: predictive_vote\n '''\n # check the shape of inputs\n if xs.ndim == 1:\n xs = np.reshape(xs, (xs.shape[0],1))\n\n predictive_vote = np.zeros((xs.shape[0],self.n_class))\n for i in range(self.n_class): # classifier for class i...\n for j in range(i+1,self.n_class): # ...and class j\n x,y = self.createBinaryClass(i,j)\n model = GPC()\n if self.newPrior:\n model.setPrior(mean=self.meanfunc, kernel=self.covfunc)\n if self.newInf:\n model.useInference(self.newInf)\n if self.newLik:\n model.useLikelihood(self.newLik)\n model.getPosterior(x,y) # fitting\n ym = model.predict(xs)[0]\n ym += 1 # now scale into 0 to 2, ym=0 is class j, ym=2 is class i\n vote_i = np.zeros((xs.shape[0],self.n_class))\n vote_j = np.zeros((xs.shape[0],self.n_class))\n vote_i[:,i:i+1] = ym\n vote_j[:,j:j+1] = 2-ym\n predictive_vote += vote_i\n predictive_vote += vote_j\n predictive_vote /= predictive_vote.sum(axis=1)[:,np.newaxis]\n return predictive_vote\n\n\n\n def optimizeAndPredict(self, xs):\n '''\n Optimize the model with given training data and predict for test points (given by xs).\n predictive_vote is a matrix where row i is each test point i,\n and column j is the probability for being class j\n\n :param xs: test inputs in shape of nn by D\n :return: predictive_vote\n '''\n # check the shape of inputs\n if xs.ndim == 1:\n xs = np.reshape(xs, (xs.shape[0],1))\n\n predictive_vote = np.zeros((xs.shape[0],self.n_class))\n for i in range(self.n_class): # classifier for class i...\n for j in range(i+1,self.n_class): # ...and class j\n x,y = self.createBinaryClass(i,j)\n model = GPC()\n if self.newPrior:\n model.setPrior(mean=self.meanfunc, kernel=self.covfunc)\n if self.newInf:\n model.useInference(self.newInf)\n if self.newLik:\n model.useLikelihood(self.newLik)\n model.optimize(x,y) # training\n ym = model.predict(xs)[0]\n ym += 1 # now scale into 0 to 2, ym=0 is class j, ym=2 is class i\n vote_i = np.zeros((xs.shape[0],self.n_class))\n vote_j = np.zeros((xs.shape[0],self.n_class))\n vote_i[:,i:i+1] = ym\n vote_j[:,j:j+1] = 2-ym\n predictive_vote += vote_i\n predictive_vote += vote_j\n predictive_vote /= predictive_vote.sum(axis=1)[:,np.newaxis]\n return predictive_vote\n\n\n\n def createBinaryClass(self, i,j):\n '''\n Create dataset x(data) and y(label) which only contains class i and j.\n Relabel class i to +1 and class j to -1\n\n :param int i: the i_th class\n :param int j: the j_th class\n :return: x(data) and y(label) which only contains class i and j\n\n '''\n class_i = []\n class_j = []\n for index in range(len(self.y_all)): # check all classes\n target = self.y_all[index]\n if target == i:\n class_i.append(index)\n elif target == j:\n class_j.append(index)\n n1 = len(class_i)\n n2 = len(class_j)\n class_i.extend(class_j)\n x = self.x_all[class_i,:]\n y = np.concatenate((np.ones((1,n1)),-np.ones((1,n2))),axis=1).T\n return x,y\n\n\n\n\n\nclass GP_FITC(GP):\n '''\n Model for FITC GP base class\n '''\n def __init__(self):\n super(GP_FITC, self).__init__()\n self.u = None # inducing points\n\n\n\n def setData(self, x, y, value_per_axis=5):\n '''\n Set training inputs and traning labels to model and derive deault inducing_points..\n\n :param x: training inputs in shape (n,D)\n :param y: training labels in shape (n,1)\n :param int value_per_axis: number of value in each dimension\n when using a uni-distant default inducing points\n\n Note this method will transform x, y to correct shape\n if x, y is given in 1d array.\n '''\n # check wether the number of inputs and labels match\n assert x.shape[0] == y.shape[0], \"number of inputs and labels does not match\"\n\n # check dimension of inputs\n # transform to correct shape if neccessary\n if x.ndim == 1:\n x = np.reshape(x, (x.shape[0],1))\n if y.ndim == 1:\n y = np.reshape(y, (y.shape[0],1))\n self.x = x\n self.y = y\n if self.usingDefaultMean:\n c = np.mean(y)\n self.meanfunc = mean.Const(c) # adapt default prior mean wrt. training labels\n\n # get range of x in each dimension\n # 5 uniformally selected value for each dimension\n gridAxis=[]\n for d in range(x.shape[1]):\n column = x[:,d]\n mini = np.min(column)\n maxi = np.max(column)\n axis = np.linspace(mini,maxi,value_per_axis)\n gridAxis.append(axis)\n # default inducing points-> a grid\n if self.u is None:\n self.u = np.array(list(itertools.product(*gridAxis)))\n self.covfunc = self.covfunc.fitc(self.u)\n\n\n\n def setPrior(self, mean=None, kernel=None, inducing_points=None):\n '''\n Set prior mean and covariance other than the default setting of current model,\n as well as the inducing points\n\n :param mean: instance of mean class. (e.g. mean.Linear())\n :param kernel: instance of covariance class. (e.g. cov.RBF())\n :inducing_points: matrix of inducing points in shape of (nu,D)\n '''\n if not kernel is None:\n if not inducing_points is None:\n self.covfunc = kernel.fitc(inducing_points)\n self.u = inducing_points\n else:\n if not self.u is None:\n self.covfunc = kernel.fitc(self.u)\n else:\n raise Exception(\"To use default inducing points, please call setData() first!\")\n if type(kernel) is cov.Pre:\n self.usingDefaultMean = False\n if not mean is None:\n self.meanfunc = mean\n self.usingDefaultMean = False\n\n\n\n\n\nclass GPR_FITC(GP_FITC):\n '''\n Model for Gaussian Process Regression FITC\n '''\n def __init__(self):\n super(GPR_FITC, self).__init__()\n self.meanfunc = mean.Zero() # default prior mean\n self.covfunc = cov.RBF() # default prior covariance\n self.likfunc = lik.Gauss() # likihood with default noise variance 0.1\n self.inffunc = inf.FITC_Exact() # inference method\n self.optimizer = opt.Minimize(self) # default optimizer\n self.u = None # no default inducing points\n\n\n\n def setNoise(self,log_sigma):\n '''\n Set noise other than default noise value\n\n :param log_sigma: logarithm of the noise sigma\n '''\n self.likfunc = lik.Gauss(log_sigma)\n\n\n\n def setOptimizer(self, method, num_restarts=None, min_threshold=None, meanRange=None, covRange=None, likRange=None):\n '''\n Overriding. Usage see base class pyGPs.gp.GP.setOptimizer\n '''\n conf = None\n if (num_restarts!=None) or (min_threshold!=None):\n conf = pyGPs.Optimization.conf.random_init_conf(self.meanfunc,self.covfunc,self.likfunc)\n conf.num_restarts = num_restarts\n conf.min_threshold = min_threshold\n if not meanRange is None:\n conf.meanRange = meanRange\n if not covRange is None:\n conf.covRange = covRange\n if not likRange is None:\n conf.likRange = likRange\n if method == \"Minimize\":\n self.optimizer = opt.Minimize(self,conf)\n elif method == \"SCG\":\n self.optimizer = opt.SCG(self,conf)\n elif method == \"CG\":\n self.optimizer = opt.CG(self,conf)\n elif method == \"BFGS\":\n self.optimizer = opt.BFGS(self,conf)\n\n\n\n def plot(self,axisvals=None):\n '''\n Plot 1d GP FITC Regression result.\n\n :param list axisvals: [min_x, max_x, min_y, max_y] setting the plot range\n '''\n plt.figure()\n xss = np.reshape(self.xs,(self.xs.shape[0],))\n ymm = np.reshape(self.ym,(self.ym.shape[0],))\n ys22 = np.reshape(self.ys2,(self.ys2.shape[0],))\n plt.plot(self.x, self.y, color=DATACOLOR, ls='None', marker='+',ms=12, mew=2)\n plt.plot(self.xs, self.ym, color=MEANCOLOR, ls='-', lw=3.)\n plt.fill_between(xss,ymm + 2.*np.sqrt(ys22), ymm - 2.*np.sqrt(ys22), facecolor=SHADEDCOLOR,linewidths=0.0)\n plt.grid()\n if not axisvals is None:\n plt.axis(axisvals)\n plt.xlabel('input x')\n plt.ylabel('output y')\n plt.plot(self.u,np.ones_like(self.u), ls='None', color='k',marker='x',markersize=12,mew=2)\n plt.show()\n\n\n\n def useInference(self, newInf):\n '''\n Use another inference techinique other than default exact inference.\n\n :param str newInf: 'Laplace' or 'EP'\n '''\n if newInf == \"Laplace\":\n self.inffunc = inf.FITC_Laplace()\n elif newInf == \"EP\":\n self.inffunc = inf.FITC_EP()\n else:\n raise Exception('Possible inf values are \"Laplace\", \"EP\".')\n\n\n\n def useLikelihood(self,newLik):\n '''\n Use another inference techinique other than default Gaussian likelihood.\n\n :param str newLik: 'Laplace'\n '''\n if newLik == \"Laplace\":\n self.likfunc = lik.Laplace()\n self.inffunc = inf.FITC_EP()\n else:\n raise Exception('Possible lik values are \"Laplace\".')\n\n\n\n\n\nclass GPC_FITC(GP_FITC):\n '''\n Model for Gaussian Process Classification FITC\n '''\n def __init__(self):\n super(GPC_FITC, self).__init__()\n self.meanfunc = mean.Zero() # default prior mean\n self.covfunc = cov.RBF() # default prior covariance\n self.likfunc = lik.Erf() # erf liklihood\n self.inffunc = inf.FITC_EP() # default inference method\n self.optimizer = opt.Minimize(self) # default optimizer\n self.u = None # no default inducing points\n\n\n\n def setOptimizer(self, method, num_restarts=None, min_threshold=None, meanRange=None, covRange=None, likRange=None):\n '''\n Overriding. Usage see base class pyGPs.gp.GP.setOptimizer\n '''\n conf = None\n if (num_restarts!=None) or (min_threshold!=None):\n conf = pyGPs.Optimization.conf.random_init_conf(self.meanfunc,self.covfunc,self.likfunc)\n conf.num_restarts = num_restarts\n conf.min_threshold = min_threshold\n if not meanRange is None:\n conf.meanRange = meanRange\n if not covRange is None:\n conf.covRange = covRange\n if not likRange is None:\n conf.likRange = likRange\n if method == \"Minimize\":\n self.optimizer = opt.Minimize(self,conf)\n elif method == \"SCG\":\n self.optimizer = opt.SCG(self,conf)\n elif method == \"CG\":\n self.optimizer = opt.CG(self,conf)\n elif method == \"BFGS\":\n self.optimizer = opt.BFGS(self,conf)\n\n\n\n def plot(self,x1,x2,t1,t2,axisvals=None):\n '''Plot 2d GP FITC classification.\n For plotting, we superimpose the data points with the posterior equi-probability contour\n lines for the probability of class two given complete information about the generating mechanism.\n\n :param x1: inputs for class +1\n :param x2: inputs for class -1\n :param t1: meshgrid array for the first axis\n :param t2: meshgrid array for the second axis\n :param list axisvals: [min_x, max_x, min_y, max_y] setting the plot range\n\n Note these parameters are (only) used for our hard-coded data for classification demo.\n '''\n fig = plt.figure()\n plt.plot(x1[:,0], x1[:,1], 'b+', markersize = 12)\n plt.plot(x2[:,0], x2[:,1], 'r+', markersize = 12)\n plt.plot(self.u[:,0],self.u[:,1],'ko', markersize=12)\n pc = plt.contour(t1, t2, np.reshape(np.exp(self.lp), (t1.shape[0],t1.shape[1]) ))\n fig.colorbar(pc)\n plt.grid()\n if not axisvals is None:\n plt.axis(axisvals)\n plt.show()\n\n\n\n def useInference(self, newInf):\n '''\n Use another inference techinique other than default exact inference.\n\n :param str newInf: 'Laplace' or 'EP'\n '''\n if newInf == \"Laplace\":\n self.inffunc = inf.FITC_Laplace()\n else:\n raise Exception('Possible inf values are \"Laplace\".')\n\n\n\n def useLikelihood(self,newLik):\n '''\n Use another inference techinique other than default Erf likelihood.\n (Not used in this version)\n\n :param str newLik: 'Logistic'\n '''\n if newLik == \"Logistic\":\n raise Exception(\"Logistic likelihood is currently not implemented.\")\n else:\n raise Exception('Possible lik values are \"Logistic\".')\n"
] | [
[
"numpy.ones_like",
"numpy.dot",
"numpy.tile",
"numpy.min",
"numpy.mean",
"numpy.exp",
"numpy.max",
"numpy.prod",
"numpy.sqrt",
"matplotlib.pyplot.axis",
"numpy.reshape",
"numpy.zeros",
"matplotlib.pyplot.figure",
"matplotlib.pyplot.show",
"numpy.tril",
"matplotlib.pyplot.grid",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.plot",
"numpy.ones",
"matplotlib.pyplot.ylabel",
"numpy.linspace",
"numpy.maximum"
]
] |
Algomorph/NeuralTracking | [
"6312be8e18828344c65e25a423c239efcd3428dd",
"6312be8e18828344c65e25a423c239efcd3428dd"
] | [
"tests/data_generation/animate_berlin_y_stretch.py",
"tests/data_generation/animate_berlin_x_offset.py"
] | [
"import sys\nimport os\nimport shutil\n\nimport cv2\nimport open3d as o3d\nimport open3d.core as o3c\nimport numpy as np\n\nfrom rendering.pytorch3d_renderer import PyTorch3DRenderer\nfrom data import StandaloneFrameDataset\nimport data.presets as presets\nimport tsdf.default_voxel_grid\nimport data.camera\nfrom settings import process_arguments, PathParameters, DeformNetParameters\n\nPROGRAM_EXIT_SUCCESS = 0\n\n\ndef main():\n process_arguments()\n frame_dataset: StandaloneFrameDataset = presets.StandaloneFramePreset.BERLIN_0.value\n\n device = o3c.Device(\"cuda:0\")\n volume: o3d.t = tsdf.default_voxel_grid.make_default_tsdf_voxel_grid(device)\n\n depth_image = frame_dataset.load_depth_image_open3d(device)\n color_image = frame_dataset.load_color_image_open3d(device)\n intrinsics_open3d_cpu, _ = data.camera.load_open3d_intrinsics_from_text_4x4_matrix_and_image(frame_dataset.get_intrinsics_path(),\n frame_dataset.get_depth_image_path())\n intrinsics_open3d_cuda = o3d.core.Tensor(intrinsics_open3d_cpu.intrinsic_matrix, o3d.core.Dtype.Float32, device)\n extrinsics_open3d_cuda = o3d.core.Tensor.eye(4, o3d.core.Dtype.Float32, device)\n\n volume.integrate(depth_image, color_image, intrinsics_open3d_cuda, extrinsics_open3d_cuda, DeformNetParameters.depth_scale.value, 3.0)\n original_mesh: o3d.geometry.TriangleMesh = volume.extract_surface_mesh(-1, 0).to_legacy_triangle_mesh()\n renderer = PyTorch3DRenderer((depth_image.rows, depth_image.columns), device, intrinsics_open3d_cuda)\n\n frame_count = 6\n scale_factor_increment = 0.1\n\n scale_center = np.array([0.0855289, -0.03289237, 2.79831315], dtype=np.float32)\n\n def scale_mesh_y(mesh: o3d.geometry.TriangleMesh, factor: float) -> o3d.geometry.TriangleMesh:\n vertices = np.array(mesh.vertices)\n stretched_vertices = vertices - scale_center\n stretched_vertices[:, 1] *= factor\n stretched_vertices += scale_center\n\n _scaled_mesh = o3d.geometry.TriangleMesh(o3d.cuda.pybind.utility.Vector3dVector(stretched_vertices), mesh.triangles)\n _scaled_mesh.vertex_colors = mesh.vertex_colors\n return _scaled_mesh\n\n # prepare folders\n root_output_directory = os.path.join(PathParameters.output_directory.value, \"berlin_y_stretch_sequence\")\n depth_output_directory = os.path.join(root_output_directory, \"depth\")\n if not os.path.exists(depth_output_directory):\n os.makedirs(depth_output_directory)\n color_output_directory = os.path.join(root_output_directory, \"color\")\n if not os.path.exists(color_output_directory):\n os.makedirs(color_output_directory)\n\n # record animation rendering output\n for i_frame in range(0, frame_count):\n scaled_mesh = scale_mesh_y(original_mesh, 1.0 + scale_factor_increment * i_frame)\n depth, color = renderer.render_mesh_legacy(scaled_mesh, depth_scale=1000.0)\n color_path = os.path.join(color_output_directory, f\"{i_frame:06d}.jpg\")\n depth_path = os.path.join(depth_output_directory, f\"{i_frame:06d}.png\")\n cv2.imwrite(color_path, color)\n cv2.imwrite(depth_path, depth.astype(np.uint16))\n\n shutil.copy(frame_dataset.get_intrinsics_path(), os.path.join(root_output_directory, \"intrinsics.txt\"))\n\n return PROGRAM_EXIT_SUCCESS\n\n\nif __name__ == \"__main__\":\n sys.exit(main())\n",
"import sys\nimport os\nimport shutil\n\nimport cv2\nimport open3d as o3d\nimport open3d.core as o3c\nimport numpy as np\n\nfrom rendering.pytorch3d_renderer import PyTorch3DRenderer\nfrom data import StandaloneFrameDataset\nimport data.presets as presets\nimport tsdf.default_voxel_grid\nimport data.camera\nfrom settings import process_arguments, PathParameters, DeformNetParameters\n\nPROGRAM_EXIT_SUCCESS = 0\n\n\ndef main():\n process_arguments()\n frame_dataset: StandaloneFrameDataset = presets.StandaloneFramePreset.BERLIN_0.value\n\n device = o3c.Device(\"cuda:0\")\n volume: o3d.t = tsdf.default_voxel_grid.make_default_tsdf_voxel_grid(device)\n\n depth_image = frame_dataset.load_depth_image_open3d(device)\n color_image = frame_dataset.load_color_image_open3d(device)\n intrinsics_open3d_cpu, _ = data.camera.load_open3d_intrinsics_from_text_4x4_matrix_and_image(frame_dataset.get_intrinsics_path(),\n frame_dataset.get_depth_image_path())\n intrinsics_open3d_cuda = o3d.core.Tensor(intrinsics_open3d_cpu.intrinsic_matrix, o3d.core.Dtype.Float32, device)\n extrinsics_open3d_cuda = o3d.core.Tensor.eye(4, o3d.core.Dtype.Float32, device)\n\n volume.integrate(depth_image, color_image, intrinsics_open3d_cuda, extrinsics_open3d_cuda, DeformNetParameters.depth_scale.value, 3.0)\n original_mesh: o3d.geometry.TriangleMesh = volume.extract_surface_mesh(-1, 0).to_legacy_triangle_mesh()\n renderer = PyTorch3DRenderer((depth_image.rows, depth_image.columns), device, intrinsics_open3d_cuda)\n\n frame_count = 6\n offset_increment = 0.01\n\n def offset_mesh_plus_x(mesh: o3d.geometry.TriangleMesh, offset: float) -> o3d.geometry.TriangleMesh:\n vertices = np.array(mesh.vertices)\n vertices[:, 0] += offset\n _offset_mesh = o3d.geometry.TriangleMesh(o3d.cuda.pybind.utility.Vector3dVector(vertices), mesh.triangles)\n _offset_mesh.vertex_colors = mesh.vertex_colors\n return _offset_mesh\n\n # prepare folders\n root_output_directory = os.path.join(PathParameters.output_directory.value, \"berlin_x_offset_sequence\")\n depth_output_directory = os.path.join(root_output_directory, \"depth\")\n if not os.path.exists(depth_output_directory):\n os.makedirs(depth_output_directory)\n color_output_directory = os.path.join(root_output_directory, \"color\")\n if not os.path.exists(color_output_directory):\n os.makedirs(color_output_directory)\n\n # record animation rendering output\n for i_frame in range(0, frame_count):\n offset_mesh = offset_mesh_plus_x(original_mesh, offset_increment * i_frame)\n depth, color = renderer.render_mesh_legacy(offset_mesh, depth_scale=1000.0)\n color_path = os.path.join(color_output_directory, f\"{i_frame:06d}.jpg\")\n depth_path = os.path.join(depth_output_directory, f\"{i_frame:06d}.png\")\n cv2.imwrite(color_path, color)\n cv2.imwrite(depth_path, depth.astype(np.uint16))\n\n shutil.copy(frame_dataset.get_intrinsics_path(), os.path.join(root_output_directory, \"intrinsics.txt\"))\n\n return PROGRAM_EXIT_SUCCESS\n\n\nif __name__ == \"__main__\":\n sys.exit(main())\n"
] | [
[
"numpy.array"
],
[
"numpy.array"
]
] |
aliabid2243/deepgaze | [
"8c602db89a1d1d8a644b44a381ddb8a693375e08"
] | [
"new_model/test_big.py"
] | [
"import os\nfrom load_data import load_batch, load_data_names, load_batch_from_names, load_batch_from_names_random\nfrom my_model import get_eye_tracker_model\nimport numpy as np\nfrom keras.models import load_model\nfrom keras.optimizers import SGD, adam\n\ndef generator(data, batch_size, img_cols, img_rows, img_ch):\n\n while True:\n for it in list(range(0, data[0].shape[0], batch_size)):\n x, y = load_batch([l[it:it + batch_size] for l in data], img_cols, img_rows, img_ch)\n yield x, y\n\n\ndef test_big(args):\n\n os.environ[\"CUDA_DEVICE_ORDER\"] = \"PCI_BUS_ID\"\n os.environ[\"CUDA_VISIBLE_DEVICES\"] = args.dev\n names_path = r\"C:\\Users\\Aliab\\PycharmProjects\\data\\test\"\n print(\"Names to test: {}\".format(names_path))\n\n dataset_path = r\"D:\\GazeCapture\"\n print(\"Dataset: {}\".format(names_path))\n\n weights_path = \"weight_vgg.hdf5\"\n print(\"Weights: {}\".format(weights_path))\n\n # image parameter\n img_cols = 128\n img_rows = 128\n img_ch = 3\n\n # test parameter\n batch_size = 64\n chunk_size = 500\n\n # model\n model = get_eye_tracker_model(img_cols, img_rows, img_ch)\n\n # model summary\n model.summary()\n\n # weights\n print(\"Loading weights...\")\n model = load_model(weights_path)\n\n model.load_weights(weights_path)\n # data\n test_names = load_data_names(names_path)\n\n # limit amount of testing data\n # test_names = test_names[:1000]\n\n # results\n err_x = []\n err_y = []\n\n print(\"Loading testing data...\")\n for it in list(range(0, len(test_names), chunk_size)):\n\n x, y = load_batch_from_names_random(test_names[it:it + chunk_size], dataset_path, batch_size, img_cols, img_rows, img_ch)\n # x, y = load_batch_from_names(test_names[it:it + chunk_size], dataset_path, img_ch, img_cols, img_rows)\n predictions = model.predict(x=x, batch_size=batch_size, verbose=1)\n\n # print and analyze predictions\n for i, prediction in enumerate(predictions):\n print(\"PR: {} {}\".format(prediction[0], prediction[1]))\n print(\"GT: {} {} \\n\".format(y[i][0], y[i][1]))\n\n err_x.append(abs(prediction[0] - y[i][0]))\n err_y.append(abs(prediction[1] - y[i][1]))\n\n # mean absolute error\n mae_x = np.mean(err_x)\n mae_y = np.mean(err_y)\n\n # standard deviation\n std_x = np.std(err_x)\n std_y = np.std(err_y)\n\n # final results\n print(\"MAE: {} {} ( samples)\".format(mae_x, mae_y))\n print(\"STD: {} {} ( samples)\".format(std_x, std_y))\n\n\nif __name__ == '__main__':\n test_big()\n"
] | [
[
"numpy.std",
"numpy.mean"
]
] |
edpolanco/air_cargo | [
"20ddf6c72dafed85b87486ca46a9c09656f31d90"
] | [
"analysis.py"
] | [
"\"\"\"Module for summarizing cargo planning testing results.\n\n Ed Polanco\n [email protected]\n\"\"\"\nimport pandas as pd\nfrom collections import OrderedDict\nimport datetime\nimport time \nfrom aimacode.search import Problem, Node\nfrom timeit import default_timer as timer\nfrom run_search import PrintableProblem, PROBLEMS\nfrom aimacode.search import (breadth_first_search, astar_search,\n breadth_first_tree_search, depth_first_graph_search, uniform_cost_search,\n greedy_best_first_graph_search, depth_limited_search,\n recursive_best_first_search)\n\n#Names of the various search algorithms\nSEARCHES_SHORT_NAME = [[\"Breadth First\", breadth_first_search, \"\"], #1\n ['Breadth First Tree', breadth_first_tree_search, \"\"], #2\n ['Depth First Graph', depth_first_graph_search, \"\"], #3\n ['Depth Limited', depth_limited_search, \"\"], #4\n ['Uniform Cost', uniform_cost_search, \"\"], #5\n ['Recursive Best First w/ h1', recursive_best_first_search, 'h_1'], #6\n ['Greedy Best First Graph w/ h1', greedy_best_first_graph_search, 'h_1'], #7\n ['Astar w/ h1', astar_search, 'h_1'], #8\n ['Astar w/ ignore pre-cond.', astar_search, 'h_ignore_preconditions'], #9\n ['Astar w/ level-sum', astar_search, 'h_pg_levelsum'], #10\n ]\n\ndef show_path(node:Node):\n \"\"\"\n Print solution set to screen\n\n Paremeter\n ----------\n node: Node\n Search tree object that has 'solution()' method \n \"\"\"\n if node is None:\n print(\"The selected planner did not find a solution for this problem. \" +\n \"Make sure you have completed the AirCargoProblem implementation \" +\n \"and pass all unit tests first.\")\n else:\n msg = \"Search function {} plan length: {} \".format(node[0],len(node[1].solution()) )\n print(msg)\n for action in node[1].solution():\n print(\"{}{}\".format(action.name, action.args))\n\ndef run_search_table(problem: Problem, search_function, parameter=None):\n \"\"\"Perform a test to find a solution to one of cargo problems.\n\n Paremeters:\n ----------\n problem: Problem\n Cargo planning problem\n \n search_function: str\n Search algorithm function name\n \n parameter: parameter value if any [None]\n Parameter value for the search algorithms that require it.\n\n Returns:\n ----------\n Returns tuple of 5 values:\n 1 = Node expansions count\n 2 = number of times we tested for goal state\n 3 = Number of new nodes\n 4 = Number of steps\n 5 = Search tree Node object\n \"\"\" \n start = timer()\n ip = PrintableProblem(problem)\n if parameter is not None:\n node = search_function(ip, parameter)\n else:\n node = search_function(ip)\n end = timer()\n\n return (ip.succs, ip.goal_tests, ip.states, end - start, node )\n\ndef search_data(problem_id: int, s_choices: list):\n \"\"\" Perform test to solve cargo planning problem with\n the given search algorithms.\n\n Paremeters:\n ----------\n problem_id: int\n Cargo planning problem id\n \n s_choices: list\n List of the search algorithm to try.\n\n Returns:\n ----------\n Returns tuple of two items:\n 1 = DataFrame that summarizes test result\n 2 = A list of tuples, where the first item in the \n tuple is the search algorithm name and the second\n is its corresponding search Node object.\n \"\"\"\n #lets get a list of problems and search algorithms\n problem_name,problem = PROBLEMS[problem_id - 1][0],PROBLEMS[problem_id- 1][1]\n searches = [SEARCHES_SHORT_NAME[i-1] for i in map(int, s_choices)]\n\n # helper variables to create DataFrame\n steps = []\n fun_name = []\n expansions = []\n goal_test =[]\n new_nodes = []\n elapsed_time = []\n nodes = []\n\n for sname, s, h in searches:\n start_time = datetime.datetime.fromtimestamp(time.time()).strftime('%Y-%m-%d %I:%M:%S%p')\n print(\"\\nSolving {} using {} start time {}...\".format(problem_name, sname, start_time))\n\n _p = problem()\n _h = None if not h else getattr(_p, h)\n \n #perform test get result\n result = run_search_table(_p, s, _h)\n\n #update helper list variables\n fun_name.append(sname)\n expansions.append(result[0])\n goal_test.append(result[1])\n new_nodes.append(result[2])\n elapsed_time.append(result[3])\n steps.append(len(result[4].solution()) )\n nodes.append([sname,result[4]])\n \n #create dictionary for DataFrame input\n table_dict = OrderedDict()\n table_dict[\"Function Name\"] = fun_name\n table_dict[\"Solution Steps\"] = steps\n table_dict[\"Expansions\"] = expansions\n table_dict[\"Goal Tests\"] = goal_test\n table_dict[\"New_Nodes\"] = new_nodes\n table_dict[\"Elapsed Seconds\"] = elapsed_time\n \n dataframe = pd.DataFrame(table_dict)\n dataframe.index +=1\n return dataframe, nodes"
] | [
[
"pandas.DataFrame"
]
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.