repo_name
stringlengths 8
130
| hexsha
sequence | file_path
sequence | code
sequence | apis
sequence |
|---|---|---|---|---|
chalant/pluto | [
"e7bfd35a2c1fc0e0753bd2f840b0a4385b5124fc"
] | [
"pluto/test/test.py"
] | [
"import logging\n\nfrom sqlalchemy import create_engine\n\nimport pandas as pd\n\nfrom numpy import testing\nimport numpy as np\n\nfrom dev import strategy_store, events\n\nfrom pluto import examples\n\nfrom pluto.utils import stream\n\nfrom pluto.control.loop import simulation_loop\n\nfrom pluto.control.processes import processes\nfrom pluto.control.processes import in_memory\n\nfrom pluto.coms.utils import conversions\n\nfrom pluto.strategies import strategies\nfrom pluto.strategies import schema\n\nfrom pluto.interface import monitor\n\nfrom pluto.universes import universes\n\nfrom protos import controller_pb2\n\n\nclass TestWatcher(monitor.AbstractWatcher):\n def __init__(self, process_id, expected_df, name, error_callback):\n super(TestWatcher, self).__init__(process_id)\n\n self._expected_df = expected_df[examples._cols_to_check]\n\n self._errors = 0\n self._tests = 0\n\n self._i = 0\n\n self._daily_perfs = []\n self._name = name\n\n self._error_callback = error_callback\n\n def performance_update(self, packet):\n\n daily_perfs = self._daily_perfs\n # append until end...\n\n perf = controller_pb2.PerformancePacket()\n perf.ParseFromString(packet.packet)\n\n perf = conversions.from_proto_performance_packet(perf)\n\n daily_perf = perf.get('daily_perf', None)\n daily_perf.update(perf['cumulative_risk_metrics'])\n\n cum_perf = perf['cumulative_perf']\n cum_perf.pop('period_close')\n cum_perf.pop('period_open')\n cum_perf.pop('capital_used')\n cum_perf.pop('starting_exposure')\n cum_perf.pop('ending_exposure')\n cum_perf.pop('starting_value')\n cum_perf.pop('starting_cash')\n cum_perf.pop('returns')\n cum_perf.pop('pnl')\n\n daily_perf.update(cum_perf)\n\n daily_perfs.append(daily_perf)\n\n if packet.end:\n\n # compare values to expected values.\n expected_perf = self._expected_df\n\n daily_dts = pd.DatetimeIndex(\n [p['period_close'] for p in daily_perfs], tz='UTC'\n )\n\n daily_stats = pd.DataFrame(daily_perfs, index=daily_dts)[examples._cols_to_check]\n\n errors = 0\n tests = 0\n\n for l, r in zip(expected_perf.iteritems(), daily_stats.iteritems()):\n\n tests += 1\n\n des = l[1]\n act = r[1]\n\n try:\n testing.assert_allclose(\n np.nan_to_num(des.values),\n act.values,\n rtol=0.1,\n atol=0.2,\n equal_nan=False)\n\n except AssertionError as e:\n errors += 1\n\n print('Name: {}\\nError: {}'.format(l[0], e))\n\n except TypeError:\n # try:\n # pd.testing.assert_series_equal(act, des, check_less_precise=3)\n # except AssertionError as e:\n # logging.warning('\\nName: {}\\nError: {}'.format(l[0], e))\n pass\n\n if errors > 0:\n self._error_callback('{} failed {} out of {}'.format(self._name, errors, tests))\n\n\nclass StrategyTester(object):\n def __init__(self, process, universe, name):\n self._process = process\n self._universe = universe\n self._name = name\n\n def run(self, stp, expected_perf):\n loop = simulation_loop.SimulationLoop(\n stp.start,\n stp.end,\n stp.data_frequency)\n\n def on_error(message):\n raise AssertionError(message)\n\n watcher = TestWatcher(\n self._process.process_id,\n expected_perf,\n self._name,\n on_error)\n\n self._process.watch(watcher)\n\n # subscribe to clock events\n events.subscribe('clock.update', self._process.clock_update)\n\n # make a watch request\n # self._process.watch()\n\n loop.start(self._universe.exchanges)\n\n\nclass TestClient(object):\n def __init__(self, directory, controllable):\n \"\"\"\n\n Parameters\n ----------\n directory: directory.directory.Directory\n\n \"\"\"\n\n self._controllable = controllable\n\n self._store = strategy_store.StrategyStore(directory)\n self._directory = directory\n\n def add_strategy(self, stp, name, source_path):\n self._store.add_strategy(name, source_path)\n\n pi = processes.ProcessInitializer(self._controllable)\n init_response = pi.initialize(stp, name)\n\n # todo: if initial requirements aren't met, raise an error...\n\n uni = universes.get_universe(stp.trading_universe)\n\n stp.fractional = init_response.fractional\n\n return StrategyTester(pi.start(stp), uni, name)\n"
] | [
[
"numpy.nan_to_num",
"pandas.DatetimeIndex",
"pandas.DataFrame"
]
] |
hyw2/Homework1 | [
"e1c5d8e343ea11909d9f79bdf33a7d604cf085a8"
] | [
"ibkr_app.py"
] | [
"from ib_insync import *\nfrom os import listdir, remove\nfrom time import sleep\nimport pickle\nimport pandas as pd\nfrom helper_functions import *\n\n# Define your variables here ###########################################################################################\nsampling_rate = 1 # How often, in seconds, to check for inputs from Dash?\n# For TWS Paper account, default port is 7497\n# For IBG Paper account, default port is 4002\nport = 7497\n# choose your master id. Mine is 10645. You can use whatever you want, just set it in API Settings within TWS or IBG.\nmaster_client_id = 10645\n# choose your dedicated id just for orders. I picked 1111.\norders_client_id = 1111\n# account number: you'll need to fill in yourself. The below is one of my paper trader account numbers.\nacc_number = 'DU229601'\n########################################################################################################################\n\n# Run your helper function to clear out any io files left over from old runs\ncheck_for_and_del_io_files()\n\n# Create an IB app; i.e., an instance of the IB() class from the ib_insync package\nib = IB()\n# Connect your app to a running instance of IBG or TWS\nib.connect(host='127.0.0.1', port=port, clientId=master_client_id)\n\n# Make sure you're connected -- stay in this while loop until ib.isConnected() is True.\nwhile not ib.isConnected():\n sleep(.01)\n\n# If connected, script proceeds and prints a success message.\nprint('Connection Successful!')\n\n# Main while loop of the app. Stay in this loop until the app is stopped by the user.\nwhile True:\n # If the app finds a file named 'currency_pair.txt' in the current directory, enter this code block.\n if 'currency_pair.txt' in listdir():\n # Code goes here...\n f = open('currency_pair.txt', 'r')\n pair = f.readline()\n f.close()\n forex = Forex(pair=pair)\n # Note that here, if you wanted to make inputs for endDateTime, durationStr, barSizeSetting, etc within the Dash\n # app, then you could save a dictionary as a pickle and import it here like we do below for the order.\n bars = ib.reqHistoricalData(\n forex, # <<- pass in your contract object here\n endDateTime='', durationStr='30 D', barSizeSetting='1 hour', whatToShow='MIDPOINT', useRTH=True\n )\n\n # Code goes here...\n df = pd.DataFrame(bars)\n df.to_csv('currency_pair_history.csv')\n # pass -- not return -- because this function doesn't return a value. It's called for what it does. In computer\n # science, we say that it's called for its 'side effects'.\n pass\n\n # If there's a file named trade_order.p in listdir(), then enter the loop below.\n if 'trade_order.p' in listdir():\n\n # Create a special instance of IB() JUST for entering orders.\n # The reason for this is because the way that Interactive Brokers automatically provides valid order IDs to\n # ib_insync is not trustworthy enough to really rely on. It's best practice to set aside a dedicated client ID\n # to ONLY be used for submitting orders, and close the connection when the order is successfully submitted.\n\n # your code goes here\n trd_ordr = pickle.load(open(\"trade_order.p\", \"rb\"))\n mrk_ordr = MarketOrder(action=trd_ordr['action'], totalQuantity=trd_ordr['trade_amt'], account=acc_number)\n cntrct = Forex(pair=trd_ordr['trade_currency'])\n ib_orders = IB()\n ib_orders.connect(host='127.0.0.1', port=port, clientId=orders_client_id)\n while not ib_orders.isConnected():\n sleep(.01)\n new_order = ib_orders.placeOrder(cntrct, mrk_ordr)\n # The new_order object returned by the call to ib_orders.placeOrder() that you've written is an object of class\n # `trade` that is kept continually updated by the `ib_insync` machinery. It's a market order; as such, it will\n # be filled immediately.\n # In this while loop, we wait for confirmation that new_order filled.\n while not new_order.orderStatus.status == 'Filled':\n ib_orders.sleep(0) # we use ib_orders.sleep(0) from the ib_insync module because the async socket connection\n # is not built for the normal time.sleep() function.\n\n # your code goes here\n remove('trade_order.p')\n ib_orders.disconnect()\n # pass: same reason as above.\n pass\n\n # sleep, for the while loop.\n ib.sleep(sampling_rate)\n\nib.disconnect()"
] | [
[
"pandas.DataFrame"
]
] |
JustCunn/fairseq | [
"ed74f553041c1b453603bfb20a36558d3e984e89"
] | [
"fairseq/options.py"
] | [
"# Copyright (c) Facebook, Inc. and its affiliates.\n#\n# This source code is licensed under the MIT license found in the\n# LICENSE file in the root directory of this source tree.\n\nimport argparse\nfrom typing import Callable, List, Optional\n\nimport torch\nfrom fairseq import utils\nfrom fairseq.data.indexed_dataset import get_available_dataset_impl\nfrom fairseq.dataclass.configs import (\n CheckpointConfig,\n CommonConfig,\n CommonEvalConfig,\n DatasetConfig,\n DistributedTrainingConfig,\n EvalLMConfig,\n GenerationConfig,\n InteractiveConfig,\n OptimizationConfig,\n)\nfrom fairseq.dataclass.utils import gen_parser_from_dataclass\n\n# this import is for backward compatibility\nfrom fairseq.utils import csv_str_list, eval_bool, eval_str_dict, eval_str_list # noqa\n\n\ndef get_preprocessing_parser(default_task=\"translation\"):\n parser = get_parser(\"Preprocessing\", default_task)\n add_preprocess_args(parser)\n return parser\n\n\ndef get_training_parser(default_task=\"translation\"):\n parser = get_parser(\"Trainer\", default_task)\n add_dataset_args(parser, train=True)\n add_distributed_training_args(parser)\n add_model_args(parser)\n add_optimization_args(parser)\n add_checkpoint_args(parser)\n return parser\n\n\ndef get_generation_parser(interactive=False, default_task=\"translation\"):\n parser = get_parser(\"Generation\", default_task)\n add_dataset_args(parser, gen=True)\n add_distributed_training_args(parser, default_world_size=1)\n add_generation_args(parser)\n add_checkpoint_args(parser)\n if interactive:\n add_interactive_args(parser)\n return parser\n\n\ndef get_interactive_generation_parser(default_task=\"translation\"):\n return get_generation_parser(interactive=True, default_task=default_task)\n\n\ndef get_eval_lm_parser(default_task=\"language_modeling\"):\n parser = get_parser(\"Evaluate Language Model\", default_task)\n add_dataset_args(parser, gen=True)\n add_distributed_training_args(parser, default_world_size=1)\n add_eval_lm_args(parser)\n return parser\n\n\ndef get_validation_parser(default_task=None):\n parser = get_parser(\"Validation\", default_task)\n add_dataset_args(parser, train=True)\n add_distributed_training_args(parser, default_world_size=1)\n group = parser.add_argument_group(\"Evaluation\")\n gen_parser_from_dataclass(group, CommonEvalConfig())\n return parser\n\n\ndef parse_args_and_arch(\n parser: argparse.ArgumentParser,\n input_args: List[str] = None,\n parse_known: bool = False,\n suppress_defaults: bool = False,\n modify_parser: Optional[Callable[[argparse.ArgumentParser], None]] = None,\n):\n \"\"\"\n Args:\n parser (ArgumentParser): the parser\n input_args (List[str]): strings to parse, defaults to sys.argv\n parse_known (bool): only parse known arguments, similar to\n `ArgumentParser.parse_known_args`\n suppress_defaults (bool): parse while ignoring all default values\n modify_parser (Optional[Callable[[ArgumentParser], None]]):\n function to modify the parser, e.g., to set default values\n \"\"\"\n if suppress_defaults:\n # Parse args without any default values. This requires us to parse\n # twice, once to identify all the necessary task/model args, and a second\n # time with all defaults set to None.\n args = parse_args_and_arch(\n parser,\n input_args=input_args,\n parse_known=parse_known,\n suppress_defaults=False,\n )\n suppressed_parser = argparse.ArgumentParser(add_help=False, parents=[parser])\n suppressed_parser.set_defaults(**{k: None for k, v in vars(args).items()})\n args = suppressed_parser.parse_args(input_args)\n return argparse.Namespace(\n **{k: v for k, v in vars(args).items() if v is not None}\n )\n\n from fairseq.models import ARCH_MODEL_REGISTRY, ARCH_CONFIG_REGISTRY, MODEL_REGISTRY\n\n # Before creating the true parser, we need to import optional user module\n # in order to eagerly import custom tasks, optimizers, architectures, etc.\n usr_parser = argparse.ArgumentParser(add_help=False, allow_abbrev=False)\n usr_parser.add_argument(\"--user-dir\", default=None)\n usr_args, _ = usr_parser.parse_known_args(input_args)\n utils.import_user_module(usr_args)\n\n if modify_parser is not None:\n modify_parser(parser)\n\n # The parser doesn't know about model/criterion/optimizer-specific args, so\n # we parse twice. First we parse the model/criterion/optimizer, then we\n # parse a second time after adding the *-specific arguments.\n # If input_args is given, we will parse those args instead of sys.argv.\n args, _ = parser.parse_known_args(input_args)\n\n # Add model-specific args to parser.\n if hasattr(args, \"arch\"):\n model_specific_group = parser.add_argument_group(\n \"Model-specific configuration\",\n # Only include attributes which are explicitly given as command-line\n # arguments or which have default values.\n argument_default=argparse.SUPPRESS,\n )\n if args.arch in ARCH_MODEL_REGISTRY:\n ARCH_MODEL_REGISTRY[args.arch].add_args(model_specific_group)\n elif args.arch in MODEL_REGISTRY:\n MODEL_REGISTRY[args.arch].add_args(model_specific_group)\n else:\n raise RuntimeError()\n\n if hasattr(args, \"task\"):\n from fairseq.tasks import TASK_REGISTRY\n\n TASK_REGISTRY[args.task].add_args(parser)\n if getattr(args, \"use_bmuf\", False):\n # hack to support extra args for block distributed data parallelism\n from fairseq.optim.bmuf import FairseqBMUF\n\n FairseqBMUF.add_args(parser)\n\n # Add *-specific args to parser.\n from fairseq.registry import REGISTRIES\n\n for registry_name, REGISTRY in REGISTRIES.items():\n choice = getattr(args, registry_name, None)\n if choice is not None:\n cls = REGISTRY[\"registry\"][choice]\n if hasattr(cls, \"add_args\"):\n cls.add_args(parser)\n elif hasattr(cls, \"__dataclass\"):\n gen_parser_from_dataclass(parser, cls.__dataclass())\n\n # Modify the parser a second time, since defaults may have been reset\n if modify_parser is not None:\n modify_parser(parser)\n\n # Parse a second time.\n if parse_known:\n args, extra = parser.parse_known_args(input_args)\n else:\n args = parser.parse_args(input_args)\n extra = None\n # Post-process args.\n if (\n hasattr(args, \"batch_size_valid\") and args.batch_size_valid is None\n ) or not hasattr(args, \"batch_size_valid\"):\n args.batch_size_valid = args.batch_size\n if hasattr(args, \"max_tokens_valid\") and args.max_tokens_valid is None:\n args.max_tokens_valid = args.max_tokens\n if getattr(args, \"memory_efficient_fp16\", False):\n args.fp16 = True\n if getattr(args, \"memory_efficient_bf16\", False):\n args.bf16 = True\n args.tpu = getattr(args, \"tpu\", False)\n args.bf16 = getattr(args, \"bf16\", False)\n if args.bf16:\n args.tpu = True\n if args.tpu and args.fp16:\n raise ValueError(\"Cannot combine --fp16 and --tpu, use --bf16 on TPUs\")\n\n if getattr(args, \"seed\", None) is None:\n args.seed = 1 # default seed for training\n args.no_seed_provided = True\n else:\n args.no_seed_provided = False\n\n # Apply architecture configuration.\n if hasattr(args, \"arch\") and args.arch in ARCH_CONFIG_REGISTRY:\n ARCH_CONFIG_REGISTRY[args.arch](args)\n\n if parse_known:\n return args, extra\n else:\n return args\n\n\ndef get_parser(desc, default_task=\"translation\"):\n # Before creating the true parser, we need to import optional user module\n # in order to eagerly import custom tasks, optimizers, architectures, etc.\n usr_parser = argparse.ArgumentParser(add_help=False, allow_abbrev=False)\n usr_parser.add_argument(\"--user-dir\", default=None)\n usr_args, _ = usr_parser.parse_known_args()\n utils.import_user_module(usr_args)\n\n parser = argparse.ArgumentParser(allow_abbrev=False)\n gen_parser_from_dataclass(parser, CommonConfig())\n\n from fairseq.registry import REGISTRIES\n\n for registry_name, REGISTRY in REGISTRIES.items():\n parser.add_argument(\n \"--\" + registry_name.replace(\"_\", \"-\"),\n default=REGISTRY[\"default\"],\n choices=REGISTRY[\"registry\"].keys(),\n )\n\n # Task definitions can be found under fairseq/tasks/\n from fairseq.tasks import TASK_REGISTRY\n\n parser.add_argument(\n \"--task\",\n metavar=\"TASK\",\n default=default_task,\n choices=TASK_REGISTRY.keys(),\n help=\"task\",\n )\n # fmt: on\n return parser\n\n\ndef add_preprocess_args(parser):\n group = parser.add_argument_group(\"Preprocessing\")\n # fmt: off\n group.add_argument(\"-s\", \"--source-lang\", default=None, metavar=\"SRC\",\n help=\"source language\")\n group.add_argument(\"-t\", \"--target-lang\", default=None, metavar=\"TARGET\",\n help=\"target language\")\n group.add_argument(\"--trainpref\", metavar=\"FP\", default=None,\n help=\"train file prefix (also used to build dictionaries)\")\n group.add_argument(\"--validpref\", metavar=\"FP\", default=None,\n help=\"comma separated, valid file prefixes \"\n \"(words missing from train set are replaced with <unk>)\")\n group.add_argument(\"--testpref\", metavar=\"FP\", default=None,\n help=\"comma separated, test file prefixes \"\n \"(words missing from train set are replaced with <unk>)\")\n group.add_argument(\"--align-suffix\", metavar=\"FP\", default=None,\n help=\"alignment file suffix\")\n group.add_argument(\"--destdir\", metavar=\"DIR\", default=\"data-bin\",\n help=\"destination dir\")\n group.add_argument(\"--thresholdtgt\", metavar=\"N\", default=0, type=int,\n help=\"map words appearing less than threshold times to unknown\")\n group.add_argument(\"--thresholdsrc\", metavar=\"N\", default=0, type=int,\n help=\"map words appearing less than threshold times to unknown\")\n group.add_argument(\"--tgtdict\", metavar=\"FP\",\n help=\"reuse given target dictionary\")\n group.add_argument(\"--srcdict\", metavar=\"FP\",\n help=\"reuse given source dictionary\")\n group.add_argument(\"--nwordstgt\", metavar=\"N\", default=-1, type=int,\n help=\"number of target words to retain\")\n group.add_argument(\"--nwordssrc\", metavar=\"N\", default=-1, type=int,\n help=\"number of source words to retain\")\n group.add_argument(\"--alignfile\", metavar=\"ALIGN\", default=None,\n help=\"an alignment file (optional)\")\n parser.add_argument('--dataset-impl', metavar='FORMAT', default='mmap',\n choices=get_available_dataset_impl(),\n help='output dataset implementation')\n group.add_argument(\"--joined-dictionary\", action=\"store_true\",\n help=\"Generate joined dictionary\")\n group.add_argument(\"--only-source\", action=\"store_true\",\n help=\"Only process the source language\")\n group.add_argument(\"--padding-factor\", metavar=\"N\", default=8, type=int,\n help=\"Pad dictionary size to be multiple of N\")\n group.add_argument(\"--workers\", metavar=\"N\", default=1, type=int,\n help=\"number of parallel workers\")\n # fmt: on\n return parser\n\n\ndef add_dataset_args(parser, train=False, gen=False):\n group = parser.add_argument_group(\"dataset_data_loading\")\n gen_parser_from_dataclass(group, DatasetConfig())\n group.add_argument(\n '--aistrigh', nargs='+',\n metavar='LIST',\n help=\"[Path to data folder, language, window-length] if you wish \"\n \"to use AistrighNLP to reapply Celtic mutations on a demutated model\"\n )\n # fmt: on\n return group\n\n\ndef add_distributed_training_args(parser, default_world_size=None):\n group = parser.add_argument_group(\"distributed_training\")\n if default_world_size is None:\n default_world_size = max(1, torch.cuda.device_count())\n gen_parser_from_dataclass(\n group, DistributedTrainingConfig(distributed_world_size=default_world_size)\n )\n return group\n\n\ndef add_optimization_args(parser):\n group = parser.add_argument_group(\"optimization\")\n # fmt: off\n gen_parser_from_dataclass(group, OptimizationConfig())\n # fmt: on\n return group\n\n\ndef add_checkpoint_args(parser):\n group = parser.add_argument_group(\"checkpoint\")\n # fmt: off\n gen_parser_from_dataclass(group, CheckpointConfig())\n # fmt: on\n return group\n\n\ndef add_common_eval_args(group):\n gen_parser_from_dataclass(group, CommonEvalConfig())\n\n\ndef add_eval_lm_args(parser):\n group = parser.add_argument_group(\"LM Evaluation\")\n add_common_eval_args(group)\n gen_parser_from_dataclass(group, EvalLMConfig())\n\n\ndef add_generation_args(parser):\n group = parser.add_argument_group(\"Generation\")\n add_common_eval_args(group)\n gen_parser_from_dataclass(group, GenerationConfig())\n return group\n\n\ndef add_interactive_args(parser):\n group = parser.add_argument_group(\"Interactive\")\n gen_parser_from_dataclass(group, InteractiveConfig())\n\n\ndef add_model_args(parser):\n group = parser.add_argument_group(\"Model configuration\")\n # fmt: off\n\n # Model definitions can be found under fairseq/models/\n #\n # The model architecture can be specified in several ways.\n # In increasing order of priority:\n # 1) model defaults (lowest priority)\n # 2) --arch argument\n # 3) --encoder/decoder-* arguments (highest priority)\n from fairseq.models import ARCH_MODEL_REGISTRY\n group.add_argument('--arch', '-a', metavar='ARCH',\n choices=ARCH_MODEL_REGISTRY.keys(),\n help='model architecture')\n # fmt: on\n return group\n"
] | [
[
"torch.cuda.device_count"
]
] |
hsuRush/CC-CycleGAN | [
"99646b3bae3bb014ee4b19330531b885a1bfddc1"
] | [
"test_cyclegan.py"
] | [
"from __future__ import print_function, division\nimport scipy\n\nfrom keras.datasets import mnist\nfrom instanceNormalization import InstanceNormalization\nfrom keras.layers import Input, Dense, Reshape, Flatten, Dropout, Concatenate, GRU, CuDNNGRU, Bidirectional, Lambda\nfrom keras.layers import BatchNormalization, Activation, ZeroPadding2D\nfrom keras.layers.merge import add, concatenate\nfrom keras.layers.advanced_activations import LeakyReLU\nfrom keras.layers.convolutional import UpSampling2D, Conv2D\nfrom keras.models import Sequential, Model\nfrom keras.optimizers import Adam\nfrom keras import backend as K\n\nimport datetime\n\nimport matplotlib\n#matplotlib.use('TKAgg')\nimport matplotlib.pyplot as plt\n\nimport sys\nfrom data_loader import DataLoader\nfrom options import train_options, test_options\nimport para\nimport json\n\nimport numpy as np\nimport os\nfrom os.path import join\n\nclass CycleGAN():\n def __init__(self, args):\n # Input shape\n self.args = args\n self.img_rows = 120#128\n self.img_cols = 240#128\n self.channels = 3\n self.img_shape = (self.img_rows, self.img_cols, self.channels)\n self.phase = 'test' if args.test else 'train'\n # Configure data loader\n self.dataset_name = args.dataset\n self.data_loader = DataLoader(dataset_name=self.dataset_name,\n img_res=(self.img_rows, self.img_cols))\n\n\n # Calculate output shape of D (PatchGAN)\n patch_rows = int(self.img_rows / 2**3)\n patch_cols = int(self.img_cols / 2**3)\n self.disc_patch = (patch_rows, patch_cols, 1)\n\n # Number of filters in the first layer of G and D\n self.gf = 64\n self.df = 64\n\n # Loss weights\n self.lambda_cycle = 10.0 # Cycle-consistency loss\n self.lambda_id = 0.1 * self.lambda_cycle # Identity loss\n self.lambda_condition = self.lambda_cycle * .1\n\n self.lr = 2e-4\n\n self.args_append_attr() \n\n #@TODO load args.json and overwrite the default\n #with open(join(args.exp_dir, 'args.json'), 'r') as f:\n # json.dump(vars(args), f, ensure_ascii=False, indent=2, sort_keys=True)\n\n #optimizer = Adam(self.lr)\n\n # Build ctc net\n if args.ctc_condition:\n self.ctc_model = self.build_condition_network(training=True, condition='ctc')\n if self.args.verbose:\n print('------------ctc-model-----------')\n self.ctc_model.summary()\n # Build and compile the discriminators\n self.d_A = self.build_discriminator()\n self.d_B = self.build_discriminator()\n if self.args.verbose:\n print('------------d_A-----------')\n self.d_A.summary()\n print('------------d_B-----------')\n self.d_B.summary()\n #self.d_A.compile(loss='mse',\n # optimizer=Adam(self.lr/2),\n # metrics=['accuracy'])\n #self.d_B.compile(loss='mse',\n # optimizer=Adam(self.lr/2),\n # metrics=['accuracy'])\n #self.ctc_model.compile(optimizer=optimizer, loss={'ctc': lambda y_true, y_pred: y_pred})\n #-------------------------\n # Construct Computational\n # Graph of Generators\n #-------------------------\n \n \n\n # Build the generators\n self.g_AB = self.build_generator()\n self.g_BA = self.build_generator()\n\n self.load_model(self.args.exp_dir, self.args.resume_epoch)\n \n \n def args_append_attr(self):\n self.args.lr = self.lr\n self.args.img_rows = self.img_rows\n self.args.img_cols = self.img_cols\n self.args.channels = self.channels \n self.args.img_shape = self.img_shape\n self.args.phase = self.phase\n \n self.args.dataset_name = self.dataset_name\n self.args.disc_patch = self.disc_patch\n\n # Number of filters in the first layer of G and D\n self.args.gf = self.gf\n self.args.df = self.df\n\n # Loss weights\n self.args.lambda_cycle = self.lambda_cycle \n self.args.lambda_id = self.lambda_id \n self.args.lambda_condition = self.lambda_condition\n\n def load_model(self, exp_dir, resume_epoch):\n if self.args.ctc_condition:\n self.ctc_model.load_weights(join(exp_dir, 'ctc_weights_{}.h5').format(resume_epoch))\n self.d_A.load_weights(join(exp_dir, 'd_A_weights_{}.h5').format(resume_epoch))\n self.d_B.load_weights(join(exp_dir, 'd_B_weights_{}.h5').format(resume_epoch))\n self.g_AB.load_weights(join(exp_dir, 'g_AB_weights_{}.h5').format(resume_epoch))\n self.g_BA.load_weights(join(exp_dir, 'g_BA_weights_{}.h5').format(resume_epoch))\n #self.combined.load_weights(join(exp_dir, 'combined_weights_{}.h5').format(resume_epoch))\n\n def build_generator(self):\n \"\"\"U-Net Generator\"\"\"\n\n def conv2d(layer_input, filters, f_size=4):\n \"\"\"Layers used during downsampling\"\"\"\n d = Conv2D(filters, kernel_size=f_size, strides=2, padding='same')(layer_input)\n d = LeakyReLU(alpha=0.2)(d)\n d = InstanceNormalization()(d)\n return d\n\n def deconv2d(layer_input, skip_input, filters, f_size=4, dropout_rate=0):\n \"\"\"Layers used during upsampling\"\"\"\n u = UpSampling2D(size=2)(layer_input)\n u = Conv2D(filters, kernel_size=f_size, strides=1, padding='same', activation='relu')(u)\n if dropout_rate:\n u = Dropout(dropout_rate)(u)\n u = InstanceNormalization()(u)\n u = Concatenate()([u, skip_input])\n return u\n\n # Image input\n d0 = Input(shape=self.img_shape)\n\n # Downsampling\n #d1 = conv2d(d0, self.gf)\n d2 = conv2d(d0, self.gf*2)\n d3 = conv2d(d2, self.gf*4)\n d4 = conv2d(d3, self.gf*8)\n\n # Upsampling\n u1 = deconv2d(d4, d3, self.gf*4)\n u2 = deconv2d(u1, d2, self.gf*2)\n #u3 = deconv2d(u2, d1, self.gf)\n\n u3 = UpSampling2D(size=2)(u2)\n output_img = Conv2D(self.channels, kernel_size=4, strides=1, padding='same', activation='tanh')(u3)\n\n return Model(d0, output_img)\n\n def build_discriminator(self):\n def d_layer(layer_input, filters, f_size=4, normalization=True):\n \"\"\"Discriminator layer\"\"\"\n d = Conv2D(filters, kernel_size=f_size, strides=2, padding='same')(layer_input)\n d = LeakyReLU(alpha=0.2)(d)\n if normalization:\n d = InstanceNormalization()(d)\n return d\n\n img = Input(shape=self.img_shape)\n\n #d1 = d_layer(img, self.df, normalization=False)\n d2 = d_layer(img, self.df*2, normalization=False)\n d3 = d_layer(d2, self.df*4)\n d4 = d_layer(d3, self.df*8)\n\n validity = Conv2D(1, kernel_size=4, strides=1, padding='same')(d4)\n\n return Model(img, validity)\n\n def build_condition_network(self, training='train', condition='ctc'):\n if condition == 'ctc':\n from model import build_ctc_network\n bool_training = True if training == 'train' else False\n return build_ctc_network(self.args, training=bool_training)\n\n def test_A2B(self, batch_size=1, iteration=64, set='test', save_dir='test_images'):\n assert args.test == True\n save_dir = join(save_dir, self.dataset_name)\n #os.makedirs(join(save_dir, '%s/comparison/%s' % (self.dataset_name, set)), exist_ok=True)\n os.makedirs(join(save_dir, '%s/transfered_image_A2B/%s' % (args.exp_dir, set)), exist_ok=True)\n \n from tqdm import tqdm\n for batch_i, (imgs_A, lbl_A) in enumerate(tqdm(self.data_loader.load_batch_A(batch_size=batch_size, set=set, is_testing=True, iteration=iteration, condition=True))):\n \n \n\n # Translate images to opposite domain\n fake_B = self.g_AB.predict(imgs_A)\n #fake_A = self.g_BA.predict(imgs_B)\n\n #reconstr_B = self.g_AB.predict(fake_A)\n reconstr_A = self.g_BA.predict(fake_B)\n # Save transfered image\n self.saved_transfered_image(fake_B, None, lbl_A, None, save_dir=join(save_dir, '%s/transfered_image_A2B/%s' % (args.exp_dir, set)), set=set, batch_id=batch_i)\n\n\n def test_B2A(self, batch_size=1, iteration=64, set='test', save_dir='test_images'):\n assert args.test == True\n save_dir = join(save_dir, self.dataset_name)\n #os.makedirs(join(save_dir, '%s/comparison/%s' % (self.dataset_name, set)), exist_ok=True)\n os.makedirs(join(save_dir, '%s/transfered_image_B2A/%s' % (args.exp_dir, set)), exist_ok=True)\n \n from tqdm import tqdm \n for batch_i, (imgs_B, lbl_B) in enumerate(tqdm(self.data_loader.load_batch_B(batch_size=batch_size, set=set, is_testing=True, iteration=iteration, condition=True))):\n\n # Translate images to opposite domain\n #fake_B = self.g_AB.predict(imgs_A)\n fake_A = self.g_BA.predict(imgs_B)\n\n reconstr_B = self.g_AB.predict(fake_A)\n #reconstr_A = self.g_BA.predict(fake_B)\n # Save transfered image\n self.saved_transfered_image(None, fake_A, None, lbl_B, save_dir=join(save_dir, '%s/transfered_image_B2A/%s' % (args.exp_dir, set)), set=set, batch_id=batch_i)\n\n \n\n def test_both(self, batch_size=1, iteration=64, set='test', save_dir='test_images'):\n assert args.test == True\n save_dir = join(save_dir, self.dataset_name)\n os.makedirs(join(save_dir, '%s/comparison/%s' % (args.exp_dir, set)), exist_ok=True)\n #os.makedirs(join(save_dir, '%s/transfered_image/%s' % (args.exp_dir, set)), exist_ok=True)\n \n from tqdm import tqdm\n for batch_i, (imgs_A, imgs_B ,lbl_A, lbl_B) in enumerate(tqdm(self.data_loader.load_batch(batch_size=batch_size, set=set, is_testing=True, iteration=iteration, condition=True))):\n\n # Translate images to opposite domain\n fake_B = self.g_AB.predict(imgs_A)\n fake_A = self.g_BA.predict(imgs_B)\n\n reconstr_B = self.g_AB.predict(fake_A)\n reconstr_A = self.g_BA.predict(fake_B)\n # Save transfered image\n #self.saved_transfered_image(fake_B, fake_A, lbl_A, lbl_B, save_dir=save_dir, set=set, batch_id=batch_i)\n \n # Comparison result \n gen_imgs = np.concatenate([imgs_A, fake_B, reconstr_A, imgs_B, fake_A, reconstr_B])\n # Rescale images 0 - 1\n gen_imgs = 0.5 * gen_imgs + 0.5\n\n titles = ['Original', 'Translated', 'Reconstructed']\n r, c = 2, 3\n fig, axs = plt.subplots(r, c)\n cnt = 0\n for i in range(r):\n for j in range(c):\n axs[i,j].imshow(gen_imgs[cnt])\n axs[i, j].set_title(titles[j])\n axs[i,j].axis('off')\n cnt += 1\n fig.savefig(join(save_dir, \"%s/comparison/%s/%d.png\" % (args.exp_dir, set, batch_i)))\n plt.close()\n # Comparison result \n \n\n def sample_images(self, epoch, batch_i):\n os.makedirs('images/%s' % self.dataset_name, exist_ok=True)\n r, c = 2, 3\n\n imgs_A = self.data_loader.load_data(domain=\"A\", batch_size=1, is_testing=True)\n imgs_B = self.data_loader.load_data(domain=\"B\", batch_size=1, is_testing=True)\n\n # Demo (for GIF)\n #imgs_A = self.data_loader.load_img('datasets/apple2orange/testA/n07740461_1541.jpg')\n #imgs_B = self.data_loader.load_img('datasets/apple2orange/testB/n07749192_4241.jpg')\n\n # Translate images to the other domain\n fake_B = self.g_AB.predict(imgs_A)\n fake_A = self.g_BA.predict(imgs_B)\n # Translate back to original domain\n reconstr_A = self.g_BA.predict(fake_B)\n reconstr_B = self.g_AB.predict(fake_A)\n\n gen_imgs = np.concatenate([imgs_A, fake_B, reconstr_A, imgs_B, fake_A, reconstr_B])\n\n # Rescale images 0 - 1\n gen_imgs = 0.5 * gen_imgs + 0.5\n\n titles = ['Original', 'Translated', 'Reconstructed']\n fig, axs = plt.subplots(r, c)\n cnt = 0\n for i in range(r):\n for j in range(c):\n axs[i,j].imshow(gen_imgs[cnt])\n axs[i, j].set_title(titles[j])\n axs[i,j].axis('off')\n cnt += 1\n fig.savefig(\"images/%s/%d_%d.png\" % (self.dataset_name, epoch, batch_i))\n plt.close()\n\n def save_model(self, epochs, exp_dir):\n \n if self.args.ctc_condition:\n self.ctc_model.save_weights(join(exp_dir,'ctc_weights_{}.h5').format(epochs))\n self.d_A.save_weights(join(exp_dir, 'd_A_weights_{}.h5').format(epochs))\n self.d_B.save_weights(join(exp_dir, 'd_B_weights_{}.h5').format(epochs))\n self.g_AB.save_weights(join(exp_dir, 'g_AB_weights_{}.h5').format(epochs))\n self.g_BA.save_weights(join(exp_dir, 'g_BA_weights_{}.h5').format(epochs))\n self.combined.save_weights(join(exp_dir,'combined_weights_{}.h5').format(epochs))\n\n def saved_transfered_image(self, fake_B, fake_A, lbl_A, lbl_B, save_dir, set, batch_id):\n \"\"\"\n fake_B is from imageA send into GAB (so the label is A)\n fake)A is from imageB send into GBA (so the label is B)\n \"\"\"\n path = save_dir #join(save_dir, '%s/transfered_image/%s' % (self.dataset_name, set))\n import cv2 \n\n os.makedirs(path, exist_ok=True)\n #print(type(lbl_A), type(fake_B))\n #print(fake_B.shape)\n for b in range(args.batch):\n image_id = batch_id * args.batch + b \n if isinstance(fake_B, np.ndarray) & isinstance(lbl_A, list):\n cv2.imwrite(join(path, '%d_%s.png'%(image_id, lbl_A[b])), self.unnormalize(fake_B[b]))\n print('wrote to ', join(path, '%d_%s.png'%(image_id, lbl_A[b])))\n if isinstance(fake_A, np.ndarray) & isinstance(lbl_B, list):\n cv2.imwrite(join(path, '%d_%s.png'%(image_id, lbl_B[b])), self.unnormalize(fake_A[b]))\n print('wrote to ', join(path, '%d_%s.png'%(image_id, lbl_B[b])))\n\n def unnormalize(self, im):\n #im = np.array(im)\n im = np.array(255 * (0.5 * im + 0.5), dtype=np.uint8)\n #print(im.shape)\n #print(im)\n \n return im\n \nif __name__ == '__main__':\n args = test_options()\n gan = CycleGAN(args)\n if args.direction == 'both':\n gan.test_both(batch_size=args.batch, iteration=args.iteration, set=args.set)\n elif args.direction == 'A2B':\n gan.test_A2B(batch_size=args.batch, iteration=args.iteration, set=args.set)\n elif args.direction == 'B2A':\n gan.test_B2A(batch_size=args.batch, iteration=args.iteration, set=args.set)"
] | [
[
"numpy.array",
"matplotlib.pyplot.close",
"numpy.concatenate",
"matplotlib.pyplot.subplots"
]
] |
BnJam/ray | [
"c32658ff7550f8672923ca6d824d85c5efd82a5b"
] | [
"python/ray/rllib/agents/impala/vtrace_test.py"
] | [
"# Copyright 2018 Google LLC\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# https://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\"\"\"Tests for V-trace.\n\nFor details and theory see:\n\n\"IMPALA: Scalable Distributed Deep-RL with\nImportance Weighted Actor-Learner Architectures\"\nby Espeholt, Soyer, Munos et al.\n\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nfrom absl.testing import parameterized\nimport numpy as np\nimport tensorflow as tf\nimport vtrace\n\n\ndef _shaped_arange(*shape):\n \"\"\"Runs np.arange, converts to float and reshapes.\"\"\"\n return np.arange(np.prod(shape), dtype=np.float32).reshape(*shape)\n\n\ndef _softmax(logits):\n \"\"\"Applies softmax non-linearity on inputs.\"\"\"\n return np.exp(logits) / np.sum(np.exp(logits), axis=-1, keepdims=True)\n\n\ndef _ground_truth_calculation(discounts, log_rhos, rewards, values,\n bootstrap_value, clip_rho_threshold,\n clip_pg_rho_threshold):\n \"\"\"Calculates the ground truth for V-trace in Python/Numpy.\"\"\"\n vs = []\n seq_len = len(discounts)\n rhos = np.exp(log_rhos)\n cs = np.minimum(rhos, 1.0)\n clipped_rhos = rhos\n if clip_rho_threshold:\n clipped_rhos = np.minimum(rhos, clip_rho_threshold)\n clipped_pg_rhos = rhos\n if clip_pg_rho_threshold:\n clipped_pg_rhos = np.minimum(rhos, clip_pg_rho_threshold)\n\n # This is a very inefficient way to calculate the V-trace ground truth.\n # We calculate it this way because it is close to the mathematical notation\n # of\n # V-trace.\n # v_s = V(x_s)\n # + \\sum^{T-1}_{t=s} \\gamma^{t-s}\n # * \\prod_{i=s}^{t-1} c_i\n # * \\rho_t (r_t + \\gamma V(x_{t+1}) - V(x_t))\n # Note that when we take the product over c_i, we write `s:t` as the\n # notation\n # of the paper is inclusive of the `t-1`, but Python is exclusive.\n # Also note that np.prod([]) == 1.\n values_t_plus_1 = np.concatenate(\n [values, bootstrap_value[None, :]], axis=0)\n for s in range(seq_len):\n v_s = np.copy(values[s]) # Very important copy.\n for t in range(s, seq_len):\n v_s += (np.prod(discounts[s:t], axis=0) * np.prod(cs[s:t], axis=0)\n * clipped_rhos[t] * (rewards[t] + discounts[t] *\n values_t_plus_1[t + 1] - values[t]))\n vs.append(v_s)\n vs = np.stack(vs, axis=0)\n pg_advantages = (clipped_pg_rhos * (rewards + discounts * np.concatenate(\n [vs[1:], bootstrap_value[None, :]], axis=0) - values))\n\n return vtrace.VTraceReturns(vs=vs, pg_advantages=pg_advantages)\n\n\nclass LogProbsFromLogitsAndActionsTest(tf.test.TestCase,\n parameterized.TestCase):\n @parameterized.named_parameters(('Batch1', 1), ('Batch2', 2))\n def test_log_probs_from_logits_and_actions(self, batch_size):\n \"\"\"Tests log_probs_from_logits_and_actions.\"\"\"\n seq_len = 7\n num_actions = 3\n\n policy_logits = _shaped_arange(seq_len, batch_size, num_actions) + 10\n actions = np.random.randint(\n 0, num_actions - 1, size=(seq_len, batch_size), dtype=np.int32)\n\n action_log_probs_tensor = vtrace.log_probs_from_logits_and_actions(\n policy_logits, actions)\n\n # Ground Truth\n # Using broadcasting to create a mask that indexes action logits\n action_index_mask = actions[..., None] == np.arange(num_actions)\n\n def index_with_mask(array, mask):\n return array[mask].reshape(*array.shape[:-1])\n\n # Note: Normally log(softmax) is not a good idea because it's not\n # numerically stable. However, in this test we have well-behaved\n # values.\n ground_truth_v = index_with_mask(\n np.log(_softmax(policy_logits)), action_index_mask)\n\n with self.test_session() as session:\n self.assertAllClose(ground_truth_v,\n session.run(action_log_probs_tensor))\n\n\nclass VtraceTest(tf.test.TestCase, parameterized.TestCase):\n @parameterized.named_parameters(('Batch1', 1), ('Batch5', 5))\n def test_vtrace(self, batch_size):\n \"\"\"Tests V-trace against ground truth data calculated in python.\"\"\"\n seq_len = 5\n\n # Create log_rhos such that rho will span from near-zero to above the\n # clipping thresholds. In particular, calculate log_rhos in\n # [-2.5, 2.5),\n # so that rho is in approx [0.08, 12.2).\n log_rhos = _shaped_arange(seq_len, batch_size) / (batch_size * seq_len)\n log_rhos = 5 * (log_rhos - 0.5) # [0.0, 1.0) -> [-2.5, 2.5).\n values = {\n 'log_rhos': log_rhos,\n # T, B where B_i: [0.9 / (i+1)] * T\n 'discounts': np.array([[0.9 / (b + 1) for b in range(batch_size)]\n for _ in range(seq_len)]),\n 'rewards': _shaped_arange(seq_len, batch_size),\n 'values': _shaped_arange(seq_len, batch_size) / batch_size,\n 'bootstrap_value': _shaped_arange(batch_size) + 1.0,\n 'clip_rho_threshold': 3.7,\n 'clip_pg_rho_threshold': 2.2,\n }\n\n output = vtrace.from_importance_weights(**values)\n\n with self.test_session() as session:\n output_v = session.run(output)\n\n ground_truth_v = _ground_truth_calculation(**values)\n for a, b in zip(ground_truth_v, output_v):\n self.assertAllClose(a, b)\n\n @parameterized.named_parameters(('Batch1', 1), ('Batch2', 2))\n def test_vtrace_from_logits(self, batch_size):\n \"\"\"Tests V-trace calculated from logits.\"\"\"\n seq_len = 5\n num_actions = 3\n clip_rho_threshold = None # No clipping.\n clip_pg_rho_threshold = None # No clipping.\n\n # Intentionally leaving shapes unspecified to test if V-trace can\n # deal with that.\n placeholders = {\n # T, B, NUM_ACTIONS\n 'behaviour_policy_logits': tf.placeholder(\n dtype=tf.float32, shape=[None, None, None]),\n # T, B, NUM_ACTIONS\n 'target_policy_logits': tf.placeholder(\n dtype=tf.float32, shape=[None, None, None]),\n 'actions': tf.placeholder(dtype=tf.int32, shape=[None, None]),\n 'discounts': tf.placeholder(dtype=tf.float32, shape=[None, None]),\n 'rewards': tf.placeholder(dtype=tf.float32, shape=[None, None]),\n 'values': tf.placeholder(dtype=tf.float32, shape=[None, None]),\n 'bootstrap_value': tf.placeholder(dtype=tf.float32, shape=[None]),\n }\n\n from_logits_output = vtrace.from_logits(\n clip_rho_threshold=clip_rho_threshold,\n clip_pg_rho_threshold=clip_pg_rho_threshold,\n **placeholders)\n\n target_log_probs = vtrace.log_probs_from_logits_and_actions(\n placeholders['target_policy_logits'], placeholders['actions'])\n behaviour_log_probs = vtrace.log_probs_from_logits_and_actions(\n placeholders['behaviour_policy_logits'], placeholders['actions'])\n log_rhos = target_log_probs - behaviour_log_probs\n ground_truth = (log_rhos, behaviour_log_probs, target_log_probs)\n\n values = {\n 'behaviour_policy_logits': _shaped_arange(seq_len, batch_size,\n num_actions),\n 'target_policy_logits': _shaped_arange(seq_len, batch_size,\n num_actions),\n 'actions': np.random.randint(\n 0, num_actions - 1, size=(seq_len, batch_size)),\n 'discounts': np.array( # T, B where B_i: [0.9 / (i+1)] * T\n [[0.9 / (b + 1) for b in range(batch_size)]\n for _ in range(seq_len)]),\n 'rewards': _shaped_arange(seq_len, batch_size),\n 'values': _shaped_arange(seq_len, batch_size) / batch_size,\n 'bootstrap_value': _shaped_arange(batch_size) + 1.0, # B\n }\n\n feed_dict = {placeholders[k]: v for k, v in values.items()}\n with self.test_session() as session:\n from_logits_output_v = session.run(\n from_logits_output, feed_dict=feed_dict)\n (ground_truth_log_rhos, ground_truth_behaviour_action_log_probs,\n ground_truth_target_action_log_probs) = session.run(\n ground_truth, feed_dict=feed_dict)\n\n # Calculate V-trace using the ground truth logits.\n from_iw = vtrace.from_importance_weights(\n log_rhos=ground_truth_log_rhos,\n discounts=values['discounts'],\n rewards=values['rewards'],\n values=values['values'],\n bootstrap_value=values['bootstrap_value'],\n clip_rho_threshold=clip_rho_threshold,\n clip_pg_rho_threshold=clip_pg_rho_threshold)\n\n with self.test_session() as session:\n from_iw_v = session.run(from_iw)\n\n self.assertAllClose(from_iw_v.vs, from_logits_output_v.vs)\n self.assertAllClose(from_iw_v.pg_advantages,\n from_logits_output_v.pg_advantages)\n self.assertAllClose(ground_truth_behaviour_action_log_probs,\n from_logits_output_v.behaviour_action_log_probs)\n self.assertAllClose(ground_truth_target_action_log_probs,\n from_logits_output_v.target_action_log_probs)\n self.assertAllClose(ground_truth_log_rhos,\n from_logits_output_v.log_rhos)\n\n def test_higher_rank_inputs_for_importance_weights(self):\n \"\"\"Checks support for additional dimensions in inputs.\"\"\"\n placeholders = {\n 'log_rhos': tf.placeholder(\n dtype=tf.float32, shape=[None, None, 1]),\n 'discounts': tf.placeholder(\n dtype=tf.float32, shape=[None, None, 1]),\n 'rewards': tf.placeholder(\n dtype=tf.float32, shape=[None, None, 42]),\n 'values': tf.placeholder(dtype=tf.float32, shape=[None, None, 42]),\n 'bootstrap_value': tf.placeholder(\n dtype=tf.float32, shape=[None, 42])\n }\n output = vtrace.from_importance_weights(**placeholders)\n self.assertEqual(output.vs.shape.as_list()[-1], 42)\n\n def test_inconsistent_rank_inputs_for_importance_weights(self):\n \"\"\"Test one of many possible errors in shape of inputs.\"\"\"\n placeholders = {\n 'log_rhos': tf.placeholder(\n dtype=tf.float32, shape=[None, None, 1]),\n 'discounts': tf.placeholder(\n dtype=tf.float32, shape=[None, None, 1]),\n 'rewards': tf.placeholder(\n dtype=tf.float32, shape=[None, None, 42]),\n 'values': tf.placeholder(dtype=tf.float32, shape=[None, None, 42]),\n # Should be [None, 42].\n 'bootstrap_value': tf.placeholder(dtype=tf.float32, shape=[None])\n }\n with self.assertRaisesRegexp(ValueError, 'must have rank 2'):\n vtrace.from_importance_weights(**placeholders)\n\n\nif __name__ == '__main__':\n tf.test.main()\n"
] | [
[
"tensorflow.placeholder",
"numpy.exp",
"numpy.copy",
"numpy.arange",
"numpy.prod",
"numpy.stack",
"numpy.concatenate",
"numpy.random.randint",
"tensorflow.test.main",
"numpy.minimum"
]
] |
MatPoliquin/retro | [
"c70c174a9818d1e97bc36e61abb4694d28fc68e1"
] | [
"retro/examples/brute.py"
] | [
"\"\"\"\nImplementation of the Brute from \"Revisiting the Arcade Learning Environment:\nEvaluation Protocols and Open Problems for General Agents\" by Machado et al.\nhttps://arxiv.org/abs/1709.06009\n\nThis is an agent that uses the determinism of the environment in order to do\npretty well at a number of retro games. It does not save emulator state but\ndoes rely on the same sequence of actions producing the same result when played\nback.\n\"\"\"\n\nimport random\nimport argparse\n\nimport numpy as np\nimport retro\nimport gym\n\n\nEXPLORATION_PARAM = 0.005\n\n\nclass Frameskip(gym.Wrapper):\n def __init__(self, env, skip=4):\n super().__init__(env)\n self._skip = skip\n\n def reset(self):\n return self.env.reset()\n\n def step(self, act):\n total_rew = 0.0\n done = None\n for i in range(self._skip):\n obs, rew, done, info = self.env.step(act)\n total_rew += rew\n if done:\n break\n\n return obs, total_rew, done, info\n\n\nclass TimeLimit(gym.Wrapper):\n def __init__(self, env, max_episode_steps=None):\n super().__init__(env)\n self._max_episode_steps = max_episode_steps\n self._elapsed_steps = 0\n\n def step(self, ac):\n observation, reward, done, info = self.env.step(ac)\n self._elapsed_steps += 1\n if self._elapsed_steps >= self._max_episode_steps:\n done = True\n info['TimeLimit.truncated'] = True\n return observation, reward, done, info\n\n def reset(self, **kwargs):\n self._elapsed_steps = 0\n return self.env.reset(**kwargs)\n\n\nclass Node:\n def __init__(self, value=-np.inf, children=None):\n self.value = value\n self.visits = 0\n self.children = {} if children is None else children\n\n def __repr__(self):\n return \"<Node value=%f visits=%d len(children)=%d>\" % (\n self.value,\n self.visits,\n len(self.children),\n )\n\n\ndef select_actions(root, action_space, max_episode_steps):\n \"\"\"\n Select actions from the tree\n\n Normally we select the greedy action that has the highest reward\n associated with that subtree. We have a small chance to select a\n random action based on the exploration param and visit count of the\n current node at each step.\n\n We select actions for the longest possible episode, but normally these\n will not all be used. They will instead be truncated to the length\n of the actual episode and then used to update the tree.\n \"\"\"\n node = root\n\n acts = []\n steps = 0\n while steps < max_episode_steps:\n if node is None:\n # we've fallen off the explored area of the tree, just select random actions\n act = action_space.sample()\n else:\n epsilon = EXPLORATION_PARAM / np.log(node.visits + 2)\n if random.random() < epsilon:\n # random action\n act = action_space.sample()\n else:\n # greedy action\n act_value = {}\n for act in range(action_space.n):\n if node is not None and act in node.children:\n act_value[act] = node.children[act].value\n else:\n act_value[act] = -np.inf\n best_value = max(act_value.values())\n best_acts = [\n act for act, value in act_value.items() if value == best_value\n ]\n act = random.choice(best_acts)\n\n if act in node.children:\n node = node.children[act]\n else:\n node = None\n\n acts.append(act)\n steps += 1\n\n return acts\n\n\ndef rollout(env, acts):\n \"\"\"\n Perform a rollout using a preset collection of actions\n \"\"\"\n total_rew = 0\n env.reset()\n steps = 0\n for act in acts:\n _obs, rew, done, _info = env.step(act)\n steps += 1\n total_rew += rew\n if done:\n break\n\n return steps, total_rew\n\n\ndef update_tree(root, executed_acts, total_rew):\n \"\"\"\n Given the tree, a list of actions that were executed before the game ended, and a reward, update the tree\n so that the path formed by the executed actions are all updated to the new reward.\n \"\"\"\n root.value = max(total_rew, root.value)\n root.visits += 1\n new_nodes = 0\n\n node = root\n for step, act in enumerate(executed_acts):\n if act not in node.children:\n node.children[act] = Node()\n new_nodes += 1\n node = node.children[act]\n node.value = max(total_rew, node.value)\n node.visits += 1\n\n return new_nodes\n\n\nclass Brute:\n \"\"\"\n Implementation of the Brute\n\n Creates and manages the tree storing game actions and rewards\n \"\"\"\n\n def __init__(self, env, max_episode_steps):\n self.node_count = 1\n self._root = Node()\n self._env = env\n self._max_episode_steps = max_episode_steps\n\n def run(self):\n acts = select_actions(self._root, self._env.action_space, self._max_episode_steps)\n steps, total_rew = rollout(self._env, acts)\n executed_acts = acts[:steps]\n self.node_count += update_tree(self._root, executed_acts, total_rew)\n return executed_acts, total_rew\n\n\ndef brute_retro(\n game,\n max_episode_steps=4500,\n timestep_limit=1e8,\n state=retro.State.DEFAULT,\n scenario=None,\n):\n env = retro.make(game, state, use_restricted_actions=retro.Actions.DISCRETE, scenario=scenario)\n env = Frameskip(env)\n env = TimeLimit(env, max_episode_steps=max_episode_steps)\n\n brute = Brute(env, max_episode_steps=max_episode_steps)\n timesteps = 0\n best_rew = float('-inf')\n while True:\n acts, rew = brute.run()\n timesteps += len(acts)\n\n if rew > best_rew:\n print(\"new best reward {} => {}\".format(best_rew, rew))\n best_rew = rew\n env.unwrapped.record_movie(\"best.bk2\")\n env.reset()\n for act in acts:\n env.step(act)\n env.unwrapped.stop_record()\n\n if timesteps > timestep_limit:\n print(\"timestep limit exceeded\")\n break\n\ndef main():\n parser = argparse.ArgumentParser()\n parser.add_argument('--game', default='Airstriker-Genesis')\n parser.add_argument('--state', default=retro.State.DEFAULT)\n parser.add_argument('--scenario', default=None)\n args = parser.parse_args()\n\n brute_retro(game=args.game, state=args.state, scenario=args.scenario)\n\n\nif __name__ == \"__main__\":\n main()\n"
] | [
[
"numpy.log"
]
] |
ewanbarr/UtmostFanbeamMapper | [
"e20721c4b21fd94977eb48503b81a784a8666045"
] | [
"fanbeams.py"
] | [
"from astropy.io import fits\nfrom coords import nsew_of_constant_dec,Molonglo,hadec_to_nsew\nfrom scipy.ndimage import filters\nimport ephem as e\nimport numpy as np\nimport copy\n\nSEC_TO_SID = 0.9972685185185185 # convert seconds to siderial \"seconds\"\nEW_R = np.radians(2.0) # EW beam HWHM\nNS_R = np.radians(1.0) # NS beam HWHM\n\nclass FanBeamTimeMap(object):\n def __init__(self,data,lsts):\n \"\"\"\n Base class for fanbeams.\n \n data: numpy array containing data with axes [nbeams,nsamps]\n lsts: the lsts for each set of beams\n \"\"\"\n self.data = data\n self.nsamps = data.shape[1]\n self.nbeams = data.shape[0]\n self.total_power = np.copy(self.data[0])\n self.data[0]= self.data[1]\n self.lsts = lsts\n self.mask = np.ones(data.shape,dtype='bool')\n self._cache = {}\n self._xcoords = np.arange(self.nsamps)\n \n def copy(self):\n fb = copy.deepcopy(self)\n fb._cache = self._cache\n return fb\n\n def append(self,other):\n self.data = np.hstack((self.data,other.data))\n self.nsamps += other.nsamps\n self.total_power = np.hstack((self.total_power,other.total_power))\n self.lsts = np.hstack((self.lsts,other.lsts))\n self.mask = np.hstack((self.mask,other.mask))\n self._cache = {}\n self._xcoords = np.arange(self.nsamps)\n\n def radec_to_track(self,ra,dec):\n \"\"\"\n Convert a single ra and dec to a track through the fanbeams.\n \n ra: ra in radians\n dec: dec in radians\n \n Note: does not cache track\n\n Returns fanbeam indexes and NS offsets\n \"\"\"\n ns,ew = nsew_of_constant_dec(self.lsts-ra,dec)\n ew_offset = ew-self.ew\n ns_offset = ns-self.ns\n idxs = (self.nbeams * (ew_offset/self.ew_r + 1)/2).astype(\"int\")\n return idxs, ns_offset\n\n def radecs_to_tracks(self,ras,decs):\n \"\"\"\n Convert an array of ra and dec coords to a set of tracks and offsets.\n \n ras: ra array in radians\n decs: dec array in radians\n \n Note: Caches based on hash of inputs\n \n Returns fanbeam indexes and NS offsets\n \"\"\"\n key = (hash(ras.tobytes()),hash(decs.tobytes()))\n if key in self._cache.keys():\n return self._cache[key]\n tracks = np.empty([decs.size,ras.size,self.nsamps],dtype='int32')\n offsets = np.empty([decs.size,ras.size,self.nsamps],dtype='float32')\n for ii,ra in enumerate(ras):\n #print ii,\"/\",ras.size,\"\\r\",\n for jj,dec in enumerate(decs):\n idxs,ns_offset = self.radec_to_track(ra,dec)\n tracks[jj,ii] = idxs\n offsets[jj,ii] = ns_offset\n #print\n self._cache[key] = (tracks,offsets)\n return tracks,offsets\n\n def extract(self,idxs,xcoords):\n \"\"\"\n Extract a trail through fanbeam space.\n\n idxs: array of fambeam indexes (can be any value)\n\n Note: only valid data are returned\n \"\"\"\n mask = (idxs > 0) & (idxs < self.nbeams)\n pixel_mask = self.mask[(idxs[mask],xcoords[mask])]\n x = xcoords[mask][pixel_mask]\n return self.data[(idxs[mask][pixel_mask],x)],x\n \n\nclass TransitFanBeamTimeMap(FanBeamTimeMap):\n def __init__(self,data,ns,ew,lsts):\n \"\"\"\n Fanbeam container for transit observations\n \n data: numpy array containing data with axes [nbeams,nsamps]\n lsts: the lsts for each set of beams\n ns: ns coordinate of central fanbeam (radians)\n ew: ew coordinate of central fanbeam (radians)\n \"\"\"\n super(TransitFanBeamTimeMap,self).__init__(data,lsts)\n self.ns = ns\n self.ew = ew\n self.ew_r = EW_R/np.cos(self.ew)\n \nclass TrackedFanBeamTimeMap(FanBeamTimeMap):\n def __init__(self,data,ra,dec,lsts):\n \"\"\"\n Fanbeam container for transit observations\n\n data: numpy array containing data with axes [nbeams,nsamps]\n lsts: the lsts for each set of beams\n ra: ra coordinate of central fanbeam (radians)\n dec: dec coordinate of central fanbeam (radians)\n \"\"\"\n super(TrackedFanBeamTimeMap,self).__init__(data,lsts)\n self.ra = float(ra)\n self.dec = float(dec)\n self.hour_angles = self.lsts-self.ra\n ns,ew = nsew_of_constant_dec(self.hour_angles,self.dec)\n self.ns = ns\n self.ew = ew\n self.ew_r = EW_R/np.cos(self.ew)\n\n def append(self,other):\n self.ns = np.hstack((self.ns,other.ns))\n self.ew = np.hstack((self.ew,other.ew))\n self.ew_r = np.hstack((self.ew_r,other.ew_r))\n self.hour_angles = np.hstack((self.hour_angles,other.hour_angles))\n super(TrackedFanBeamTimeMap,self).append(other)\n\n\ndef subtract_background(fanbeams,background,thresh=None):\n \"\"\"\n Subtract a background array and normalise the fanbeams.\n\n fanbeams: An object of basetype FanBeamTimeMap\n background: A FanBeamTimeMap containing a background \n thresh: Sigma threshold for clipping\n \"\"\"\n clean = fanbeams.copy()\n data = clean.data\n data-=background.data\n mad = 1.4826 * np.median(abs(data-np.median(data,axis=0)),axis=0)\n muad = 1.253314 * np.mean(abs(data-np.mean(data,axis=0)),axis=0)\n mad[mad==0] = muad[mad==0]\n data/=mad\n if thresh is not None:\n data = data.clip(max=thresh)\n clean.data = data\n return clean\n\ndef median_filter(fanbeams,window,mode='nearest'):\n \"\"\"\n Apply a median filter to a set of fanbeams.\n\n fanbeams: An object of basetype FanBeamTimeMap\n window: size of the filter window.\n mode: filter mode for edges\n \"\"\"\n background = fanbeams.copy()\n background.data = filters.median_filter(fanbeams.data,size=[window,1],mode=mode)\n return background\n\ndef poly_filter(fanbeams,deg):\n \"\"\"\n Apply a polynomial filter to a set of fanbeams.\n\n fanbeams: An object of basetype FanBeamTimeMap\n deg: degree of polynomial\n \"\"\"\n background = fanbeams.copy()\n data = background.data\n x = np.arange(background.nbeams)\n background.data = np.array([np.polyval(j,x) for j in np.polyfit(x,data,deg).T]).T\n return background\n\ndef _load_fanbeams(fname,utc_start,tsamp):\n \"\"\"Helper function\"\"\"\n obs = Molonglo(date=utc_start)\n lst = obs.sidereal_time()\n hdu = fits.open(fname)[0]\n dlst = 2*np.pi*tsamp/86400.0 * SEC_TO_SID\n lsts = np.arange(hdu.data.shape[1])*dlst + lst\n return hdu.data,lsts,obs\n\ndef load_tracked_fanbeams(fname,utc_start,ra,dec,tsamp):\n \"\"\"Load a tracked fanbeam observation\"\"\"\n data,lsts,obs = _load_fanbeams(fname,utc_start,tsamp)\n body = e.FixedBody()\n body._ra = ra\n body._dec = dec\n body.compute(obs)\n return TrackedFanBeamTimeMap(data,body.ra,body.dec,lsts)\n\ndef load_transit_fanbeams(fname,utc_start,ha,dec,tsamp):\n \"\"\"Load a transit fanbeam observation\"\"\"\n data,lsts,obs = _load_fanbeams(fname,utc_start,tsamp)\n ns,ew = hadec_to_nsew(ha,dec)\n return TransitFanBeamTimeMap(data,ns,ew,lsts)\n\n\n##### testing: IGNORE #####\n\ndef test():\n ra,dec = \"07:16:35\",\"-19:00:40\"\n eq = e.Equatorial(ra,dec)\n ra = eq.ra\n dec = eq.dec\n lst = float(e.hours(\"03:56\"))\n dlst = float(e.hours(\"00:00:20.0001\"))*SEC_TO_SID\n data = read(\"molonglo_fb_map.fits\")\n lsts = np.arange(data.shape[1])*dlst + lst\n return FanBeamTimeMap(data,ra,dec,lst,dlst)\n\ndef test_track_map(fname=\"molonglo_fb_map.fits\"):\n ra,dec = \"07:16:35\",\"-19:00:40\"\n eq = e.Equatorial(ra,dec)\n ra = eq.ra\n dec = eq.dec\n lst = float(e.hours(\"03:56\"))\n dlst = float(e.hours(\"00:00:20.0016\"))*SEC_TO_SID\n data = read(fname)\n lsts = np.arange(data.shape[1])*dlst + lst\n return TrackedFanBeamTimeMap(data,ra,dec,lsts)\n\ndef track_map(fname,utc_start,ra,dec):\n obs = Molonglo(date=utc_start)\n body = e.FixedBody()\n body._ra = ra\n body._dec = dec\n body.compute(obs)\n data = read(fname)\n lst = obs.sidereal_time()\n dlst = float(e.hours(\"00:00:20.0016\"))*SEC_TO_SID\n lsts = np.arange(data.shape[1])*dlst + lst\n return TrackedFanBeamTimeMap(data,body.ra,body.dec,lsts)\n\ndef test_transit_map():\n obs = Molonglo(\"2015/07/28 22:34:23\")\n lst = obs.sidereal_time()\n dlst = float(e.hours(\"00:00:01\"))*SEC_TO_SID\n data = read(\"SN1987A.2015-07-28-22_34_23.fixed.fits\")\n lsts = np.arange(data.shape[1])*dlst + lst\n ns,ew = hadec_to_nsew(0.0,np.radians(-70.0))\n return TransitFanBeamTimeMap(data,ns,ew,lsts)\n \n \n \n"
] | [
[
"numpy.ones",
"numpy.empty",
"scipy.ndimage.filters.median_filter",
"numpy.cos",
"numpy.copy",
"numpy.median",
"numpy.arange",
"numpy.hstack",
"numpy.polyfit",
"numpy.polyval",
"numpy.radians",
"numpy.mean"
]
] |
Siemingfong/FilmFeatureCrawler | [
"98ab581ca8d9df70452ff28a8d061dc658461459"
] | [
"code/haha.py"
] | [
"import time \r\nimport random\r\nimport datetime\r\nfrom bs4 import BeautifulSoup as bs\r\nimport pandas as pd\r\nimport os\r\nimport json\r\nimport requests\r\n\r\nmonth=['01','02','03','04','05','06','07','08','09','10','11','12']\r\nyear=['2015','2016','2017','2018','2019','2020']\r\ndate=[]\r\nmovies=[]\r\n\r\ndef craw(startdate,enddate):\r\n url = 'https://www.imdb.com/search/title/?title_type=feature&release_date='+startdate+','+enddate\r\n html=requests.get(url).text\r\n soup = bs(html,'lxml')\r\n count=soup.find('span').text.split()\r\n print(count)\r\n return count[2]\r\n\r\nfor i in range(0,6):\r\n for j in range(0,12):\r\n startdate=year[i]+'-'+month[j]+'-01'\r\n if(month[j]=='12'):\r\n enddate=str(int(year[i])+1)+'-01-01'\r\n else:\r\n enddate=year[i]+'-'+month[j+1]+'-01'\r\n date.append(year[i]+'-'+month[j])\r\n movies.append(int(craw(startdate,enddate).replace(',','')))\r\n\r\ndf= pd.DataFrame()\r\ndf['month']=date\r\ndf['number']=movies\r\n\r\n\r\n\r\n\r\n\r\n"
] | [
[
"pandas.DataFrame"
]
] |
jfear/larval_gonad | [
"624a71741864b74e0372f89bdcca578e5cca3722"
] | [
"polII-wf/scripts/plot_boxplot_polII.py"
] | [
"\"\"\"Playing with plots for galletta\"\"\"\nimport os\n\nimport matplotlib\n\nmatplotlib.use(\"Agg\")\n\nimport matplotlib.pyplot as plt\nimport pandas as pd\nimport seaborn as sns\nfrom scipy.stats import ttest_ind\n\nfrom larval_gonad.plotting.stats import pval_to_string\n\n\ndef main():\n plt.style.use([\"2c\", \"science_base\"])\n fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(4.75, 1.16), sharey=True, gridspec_kw=dict(wspace=0.01))\n ax1.set_ylim(None, 2.3)\n\n # S2\n s2 = get_data(snakemake.input[0], \"S2\")\n sns.boxplot(\"chrom\", \"norm\", data=s2, ax=ax1, palette=snakemake.params.colors, notch=True)\n ax1.set(xlabel=\"\", title=\"S2 Phospho CTD / Total Pol II\", ylabel=\"Normalized Pixel Intensity\")\n sns.despine(ax=ax1)\n pval = get_pval(s2)\n add_pval_and_line(pval, ax1)\n\n # S5\n s5 = get_data(snakemake.input[0], \"S5\")\n sns.boxplot(\"chrom\", \"norm\", data=s5, ax=ax2, palette=snakemake.params.colors, notch=True)\n ax2.set(xlabel=\"\", title=\"S5 Phospho CTD / Total Pol II\", ylabel=\"\")\n sns.despine(ax=ax2)\n pval = get_pval(s5)\n add_pval_and_line(pval, ax2)\n\n fig.savefig(snakemake.output[0])\n\n\ndef get_data(file_name, antibody):\n return (\n pd.read_excel(file_name, sheet_name=antibody, skiprows=1)\n .melt(value_name=\"norm\", var_name=\"chrom\")\n .dropna()\n .assign(antibody=antibody)\n )\n\n\ndef get_pval(df):\n x = df.query(f'chrom == \"X\"').norm\n a = df.query(f'chrom == \"A\"').norm\n _, pval = ttest_ind(x, a, equal_var=False)\n return pval_to_string(pval)\n\n\ndef add_pval_and_line(pval, ax):\n ax.text(0.5, 0.99, pval, transform=ax.transAxes, va=\"top\", ha=\"center\")\n l = plt.Line2D([0.3, 0.7], [0.94, 0.94], transform=ax.transAxes, color=\"k\", lw=0.8, ls=\"-\")\n ax.add_line(l)\n return ax\n\n\nif __name__ == \"__main__\":\n if os.getenv(\"SNAKE_DEBUG\", False):\n from larval_gonad.debug import snakemake_debug\n\n snakemake = snakemake_debug(\n workdir=\"polII-wf\",\n input=\"../data/external/galletta/phos_over_tot_data_late_SC_only_061819.xlsx\",\n params=dict(colors=[\"red\", \"grey\"]),\n )\n\n plt.style.use(\"../config/figure_styles.mplstyle\")\n\n main()\n"
] | [
[
"matplotlib.pyplot.style.use",
"scipy.stats.ttest_ind",
"pandas.read_excel",
"matplotlib.use",
"matplotlib.pyplot.Line2D"
]
] |
chenpocufa/Chatbot_CN | [
"1adf1c01d3eced5f0644102bdec9be22705b6f3f"
] | [
"Chatbot_Model/Info_Extraction/Entity_Extraction/data.py"
] | [
"#-*- coding:utf-8 _*-\n\"\"\"\n@author:charlesXu\n@file: data.py\n@desc: 构建字向量、词向量\n@time: 2018/08/08\n\"\"\"\n\n\nimport sys, pickle, os, random\nimport numpy as np\n\nimport pdb\n\n## tags, BIO 标注策略 标签矩阵\ntag2label = {\"O\": 0,\n \"B-PER\": 1, \"I-PER\": 2,\n \"B-LOC\": 3, \"I-LOC\": 4,\n \"B-ORG\": 5, \"I-ORG\": 6,\n \"B-TIM\": 7, \"I-TIM\": 8 # 时间标签\n }\n\n\ndef read_corpus(corpus_path):\n \"\"\"\n read corpus and return the list of samples\n :param corpus_path:\n :return: data\n \"\"\"\n data = []\n with open(corpus_path, encoding='utf-8') as fr:\n lines = fr.readlines()\n sent_, tag_ = [], []\n for line in lines:\n if line != '\\n':\n [char, label] = line.strip().split()\n sent_.append(char)\n tag_.append(label)\n else:\n data.append((sent_, tag_))\n sent_, tag_ = [], []\n\n return data\n\n\ndef vocab_build(vocab_path, corpus_path, min_count):\n \"\"\"\n :param vocab_path:\n :param corpus_path:\n :param min_count:\n :return:\n \"\"\"\n data = read_corpus(corpus_path)\n word2id = {}\n for sent_, tag_ in data:\n for word in sent_:\n if word.isdigit():\n word = '<NUM>'\n elif ('\\u0041' <= word <='\\u005a') or ('\\u0061' <= word <='\\u007a'):\n word = '<ENG>'\n if word not in word2id:\n word2id[word] = [len(word2id)+1, 1]\n else:\n word2id[word][1] += 1\n low_freq_words = []\n for word, [word_id, word_freq] in word2id.items():\n if word_freq < min_count and word != '<NUM>' and word != '<ENG>':\n low_freq_words.append(word)\n for word in low_freq_words:\n del word2id[word]\n\n new_id = 1\n for word in word2id.keys():\n word2id[word] = new_id\n new_id += 1\n word2id['<UNK>'] = new_id\n word2id['<PAD>'] = 0\n\n print(len(word2id))\n with open(vocab_path, 'wb') as fw:\n pickle.dump(word2id, fw)\n\n\ndef sentence2id(sent, word2id):\n \"\"\"\n\n :param sent:\n :param word2id:\n :return:\n \"\"\"\n sentence_id = []\n for word in sent:\n if word.isdigit():\n word = '<NUM>'\n elif ('\\u0041' <= word <= '\\u005a') or ('\\u0061' <= word <= '\\u007a'):\n word = '<ENG>'\n if word not in word2id:\n word = '<UNK>'\n sentence_id.append(word2id[word])\n return sentence_id\n\n\ndef read_dictionary(vocab_path):\n \"\"\"\n\n :param vocab_path:\n :return:\n \"\"\"\n vocab_path = os.path.join(vocab_path)\n with open(vocab_path, 'rb') as fr:\n word2id = pickle.load(fr)\n print('vocab_size:', len(word2id))\n return word2id\n\n\ndef random_embedding(vocab, embedding_dim):\n \"\"\"\n\n :param vocab:\n :param embedding_dim:\n :return:\n \"\"\"\n embedding_mat = np.random.uniform(-0.25, 0.25, (len(vocab), embedding_dim))\n embedding_mat = np.float32(embedding_mat)\n return embedding_mat\n\n\ndef pad_sequences(sequences, pad_mark=0):\n \"\"\"\n\n :param sequences:\n :param pad_mark:\n :return:\n \"\"\"\n max_len = max(map(lambda x : len(x), sequences))\n seq_list, seq_len_list = [], []\n for seq in sequences:\n seq = list(seq)\n seq_ = seq[:max_len] + [pad_mark] * max(max_len - len(seq), 0)\n seq_list.append(seq_)\n seq_len_list.append(min(len(seq), max_len))\n return seq_list, seq_len_list\n\n\ndef batch_yield(data, batch_size, vocab, tag2label, shuffle=False):\n \"\"\"\n\n :param data:\n :param batch_size:\n :param vocab:\n :param tag2label: 标签矩阵转化为数字\n :param shuffle:\n :return:\n \"\"\"\n if shuffle:\n random.shuffle(data) # 每次训练都打乱数据\n\n seqs, labels = [], []\n for (sent_, tag_) in data:\n sent_ = sentence2id(sent_, vocab)\n label_ = [tag2label[tag] for tag in tag_]\n\n if len(seqs) == batch_size:\n yield seqs, labels\n seqs, labels = [], []\n\n seqs.append(sent_)\n labels.append(label_)\n\n if len(seqs) != 0:\n yield seqs, labels\n\n\n# 构建word2id.pkl\n# vocab_path = 'D:\\project\\Chatbot_CN\\Chatbot_Model\\Info_Extraction\\Entity_Extraction\\data\\word2id_tim.pkl'\n# corpus_path = 'D:\\project\\Chatbot_CN\\Chatbot_Data\\Info_Extraction\\\\train_data_tim'\n# min = 5\n# vocab_build(vocab_path, corpus_path, min)\n\n"
] | [
[
"numpy.float32"
]
] |
BeibinLi/affspec | [
"d00a290cb1c86cb079acef69f914805737cb3696"
] | [
"affspec/models/cnn_utils.py"
] | [
"import torch.nn as nn\n\n__author__ = \"Sachin Mehta\"\n__version__ = \"1.0.1\"\n__maintainer__ = \"Sachin Mehta\"\n\nclass CBR(nn.Module):\n '''\n This class defines the convolution layer with batch normalization and PReLU activation\n '''\n\n def __init__(self, nIn, nOut, kSize, stride=1, groups=1):\n '''\n\n :param nIn: number of input channels\n :param nOut: number of output channels\n :param kSize: kernel size\n :param stride: stride rate for down-sampling. Default is 1\n '''\n super().__init__()\n padding = int((kSize - 1) / 2)\n self.conv = nn.Conv2d(nIn, nOut, kSize, stride=stride, padding=padding, bias=False, groups=groups)\n self.bn = nn.BatchNorm2d(nOut)\n self.act = nn.PReLU(nOut)\n\n def forward(self, input):\n '''\n :param input: input feature map\n :return: transformed feature map\n '''\n output = self.conv(input)\n # output = self.conv1(output)\n output = self.bn(output)\n output = self.act(output)\n return output\n\n\nclass BR(nn.Module):\n '''\n This class groups the batch normalization and PReLU activation\n '''\n\n def __init__(self, nOut):\n '''\n :param nOut: output feature maps\n '''\n super().__init__()\n self.bn = nn.BatchNorm2d(nOut)\n self.act = nn.PReLU(nOut)\n\n def forward(self, input):\n '''\n :param input: input feature map\n :return: normalized and thresholded feature map\n '''\n output = self.bn(input)\n output = self.act(output)\n return output\n\n\nclass CB(nn.Module):\n '''\n This class groups the convolution and batch normalization\n '''\n\n def __init__(self, nIn, nOut, kSize, stride=1, groups=1):\n '''\n :param nIn: number of input channels\n :param nOut: number of output channels\n :param kSize: kernel size\n :param stride: optinal stide for down-sampling\n '''\n super().__init__()\n padding = int((kSize - 1) / 2)\n self.conv = nn.Conv2d(nIn, nOut, kSize, stride=stride, padding=padding, bias=False,\n groups=groups)\n self.bn = nn.BatchNorm2d(nOut)\n\n def forward(self, input):\n '''\n\n :param input: input feature map\n :return: transformed feature map\n '''\n output = self.conv(input)\n output = self.bn(output)\n return output\n\n\nclass C(nn.Module):\n '''\n This class is for a convolutional layer.\n '''\n\n def __init__(self, nIn, nOut, kSize, stride=1, groups=1):\n '''\n\n :param nIn: number of input channels\n :param nOut: number of output channels\n :param kSize: kernel size\n :param stride: optional stride rate for down-sampling\n '''\n super().__init__()\n padding = int((kSize - 1) / 2)\n self.conv = nn.Conv2d(nIn, nOut, kSize, stride=stride, padding=padding, bias=False,\n groups=groups)\n\n def forward(self, input):\n '''\n :param input: input feature map\n :return: transformed feature map\n '''\n output = self.conv(input)\n return output\n\n\nclass CDilated(nn.Module):\n '''\n This class defines the dilated convolution.\n '''\n\n def __init__(self, nIn, nOut, kSize, stride=1, d=1, groups=1):\n '''\n :param nIn: number of input channels\n :param nOut: number of output channels\n :param kSize: kernel size\n :param stride: optional stride rate for down-sampling\n :param d: optional dilation rate\n '''\n super().__init__()\n padding = int((kSize - 1) / 2) * d\n self.conv = nn.Conv2d(nIn, nOut,kSize, stride=stride, padding=padding, bias=False,\n dilation=d, groups=groups)\n\n def forward(self, input):\n '''\n :param input: input feature map\n :return: transformed feature map\n '''\n output = self.conv(input)\n return output\n\nclass CDilatedB(nn.Module):\n '''\n This class defines the dilated convolution with batch normalization.\n '''\n\n def __init__(self, nIn, nOut, kSize, stride=1, d=1, groups=1):\n '''\n :param nIn: number of input channels\n :param nOut: number of output channels\n :param kSize: kernel size\n :param stride: optional stride rate for down-sampling\n :param d: optional dilation rate\n '''\n super().__init__()\n padding = int((kSize - 1) / 2) * d\n self.conv = nn.Conv2d(nIn, nOut,kSize, stride=stride, padding=padding, bias=False,\n dilation=d, groups=groups)\n self.bn = nn.BatchNorm2d(nOut)\n\n def forward(self, input):\n '''\n :param input: input feature map\n :return: transformed feature map\n '''\n return self.bn(self.conv(input))\n"
] | [
[
"torch.nn.PReLU",
"torch.nn.BatchNorm2d",
"torch.nn.Conv2d"
]
] |
arrismo/tripods-testing | [
"4ab9a7059df84cfd1f8984960900a3cf80b5c13c",
"4ab9a7059df84cfd1f8984960900a3cf80b5c13c"
] | [
"source/summary.py",
"analysis/main.py"
] | [
"# -*- coding: utf-8 -*-\n\"\"\"\nPrints out a simple summary of the courses extracted from the school catalogs.\n\nCreated on Mon Jun 8 11:51:22 2020\n\n@author: Francisco Vazquez\n\"\"\"\n\nimport os\nimport pandas as pd\n\nn_colleges=0\nn_courses = 0\nfor filename in os.listdir('../courses'):\n\n # if current file is the one for all schools, skip it\n if filename == \"AllSchools.csv\":\n continue\n\n csv = pd.read_csv('../courses/'+filename,encoding = 'utf-8')\n n_colleges +=1\n n_courses += len(csv['CourseID'])\n print('number of courses in ' + filename + ': ' + str(len(csv['CourseID'])))\n\nprint('\\n')\nprint('number of colleges: ' + str(n_colleges))\nprint(\"number of courses: \" +str(n_courses))\nprint(\"average number of courses per college: \" + str((n_courses/n_colleges)))",
"\n# -*- coding: utf-8 -*-\n\n#Import Statements\n\nimport pandas as pd\nimport numpy as np\nimport nltk\nimport spacy\nimport courseToBOK\nnltk.download('punkt')\nnltk.download('stopwords')\nnltk.download('wordnet')\nnltk.download('averaged_perceptron_tagger')\nimport re\nfrom re import *\nfrom nltk.util import ngrams\nfrom nltk.corpus import stopwords\nimport gower\nimport matplotlib.pyplot as plt\nfrom scipy.cluster.hierarchy import linkage, fcluster, dendrogram\nfrom sklearn.cluster import KMeans\nfrom sklearn import metrics\nfrom scipy.spatial.distance import cdist\nfrom get_df_name_func import get_df_name\nfrom process_words_funct import process_words\nfrom tfidf_analysis import tfidf\nfrom tokenizer import tokenize\n\n\nnlp = spacy.load('en_core_web_sm')\n\n##Import CSV as Dataframes\nschools_df = pd.read_csv(\"Smith-07-10-2020-FROZEN.csv\")\ndel(schools_df['Unnamed: 0'])\n\n\ntext_file = open(\"bok.txt\", \"r\")\nbok = text_file.read().split('\\n')\nbok = courseToBOK.cleanBOK(bok)\nfor i in range(len(bok)): #lowercase each bok term\n bok[i] = bok[i].lower()\n\n\n\n#retain only courses pertinent to Data Science\ntemp_df = []\nfor i in range(len(schools_df)): #for each course\n des = str(schools_df['CourseID'][i])\n des = des.lower()\n temp_list = []\n terms = []\n #print(i)\n for w in bok: #for each bok term\n space = r'\\s' #regex space pattern\n if re.search(space+w+space,des): #if the course contains the bok term\n if w not in terms: #if the bok term is not already in the list for that description\n terms.append(w) #append bok term\n if len(terms) != 0: #if at least 1 term is in the description\n temp_list = [schools_df['School'][i], schools_df['CourseID'][i], schools_df['Descriptions'][i],', '.join(terms)] #append course to new list\n temp_df.append(temp_list) #append list to new dataframe\nds_schools_df = pd.DataFrame(temp_df) #create permanent new data frame\nds_schools_df.columns = ['School','CourseID','Descriptions','Data Science Term'] #label columns\nprint(\"Creating 'csvs/SMITH_THE_courses.csv'...\") #create csv of data science courses\nds_schools_df.to_csv('csvs/SMITH_blank_courses.csv',encoding=\"utf-8-sig\")\n\n#creating new columns with key words\nbody = ['Data Science Analytics','Data Science Engineering','Data Management','Research Methods and Project Management','Business Analytics'] #overall headings\ndsana = ['accuracy metrics','data analytics','data analysis','data analytics assessment', 'data lifecycle','data mining','data preparation','graph data analytics',\n 'machine learning','natural language processing','open data','operations research', 'optimisation','optimization','predictive analytics','prescriptive analytics',\n 'qualitative analytics','reinforced learning','simulation'] #keywords for this category\ndseng = ['big data infrastructures','cloud computing','cloud powered services','collaborative system','continuous improvement cycle','data access',\n 'data anonymisation','data driven','data handling','data lifecycle', 'data science engineering','data security','data warehouse solution',\n 'devops','dmp','engineering principles','etl','extract transform load','federated access control','ipr protection','nosql','olap','oltp',\n 'relational databases','simulation','sql','systems software'] #keywords for this category\ndman = ['data architecture','data archive services','data curation','data factories', 'data formats','data governance strategy','data handling','data integration',\n 'data lifecycle','data management','data management plan','data modeling', 'data modeling design','data provenance','data registries','data storage systems',\n 'data types','digital libraries','etl','extract transform load','linked data', 'meta data','metadata','meta-data','olap','oltp','open access','open data',\n 'open science','operational models','pid'] #keywords for this category\nremeprma = ['data collection','data driven','data lifecycle','data quality evaluation','project management','quality evaluation','research methods','team management',\n 'use cases analysis'] #keywords for this category\nbusana = ['agile data driven','bpm','business analytics','business intelligence', 'cognitive technologies','crp','customer relations management',\n 'data marketing technologies','data driven marketing','data integration analytics', 'data warehouses technologies','econometrics','enterprises','open data',\n 'optimization','processes management','use cases analysis','user experience','ux'] #keywords for this category\nbok_cats = {} #dictionary to hold bok categories\nbody_keywords = [] #list to hold bok keywords\n#append keyword lists to body_keywords\nbody_keywords.append(dsana)\nbody_keywords.append(dseng)\nbody_keywords.append(dman)\nbody_keywords.append(remeprma)\nbody_keywords.append(busana)\ni=0\nfor i in range(len(body)): #assign each keyword list to their respective category name\n bok_cats[body[i]] = body_keywords[i]\n\n\ndiff = ['Website','Data Visualization','Statistics','Experimental Design','Programming','Algorithms/Modeling/AI','Data Collection','Data Sources','Data Types','Data Analysis','Application','Simulation','Software','Lab']\nwebsite = ['information technology','web design','website','network','webpage','web','shiny'] #keywords for this category\ndatavis = ['graph','graphs','chart','charts','color theory','barplot','bar plot','visualization', 'visualisation','visualizations','visual','visuals','box plot','boxplot',\n 'color','colors','ggplot2','dashboard','boxplot','barplot','pie chart','piechart','tableau'] #keywords for this category\nstatistics = ['anova','linear regression','chi squared','probability', 'hypothesis test','regression','statistics','statistic','distribution',\n 'variability','variance','percentile','standard deviation','mean','median','mode','average','trendline','trend line'] #keywords for this category\nresmeth = ['research methods','research','research process','design of experiment', 'design of experiments','research question','design study','design studies',\n 'research design'] #keywords for this category\nproglang = ['r','python','c++','mysql','c','spss','sql','nosql','programming language', 'programming languages','tools','sas','programming','pandas','package',\n 'library','coding','code'] #keywords for this category\nalgmodai = ['artificial intelligence','ai','algorithm','algorithms','model','models','modeling', 'machine learning','predict','natural language processing','nlp',\n 'topic model','supervised learning','unsupervised learning', 'neural network','k-means cluster','clustering','decision tree'] #keywords for this category\ncollect = ['data collection','collect','sample size','raw data','collection','collections'] #keywords for this category\nsources = ['data source','data sources','retrieve','database','databases','import'] #keywords for this category\ntypes = ['medicalpharmecutical','qualitative','quantitative','econometrics', 'public health','big data','large volumes'] #keywords for this category\nanaly = ['data analysis','analyze data','analysis','summary','summarize','summarizing'] #keywords for this category\napplic = ['communication','results','interpretation','application', 'data representation','presentation'] #keywords for this category\nsim = ['simulation','simulations'] #keywords for this category\nsoftware = ['software','github','rstudio','excel','microsoft','gis','colab','jupyter', 'tableau'] #keywords for this category\nlab = ['lab','labs','laboratory'] #keywords for this category\ndiff_cats = {} #dictionary to hold diff categories\ndiff_keywords = [] #list to hold diff keywords\n#append keyword lists to diff_keywords\ndiff_keywords.append(website)\ndiff_keywords.append(datavis)\ndiff_keywords.append(statistics)\ndiff_keywords.append(resmeth)\ndiff_keywords.append(proglang)\ndiff_keywords.append(algmodai)\ndiff_keywords.append(collect)\ndiff_keywords.append(sources)\ndiff_keywords.append(types)\ndiff_keywords.append(analy)\ndiff_keywords.append(applic)\ndiff_keywords.append(sim)\ndiff_keywords.append(software)\ndiff_keywords.append(lab)\ni=0\n# this was originally ellie not sure why\nfor i in range(len(diff)): #assign each keyword list to their respective category name\n diff_cats[diff[i]] = diff_keywords[i]\n\n#adding keywords to columns\nfor b in body:\n ds_schools_df[b] = 0\nfor d in diff:\n ds_schools_df[d] = 0\n\nj=0\n\nfor j in range(len(ds_schools_df)): #for each description\n for b in bok_cats: #for each overall category in bok\n i = 0\n for i in range(len(bok_cats[b])): #for each keyword\n comp = str(ds_schools_df['Descriptions'][j]).lower()\n if re.search('\\s'+re.escape(bok_cats[b][i])+'\\s',comp): #search for keyword in description\n ds_schools_df[b][j] = 1 #assign value of 1 if keyword exists in description\n\n for d in diff_cats: #for each overall category in diff\n i = 0\n for i in range(len(diff_cats[d])): #for each keyword\n comp = str(ds_schools_df['Descriptions'][j]).lower()\n if re.search('\\s'+re.escape(diff_cats[d][i])+'\\s',comp): #search for keyword in description\n ds_schools_df[d][j] = 1 #assing value of 1 if keyword exists in description\n\n#creating summation column\nds_schools_df['Sum'] = ds_schools_df.sum(axis=1)\n\n#creating weights\nnum = 0\ndenom = 1\nfrac = float(num/denom)\n\n#create \"others\" list with all keywords\nothers = website\nothers.extend(datavis)\nothers.extend(statistics)\nothers.extend(resmeth)\nothers.extend(proglang)\nothers.extend(algmodai)\nothers.extend(collect)\nothers.extend(sources)\nothers.extend(types)\nothers.extend(analy)\nothers.extend(applic)\nothers.extend(sim)\nothers.extend(software)\nothers.extend(lab)\nothers = list(set(others))\nothers.sort()\n\n#remove items from \"others\" already in \"bok\"\n#this helps ensure that bok keywords can get a higher weight than non bok keywords \ni = len(others) - 1\nwhile i >=0:\n if others[i] in bok:\n del others[i]\n i -=1\n\n\n#stop words definition\nstop_words = list(stopwords.words('english'))\nnlp = spacy.load('en_core_web_sm', disable=['parser', 'ner'])\nstop_words.append('-PRON-')\nfirst_stops = ['cr','ul','ii','cog','pp','ps','geog','cosc','biol','el','sesp',\n 'eecs','oba','phys','phy','mth','cmsc','nur','ce','cs','iii'] #unkown/unnecessary abbreviations\nsecond_stops = ['make','impact','apply','change','involve','reside','vary','may',\n 'meet','use','include','pertain','tell','cover','devote',\n 'recognize','carry'] #verbs that are not useful\nthird_stops = ['new','minimum','useful','mainly','large','liberal','formerly',\n 'especially','absolutely','graduate','odd','one','throughout',\n 'weekly','least','well','hour','common','require','along','least',\n 'long','related','prior','open','sophomore','junior','single',\n 'necessary'] #unuseful descriptors\nfourth_stops = ['treat','prereq','prerequisite','creditsprerequisite',\n 'corequisite','either','assignment','major','none','arts','core',\n 'andor','semester','hoursprereq','student','instructor','threehour',\n 'within','lecturescover','satisfactoryno','summer','yifat',\n 'givenfor','term','classroom','area','inquiry','researchintensive',\n 'year','via','teacher','ofhow', 'specialstudies', 'research', 'special', 'studies'] #other unuseful words\nstop_words.extend(first_stops)\nstop_words.extend(second_stops)\nstop_words.extend(third_stops)\nstop_words.extend(fourth_stops)\n\n#remove stopwords from df:\nfor i in range(len(ds_schools_df)): # for each row\n des = ds_schools_df.loc[i,'Descriptions'].split()\n j = len(des) - 1\n while j >=0:\n if des[j] in stop_words:\n del des[j]\n j-=1\n ds_schools_df.loc[i,'Descriptions'] = ' '.join(des)\n\n#create weights\nds_schools_df[\"Weights\"] = 0\nfor i in range(len(ds_schools_df)): #for each row\n #print(i)\n num = 0\n d = ds_schools_df['Descriptions'][i]\n d = d.split() #split for word count\n denom = len(d) #overall word count\n for b in bok: #for each BoK term\n b = b.split() #split for word count\n b_len = len(b) #num of words in BoK term\n b = ' '.join(b) #join for analysis\n d = ' '.join(d).lower() #join for analysis\n token = nltk.word_tokenize(d) #tokenize for ngrams\n ngram = list(ngrams(token,b_len)) #create ngrams\n for n in range(len(ngram)): #turn tuples to strings\n ngram[n] = ' '.join(ngram[n])\n num += (ngram.count(b) * b_len)\n d = d.split() #split for continuity\n for b in others: #for each \"others\" term\n b = b.split() #split for word count\n b_len = len(b) #num of words in \"others\" term\n b = ' '.join(b) #join for analysis\n d = ' '.join(d) #join for analysis\n token = nltk.word_tokenize(d) #tokenize for ngrams\n ngram = list(ngrams(token,b_len)) #create ngrams\n for n in range(len(ngram)): #turn tuples to strings\n ngram[n] = ' '.join(ngram[n])\n num += (ngram.count(b) * 0.5)\n d = d.split() #split for continuity\n frac = float(num/denom)\n ds_schools_df.loc[i, 'Weights'] = frac\nprint(\"Creating 'csvs/0713_bok_courses_cat_weights.csv'...\")\nds_schools_df.to_csv('csvs/0713_bok_courses_cat_weights.csv',index=False)\n\n#process words, create dictionaries for future function calls\nresponses, ds_school_list = process_words(stop_words,ds_schools_df)\n\n#tfidf analysis\ntfidf(responses,ds_school_list)\n\n\n#MACHINE lEARNING\n#make floats finite\nfor i in range(len(ds_schools_df)):\n ds_schools_df.loc[i, 'Weights'] = float('%.5f'%(ds_schools_df.loc[i,'Weights']))\n\n#create gower matrix & linkage\ndm = gower.gower_matrix(ds_schools_df)\n\n# determine k using elbow method\n\nx1 = np.array(ds_schools_df['Sum'])\nx2 = np.array(ds_schools_df['Weights'])\n\n#plot points\nplt.plot()\nplt.xlim([0, 20])\nplt.ylim([0, 1])\nplt.title('Dataset')\nplt.scatter(x1, x2)\nplt.show()\n\n# create new plot and data\nplt.plot()\nX = np.array(list(zip(x1, x2))).reshape(len(x1), 2)\ncolors = ['b', 'g', 'r']\nmarkers = ['o', 'v', 's']\n\n# k means determine k\ndistortions = []\nK = range(1,10)\nfor k in K:\n kmeanModel = KMeans(n_clusters=k).fit(X)\n kmeanModel.fit(X)\n distortions.append(sum(np.min(cdist(X, kmeanModel.cluster_centers_, 'euclidean'), axis=1)) / X.shape[0])\n\n# Plot the elbow\nplt.plot(K, distortions, 'bx-')\nplt.xlabel('k')\nplt.ylabel('Distortion')\nplt.title('The Elbow Method showing the optimal k')\nplt.show()\n\n# create kmeans object\nkmeans = KMeans(n_clusters=4)\n# fit kmeans object to data\nkmeans.fit(dm)\n\n# save new clusters for chart\ny_km = kmeans.fit_predict(dm)\nds_schools_df['category']=pd.DataFrame(y_km)\n\ngroups = ds_schools_df.groupby(\"category\")\nfor name, group in groups:\n plt.plot(group[\"Weights\"], group[\"Sum\"], marker=\"o\", linestyle=\"\", label=name)\nplt.legend()\n\n#save to csv\nprint(\"Creating 'csvs/SMITH_FINAL_THE_results.csv'...\")\nds_schools_df.to_csv('csvs/SMITH_FINAL_THE_results.csv', index=False)\n\n\n"
] | [
[
"pandas.read_csv"
],
[
"matplotlib.pyplot.legend",
"scipy.spatial.distance.cdist",
"pandas.read_csv",
"pandas.DataFrame",
"matplotlib.pyplot.xlim",
"matplotlib.pyplot.title",
"sklearn.cluster.KMeans",
"matplotlib.pyplot.show",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.ylim",
"numpy.array",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.scatter"
]
] |
sambit-giri/DMemu | [
"1827832efdab2dfcb735035b6956854e34d17202"
] | [
"src/functions.py"
] | [
"import numpy as np \nimport pickle\n\ndef ps_suppression_8param(theta, emul, return_std=False):\n log10Mc, mu, thej, gamma, delta, eta, deta, fb = theta\n # fb = 0.1612\n mins = [11, 0.0, 2, 1, 3, 0.2, 0.2, 0.10]\n maxs = [15, 2.0, 8, 4, 11, 0.4, 0.4, 0.25]\n assert mins[0]<=log10Mc<=maxs[0]\n assert mins[1]<=mu<=maxs[1]\n assert mins[2]<=thej<=maxs[2]\n assert mins[3]<=gamma<=maxs[3]\n assert mins[4]<=delta<=maxs[4]\n assert mins[5]<=eta<=maxs[5]\n assert mins[6]<=deta<=maxs[6]\n assert mins[7]<=fb<=maxs[7]\n theta = [log10Mc, mu, thej, gamma, delta, eta, deta, fb]\n if type(theta)==list: theta = np.array(theta)\n if theta.ndim==1: theta = theta[None,:]\n out = emul.predict_values(theta)#, return_std=True)\n # print(out.shape)\n return out.squeeze()\n\nclass use_emul:\n\tdef __init__(self, emul_name):\n\t\tself.emul_name = emul_name\n\t\tself.load_emulators()\n\t\t\n\t\tself.fb = Ob/Om\n\t\tprint('Baryon fraction is set to {:.3f}'.format(self.fb))\n\t\tself.load_emulators()\n\t\tself.fix_params()\n\n\tdef load_emulators(self, emul_names=None):\n\t\tif emul_names is not None: self.emul_names = emul_names\n\t\temulators = []\n\t\tzs = []\n\t\tfor ke in self.emul_names:\n\t\t\tzs.append(float(ke))\n\t\t\temu = pickle.load(open(self.emul_names[ke],'rb'))\n\t\t\temu.options['print_prediction'] = False\n\t\t\temulators.append(emu)\n\t\tprint('Emulators loaded.')\n\t\tself.emulators = np.array(emulators)\n\t\tself.emul_zs = np.array(zs)\n\n\tdef fix_params(self):\n\t\tmu, gamma, delta, deta = 0.93, 2.25, 6.40, 0.240 \n\t\tthej, eta = 4.235, 0.22\n\t\tself.mu = mu\n\t\tself.gamma = gamma\n\t\tself.delta = delta\n\t\tself.deta = deta \n\t\tself.thej = thej \n\t\tself.eta = eta \n\n\tdef run(self, log10Mc=13.322, nu_Mc=-0.015, z=0):\n\t\tassert 12.3<=log10Mc<=14.5\n\t\tassert -0.1<=nu_Mc<=0.01\n\t\tassert 0<=z<=2\n\n\t\tif z in self.emul_zs:\n\t\t\ttheta = [log10Mc*(1+z)**nu_Mc, self.mu, self.thej, self.gamma, self.delta, self.eta, self.deta, self.fb]\n\t\t\temu0 = self.emulators[self.emul_zs==z][0]\n\t\t\t# print(emu0)\n\t\t\tps = ps_suppression_8param(theta, emu0, return_std=False)\n\t\t\treturn ps, ks0\n\t\telse:\n\t\t\ti0, i1 = nearest_element_idx(self.emul_zs, z)\n\t\t\ttheta0 = [log10Mc*(1+self.emul_zs[i0])**nu_Mc, self.mu, self.thej, self.gamma, self.delta, self.eta, self.deta, self.fb]\n\t\t\temu0 = self.emulators[i0]\n\t\t\ttheta1 = [log10Mc*(1+self.emul_zs[i1])**nu_Mc, self.mu, self.thej, self.gamma, self.delta, self.eta, self.deta, self.fb]\n\t\t\temu1 = self.emulators[i1]\n\t\t\tps0 = ps_suppression_8param(theta0, emu0, return_std=False)\n\t\t\tps1 = ps_suppression_8param(theta1, emu1, return_std=False)\n\t\t\treturn ps0 + (ps1-ps0)*(z-self.emul_zs[i0])/(self.emul_zs[i1]-self.emul_zs[i0]), ks0\n\n\n\ndef nearest_element_idx(arr, a, both=True):\n\tif both:\n\t\tdist = np.abs(arr-a)\n\t\tdist_arg = np.argsort(dist)\n\t\treturn dist_arg[0], dist_arg[1]\n\telse:\n\t\treturn np.abs(arr-a).argmin()\n\n\n"
] | [
[
"numpy.array",
"numpy.abs",
"numpy.argsort"
]
] |
egaznep/toy_vae_example | [
"a41bed14454462da9a1b0ca658f4e72998b7d10b"
] | [
"src/models/train_model.py"
] | [
"import re\nimport click\nimport logging\nfrom pathlib import Path\nfrom dotenv import find_dotenv, load_dotenv\n\nimport importlib\n\nimport torch\nimport torch.autograd\nfrom torch.utils.data import dataset\nimport torch.utils.data.dataloader\n\nimport ignite.utils\nimport ignite.handlers.early_stopping\nimport ignite.engine\nimport ignite.metrics\nimport ignite.contrib.handlers\nimport ignite.contrib.handlers.tensorboard_logger\nimport ignite.contrib.handlers.tqdm_logger\nimport ignite.handlers.param_scheduler\n\nfrom copy import deepcopy\n\nimport tensorboardX\n\nimport src.models\nimport src.data.load_dataset\nfrom src.config.load_config import load_config\nfrom src.common import get_constructor, magma_init\nimport src.torch_extensions\n\n\nclass Training:\n def __init__(self, config, *args, **kwargs):\n # parse config\n\n self.seed = config['random']['seed']\n self.num_epoch = config['training']['num_epoch']\n self.dim_input = (1, config['model']['architecture']['num_input'])\n self.cfg = config['model']\n self.early_stopping = config['training']['early_stopping']\n self.reduce_lr_plateau = config['training']['reduce_lr_plateau']\n\n self.setup_cuda()\n self.dummy_input = torch.autograd.Variable(\n torch.zeros(self.dim_input).to(self.device))\n self.setup_tensorboard(\n config['experiment']['name'] + config['model']['name'], **config['tensorboard'])\n self.setup_model(**self.cfg)\n self.setup_ignite()\n\n def setup_cuda(self, cuda_device_id=0):\n torch.backends.cuda.fasval = True\n torch.cuda.set_device(cuda_device_id)\n self.device = torch.device('cuda')\n torch.cuda.manual_seed_all(self.seed)\n torch.manual_seed(self.seed)\n magma_init()\n\n def setup_model(self, architecture, loss, optim, **kwargs):\n constructor = get_constructor('src.models', architecture['type'])\n self.model = constructor(**architecture).to(self.device)\n self.optim = torch.optim.Adam(self.model.parameters(), lr=optim['lr'])\n\n def setup_ignite(self):\n ignite.utils.manual_seed(self.seed)\n\n val_metrics = {key: ignite.metrics.Loss(self.model.loggable_losses[key])\n for key in self.model.loggable_losses}\n\n def prepare_batch(batch, device=None, non_blocking=False, *args, **kwargs):\n converted = ignite.utils.convert_tensor(\n batch, device, non_blocking)\n return converted, converted\n\n def output_transform(x, y, y_pred, loss=None):\n return {'y': y, 'y_pred': y_pred, 'criterion_kwargs': {}, 'loss': loss}\n\n self.trainer = ignite.engine.create_supervised_trainer(\n self.model, self.optim, self.model.loss, device=self.device, prepare_batch=prepare_batch, output_transform=output_transform)\n self.evaluator = ignite.engine.create_supervised_evaluator(\n self.model, val_metrics, device=self.device, prepare_batch=prepare_batch, output_transform=output_transform)\n for mtrc in val_metrics:\n val_metrics[mtrc].attach(self.trainer, mtrc)\n \n # prevent messages from cluttering the log\n self.trainer.logger.setLevel(logging.WARN)\n self.evaluator.logger.setLevel(logging.WARN)\n\n # progress bar\n pbar = ignite.contrib.handlers.tqdm_logger.ProgressBar()\n pbar.attach(self.trainer)\n\n # save graph to tensorboard\n self.tb_logger.writer.add_graph(self.model, self.dummy_input)\n\n # attach events - tensorboard loggers\n losses = [loss for loss in self.model.loggable_losses]\n self.tb_logger.attach_output_handler(\n self.trainer, ignite.engine.Events.EPOCH_COMPLETED, tag='training', \n metric_names=losses,\n global_step_transform=ignite.contrib.handlers.tensorboard_logger.global_step_from_engine(self.trainer))\n self.tb_logger.attach_output_handler(\n self.evaluator, ignite.engine.Events.EPOCH_COMPLETED, tag='validation', \n metric_names=losses,\n global_step_transform=ignite.contrib.handlers.tensorboard_logger.global_step_from_engine(self.trainer))\n\n # attach events - early stopping\n def score_function(engine):\n return -engine.state.metrics['loss']\n self.es = ignite.handlers.early_stopping.EarlyStopping(**self.early_stopping, score_function=score_function, trainer=self.trainer)\n self.evaluator.add_event_handler(ignite.engine.Events.COMPLETED, self.es)\n\n # attach events - learning rate scheduling\n self.ps = src.torch_extensions.ReduceLROnPlateauScheduler(self.optim, metric_name='loss', **self.reduce_lr_plateau)\n self.evaluator.add_event_handler(ignite.engine.Events.COMPLETED, self.ps)\n\n @self.trainer.on(ignite.engine.Events.STARTED)\n def on_start(engine):\n logging.info('Starting training')\n\n @self.trainer.on(ignite.engine.Events.COMPLETED)\n def on_complete(engine):\n torch.save(self.model.state_dict(), self.model_save_path)\n logging.info('Training complete. Saved model to:{}'.format(\n self.model_save_path))\n\n @self.evaluator.on(ignite.engine.Events.COMPLETED)\n def on_complete(engine):\n # print loss etc.\n logging.info(\n f'Avg validation loss: {engine.state.metrics[\"loss\"]}')\n\n def train(self, train_loader, val_loader, model_save_path):\n self.model_save_path = model_save_path\n self.loss_list = []\n\n @self.trainer.on(ignite.engine.Events.EPOCH_COMPLETED)\n def on_epoch_complete(engine):\n logging.info(\n f'Training epoch {engine.state.epoch} complete. Avg training loss: {engine.state.metrics[\"loss\"]}')\n self.evaluator.run(val_loader)\n self.trainer.run(train_loader, self.num_epoch)\n\n def setup_tensorboard(self, folder_name, save_path, **kwargs):\n path = Path(save_path) / folder_name\n self.tb_logger = ignite.contrib.handlers.TensorboardLogger(\n log_dir=path)\n\n\[email protected]()\[email protected]('data_path', type=click.Path(exists=True))\[email protected]('experiment_cfg_path', type=click.Path(exists=True))\ndef main(data_path, experiment_cfg_path):\n # not used in this stub but often useful for finding various files\n project_dir = Path(__file__).resolve().parents[2]\n\n # find .env automagically by walking up directories until it's found, then\n # load up the .env entries as environment variables\n load_dotenv(find_dotenv())\n data_path = Path(data_path)\n\n # config loader\n cfg = load_config(experiment_cfg_path)\n\n # data loader\n dataset_name_prefix = cfg['dataset']['name']\n train_dataset = src.data.load_dataset.Waveform_dataset(\n data_path, '{}_train.hdf5'.format(dataset_name_prefix))\n val_dataset = src.data.load_dataset.Waveform_dataset(\n data_path, '{}_val.hdf5'.format(dataset_name_prefix))\n train_loader = torch.utils.data.dataloader.DataLoader(\n dataset=train_dataset, **cfg['train_loader'])\n val_loader = torch.utils.data.dataloader.DataLoader(\n dataset=val_dataset, **cfg['val_loader'])\n\n # model\n trainer = Training(cfg)\n model_save_path = Path(cfg['model']['path']) / cfg['model']['name']\n\n trainer.train(train_loader, val_loader, model_save_path)\n\n\nif __name__ == '__main__':\n log_fmt = '%(asctime)s - %(levelname)s - %(message)s'\n logging.basicConfig(level=logging.INFO, format=log_fmt)\n main()\n"
] | [
[
"torch.cuda.manual_seed_all",
"torch.manual_seed",
"torch.utils.data.dataloader.DataLoader",
"torch.zeros",
"torch.device",
"torch.cuda.set_device"
]
] |
DrewNow/pyod | [
"3b814b567ba8ea9ab8a64c97c24165df48c6e699"
] | [
"pyod/test/test_stat_models.py"
] | [
"# -*- coding: utf-8 -*-\n\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport os\nimport sys\n\nimport unittest\nfrom sklearn.utils.testing import assert_equal\n# noinspection PyProtectedMember\nfrom sklearn.utils.testing import assert_allclose\nfrom sklearn.utils.testing import assert_raises\nfrom sklearn.utils.testing import assert_greater_equal\nfrom sklearn.utils.testing import assert_less_equal\n\nimport numpy as np\n\n# temporary solution for relative imports in case pyod is not installed\n# if pyod is installed, no need to use the following line\nsys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))\n\nfrom pyod.utils.stat_models import pairwise_distances_no_broadcast\nfrom pyod.utils.stat_models import wpearsonr\nfrom pyod.utils.stat_models import pearsonr_mat\n\n\nclass TestStatModels(unittest.TestCase):\n def setUp(self):\n self.a = [1, 2, 3, 2, 3, 1, 0, 5]\n self.b = [1, 2, 1, 2, 2, 1, 0, 2]\n self.w = [2, 2, 1, 2, 4, 1, 0, 2]\n\n self.mat = np.random.rand(10, 20)\n self.w_mat = np.random.rand(10, 1)\n\n self.X = np.array([[1, 2, 3],\n [3, 4, 5],\n [3, 6, 7],\n [4, 1, 1]])\n self.Y = np.array([[2, 2, 2],\n [3, 3, 3],\n [4, 4, 3],\n [0, 1, 2]])\n\n def test_pairwise_distances_no_broadcast(self):\n assert_allclose(pairwise_distances_no_broadcast(self.X, self.Y),\n [1.41421356, 2.23606798, 4.58257569, 4.12310563])\n\n with assert_raises(ValueError):\n pairwise_distances_no_broadcast([1, 2, 3], [6])\n\n def test_wpearsonr(self):\n # TODO: if unweight version changes, wp[0] format should be changed\n wp = wpearsonr(self.a, self.b)\n assert_allclose(wp[0], 0.6956083, atol=0.01)\n\n wp = wpearsonr(self.a, self.b, w=self.w)\n assert_allclose(wp, 0.5477226, atol=0.01)\n\n def test_pearsonr_mat(self):\n pear_mat = pearsonr_mat(self.mat)\n assert_equal(pear_mat.shape, (10, 10))\n\n pear_mat = pearsonr_mat(self.mat, self.w_mat)\n assert_equal(pear_mat.shape, (10, 10))\n\n assert_greater_equal(np.min(pear_mat), -1)\n assert_less_equal(np.max(pear_mat), 1)\n\n def tearDown(self):\n pass\n\n\nif __name__ == '__main__':\n unittest.main()\n"
] | [
[
"sklearn.utils.testing.assert_raises",
"sklearn.utils.testing.assert_allclose",
"sklearn.utils.testing.assert_equal",
"numpy.max",
"numpy.random.rand",
"numpy.min",
"numpy.array"
]
] |
JasonDu1993/ATEN | [
"74cb892d88f4d2f5ba5014336d61b6fa90dc250a"
] | [
"train_parsingrcnn.py"
] | [
"import os\nimport sys\nfrom time import time\n\nsys.path.insert(0, os.getcwd())\nimport tensorflow as tf\n\nos.environ[\"CUDA_VISIBLE_DEVICES\"] = \"1\"\nconfig = tf.ConfigProto()\nconfig.gpu_options.allow_growth = True\nsession = tf.Session(config=config)\n\nfrom configs.vip import ParsingRCNNModelConfig\nfrom configs.vip import VIPDataset\n# from models.parsing_rcnn_model import PARSING_RCNN\nfrom models.parsing_rcnn_model_dilated import PARSING_RCNN\n\n\nclass trainConfig(ParsingRCNNModelConfig):\n # NAME = \"vip_singleframe_20190408a\"\n NAME = \"vip_singleframe_test\"\n GPU_COUNT = 1\n IMAGES_PER_GPU = 4\n STEPS_PER_EPOCH = 2000\n # STEPS_PER_EPOCH = 20\n VALIDATION_STEPS = 100\n # VALIDATION_STEPS = 10\n SAVE_MODEL_PERIOD = 1\n\n\n# Root directory of the project\nROOT_DIR = os.getcwd()\n\n# Path to trained weights file\nPRETRAIN_MODEL_PATH = os.path.join(ROOT_DIR, \"checkpoints\", \"parsing_rcnn.h5\")\n# PRETRAIN_MODEL_PATH = \"/home/sk49/workspace/zhoudu/ATEN/outputs/vip_singleframe_20190326a/checkpoints/\" \\\n# \"parsing_rcnn_vip_singleframe_20190326a_epoch038_loss0.491_valloss0.550.h5\"\n\n# Directory to save logs and model checkpoints, if not provided\n# through the command line argument --logs\nDEFAULT_LOGS_DIR = \"./outputs\"\n# DEFAULT_DATASET_DIR = \"/home/sk49/workspace/dataset/VIP\"\nDEFAULT_DATASET_DIR = \"D:\\dataset\\VIP_tiny\"\n\n############################################################\n# Training\n############################################################\n\n\nif __name__ == '__main__':\n import argparse\n\n t0 = time()\n # Parse command line arguments\n parser = argparse.ArgumentParser(\n description='Train Mask R-CNN on Pascal Person Part.')\n parser.add_argument('--dataset', required=False,\n default=DEFAULT_DATASET_DIR,\n metavar=\"/path/to/dataset/\",\n help='Directory of the dataset')\n parser.add_argument('--model', required=False,\n default=\"pretrain\",\n metavar=\"/path/to/weights.h5\",\n help=\"Path to weights .h5 file\")\n parser.add_argument('--logs', required=False,\n default=DEFAULT_LOGS_DIR,\n metavar=\"/path/to/logs/\",\n help='Logs and checkpoints directory (default=logs/)')\n\n args = parser.parse_args()\n print(\"Model: \", args.model)\n print(\"Dataset: \", args.dataset)\n print(\"Logs: \", args.logs)\n\n # Configurations\n config = trainConfig()\n config.display()\n\n # Create model\n model = PARSING_RCNN(mode=\"training\", config=config,\n model_dir=args.logs)\n\n # Select weights file to load\n if args.model.lower() == \"last\":\n # Find last trained weights\n model_path = model.find_last()[1]\n elif args.model.lower() == \"pretrain\":\n model_path = PRETRAIN_MODEL_PATH\n else:\n model_path = args.model\n # common load weight \n print(\"Loading weights \", model_path)\n t0 = time()\n model.load_weights(model_path, by_name=True)\n print(\"Loaded weights \", time() - t0, \"s\")\n # Training dataset. Use the training set and 35K from the\n # validation set, as as in the Mask RCNN paper.\n # dataset_train = VIPDataset()\n # dataset_train.load_vip(args.dataset, \"trainval\")\n # dataset_train.prepare()\n dataset_train = VIPDataset()\n dataset_train.load_vip(args.dataset, \"traintiny\")\n dataset_train.prepare()\n\n # Validation dataset\n # dataset_val = VIPDataset()\n # dataset_val.load_vip(args.dataset, \"val\")\n # dataset_val.prepare()\n dataset_val = VIPDataset()\n dataset_val.load_vip(args.dataset, \"traintiny\")\n dataset_val.prepare()\n\n # *** This training schedule is an example. Update to your needs ***\n\n # Fine tune all layers\n\n model.train(dataset_train, dataset_val,\n learning_rate=0.001,\n epochs=200,\n layers='all',\n period=config.SAVE_MODEL_PERIOD)\n\n # model.train(dataset_train, dataset_val,\n # learning_rate=0.0001,\n # epochs=150,\n # layers='all',\n # period=config.SAVE_MODEL_PERIOD)\n print(\"total\", (time() - t0), \"s\")\n"
] | [
[
"tensorflow.ConfigProto",
"tensorflow.Session"
]
] |
wlad111/pymc3 | [
"43432834be5bbca72caa32d40a848515eea554a8",
"43432834be5bbca72caa32d40a848515eea554a8"
] | [
"pymc3_ext/step_methods/hmc/hmc.py",
"pymc3_ext/tests/test_missing.py"
] | [
"import numpy as np\n\nfrom ..arraystep import Competence\nfrom pymc3_ext.vartypes import discrete_types\nfrom pymc3_ext.step_methods.hmc.integration import IntegrationError\nfrom pymc3_ext.step_methods.hmc.base_hmc import BaseHMC, HMCStepData, DivergenceInfo\n\n\n__all__ = ['HamiltonianMC']\n\n\ndef unif(step_size, elow=.85, ehigh=1.15):\n return np.random.uniform(elow, ehigh) * step_size\n\n\nclass HamiltonianMC(BaseHMC):\n R\"\"\"A sampler for continuous variables based on Hamiltonian mechanics.\n\n See NUTS sampler for automatically tuned stopping time and step size scaling.\n \"\"\"\n\n name = 'hmc'\n default_blocked = True\n generates_stats = True\n stats_dtypes = [{\n 'step_size': np.float64,\n 'n_steps': np.int64,\n 'tune': np.bool,\n 'step_size_bar': np.float64,\n 'accept': np.float64,\n 'diverging': np.bool,\n 'energy_error': np.float64,\n 'energy': np.float64,\n 'max_energy_error': np.float64,\n 'path_length': np.float64,\n 'accepted': np.bool,\n 'model_logp': np.float64,\n }]\n\n def __init__(self, vars=None, path_length=2., **kwargs):\n \"\"\"Set up the Hamiltonian Monte Carlo sampler.\n\n Parameters\n ----------\n vars : list of theano variables\n path_length : float, default=2\n total length to travel\n step_rand : function float -> float, default=unif\n A function which takes the step size and returns an new one used to\n randomize the step size at each iteration.\n step_scale : float, default=0.25\n Initial size of steps to take, automatically scaled down\n by 1/n**(1/4).\n scaling : array_like, ndim = {1,2}\n The inverse mass, or precision matrix. One dimensional arrays are\n interpreted as diagonal matrices. If `is_cov` is set to True,\n this will be interpreded as the mass or covariance matrix.\n is_cov : bool, default=False\n Treat the scaling as mass or covariance matrix.\n potential : Potential, optional\n An object that represents the Hamiltonian with methods `velocity`,\n `energy`, and `random` methods. It can be specified instead\n of the scaling matrix.\n target_accept : float, default 0.65\n Adapt the step size such that the average acceptance\n probability across the trajectories are close to target_accept.\n Higher values for target_accept lead to smaller step sizes.\n Setting this to higher values like 0.9 or 0.99 can help\n with sampling from difficult posteriors. Valid values are\n between 0 and 1 (exclusive). Default of 0.65 is from (Beskos et.\n al. 2010, Neal 2011). See Hoffman and Gelman's \"The No-U-Turn\n Sampler: Adaptively Setting Path Lengths in Hamiltonian Monte\n Carlo\" section 3.2 for details.\n gamma : float, default .05\n k : float, default .75\n Parameter for dual averaging for step size adaptation. Values\n between 0.5 and 1 (exclusive) are admissible. Higher values\n correspond to slower adaptation.\n t0 : float > 0, default 10\n Parameter for dual averaging. Higher values slow initial\n adaptation.\n adapt_step_size : bool, default=True\n Whether step size adaptation should be enabled. If this is\n disabled, `k`, `t0`, `gamma` and `target_accept` are ignored.\n model : pymc3.Model\n The model\n **kwargs : passed to BaseHMC\n \"\"\"\n kwargs.setdefault('step_rand', unif)\n kwargs.setdefault('target_accept', 0.65)\n super().__init__(vars, **kwargs)\n self.path_length = path_length\n\n def _hamiltonian_step(self, start, p0, step_size):\n n_steps = max(1, int(self.path_length / step_size))\n\n energy_change = -np.inf\n state = start\n div_info = None\n try:\n for _ in range(n_steps):\n state = self.integrator.step(step_size, state)\n except IntegrationError as e:\n div_info = DivergenceInfo('Divergence encountered.', e, state)\n else:\n if not np.isfinite(state.energy):\n div_info = DivergenceInfo(\n 'Divergence encountered, bad energy.', None, state)\n energy_change = start.energy - state.energy\n if np.abs(energy_change) > self.Emax:\n div_info = DivergenceInfo(\n 'Divergence encountered, large integration error.',\n None, state)\n\n accept_stat = min(1, np.exp(energy_change))\n\n if div_info is not None or np.random.rand() >= accept_stat:\n end = start\n accepted = False\n else:\n end = state\n accepted = True\n\n stats = {\n 'path_length': self.path_length,\n 'n_steps': n_steps,\n 'accept': accept_stat,\n 'energy_error': energy_change,\n 'energy': state.energy,\n 'accepted': accepted,\n 'model_logp': state.model_logp,\n }\n return HMCStepData(end, accept_stat, div_info, stats)\n\n @staticmethod\n def competence(var, has_grad):\n \"\"\"Check how appropriate this class is for sampling a random variable.\"\"\"\n if var.dtype in discrete_types or not has_grad:\n return Competence.INCOMPATIBLE\n return Competence.COMPATIBLE\n",
"import pytest\nfrom numpy import ma, array\nimport numpy\nimport pandas as pd\nfrom pymc3_ext import Model, Normal, sample_prior_predictive, sample, ImputationWarning\n\ndef test_missing():\n data = ma.masked_values([1, 2, -1, 4, -1], value=-1)\n with Model() as model:\n x = Normal('x', 1, 1)\n with pytest.warns(ImputationWarning):\n Normal('y', x, 1, observed=data)\n\n y_missing, = model.missing_values\n assert y_missing.tag.test_value.shape == (2,)\n\n model.logp(model.test_point)\n\n with model:\n prior_trace = sample_prior_predictive()\n assert set(['x', 'y']) <= set(prior_trace.keys())\n\n\ndef test_missing_pandas():\n data = pd.DataFrame([1, 2, numpy.nan, 4, numpy.nan])\n with Model() as model:\n x = Normal('x', 1, 1)\n with pytest.warns(ImputationWarning):\n Normal('y', x, 1, observed=data)\n\n y_missing, = model.missing_values\n assert y_missing.tag.test_value.shape == (2,)\n\n model.logp(model.test_point)\n\n with model:\n prior_trace = sample_prior_predictive()\n assert set(['x', 'y']) <= set(prior_trace.keys())\n\ndef test_missing_with_predictors():\n predictors = array([0.5, 1, 0.5, 2, 0.3])\n data = ma.masked_values([1, 2, -1, 4, -1], value=-1)\n with Model() as model:\n x = Normal('x', 1, 1)\n with pytest.warns(ImputationWarning):\n Normal('y', x * predictors, 1, observed=data)\n\n y_missing, = model.missing_values\n assert y_missing.tag.test_value.shape == (2,)\n\n model.logp(model.test_point)\n\n with model:\n prior_trace = sample_prior_predictive()\n assert set(['x', 'y']) <= set(prior_trace.keys())\n\n\ndef test_missing_dual_observations():\n with Model() as model:\n obs1 = ma.masked_values([1, 2, -1, 4, -1], value=-1)\n obs2 = ma.masked_values([-1, -1, 6, -1, 8], value=-1)\n beta1 = Normal('beta1', 1, 1)\n beta2 = Normal('beta2', 2, 1)\n latent = Normal('theta', shape=5)\n with pytest.warns(ImputationWarning):\n ovar1 = Normal('o1', mu=beta1 * latent, observed=obs1)\n with pytest.warns(ImputationWarning):\n ovar2 = Normal('o2', mu=beta2 * latent, observed=obs2)\n\n prior_trace = sample_prior_predictive()\n assert set(['beta1', 'beta2', 'theta', 'o1', 'o2']) <= set(prior_trace.keys())\n sample()\n\ndef test_internal_missing_observations():\n with Model() as model:\n obs1 = ma.masked_values([1, 2, -1, 4, -1], value=-1)\n obs2 = ma.masked_values([-1, -1, 6, -1, 8], value=-1)\n with pytest.warns(ImputationWarning):\n theta1 = Normal('theta1', mu=2, observed=obs1)\n with pytest.warns(ImputationWarning):\n theta2 = Normal('theta2', mu=theta1, observed=obs2)\n\n prior_trace = sample_prior_predictive()\n assert set(['theta1', 'theta2']) <= set(prior_trace.keys())\n sample()\n"
] | [
[
"numpy.random.uniform",
"numpy.abs",
"numpy.exp",
"numpy.random.rand",
"numpy.isfinite"
],
[
"numpy.array",
"pandas.DataFrame",
"numpy.ma.masked_values"
]
] |
MarceloFCandido/PIC | [
"884cdc3706fd00f7652cb3a04801c0c00fe7e73f"
] | [
"src/TR/src/classesRT.py"
] | [
"\"\"\"\n Arquivo: classesRT.py\n Reune as classes utilizadas no tracamento de raios, definindo os elementos\n que compoem o meio onde os raios serao tracados, definindo tambem os\n proprios raios.\n\"\"\"\n\nfrom eqDiferencialOrdinaria import eqDiferencialOrdinaria as EDO\nimport numpy as np\n\nclass ray(EDO):\n \"\"\"\n Herda: EDO\n Define, a partir da teoria matematica, o que e um raio, armazenando\n em arrays os seus pontos e direcoes ao longo do tempo.\n \"\"\"\n def __init__(self, dimension, XP, time = 0.):\n \"\"\"\n Definicao de construtor\n Recebe: dimension - numero de EDOs que definem o raio (4)\n XP - array de posicoes/direcoes ao longo do tempo\n time - array que guarda o tempo de transito do raio\n \"\"\"\n super(ray, self).__init__(dimension)\n self.XP = XP\n self.time = np.array([0.])\n\n def evaluate(self, Y, v):\n \"\"\"\n Definicao de funcao\n Avalia as quatro equacoes que definem o raio usando os pontos e\n direcoes passadas em Y e o modelo de velocidade definido em v.\n Recebe: Y - ultimos valores calculados pelo RK4 para a\n posicao e a direcao do raio em questao\n v - objeto velocidade que, quando chamado (utilizan-\n do a funcao __call__) retorna a velocidade no\n ponto (x, y) passado por parametro\n Retorna: retorno - array contendo os valores calculados pelas\n equacoes do raio\n \"\"\"\n retorno = np.zeros(4) # Array que servira de retorno\n Vxy = v(Y[0], Y[1], \"0\")\n iVxy = 1. / Vxy\n dVx = v(Y[0], Y[1], \"1x\")\n dVy = v(Y[0], Y[1], \"1y\")\n\n retorno[0] = Vxy * Vxy * Y[2] # dx/dt\n retorno[1] = Vxy * Vxy * Y[3] # dy/dt\n retorno[2] = iVxy * dVx # dPx/dt\n retorno[3] = iVxy * dVy # dPy/dt\n\n return retorno\n\nclass source(object):\n \"\"\"\n Herda: object\n Define a fonte de raios, que os cria de acordo com os parametros que re-\n cebeu.\n \"\"\"\n def __init__(self, posY, angMin, angMax, nRays, initialVelocity):\n \"\"\"\n Definicao de um construtor\n Recebe: posY - Posicao de onde partirao os raios\n angMin - Inicio do intervalo que sera iluminado\n pelos raios\n angMax - Fim desse intervalo\n nRays - Numero de raios a serem tracados\n initialVelocity - velocidade no ponto de partida dos\n raios\n \"\"\"\n self.posY = posY\n self.angMin = angMin\n self.angMax = angMax\n self.nRays = nRays\n self.initialVelocity = initialVelocity\n self.genRays()\n\n def genRays(self):\n \"\"\"\n Procedimento que cria os raios de acordo com os parametros da fonte.\n \"\"\"\n # Determinando 'passo angular'\n h = (self.angMax - self.angMin) / (self.nRays - 1)\n\n # Criando lista vazia\n self.rays = []\n\n for i in range(0, self.nRays):\n # Determinando angulo do raio\n ang = self.angMin + i * h\n # Criando vetor posicao-direcao do raio\n Y = np.zeros((4, 2))\n Y[:, 0] = np.nan # Para permitir o anexamento no metodo 'go'\n Y[0, 1] = Y[1, 1] = 0. # Posicao inicial\n Y[2, 1] = np.sin(ang) / self.initialVelocity # Direcao inicial\n Y[3, 1] = np.cos(ang) / self.initialVelocity\n\n # Criando raio auxiliar\n Aux = ray(4, Y)\n\n # Colocando raio na lista\n self.rays.append(Aux)\n\nclass velocity(object):\n \"\"\"\n Herda: object\n Define a velocidade como uma funcao quadratica com coeficientes a, b e c\n bem como as derivadas dessa funcao\n \"\"\"\n def __init__(self, type, a = 0., b = 0., c = 1.):\n \"\"\"\n Definicao de um construtor\n Recebe: type - tipo de velocidade (neste trabalho foi defi-\n nido apenas o modelo quadratico de veloci-\n dade, entretanto, essa variavel permite que\n mais modelos sejam implementados)\n a, b, c - coeficientes da funcao quadratica que\n define a velocidade\n \"\"\"\n self.type = type\n self.a = a\n self.b = b\n self.c = c\n\n def getGradientVelocity(self, x, y, derv = \"0\"):\n \"\"\"\n Funcao que retorna a velocidade (ou uma de suas derivadas) em um da-\n do ponto (x, y)\n Recebe x - coordenada x do ponto em que se deseja calcular\n a velocidade\n y - coordenada y do mesmo ponto\n derv - a derivada desejada\n Retorna a velocidade no ponto (x, y) ou a derivada desejada\n da funcao\n \"\"\"\n\n return {\n \"0\" : self.a * x + self.b * y + self.c,\n \"1x\" : self.a,\n \"1y\" : self.b\n }.get(derv, \"0\")\n\n def __call__(self, x, y, derv = \"0\"):\n \"\"\"\n Uma funcao call para uma classe permite que um objeto desta\n seja chamado como uma funcao. No caso de um objeto velocity ser\n chamado, ele retornara a velocidade v_type(x, y), sendo type o tipo\n de velocidade a ser retornada e derv a derivada da velocidade\n \"\"\"\n return {\n '0' : self.getGradientVelocity(x, y, derv)\n }.get(self.type, '0')\n\nclass interface(object):\n \"\"\"\n Herda: object\n Responsavel por permitir a interpretacao de uma interface como uma reta,\n na sua forma parametrica, ou seja, com um vetor diretor e um ponto por\n onde ela passa. Alem disso, sao definidos os seus pontos extremos (pon-\n tos laterais).\n \"\"\"\n\n def __init__(self, diretor, lateralPoints):\n \"\"\"\n Definicao de construtor\n Recebe: diretor - vetor diretor da interface\n lateralPoints - pontos extremos da interface\n \"\"\"\n self.vDiretor = diretor\n self.vNormal = np.array([-diretor[1], diretor[0]])\n self.a = diretor[1] / diretor[0]\n self.b = lateralPoints[0]\n self.lP = lateralPoints\n\n def __call__(self, x):\n \"\"\"\n Funcao que possibilita que, ao se chamar um objeto da classe inter-\n face, passando-se um valor na coordenada x para ele, se obtenha o\n valor y correspondente, como em uma reta.\n Recebe: x - coordenada nas abscissas\n Retorna: y - valor correspondente a x nas ordenadas\n \"\"\"\n return self.a * x + self.b\n\nclass layer(object):\n \"\"\"\n Herda: object\n Define como e interpretada uma camada. A camada e interpretada como\n possuindo uma interface superior e uma interface inferior. Entre ambas\n as interfaces, ha uma parcela do meio que possui uma determinada velo-\n cidade.\n \"\"\"\n def __init__(self, mediumsDimension, lateralPoints, velocity):\n \"\"\"\n Definicao de construtor\n Recebe: mediumsDimension - dimensao do meio\n lateralPoints - pontos extremos da interface supe-\n rior\n velocity - modelo de velocidade para a camada\n \"\"\"\n self.mediumsDimension = mediumsDimension\n self.lateralPoints = lateralPoints\n self.velocity = velocity\n self.makeDirector()\n self.supInt = interface(self.director, lateralPoints)\n\n def makeDirector(self):\n \"\"\"\n Metodo responsavel por criar um vetor diretor para a camada (e,\n consequentemente, para sua interface superior)\n \"\"\"\n # Criando vetor paralelo a interface\n self.director = np.array([self.mediumsDimension[0],\n self.lateralPoints[1] - self.lateralPoints[0]])\n # Calculando a norma do vetor\n directorNorm = np.linalg.norm(self.director)\n # Normalizando o vetor\n self.director /= directorNorm\n\n def setInfInt(self, Int):\n \"\"\"\n Metodo responsavel por setar a interface inferior da camada\n \"\"\"\n self.infInt = Int\n\nclass medium(object):\n \"\"\"\n Herda: object\n Define o meio por meio dos seus principais elementos\n \"\"\"\n def __init__(self, dimension, s0, layers):\n \"\"\"\n Definicao de construtor\n Recebe: dimension - dimensoes do meio\n s0 - fonte que dispara raios no meio\n layers - camadas (e, consequentemente, interfaces do\n meio)\n \"\"\"\n self.dimension = dimension\n self.s0 = s0\n self.layers = layers\n"
] | [
[
"numpy.zeros",
"numpy.cos",
"numpy.array",
"numpy.sin",
"numpy.linalg.norm"
]
] |
pmoe7/Stock-Price-Prediction | [
"062874fc2565fb14b5a25856baeabdcf705c646f"
] | [
"src/model.py"
] | [
"\"\"\"\r\n-------------------------------------------------------\r\nmodel.py\r\n[program description]\r\n-------------------------------------------------------\r\nAuthor: Mohammed Perves\r\nID: 170143440\r\nEmail: [email protected]\r\n__updated__ = \"2018-06-20\"\r\n-------------------------------------------------------\r\n\"\"\"\r\nimport csv\r\nimport numpy as np\r\nfrom sklearn.svm import SVR\r\nimport matplotlib.pyplot as plt\r\nfrom sklearn import linear_model\r\nfrom sklearn import preprocessing\r\nimport stock_data\r\n#import matplotlib.animation as animation\r\n#from matplotlib import style\r\n#from googlefinance.client import get_price_data\r\n#from datetime import datetime\r\nfrom sklearn.externals import joblib\r\n\r\nscaler = preprocessing.StandardScaler()\r\ndates = []\r\nprices = []\r\n\r\n\"\"\"\r\ndef animate(symbol):\r\n graph_data = open('example.txt','r').read()\r\n lines = graph_data.split('\\n')\r\n param = {\r\n 'q': \"TSLA\", # Stock symbol (ex: \"AAPL\")\r\n 'i': \"3600\", # Interval size in seconds (\"86400\" = 1 day intervals)\r\n 'x': \"NASD\", # Stock exchange symbol on which stock is traded (ex: \"NASD\")\r\n 'p': \"1M\" # Period (Ex: \"1Y\" = 1 year)\r\n }\r\n df = get_price_data(param)\r\n dates = df.index.tolist()\r\n xs = []\r\n for value in dates:\r\n xs.append(value.timestamp())\r\n ys = df[\"Close\"].tolist()\r\n ax1.clear()\r\n ax1.plot(xs, ys\r\n \r\n return\r\n\"\"\"\r\n\r\n\r\ndef normalize_data(data):\r\n np_data = np.array(data, dtype=float)\r\n np_data = np_data.reshape(-1,1)\r\n scaler.fit(np_data)\r\n normalized = scaler.transform(np_data)\r\n # inverse transform and print the first 5 rows\r\n \r\n return normalized\r\n\r\ndef inverse_normalization(data):\r\n inversed = scaler.inverse_transform(data)\r\n \r\n return inversed\r\n\r\ndef format_dates(rows):\r\n for row in rows:\r\n #date=row[:4] + row[5:7] + row[8:]\r\n date=row[5:7] + row[8:]\r\n dates.append(int(date))\r\n\r\ndef get_data(filename):\r\n with open(filename, 'r') as csvfile:\r\n csvFileReader = csv.reader(csvfile)\r\n next(csvFileReader) # skipping column names\r\n for row in csvFileReader:\r\n date = row.split('-')[1] + row[0].split('-')[2]\r\n dates.append(int(date))\r\n prices.append(float(row[4]))\r\n return\r\n\r\ndef train_model(dates, prices):\r\n dates = np.reshape(dates,(len(dates), 1)) # converting to matrix of n X 1\r\n #svr_lin = SVR(kernel= 'linear', C= 1e3)\r\n #svr_poly = SVR(kernel= 'poly', degree= 2)\r\n svr_rbf = SVR(kernel= 'rbf', C= 1e3, gamma= 0.3) # defining the support vector regression models\r\n svr_rbf.fit(dates, prices) # fitting the data points in the models\r\n # Create linear regression object\r\n regr = linear_model.LinearRegression()\r\n # Train the model using the training sets\r\n regr.fit(dates, prices)\r\n \r\n plt.scatter(dates, prices, color= 'black', label= 'Data') # plotting the initial datapoints \r\n plt.plot(dates, svr_rbf.predict(dates), color= 'red', label= 'RBF model') # plotting the line made by the RBF kernel\r\n #plt.plot(dates,svr_lin.predict(dates), color= 'green', label= 'Linear model') # plotting the line made by linear kernel\r\n #plt.plot(dates,svr_poly.predict(dates), color= 'blue', label= 'Polynomial model') # plotting the line made by polynomial kernel\r\n plt.plot(dates, regr.predict(dates), color='green', label= 'Linear model', linewidth=3)\r\n \r\n plt.xticks(())\r\n plt.xlabel('Date')\r\n plt.ylabel('Stock Price')\r\n plt.title('Support Vector Regression')\r\n plt.legend()\r\n \r\n # save the model to disk\r\n filename = 'finalized_model.sav'\r\n joblib.dump(svr_rbf, filename)\r\n plt.show()\r\n\r\n return #svr_rbf.predict(x)[0], regr.predict(x)[0]\r\n #svr_rbf.predict(x)[0], svr_lin.predict(x)[0], svr_poly.predict(x)[0]\r\n\r\n#get_data('TSLA_annual.csv') # calling get_data method by passing the csv file to it'\r\n\r\ndata = stock_data.fetch_data(\"AAPL\")\r\nprices = data['close']\r\nformat_dates(data.index.values)\r\n#dates = normalize_data(dates)\r\n#prices = normalize_data(prices)\r\n#print(data.index.values)\r\n#print(dates)\r\ntrain_model(dates, prices)\r\nprint(\"Finished Training Model...\")"
] | [
[
"matplotlib.pyplot.legend",
"matplotlib.pyplot.xticks",
"sklearn.svm.SVR",
"sklearn.linear_model.LinearRegression",
"matplotlib.pyplot.title",
"matplotlib.pyplot.show",
"matplotlib.pyplot.ylabel",
"sklearn.preprocessing.StandardScaler",
"sklearn.externals.joblib.dump",
"numpy.array",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.scatter"
]
] |
alishiba14/Neural-Class-Alignement-for-OSM-and-KG- | [
"0c7d15e27fe85287043273f187c9aff3d8c438ae"
] | [
"Scripts/schemaMatch.py"
] | [
"#!/usr/bin/env python\n# coding: utf-8\n\n\n\n\nfrom sklearn.model_selection import KFold\nimport pandas as pd\nimport numpy as np\nfrom keras.preprocessing.sequence import pad_sequences\nfrom skmultilearn.problem_transform import LabelPowerset\nfrom imblearn.over_sampling import RandomOverSampler\nfrom keras.models import Model\nfrom keras.losses import binary_crossentropy\nfrom keras.optimizers import Adam\nfrom keras.layers import Input, Dense\nimport pickle\nimport psycopg2\nimport scipy\nimport keras\nfrom tqdm import tqdm\nfrom keras import activations\nfrom keras.models import load_model\nfrom keras import backend as K\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport tensorflow as tf\nimport random as rn\nimport os\nimport sys\n\ninputFile = sys.argv[1]\noutputFile = sys.argv[2]\nthreshold = sys.argv[3]\n\n\ndata = pd.read_csv(inputFile, sep='\\t', encoding='utf-8',)\nlatentSpace = 30\n\n\nnum = data._get_numeric_data()\nnum[num > 1] = 1\nlabelName = []\ncolNameOsm = []\ncolNameWiki = []\nfor col in data.columns:\n if 'cls_' in col:\n labelName.append(col)\n if 'osmTagKey_' in col:\n try:\n if data[col].value_counts()[1]>50:\n colNameOsm.append(col)\n except KeyError:\n KeyError\n elif 'prop_' in col and 'prop_instance of' not in col:\n colNameWiki.append(col)\nlabels = data[labelName]\ncolumnsOSM = data[colNameOsm]\ncolumnsWiki = data[colNameWiki]\nlabelNameDict = {}\nfor i in range(len(labelName)):\n labelNameDict[i] = labelName[i]\ncolumnsWikiDict = {}\nfor i in range(len(colNameWiki)):\n columnsWikiDict[i] = colNameWiki[i]\ncolNameOsmDict = {}\nfor i in range(len(colNameOsm)):\n colNameOsmDict[i] = colNameOsm[i]\n #print(c)\ncolumns = colNameOsm+colNameWiki\ncolumnsDict = {}\nfor i in range(len(columns)):\n columnsDict[i] = columns[i]\n\nfold_var = 1\nkf = KFold(n_splits = 3, random_state = 42, shuffle = True)\ntrain_index, val_index = list(kf.split(columnsOSM,labels))[0]\nosm_train = columnsOSM.iloc[train_index].values\nosm_test = columnsOSM.iloc[val_index].values\nwiki_train = columnsWiki.iloc[train_index].values\nwiki_test = columnsWiki.iloc[val_index].values\ny_train = labels.iloc[train_index].values\ny_test = labels.iloc[val_index].values\n\n\n# generate training data for discriminator\ndef generate_adverse_labels(osm, wiki):\n osm_part = np.ones((osm.shape[0], 1))\n wiki_part = np.zeros((wiki.shape[0], 1))\n return np.concatenate((osm_part, wiki_part))\n\n\ndef balance(x,y):\n # Import a dataset with X and multi-label y\n\n lp = LabelPowerset()\n ros = RandomOverSampler(random_state=42)\n\n # Applies the above stated multi-label (ML) to multi-class (MC) transformation.\n yt = lp.transform(y)\n\n X_resampled, y_resampled = ros.fit_sample(x, yt)\n # Inverts the ML-MC transformation to recreate the ML set\n y_resampled = lp.inverse_transform(y_resampled)\n y_resampled = y_resampled.toarray()\n return X_resampled, y_resampled\n\n\n\n\n\ndef transform_input(osm_train, osm_test, wiki_train, wiki_test, y_train, y_test):\n \n #total length of the input = OSM tags + OSM keys + KG properties\n maxlen =osm_train.shape[1]+wiki_train.shape[1]\n osm_train_pad = pad_sequences(osm_train, padding='post', maxlen=maxlen)\n osm_test_pad = pad_sequences(osm_test, padding='post', maxlen=maxlen)\n wiki_train_pad = pad_sequences(wiki_train, padding='pre', maxlen=maxlen)\n wiki_test_pad = pad_sequences(wiki_test, padding='pre', maxlen=maxlen)\n \n print(\"osm_train\", osm_train_pad.shape, \"wiki_train\", wiki_train_pad.shape)\n x_train = np.concatenate((osm_train_pad, wiki_train_pad))\n print(\"x_train\", x_train.shape)\n\n print(\"osm_test\", osm_test_pad.shape, \"wiki_test\", wiki_test_pad.shape)\n x_test = np.concatenate((osm_test_pad, wiki_test_pad))\n print(\"x_test\", x_test.shape)\n\n print(\"y_train\", y_train.shape)\n y_train = np.concatenate((y_train, y_train))\n print(\"y_train\", y_train.shape)\n\n print(\"y_test\", y_test.shape)\n y_test = np.concatenate((y_test, y_test))\n print(\"y_test\", y_test.shape)\n\n adverse_train = generate_adverse_labels(osm_train, wiki_train)\n print(\"adverse_train\", adverse_train.shape)\n adverse_test = generate_adverse_labels(osm_test, wiki_test)\n print(\"adverse_test\", adverse_test.shape)\n\n \n return x_train, y_train, adverse_train, x_test, y_test, adverse_test\n\n\nx_train, y_train, adverse_train, x_test, y_test, adverse_test = transform_input(osm_train, osm_test, wiki_train, wiki_test, y_train, y_test)\n\n#loss for adversarial component\ndef maxLoss(y_true, y_pred):\n return -1.0 * binary_crossentropy(y_true, y_pred)\n\n\n\nclass SchemaModel:\n\n def __init__(self, no_inputs, no_outputs):\n optimizer = Adam(0.0001, 0.5)\n self.model = self.define_discriminator(no_inputs, no_outputs)\n \n losses = {\n \"class\": 'binary_crossentropy',\n \"adverse\": maxLoss,\n }\n self.model.compile(loss=losses,\n optimizer=optimizer,\n metrics=['accuracy'])\n \n \n def define_discriminator(self, no_inputs, no_outputs):\n inputs = Input(shape=(no_inputs,), name = 'input')\n \n X_1 = Dense(100, activation='relu', name = 'layer1')(inputs)\n latent_rep = Dense(latentSpace, activation='relu', name = 'latentRep')(X_1)\n\n # KG classfication\n fc_1 = Dense(latentSpace, activation='relu', name = 'layer3')(latent_rep)\n fc_2 = Dense(latentSpace , activation='relu', name = 'layer4')(fc_1)\n \n classifier = Dense(no_outputs, activation='sigmoid', name = 'class')(fc_2)\n \n #adversarial compenent\n adverse= Dense(1, activation='softmax', name = 'adverse')(latent_rep)\n \n \n model = Model(inputs, [classifier, adverse])\n return model\n\n\n\n\n\nos.environ['PYTHONHASHSEED'] = '0'\n\n# Setting the seed for numpy-generated random numbers\nnp.random.seed(0)\n\n# Setting the seed for python random numbers\nrn.seed(1254)\n\n# Setting the graph-level random seed.\ntf.set_random_seed(89)\n\nfrom keras import backend as K\n\nsession_conf = tf.ConfigProto(\n intra_op_parallelism_threads=1,\n inter_op_parallelism_threads=1)\n\n#Force Tensorflow to use a single thread\nsess = tf.Session(graph=tf.get_default_graph(), config=session_conf)\n\nK.set_session(sess)\n\n\nm = SchemaModel(x_train.shape[1], y_train.shape[1])\n\n\nm.model.summary()\n\nhist = m.model.fit(x=x_train, y=[y_train, adverse_train], epochs=100, shuffle=True)\n\ndef getClassIndex(clsId, y_test):\n t = np.argwhere(y_test>0)\n clsIndex = []\n for i in range(len(t)):\n if t[i][1] == clsId:\n clsIndex.append(t[i][0])\n return clsIndex\n\ndef getClassAcc(y_test, y_pred, cls, threshold):\n indexes = getClassIndex(cls, y_test)\n total_number = len(indexes)\n fn = 0\n tp = 0\n fp = 0\n for i in range(len(y_pred)):\n if i in indexes:\n if y_pred[i][cls]>threshold:\n tp = tp+1\n elif y_pred[i][cls]<threshold:\n fn = fn+1\n elif i not in indexes:\n if y_pred[i][cls]>threshold:\n fp = fp+1\n try:\n precision = tp/(tp+fp)\n except ZeroDivisionError:\n precision = 0\n try:\n recall = tp/(tp+fn)\n except ZeroDivisionError:\n recall = 0\n return cls, total_number, precision, recall\n \n\n#a = m.model.predict(x_test)\n\n\n#get per class accuracy\n#for i in range(y_test.shape[1]):\n# print(getClassAcc(y_test, a[0],i , 0.9))\n\n#create the array for testing with one row for 1 input\ntestKeyTag = np.zeros((x_train.shape[1], x_train.shape[1]))\nfor i in range(len(testKeyTag)):\n testKeyTag[i][i] = 1\n\n#get the activations of the last layer\nget_layer_output = K.function([m.model.layers[0].input],\n [m.model.layers[5].output])\n\nlayer_output = get_layer_output(testKeyTag)[0]\ndef getMatches():\n listPrecRecall = []\n for i in range(len(testKeyTag)):\n if '=' in columnsDict[np.argmax(testKeyTag[i])] and not any(map(str.isdigit, columnsDict[np.argmax(testKeyTag[i])])) and '=yes' not in columnsDict[np.argmax(testKeyTag[i])] and '=no' not in columnsDict[np.argmax(testKeyTag[i])]:\n for j in range(len(layer_output[i])):\n listPrecRecall.append((columnsDict[np.argmax(testKeyTag[i])].replace('osmTagKey_',''),labelNameDict[j].replace('cls_',''), layer_output[i][j]))\n return listPrecRecall\n\nmatches = getMatches()\nmatchDF = pd.DataFrame(matches, columns=['tag', 'cls', 'value'])\nmatchDF = matchDF[matchDF['value']>threshold]\nmatchDF.to_csv(outputFile, sep='\\t', encoding='utf-8', index=False)\n\n"
] | [
[
"numpy.ones",
"numpy.zeros",
"numpy.argwhere",
"pandas.read_csv",
"pandas.DataFrame",
"numpy.random.seed",
"numpy.argmax",
"tensorflow.set_random_seed",
"tensorflow.get_default_graph",
"sklearn.model_selection.KFold",
"numpy.concatenate",
"tensorflow.ConfigProto"
]
] |
gazprom-neft/seismiqb | [
"d4906d41c79407c99cfa6f91d6005c0e453d1138"
] | [
"seismiqb/src/controllers/extender.py"
] | [
"\"\"\" A holder for horizon extension steps inherited from `.class:Enhancer` with:\n - redifined get_mask_transform_ppl to thin out loaded mask\n - making an iterative inference to cover the holes in a given horizon.\n\"\"\"\nimport gc\nfrom copy import copy\nfrom pprint import pformat\nfrom time import perf_counter\n\nimport numpy as np\nimport torch\n\nfrom .enhancer import Enhancer\n\nfrom ..labels import Horizon\nfrom ..samplers import ExtensionGrid\n\nfrom ...batchflow import Pipeline, Config, Notifier, Monitor\nfrom ...batchflow import B, F, C, V, P, R\n\n\n\nclass Extender(Enhancer):\n \"\"\" Provides interface for train, inference and quality assesment for the task of horizon extension. \"\"\"\n #pylint: disable=attribute-defined-outside-init\n DEFAULTS = Config({\n **Enhancer.DEFAULTS,\n 'inference': {\n 'batch_size': None,\n 'crop_shape': None,\n 'width': 3,\n\n 'n_steps': 100,\n 'stride': 32,\n 'threshold': 10,\n\n 'prefetch': 0,\n }\n })\n\n def inference(self, horizon, model, config=None, **kwargs):\n \"\"\" Fill the holes of a given horizon with the supplied model.\n\n Works by making predictions near the horizon boundaries and stitching them to the original one.\n \"\"\"\n # Prepare parameters\n config = config or {}\n config = Config({**self.config['common'], **self.config['inference'], **config, **kwargs})\n n_steps, stride, batch_size, crop_shape = config.get(['n_steps', 'stride', 'batch_size', 'crop_shape'])\n threshold = config.get('threshold', 25)\n prefetch = config.get('prefetch', 0)\n\n # Log: pipeline_config to a file\n self.log_to_file(pformat(config.config, depth=2), '末 inference_config.txt')\n\n # Start resource tracking\n if self.monitor:\n monitor = Monitor(['uss', 'gpu', 'gpu_memory'], frequency=0.5, gpu_list=self.gpu_list)\n monitor.__enter__()\n\n # Make dataset and copy horizon\n horizon = copy(horizon)\n dataset = self.make_dataset(horizon=horizon)\n\n prev_len = initial_len = len(horizon)\n self.log(f'Inference started for {n_steps} steps with stride {stride}')\n notifier = Notifier(self.config.bar,\n desc='Extender inference',\n file=self.make_savepath('末 inference.log'))\n\n start_time = perf_counter()\n for i in notifier(range(n_steps)):\n # Create grid of crops near horizon holes\n grid = ExtensionGrid(horizon=horizon, crop_shape=crop_shape,\n batch_size=batch_size, stride=stride,\n top=1, threshold=5)\n config['grid'] = grid\n\n # Create pipeline TODO: make better `add_model`\n inference_pipeline = self.get_inference_template() << config << dataset\n inference_pipeline.models.add_model('model', model)\n inference_pipeline.run(n_iters=grid.n_iters, prefetch=prefetch)\n\n # Merge surfaces on crops to the horizon itself\n for patch_horizon in inference_pipeline.v('predicted_horizons'):\n merge_code, _ = Horizon.verify_merge(horizon, patch_horizon,\n mean_threshold=0.5, adjacency=1)\n if merge_code == 3:\n _ = horizon.overlap_merge(patch_horizon, inplace=True)\n\n # Log length increase\n curr_len = len(horizon)\n if (curr_len - prev_len) < threshold:\n break\n self.log(f'Iteration {i}: extended from {prev_len} to {curr_len}, + {curr_len - prev_len}')\n prev_len = curr_len\n\n # Cleanup\n gc.collect()\n inference_pipeline.reset('variables')\n\n notifier.close()\n elapsed = perf_counter() - start_time\n\n # Log: resource graphs\n if self.monitor:\n monitor.__exit__(None, None, None)\n monitor.visualize(savepath=self.make_savepath('末 inference_resource.png'), show=self.plot)\n\n self.log(f'Total points added: {curr_len - initial_len}')\n\n torch.cuda.empty_cache()\n horizon.name = f'extended_{horizon.name[8:]}' # get rid of `copy_of_` postfix\n\n self.inference_log = {\n 'elapsed': elapsed,\n 'added_points': curr_len - initial_len,\n }\n return horizon\n\n\n def distortion_pipeline(self):\n \"\"\" Defines transformations performed with `masks` component. \"\"\"\n def functor(scale):\n return lambda m: np.sin(m[:, 0] * scale)\n\n return (\n Pipeline()\n .transpose(src='masks', order=(1, 2, 0))\n .filter_out(src='masks', dst='prior_masks',\n expr=lambda m: m[:, 0],\n low=P(R('uniform', low=0., high=0.4)),\n length=P(R('uniform', low=0.30, high=0.5)))\n .filter_out(src='prior_masks', dst='prior_masks',\n expr=F(functor)(R('uniform', low=15, high=35)), low=0.0, p=0.7)\n .transpose(src=['masks', 'prior_masks'], order=(2, 0, 1))\n )\n\n\n def get_inference_template(self):\n \"\"\" Defines inference pipeline. \"\"\"\n inference_template = (\n Pipeline()\n\n # Init everything\n .init_variable('predicted_horizons', default=[])\n\n # Load data\n .make_locations(generator=C('grid'))\n .load_cubes(dst='images')\n .create_masks(dst='prior_masks', width=C('width', default=3))\n .adaptive_reshape(src=['images', 'prior_masks'])\n .normalize(src='images')\n .concat_components(src=['images', 'prior_masks'], dst='images', axis=1)\n\n # Use model for prediction\n .predict_model('model',\n B('images'),\n fetches='predictions',\n save_to=B('predicted_masks', mode='w'))\n .masks_to_horizons(src_masks='predicted_masks', threshold=0.5, minsize=16,\n dst='horizons', skip_merge=True)\n .update(V('predicted_horizons', mode='e'), B('horizons'))\n )\n return inference_template\n\n\n # One method to rule them all\n def run(self, cube_paths=None, horizon_paths=None, horizon=None, **kwargs):\n \"\"\" Run the entire procedure of horizon extension. \"\"\"\n dataset = self.make_dataset(cube_paths=cube_paths, horizon_paths=horizon_paths, horizon=horizon)\n horizon = dataset.labels[0][0]\n\n model = self.train(horizon=horizon, **kwargs)\n\n prediction = self.inference(horizon, model, **kwargs)\n prediction = self.postprocess(prediction)\n info = self.evaluate(prediction, dataset=dataset)\n return prediction, info\n"
] | [
[
"torch.cuda.empty_cache",
"numpy.sin"
]
] |
YannHyaric/evolutionary-computation | [
"af7778fd1b5d60a1e5630b483b55257adac0bbc6"
] | [
"main.py"
] | [
"import sys\n\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nfrom ppa.ppa import prey_predator_algorithm\nfrom ppa.config import Config\nfrom acs.objective import fitness, fitness_population\nfrom acs.instance import Instance, print_instance\n\ndef read_files(instance_config_filename, config_filename):\n if instance_config_filename is None:\n instance = Instance.load_test()\n else:\n instance = Instance.load_from_file(instance_config_filename)\n\n # print_instance(instance)\n # print(\"\")\n\n if config_filename is None:\n config = Config.load_test()\n else:\n config = Config.load_from_file(config_filename)\n\n return (instance, config)\n\n\n# assert(len(sys.argv) >= 2)\ninstance_config_filename = None\nif (len(sys.argv) >= 2):\n instance_config_filename = sys.argv[1]\n\nconfig_filename = None\nif (len(sys.argv) >= 3):\n config_filename = sys.argv[2]\n\nnum_repetitions = 10\n\n(instance, config) = read_files(instance_config_filename, config_filename)\nbest_fitness = np.zeros((config.num_iterations + 1, num_repetitions)) # Um valor extra para salvar os valores iniciais\nperf_counter = np.zeros((config.num_iterations + 1, num_repetitions))\nprocess_time = np.zeros((config.num_iterations + 1, num_repetitions))\n\nfor i in range(num_repetitions):\n (population, survival_values) = prey_predator_algorithm(instance, config, fitness_population, best_fitness=best_fitness[:,i], perf_counter=perf_counter[:,i], process_time=process_time[:,i])\n print('#{}\\n'.format(i))\n print('Survival values:\\n{}\\n'.format(survival_values))\n print('Best Individual:\\n{}\\n'.format(population[0]))\n\nmean_best_fitness = np.mean(best_fitness, axis=1)\nmean_perf_counter = np.mean(perf_counter, axis=1)\nmean_process_time = np.mean(process_time, axis=1)\n\nprint('Statistics:')\nprint('Fitness:\\n{}\\n'.format(mean_best_fitness))\nprint('perf_counter:\\n{}\\n'.format(mean_perf_counter))\nprint('process_time:\\n{}\\n'.format(mean_process_time))\n\nfig = plt.figure()\nfig.suptitle('PPA: perf_counter vs. process_time')\nplt.plot(mean_perf_counter, 'r.')\nplt.plot(mean_process_time, 'b.')\nplt.show()\n\nfig = plt.figure()\nfig.suptitle('PPA: best fitness')\nplt.plot(mean_best_fitness, 'r')\nplt.show()\n"
] | [
[
"numpy.zeros",
"matplotlib.pyplot.figure",
"matplotlib.pyplot.show",
"matplotlib.pyplot.plot",
"numpy.mean"
]
] |
ADCenterNetwork/discern-fmk | [
"4781f1a986f7b24f298b2729b87ddee4227cb1d0"
] | [
"first_neural_network/node.py"
] | [
"import ast\nimport numpy as np\nimport torch as torch\nimport torch.nn as nn\nimport torch.nn.functional as F\n\ndef get_descendants(node, ls):\n for child in node.children:\n ls.append(child)\n get_descendants(child, ls)\n return ls\n\n\nclass Node():\n '''\n For each node we store its parent and children nodes, as well as, its node type and its vector \n representation\n '''\n def __init__(self, node, depth, parent = None):\n self.node = node\n self.children = []\n self.parent = parent\n self.type = self.get_node_type(node)\n self.vector = []\n self.combined_vector = []\n self.leaves = None\n self.depth = depth\n self.position = None\n self.siblings = None\n self.y = None\n self.pool = None\n\n\n def get_node_type(self, node):\n if node.__class__.__name__ == 'FunctionDef':\n if 'wrap' in node.name:\n return 'wrap'\n else:\n return node.__class__.__name__\n else:\n return node.__class__.__name__\n\n\n def __str__(self):\n return self.type\n\n #Returns the children nodes of each node\n def get_children(self):\n ls = []\n for child in ast.iter_child_nodes(self.node):\n #nodeChild = Node(child, self)\n ls.append(child)\n return ls\n\n def descendants(self):\n '''\n This function will return all of the nodes under the node itself.\n Note: the node itself is considered a descendant. This is done because it's useful when obtaining\n all of the nodes (otherwise we would miss the 'Module' node)\n '''\n ls = [self]\n return get_descendants(self, ls)\n\n # Assigns the vector embedding to each node\n def set_vector(self, df):\n if self.type in df.columns:\n vector = df[self.type]\n else:\n num = len(df['Yield'])\n vector = [0 for i in range(num)]\n \n if type(vector) == torch.Tensor:\n self.vector = vector\n else:\n self.vector = torch.tensor(vector).float().requires_grad_()\n \n def set_combined_vector(self, vector):\n self.combined_vector = vector\n '''\n # Assigns the number of leaves nodes under each node\n def set_l(self, leaves_nodes):\n self.leaves_nodes = leaves_nodes\n '''\n def get_leaves(self):\n # TODO determinar cuándo hace falta hacer esto\n leaves = []\n descendants = self.descendants()\n for descendant in descendants:\n if descendant.children == []:\n leaves.append(descendant)\n return leaves\n\n def set_leaves(self):\n self.leaves = self.get_leaves()\n\n\n def set_y(self, y):\n self.y = y\n\n\n def set_pool(self, pool):\n self.pool = pool\n\n def set_children(self, child):\n self.children.append(child)\n\n def set_matrix_and_coeffs(self, matrix, t,l,r):\n self.matrix = matrix\n self.coeff_t = t\n self.coeff_l = l\n self.coeff_r = r"
] | [
[
"torch.tensor"
]
] |
Lucas-Marcelino/CV_Pi-VII | [
"a7fdc0955e9710f351a7d16278de2093e9e84c69"
] | [
"Documentacao/17-retroprojecao.py"
] | [
"import cv2\nimport numpy as np\n\nroi = cv2.imread('banana.jpg')\nhsv = cv2.cvtColor(roi,cv2.COLOR_BGR2HSV)\n\ntarget = cv2.imread('banana_recortada.png')\nhsvt = cv2.cvtColor(target,cv2.COLOR_BGR2HSV)\n\n# calculating object histogram\nroihist = cv2.calcHist([hsv],[0, 1], None, [180, 256], [0, 180, 0, 256] )\n\n# normalize histogram and apply backprojection\ncv2.normalize(roihist,roihist,0,255,cv2.NORM_MINMAX)\ndst = cv2.calcBackProject([hsvt],[0,1],roihist,[0,180,0,256],1)\n\n# Now convolute with circular disc\ndisc = cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(5,5))\ncv2.filter2D(dst,-1,disc,dst)\n\n# threshold and binary AND\nret,thresh = cv2.threshold(dst,50,255,0)\nthresh = cv2.merge((thresh,thresh,thresh))\nres = cv2.bitwise_and(target,thresh)\n\nres = np.vstack((target,thresh,res))\ncv2.imwrite('res.jpg',res)"
] | [
[
"numpy.vstack"
]
] |
LoLongE/FaceRecognition | [
"5730e1e49fe15c295d002c760e7c1b2491113609"
] | [
"Function.py"
] | [
"# DB Server http://192.168.0.154:8080\nimport face_recognition_api\nimport cv2\nimport os\nimport pickle\nimport datetime\nimport cx_Oracle\nimport pandas as pd\nimport csv\n\ndef getTime(type_print):\n if type_print == 1:\n return datetime.datetime.now().strftime('%Y-%m-%d %H-%M')\n else:\n return datetime.datetime.now()\n\ndef makeDir(dir_name):\n path = \"./\"+dir_name\n if not os.path.isdir(\"%s\" %path):\n os.mkdir(\"%s\" %path)\n os.chdir(\"%s\" % path)\n\ndef printInfo(now, now2, small_frame):\n font = cv2.FONT_HERSHEY_DUPLEX\n cv2.putText(small_frame , \"Start:\" + str(now),(20,50), font,1.0,(255,255,255),1)\n cv2.putText(small_frame , \"End:\" + str(now2),(20,100), font,1.0,(255,255,255),1)\n cv2.putText(small_frame , \"Processing: \" + str(now2-now),(20,150), font,1.0,(255,255,255),1)\n cv2.putText(small_frame, \"People: \", (20, 200), font, 1.0, (255, 255, 255), 1)\n\ndef print_log(check_name, check_time, not_in_name, not_in_time):\n print(\"들어온 사람: \", end=\"\")\n print(check_name)\n print(\"들어온 시간: \", end=\"\")\n print(check_time)\n if len(not_in_name) >0:\n print(\"추가로 들어온 사람: \", end=\"\")\n print(not_in_name)\n print(\"들어온 시간: \", end=\"\")\n print(not_in_time)\n\ndef send_query(curs, conn, query, c_name, c_time):\n input = []\n #if len(not_in_name) >0 :\n for i in range(len(c_name)):\n list = ('AI_1', 'cor_1', c_name[i], c_time[i], 'True')\n input.append(list)\n print(input)\n curs.executemany(query,input)\n conn.commit()\n\ndef check_Person(image):\n # query를 이용해 db에서 정보 얻어옴\n connstr = \"test/test\"\n conn = cx_Oracle.connect(connstr)\n curs = conn.cursor()\n curs.execute(\"select name from enroll, student where enroll.stu_id = student.stu_id and enroll.course_id = 'cor_1'\")\n result = curs.fetchall()\n\n name_result = [] #db에 있는 학생의 이름 가져오기위해\n check_time = [] #들어온 시간 출력\n check_name = [] #출석이 된 학생의 이름 받아오기 위해\n not_in_name = [] #새로 들어온 사람의 이름을 받기 위해\n not_in_time=[] #새로 들어온 사람의 시간을 받기 위해\n\n for i in range(len(result)): #db에서 학생의 이름만 받아옴\n name_result.append(result[i][0])\n\n now = getTime(0)\n #print(now)\n fname = 'classifier.pkl' #학습한 정보 가져옴\n if os.path.isfile(fname):\n with open(fname, 'rb') as f:\n (le, clf) = pickle.load(f)\n else:\n print('\\x1b[0;37;43m' + \"Classifier '{}' does not exist\".format(fname) + '\\x1b[0m')\n quit()\n\n # Initialize some variables\n face_locations = []\n face_encodings = []\n face_names = []\n process_this_frame = True\n\n # 촬영된 영상을 한장의 사진으로 받아옴\n small_frame = cv2.imread(\"%s\" %image)\n\n # 사진 이미지를 resize\n #small_frame = cv2.resize(small_frame, (1280, 960), cv2.INTER_AREA)\n\n # Only process every other frame of video to save time\n if process_this_frame:\n # Find all the faces and face encodings in the current frame of video\n face_locations = face_recognition_api.face_locations(small_frame)\n face_encodings = face_recognition_api.face_encodings(small_frame, face_locations)\n\n face_names = []\n predictions = []\n if len(face_encodings) > 0:\n closest_distances = clf.kneighbors(face_encodings, n_neighbors=1)\n is_recognized = [closest_distances[0][i][0] <= 0.5 for i in range(len(face_locations))]\n # predict classes and cull classifications that are not with high confidence\n predictions = [(le.inverse_transform(int(pred)).title(), loc) if rec else (\"Unknown\", loc) for pred, loc, rec in\n zip(clf.predict(face_encodings), face_locations, is_recognized)]\n\n process_this_frame = not process_this_frame\n\n # Display the results\n for name, (top, right, bottom, left) in predictions: # 사람 얼굴 인식\n # 인식된 얼굴에 사각형 출력\n cv2.rectangle(small_frame, (left, top), (right, bottom), (0, 0, 255), 2)\n #사각형밑에 라벨이 출력되도록\n cv2.rectangle(small_frame, (left, bottom - 15), (right, bottom), (0, 0, 255), cv2.FILLED)\n font = cv2.FONT_HERSHEY_DUPLEX\n cv2.putText(small_frame, name, (left + 6, bottom - 6), font, 1.0, (255, 255, 255), 1)\n check_time.append(datetime.datetime.now().strftime('%Y-%m-%d %H-%M')) # 인식됐을때의 시간 저장\n check_name.append(name) # 검출된 사람의 이름 저장\n\n now2 = getTime(0)\n printInfo(now,now2,small_frame)\n\n for i in range(len(predictions)): #전체 사진에서 검출된 사람의 이름 전부 출력\n font = cv2.FONT_HERSHEY_DUPLEX\n cv2.putText(small_frame , predictions[i][0],( (i*120)+ 160 ,200), font,1.0,(255,255,255),1)\n\n # Display the resulting image\n #cv2.imshow('Video', small_frame)\n\n tm = datetime.datetime.now()\n dir_time= tm.strftime('%Y-%m-%d')\n\n path = makeDir(dir_time)\n cv2.imwrite('%s.jpg' % \"image_name\", small_frame)\n\n path = os.getcwd() + \"/cor_1\"\n\n #해당날짜에 해당하는 폴더가 있으면 기존 폴더를 열어서 처음 검출된 학생의 이름과 시간만 csv파일에 저장\n if os.path.isdir(path):\n print(\"파일 있당\")\n os.chdir(path)\n read_data = pd.read_csv('check.csv') #기존 csv파일 오픈\n for i in range(len(check_name)):\n list_csv=[]\n for j in range(len(read_data['Name'])): #csv파일에서 name만 가져와서 list_csv배열에 저장\n list_csv.append(read_data['Name'][j])\n if not (check_name[i] in list_csv): #검출된 사람의 이름이 csv파일에 없으면 배열에 저장\n not_in_name.append(check_name[i])\n not_in_time.append(check_time[i])\n print_log(check_name, check_time, not_in_name, not_in_time)\n data = {'Name': not_in_name, 'Time': not_in_time}\n dataframe = pd.DataFrame(data)\n dataframe.to_csv(\"check.csv\", mode='a',header=False, index=False)\n if len(not_in_name) >0 :\n send_query(curs,conn,\"insert into attend(attend_id,course_id,stu_name,enter_time,ischeck) values(:1,:2,:3,:4,:5)\",not_in_name, not_in_time)\n\n else:\n print(\"파일 없음\")\n makeDir(\"cor_1\")\n f = open('check.csv', 'w', encoding='utf-8', newline='')\n wr = csv.writer(f, delimiter='\\t')\n data = {'Name': check_name, 'Time': check_time}\n dataframe = pd.DataFrame(data)\n print_log(check_name, check_time, not_in_name, not_in_time)\n dataframe.to_csv(\"check.csv\", header=True, index=False)\n send_query(curs, conn, \"insert into attend(attend_id,course_id,stu_name,enter_time,ischeck) values(:1,:2,:3,:4,:5)\", check_name, check_time)\n\n f.close()\n curs.close()\n\n cv2.waitKey(0)\n cv2.destroyAllWindows()"
] | [
[
"pandas.read_csv",
"pandas.DataFrame"
]
] |
fqhuy/minimind | [
"627ef0edeabc0c952c9439ca4eccac5a9aaf68ae"
] | [
"prototypes/test_george.py"
] | [
"import sys\nsys.path.append('/Users/phanquochuy/Projects/minimind/prototypes/george/build/lib.macosx-10.10-x86_64-2.7')\nimport numpy as np\nimport george\nfrom george.kernels import ExpSquaredKernel\n\n# Generate some fake noisy data.\nx = 10 * np.sort(np.random.rand(10))\nyerr = 0.2 * np.ones_like(x)\ny = np.sin(x) + yerr * np.random.randn(len(x))\n\n# Set up the Gaussian process.\nkernel = ExpSquaredKernel(1.0)\ngp = george.GP(kernel)\n\n# Pre-compute the factorization of the matrix.\ngp.compute(x, yerr)\ngp.optimize(x, y, verbose=True)\n\n# Compute the log likelihood.\nprint(gp.lnlikelihood(y))\n\nt = np.linspace(0, 10, 500)\nmu, cov = gp.predict(y, t)\nstd = np.sqrt(np.diag(cov))"
] | [
[
"numpy.diag",
"numpy.ones_like",
"numpy.random.rand",
"numpy.sin",
"numpy.linspace"
]
] |
ho0-kim/yolact_edge | [
"f2b4a0db5505d2b16f9212d0ffc1072e09282b01"
] | [
"gb_yolact.py"
] | [
"import torch, torchvision\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom torchvision.models.resnet import Bottleneck, conv1x1, conv3x3\nimport numpy as np\nfrom functools import partial\nfrom itertools import product, chain\nfrom math import sqrt\nfrom typing import List, Tuple\n\nuse_torch2trt = False\n\nuse_jit = False if use_torch2trt else torch.cuda.device_count() <= 1\nNoneTensor = None if use_torch2trt else torch.Tensor()\n\nScriptModuleWrapper = torch.jit.ScriptModule if use_jit else nn.Module\nscript_method_wrapper = torch.jit.script_method if use_jit else lambda fn, _rcn=None: fn\n\nclass InterpolateModule(nn.Module):\n\t\"\"\"\n\tThis is a module version of F.interpolate (rip nn.Upsampling).\n\tAny arguments you give it just get passed along for the ride.\n\t\"\"\"\n\n\tdef __init__(self, *args, **kwdargs):\n\t\tsuper().__init__()\n\n\t\tself.args = args\n\t\tself.kwdargs = kwdargs\n\n\tdef forward(self, x):\n\t\treturn F.interpolate(x, *self.args, **self.kwdargs)\n\ndef make_net(in_channels, conf, include_last_relu=True):\n \"\"\"\n A helper function to take a config setting and turn it into a network.\n Used by protonet and extrahead. Returns (network, out_channels)\n \"\"\"\n def make_layer(layer_cfg):\n nonlocal in_channels\n \n # Possible patterns:\n # ( 256, 3, {}) -> conv\n # ( 256,-2, {}) -> deconv\n # (None,-2, {}) -> bilinear interpolate\n # ('cat',[],{}) -> concat the subnetworks in the list\n #\n # You know it would have probably been simpler just to adopt a 'c' 'd' 'u' naming scheme.\n # Whatever, it's too late now.\n if isinstance(layer_cfg[0], str):\n layer_name = layer_cfg[0]\n\n if layer_name == 'cat':\n nets = [make_net(in_channels, x) for x in layer_cfg[1]]\n layer = Concat([net[0] for net in nets], layer_cfg[2])\n num_channels = sum([net[1] for net in nets])\n else:\n num_channels = layer_cfg[0]\n kernel_size = layer_cfg[1]\n\n if kernel_size > 0:\n layer = nn.Conv2d(in_channels, num_channels, kernel_size, **layer_cfg[2])\n else:\n if num_channels is None:\n layer = InterpolateModule(scale_factor=-kernel_size, mode='bilinear', align_corners=False, **layer_cfg[2])\n else:\n layer = nn.ConvTranspose2d(in_channels, num_channels, -kernel_size, **layer_cfg[2])\n \n in_channels = num_channels if num_channels is not None else in_channels\n\n # Don't return a ReLU layer if we're doing an upsample. This probably doesn't affect anything\n # output-wise, but there's no need to go through a ReLU here.\n # Commented out for backwards compatibility with previous models\n # if num_channels is None:\n # return [layer]\n # else:\n return [layer, nn.ReLU(inplace=True)]\n\n # Use sum to concat together all the component layer lists\n net = sum([make_layer(x) for x in conf], [])\n if not include_last_relu:\n net = net[:-1]\n\n return nn.Sequential(*(net)), in_channels\n\nclass Bottleneck(nn.Module):\n \"\"\" Adapted from torchvision.models.resnet \"\"\"\n expansion = 4\n\n def __init__(self, inplanes, planes, stride=1, downsample=None, norm_layer=nn.BatchNorm2d, dilation=1):\n super(Bottleneck, self).__init__()\n self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False, dilation=dilation)\n self.bn1 = norm_layer(planes)\n self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride,\n padding=dilation, bias=False, dilation=dilation)\n self.bn2 = norm_layer(planes)\n self.conv3 = nn.Conv2d(planes, planes * 4, kernel_size=1, bias=False, dilation=dilation)\n self.bn3 = norm_layer(planes * 4)\n self.relu = nn.ReLU(inplace=True)\n if downsample is not None:\n self.downsample = downsample\n else:\n self.downsample = nn.Sequential()\n self.stride = stride\n\n def forward(self, x):\n out = self.conv1(x)\n out = self.bn1(out)\n out = self.relu(out)\n\n out = self.conv2(out)\n out = self.bn2(out)\n out = self.relu(out)\n\n out = self.conv3(out)\n out = self.bn3(out)\n\n residual = self.downsample(x)\n\n out += residual\n out = self.relu(out)\n\n return out\n\nclass ResNetBackbone(nn.Module):\n \"\"\" Adapted from torchvision.models.resnet \"\"\"\n\n def __init__(self, layers, atrous_layers=[], block=Bottleneck, norm_layer=nn.BatchNorm2d):\n super().__init__()\n\n # These will be populated by _make_layer\n self.num_base_layers = len(layers)\n self.layers = nn.ModuleList()\n self.channels = []\n self.norm_layer = norm_layer\n self.dilation = 1\n self.atrous_layers = atrous_layers\n\n # From torchvision.models.resnet.Resnet\n self.inplanes = 64\n \n self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False)\n self.bn1 = norm_layer(64)\n self.relu = nn.ReLU(inplace=True)\n self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)\n \n self._make_layer(block, 64, layers[0])\n self._make_layer(block, 128, layers[1], stride=2)\n self._make_layer(block, 256, layers[2], stride=2)\n self._make_layer(block, 512, layers[3], stride=2)\n\n # This contains every module that should be initialized by loading in pretrained weights.\n # Any extra layers added onto this that won't be initialized by init_backbone will not be\n # in this list. That way, Yolact::init_weights knows which backbone weights to initialize\n # with xavier, and which ones to leave alone.\n self.backbone_modules = [m for m in self.modules() if isinstance(m, nn.Conv2d)]\n \n \n def _make_layer(self, block, planes, blocks, stride=1):\n \"\"\" Here one layer means a string of n Bottleneck blocks. \"\"\"\n downsample = None\n\n # This is actually just to create the connection between layers, and not necessarily to\n # downsample. Even if the second condition is met, it only downsamples when stride != 1\n if stride != 1 or self.inplanes != planes * block.expansion:\n if len(self.layers) in self.atrous_layers:\n self.dilation += 1\n stride = 1\n \n downsample = nn.Sequential(\n nn.Conv2d(self.inplanes, planes * block.expansion,\n kernel_size=1, stride=stride, bias=False,\n dilation=self.dilation),\n self.norm_layer(planes * block.expansion),\n )\n\n layers = []\n layers.append(block(self.inplanes, planes, stride, downsample, self.norm_layer, self.dilation))\n self.inplanes = planes * block.expansion\n for i in range(1, blocks):\n layers.append(block(self.inplanes, planes, norm_layer=self.norm_layer))\n\n layer = nn.Sequential(*layers)\n\n self.channels.append(planes * block.expansion)\n self.layers.append(layer)\n\n return layer\n\n def forward(self, x, partial:bool=False):\n \"\"\" Returns a list of convouts for each layer. \"\"\"\n\n x = self.conv1(x)\n x = self.bn1(x)\n x = self.relu(x)\n x = self.maxpool(x)\n\n outs = []\n layer_idx = 0\n for layer in self.layers:\n layer_idx += 1\n if not partial or layer_idx <= 2:\n x = layer(x)\n outs.append(x)\n return outs\n\n def init_backbone(self, path, map_location=None):\n \"\"\" Initializes the backbone weights for training. \"\"\"\n state_dict = torch.load(path, map_location=map_location)\n\n # Replace layer1 -> layers.0 etc.\n keys = list(state_dict)\n for key in keys:\n if key.startswith('layer'):\n idx = int(key[5])\n new_key = 'layers.' + str(idx-1) + key[6:]\n state_dict[new_key] = state_dict.pop(key)\n\n # Note: Using strict=False is berry scary. Triple check this.\n self.load_state_dict(state_dict, strict=False)\n\n def add_layer(self, conv_channels=1024, downsample=2, depth=1, block=Bottleneck):\n \"\"\" Add a downsample layer to the backbone as per what SSD does. \"\"\"\n self._make_layer(block, conv_channels // block.expansion, blocks=depth, stride=downsample)\n\nclass FPN_phase_1(ScriptModuleWrapper):\n __constants__ = ['interpolation_mode', 'lat_layers']\n\n def __init__(self, in_channels):\n super().__init__()\n\n self.src_channels = in_channels\n\n self.lat_layers = nn.ModuleList([\n nn.Conv2d(x, 256, kernel_size=1)\n for x in reversed(in_channels)\n ])\n\n self.interpolation_mode = 'bilinear'\n\n @script_method_wrapper\n def forward(self, x1=NoneTensor, x2=NoneTensor, x3=NoneTensor, x4=NoneTensor, x5=NoneTensor, x6=NoneTensor, x7=NoneTensor):\n \"\"\"\n Args:\n - convouts (list): A list of convouts for the corresponding layers in in_channels.\n Returns:\n - A list of FPN convouts in the same order as x with extra downsample layers if requested.\n \"\"\"\n\n convouts_ = [x1, x2, x3, x4, x5, x6, x7]\n convouts = []\n j = 0\n while j < len(convouts_):\n if convouts_[j] is not None and convouts_[j].size(0):\n convouts.append(convouts_[j])\n j += 1\n # convouts = [x for x in convouts if x is not None]\n\n out = []\n lat_layers = []\n x = torch.zeros(1, device=convouts[0].device)\n for i in range(len(convouts)):\n out.append(x)\n lat_layers.append(x)\n\n # For backward compatability, the conv layers are stored in reverse but the input and output is\n # given in the correct order. Thus, use j=-i-1 for the input and output and i for the conv layers.\n j = len(convouts)\n for lat_layer in self.lat_layers:\n j -= 1\n\n if j < len(convouts) - 1:\n _, _, h, w = convouts[j].size()\n x = F.interpolate(x, size=(h, w), mode=self.interpolation_mode, align_corners=False)\n lat_j = lat_layer(convouts[j])\n lat_layers[j] = lat_j\n x = x + lat_j\n out[j] = x\n \n for i in range(len(convouts)):\n out.append(lat_layers[i])\n return out\n\nclass FPN_phase_2(ScriptModuleWrapper):\n __constants__ = ['num_downsample', 'use_conv_downsample', 'pred_layers', 'downsample_layers']\n\n def __init__(self, in_channels):\n super().__init__()\n\n self.src_channels = in_channels\n\n # This is here for backwards compatability\n padding = 1\n self.pred_layers = nn.ModuleList([\n nn.Conv2d(256, 256, kernel_size=3, padding=padding)\n for _ in in_channels\n ])\n\n self.downsample_layers = nn.ModuleList([\n nn.Conv2d(256, 256, kernel_size=3, padding=1, stride=2)\n for _ in range(2)\n ])\n\n self.num_downsample = 2\n self.use_conv_downsample = True\n\n @script_method_wrapper\n def forward(self, x1=NoneTensor, x2=NoneTensor, x3=NoneTensor, x4=NoneTensor, x5=NoneTensor, x6=NoneTensor, x7=NoneTensor):\n \"\"\"\n Args:\n - convouts (list): A list of convouts for the corresponding layers in in_channels.\n Returns:\n - A list of FPN convouts in the same order as x with extra downsample layers if requested.\n \"\"\"\n\n # out = [x1, x2, x3, x4, x5, x6, x7]\n # out = [x for x in out if x is not None]\n\n out_ = [x1, x2, x3, x4, x5, x6, x7]\n out = []\n j = 0\n while j < len(out_):\n if out_[j] is not None and out_[j].size(0):\n out.append(out_[j])\n j += 1\n\n len_convouts = len(out)\n\n j = len_convouts\n for pred_layer in self.pred_layers:\n j -= 1\n out[j] = F.relu(pred_layer(out[j]))\n\n # In the original paper, this takes care of P6\n if self.use_conv_downsample:\n for downsample_layer in self.downsample_layers:\n out.append(downsample_layer(out[-1]))\n else:\n for idx in range(self.num_downsample):\n # Note: this is an untested alternative to out.append(out[-1][:, :, ::2, ::2]). Thanks TorchScript.\n out.append(nn.functional.max_pool2d(out[-1], 1, stride=2))\n\n return out\n\nclass FPN(ScriptModuleWrapper):\n \"\"\"\n Implements a general version of the FPN introduced in\n https://arxiv.org/pdf/1612.03144.pdf\n\n Parameters (in cfg.fpn):\n - num_features (int): The number of output features in the fpn layers.\n - interpolation_mode (str): The mode to pass to F.interpolate.\n - num_downsample (int): The number of downsampled layers to add onto the selected layers.\n These extra layers are downsampled from the last selected layer.\n\n Args:\n - in_channels (list): For each conv layer you supply in the forward pass,\n how many features will it have?\n \"\"\"\n __constants__ = ['interpolation_mode', 'num_downsample', 'use_conv_downsample',\n 'lat_layers', 'pred_layers', 'downsample_layers']\n\n def __init__(self, in_channels):\n super().__init__()\n\n self.lat_layers = nn.ModuleList([\n nn.Conv2d(x, cfg.fpn.num_features, kernel_size=1)\n for x in reversed(in_channels)\n ])\n\n # This is here for backwards compatability\n padding = 1 if cfg.fpn.pad else 0\n self.pred_layers = nn.ModuleList([\n nn.Conv2d(256, 256, kernel_size=3, padding=padding)\n for _ in in_channels\n ])\n\n if cfg.fpn.use_conv_downsample:\n self.downsample_layers = nn.ModuleList([\n nn.Conv2d(256, 256, kernel_size=3, padding=1, stride=2)\n for _ in range(2)\n ])\n \n self.interpolation_mode = 'bilinear'\n self.num_downsample = 2\n self.use_conv_downsample = True\n\n @script_method_wrapper\n def forward(self, convouts:List[torch.Tensor]):\n \"\"\"\n Args:\n - convouts (list): A list of convouts for the corresponding layers in in_channels.\n Returns:\n - A list of FPN convouts in the same order as x with extra downsample layers if requested.\n \"\"\"\n\n out = []\n x = torch.zeros(1, device=convouts[0].device)\n for i in range(len(convouts)):\n out.append(x)\n\n # For backward compatability, the conv layers are stored in reverse but the input and output is\n # given in the correct order. Thus, use j=-i-1 for the input and output and i for the conv layers.\n j = len(convouts)\n for lat_layer in self.lat_layers:\n j -= 1\n\n if j < len(convouts) - 1:\n _, _, h, w = convouts[j].size()\n x = F.interpolate(x, size=(h, w), mode=self.interpolation_mode, align_corners=False)\n x = x + lat_layer(convouts[j])\n out[j] = x\n\n # This janky second loop is here because TorchScript.\n j = len(convouts)\n for pred_layer in self.pred_layers:\n j -= 1\n out[j] = F.relu(pred_layer(out[j]))\n\n # In the original paper, this takes care of P6\n if self.use_conv_downsample:\n for downsample_layer in self.downsample_layers:\n out.append(downsample_layer(out[-1]))\n else:\n for idx in range(self.num_downsample):\n # Note: this is an untested alternative to out.append(out[-1][:, :, ::2, ::2]). Thanks TorchScript.\n out.append(nn.functional.max_pool2d(out[-1], 1, stride=2))\n\n return out\n\nclass PredictionModule(nn.Module):\n \"\"\"\n The (c) prediction module adapted from DSSD:\n https://arxiv.org/pdf/1701.06659.pdf\n\n Note that this is slightly different to the module in the paper\n because the Bottleneck block actually has a 3x3 convolution in\n the middle instead of a 1x1 convolution. Though, I really can't\n be arsed to implement it myself, and, who knows, this might be\n better.\n\n Args:\n - in_channels: The input feature size.\n - out_channels: The output feature size (must be a multiple of 4).\n - aspect_ratios: A list of lists of priorbox aspect ratios (one list per scale).\n - scales: A list of priorbox scales relative to this layer's convsize.\n For instance: If this layer has convouts of size 30x30 for\n an image of size 600x600, the 'default' (scale\n of 1) for this layer would produce bounding\n boxes with an area of 20x20px. If the scale is\n .5 on the other hand, this layer would consider\n bounding boxes with area 10x10px, etc.\n - parent: If parent is a PredictionModule, this module will use all the layers\n from parent instead of from this module.\n \"\"\"\n \n def __init__(self, in_channels, out_channels=1024, aspect_ratios=[[1]], scales=[1], parent=None, index=0, mask_dim=None, num_classes=81):\n super().__init__()\n\n self.params = [in_channels, out_channels, aspect_ratios, scales, parent, index]\n\n self.num_classes = num_classes\n self.mask_dim = mask_dim\n self.num_priors = sum(len(x) for x in aspect_ratios)\n self.parent = [parent] # Don't include this in the state dict\n self.index = index\n\n self.extra_head_net = [(256, 3, {'padding': 1})]\n self.head_layer_params = {'kernel_size': 3, 'padding': 1}\n self.num_instance_coeffs = 64\n\n if parent is None:\n if self.extra_head_net is None:\n out_channels = in_channels\n else:\n self.upfeature, out_channels = make_net(in_channels, self.extra_head_net)\n\n self.bbox_layer = nn.Conv2d(out_channels, self.num_priors * 4, **(self.head_layer_params))\n self.conf_layer = nn.Conv2d(out_channels, self.num_priors * self.num_classes, **(self.head_layer_params))\n self.mask_layer = nn.Conv2d(out_channels, self.num_priors * self.mask_dim, **(self.head_layer_params))\n \n # What is this ugly lambda doing in the middle of all this clean prediction module code?\n def make_extra(num_layers):\n if num_layers == 0:\n return lambda x: x\n else:\n # Looks more complicated than it is. This just creates an array of num_layers alternating conv-relu\n return nn.Sequential(*sum([[\n nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1),\n nn.ReLU(inplace=True)\n ] for _ in range(num_layers)], []))\n extra_layers = (0, 0, 0)\n self.bbox_extra, self.conf_extra, self.mask_extra = [make_extra(x) for x in extra_layers]\n\n self.aspect_ratios = aspect_ratios\n self.scales = scales\n\n self.priors = None\n self.last_conv_size = None\n\n def forward(self, x):\n \"\"\"\n Args:\n - x: The convOut from a layer in the backbone network\n Size: [batch_size, in_channels, conv_h, conv_w])\n\n Returns a tuple (bbox_coords, class_confs, mask_output, prior_boxes) with sizes\n - bbox_coords: [batch_size, conv_h*conv_w*num_priors, 4]\n - class_confs: [batch_size, conv_h*conv_w*num_priors, num_classes]\n - mask_output: [batch_size, conv_h*conv_w*num_priors, mask_dim]\n - prior_boxes: [conv_h*conv_w*num_priors, 4]\n \"\"\"\n # In case we want to use another module's layers\n src = self if self.parent[0] is None else self.parent[0]\n \n conv_h = x.size(2)\n conv_w = x.size(3)\n \n if self.extra_head_net is not None:\n x = src.upfeature(x)\n\n bbox_x = src.bbox_extra(x)\n conf_x = src.conf_extra(x)\n mask_x = src.mask_extra(x)\n\n bbox = src.bbox_layer(bbox_x).permute(0, 2, 3, 1).contiguous().view(x.size(0), -1, 4)\n conf = src.conf_layer(conf_x).permute(0, 2, 3, 1).contiguous().view(x.size(0), -1, self.num_classes)\n\n mask = src.mask_layer(mask_x).permute(0, 2, 3, 1).contiguous().view(x.size(0), -1, self.mask_dim)\n\n mask = torch.tanh(mask)\n \n priors = self.make_priors(conv_h, conv_w)\n\n preds = { 'loc': bbox, 'conf': conf, 'mask': mask, 'priors': priors }\n \n return preds\n\nclass Detect(object):\n \"\"\"At test time, Detect is the final layer of SSD. Decode location preds,\n apply non-maximum suppression to location predictions based on conf\n scores and threshold to a top_k number of output predictions for both\n confidence score and locations, as the predicted masks.\n \"\"\"\n # TODO: Refactor this whole class away. It needs to go.\n\n def __init__(self, num_classes, bkg_label, top_k, conf_thresh, nms_thresh):\n self.num_classes = num_classes\n self.background_label = bkg_label\n self.top_k = top_k\n # Parameters used in nms.\n self.nms_thresh = nms_thresh\n if nms_thresh <= 0:\n raise ValueError('nms_threshold must be non negative.')\n self.conf_thresh = conf_thresh\n \n self.cross_class_nms = False\n self.use_fast_nms = False\n\n def __call__(self, predictions, extras=None):\n \"\"\"\n Args:\n loc_data: (tensor) Loc preds from loc layers\n Shape: [batch, num_priors, 4]\n conf_data: (tensor) Shape: Conf preds from conf layers\n Shape: [batch, num_priors, num_classes]\n mask_data: (tensor) Mask preds from mask layers\n Shape: [batch, num_priors, mask_dim]\n prior_data: (tensor) Prior boxes and variances from priorbox layers\n Shape: [num_priors, 4]\n proto_data: (tensor) If using mask_type.lincomb, the prototype masks\n Shape: [batch, mask_h, mask_w, mask_dim]\n \n Returns:\n output of shape (batch_size, top_k, 1 + 1 + 4 + mask_dim)\n These outputs are in the order: class idx, confidence, bbox coords, and mask.\n\n Note that the outputs are sorted only if cross_class_nms is False\n \"\"\"\n\n loc_data = predictions['loc']\n conf_data = predictions['conf']\n mask_data = predictions['mask']\n prior_data = predictions['priors']\n\n proto_data = predictions['proto'] if 'proto' in predictions else None\n inst_data = predictions['inst'] if 'inst' in predictions else None\n\n out = []\n\n with timer.env('Detect'):\n batch_size = loc_data.size(0)\n num_priors = prior_data.size(0)\n\n conf_preds = conf_data.view(batch_size, num_priors, self.num_classes).transpose(2, 1).contiguous()\n\n for batch_idx in range(batch_size):\n decoded_boxes = decode(loc_data[batch_idx], prior_data)\n result = self.detect(batch_idx, conf_preds, decoded_boxes, mask_data, inst_data, extras)\n\n if result is not None and proto_data is not None:\n result['proto'] = proto_data[batch_idx]\n \n out.append(result)\n \n return out\n\n\n def detect(self, batch_idx, conf_preds, decoded_boxes, mask_data, inst_data, extras=None):\n \"\"\" Perform nms for only the max scoring class that isn't background (class 0) \"\"\"\n cur_scores = conf_preds[batch_idx, 1:, :]\n conf_scores, _ = torch.max(cur_scores, dim=0)\n\n keep = (conf_scores > self.conf_thresh)\n scores = cur_scores[:, keep]\n boxes = decoded_boxes[keep, :]\n masks = mask_data[batch_idx, keep, :]\n\n if inst_data is not None:\n inst = inst_data[batch_idx, keep, :]\n \n if scores.size(1) == 0:\n return None\n \n if self.use_fast_nms:\n boxes, masks, classes, scores = self.fast_nms(boxes, masks, scores, self.nms_thresh, self.top_k)\n else:\n boxes, masks, classes, scores = self.traditional_nms(boxes, masks, scores, self.nms_thresh, self.conf_thresh)\n\n return {'box': boxes, 'mask': masks, 'class': classes, 'score': scores}\n \n\n def coefficient_nms(self, coeffs, scores, cos_threshold=0.9, top_k=400):\n _, idx = scores.sort(0, descending=True)\n idx = idx[:top_k]\n coeffs_norm = F.normalize(coeffs[idx], dim=1)\n\n # Compute the pairwise cosine similarity between the coefficients\n cos_similarity = coeffs_norm @ coeffs_norm.t()\n \n # Zero out the lower triangle of the cosine similarity matrix and diagonal\n cos_similarity.triu_(diagonal=1)\n\n # Now that everything in the diagonal and below is zeroed out, if we take the max\n # of the cos similarity matrix along the columns, each column will represent the\n # maximum cosine similarity between this element and every element with a higher\n # score than this element.\n cos_max, _ = torch.max(cos_similarity, dim=0)\n\n # Now just filter out the ones higher than the threshold\n idx_out = idx[cos_max <= cos_threshold]\n\n\n # new_mask_norm = F.normalize(masks[idx_out], dim=1)\n # print(new_mask_norm[:5] @ new_mask_norm[:5].t())\n \n return idx_out, idx_out.size(0)\n\n def fast_nms(self, boxes, masks, scores, iou_threshold:float=0.5, top_k:int=200, second_threshold:bool=False):\n scores, idx = scores.sort(1, descending=True)\n\n idx = idx[:, :top_k].contiguous()\n scores = scores[:, :top_k]\n \n num_classes, num_dets = idx.size()\n\n boxes = boxes[idx.view(-1), :].view(num_classes, num_dets, 4)\n masks = masks[idx.view(-1), :].view(num_classes, num_dets, -1)\n\n iou = jaccard(boxes, boxes)\n iou.triu_(diagonal=1)\n iou_max, _ = iou.max(dim=1)\n\n # Now just filter out the ones higher than the threshold\n keep = (iou_max <= iou_threshold)\n\n # We should also only keep detections over the confidence threshold, but at the cost of\n # maxing out your detection count for every image, you can just not do that. Because we\n # have such a minimal amount of computation per detection (matrix mulitplication only),\n # this increase doesn't affect us much (+0.2 mAP for 34 -> 33 fps), so we leave it out.\n # However, when you implement this in your method, you should do this second threshold.\n if second_threshold:\n keep *= (scores > self.conf_thresh)\n\n # Assign each kept detection to its corresponding class\n classes = torch.arange(num_classes, device=boxes.device)[:, None].expand_as(keep)\n\n # This try-except block aims to fix the IndexError that we might encounter when we train on custom datasets and evaluate with TensorRT enabled. See https://github.com/haotian-liu/yolact_edge/issues/27.\n try:\n classes = classes[keep]\n except IndexError:\n\n import logging\n logger = logging.getLogger(\"yolact.layers.detect\")\n logger.warning(\"Encountered IndexError as mentioned in https://github.com/haotian-liu/yolact_edge/issues/27. Flattening predictions to avoid error, please verify the outputs. If there are any problems you met related to this, please report an issue.\")\n\n classes = torch.flatten(classes, end_dim=1)\n boxes = torch.flatten(boxes, end_dim=1)\n masks = torch.flatten(masks, end_dim=1)\n scores = torch.flatten(scores, end_dim=1)\n keep = torch.flatten(keep, end_dim=1)\n\n classes = classes[keep]\n\n boxes = boxes[keep]\n masks = masks[keep]\n scores = scores[keep]\n \n # Only keep the top cfg.max_num_detections highest scores across all classes\n scores, idx = scores.sort(0, descending=True)\n idx = idx[:cfg.max_num_detections]\n scores = scores[:cfg.max_num_detections]\n\n try:\n classes = classes[idx]\n boxes = boxes[idx]\n masks = masks[idx]\n except IndexError:\n\n import logging\n logger = logging.getLogger(\"yolact.layers.detect\")\n logger.warning(\"Encountered IndexError as mentioned in https://github.com/haotian-liu/yolact_edge/issues/27. Using `torch.index_select` to avoid error, please verify the outputs. If there are any problems you met related to this, please report an issue.\")\n\n classes = torch.index_select(classes, 0, idx)\n boxes = torch.index_select(boxes, 0, idx)\n masks = torch.index_select(masks, 0, idx)\n\n return boxes, masks, classes, scores\n\n def traditional_nms(self, boxes, masks, scores, iou_threshold=0.5, conf_thresh=0.05):\n num_classes = scores.size(0)\n\n idx_lst = []\n cls_lst = []\n scr_lst = []\n\n # Multiplying by max_size is necessary because of how cnms computes its area and intersections\n boxes = boxes * cfg.max_size\n\n for _cls in range(num_classes):\n cls_scores = scores[_cls, :]\n conf_mask = cls_scores > conf_thresh\n idx = torch.arange(cls_scores.size(0), device=boxes.device)\n\n cls_scores = cls_scores[conf_mask]\n idx = idx[conf_mask]\n\n if cls_scores.size(0) == 0:\n continue\n \n preds = torch.cat([boxes[conf_mask], cls_scores[:, None]], dim=1).cpu().numpy()\n keep = cnms(preds, iou_threshold)\n keep = torch.Tensor(keep, device=boxes.device).long()\n\n idx_lst.append(idx[keep])\n cls_lst.append(keep * 0 + _cls)\n scr_lst.append(cls_scores[keep])\n \n idx = torch.cat(idx_lst, dim=0)\n classes = torch.cat(cls_lst, dim=0)\n scores = torch.cat(scr_lst, dim=0)\n\n scores, idx2 = scores.sort(0, descending=True)\n idx2 = idx2[:cfg.max_num_detections]\n scores = scores[:cfg.max_num_detections]\n\n idx = idx[idx2]\n classes = classes[idx2]\n\n # Undo the multiplication above\n return boxes[idx] / cfg.max_size, masks[idx], classes, scores\n\n\nclass yolactedge(nn.Module):\n def __init__(self, training=False):\n super().__init__()\n\n self.training = training\n\n self.fpn_num_features = 256\n\n self.backbone = ResNetBackbone([3, 4, 23, 3])\n num_layers = max(list(range(1, 4))) + 1\n while len(self.backbone.layers) < num_layers:\n self.backbone.add_layer()\n\n self.num_grids = 0\n\n self.proto_src = 0\n\n self.num_classes = 81\n \n in_channels = self.fpn_num_features\n in_channels += self.num_grids\n \n # The include_last_relu=false here is because we might want to change it to another function\n mask_proto_net = [(256, 3, {'padding': 1})] * 3 + [(None, -2, {}), (256, 3, {'padding': 1})] + [(32, 1, {})]\n self.proto_net, self.mask_dim = make_net(in_channels, mask_proto_net, include_last_relu=False)\n\n self.selected_layers = list(range(1, 4))\n src_channels = self.backbone.channels\n \n self.fpn_phase_1 = FPN_phase_1([src_channels[i] for i in self.selected_layers])\n self.fpn_phase_2 = FPN_phase_2([src_channels[i] for i in self.selected_layers])\n\n self.selected_layers = list(range(len(self.selected_layers) + 2))\n\n src_channels = [self.fpn_num_features] * len(self.selected_layers)\n\n self.prediction_layers = nn.ModuleList()\n\n for idx, layer_idx in enumerate(self.selected_layers):\n # If we're sharing prediction module weights, have every module's parent be the first one\n parent = None\n if idx > 0:\n parent = self.prediction_layers[0]\n\n pred_aspect_ratios = [ [[1, 1/2, 2]] ]*5\n pred_scales = [[24], [48], [96], [192], [384]]\n\n pred = PredictionModule(src_channels[layer_idx], src_channels[layer_idx],\n aspect_ratios = pred_aspect_ratios[idx],\n scales = pred_scales[idx],\n parent = parent,\n index = idx,\n mask_dim = self.mask_dim,\n num_classes = self.num_classes)\n self.prediction_layers.append(pred)\n\n self.semantic_seg_conv = nn.Conv2d(src_channels[0], self.num_classes-1, kernel_size=1)\n\n # # For use in evaluation\n # self.detect = Detect(self.num_classes, bkg_label=0, top_k=200, conf_thresh=0.05, nms_thresh=0.5)\n\n def forward(self, inp):\n return inp\n\nif __name__ == '__main__':\n print('hello world')\n net = yolactedge().cuda()\n\n\n dummy_input = torch.randn(10, 3, 550, 550, device='cuda')\n torch.onnx.export(net, dummy_input, \"test.onnx\", verbose=True)\n \n"
] | [
[
"torch.nn.Conv2d",
"torch.nn.ModuleList",
"torch.max",
"torch.cat",
"torch.nn.ConvTranspose2d",
"torch.onnx.export",
"torch.randn",
"torch.cuda.device_count",
"torch.arange",
"torch.tanh",
"torch.index_select",
"torch.Tensor",
"torch.nn.MaxPool2d",
"torch.load",
"torch.nn.functional.max_pool2d",
"torch.nn.functional.normalize",
"torch.flatten",
"torch.nn.Sequential",
"torch.zeros",
"torch.nn.ReLU",
"torch.nn.functional.interpolate"
]
] |
jim-schwoebel/allie | [
"d85db041b91c81dfb3fd1a4d719b5aaaf3b6697e"
] | [
"training/helpers/archived/WIP_train_mlbox-WIP.py"
] | [
"import os, json, shutil, pickle\r\nfrom sklearn.model_selection import train_test_split\r\nfrom sklearn.metrics import accuracy_score, mean_squared_log_error\r\nimport pandas as pd\r\n\r\nprint('installing library')\r\nos.system('pip3 install mlbox==0.8.4')\r\n\r\nfrom mlbox.preprocessing import *\r\nfrom mlbox.optimisation import *\r\nfrom mlbox.prediction import *\r\n\r\n'''\r\nFrom the documentation: https://mlbox.readthedocs.io/en/latest/\r\n'''\r\n# install mlblocks\r\n\r\ndef train_mlbox(alldata, labels, mtype, jsonfile, problemtype, default_features, settings):\r\n\r\n\t# name model\r\n\tmodelname=jsonfile[0:-5]+'_mlbox_'+str(default_features).replace(\"'\",'').replace('\"','')\r\n\r\n\t# training and testing sets\r\n\tX_train, X_test, y_train, y_test = train_test_split(alldata, labels, train_size=0.750, test_size=0.250)\r\n\tdf = {\"train\" : pd.DataFrame(X_train), \"target\" : pd.DataFrame(y_train), \"test\" : pd.DataFrame(X_test)}\r\n\tprint(df)\r\n\r\n\tif mtype=='c': \r\n\r\n\t\t# rename files with classification\r\n\t\tmodelname=modelname+'_classification'\r\n\t\tmodel_name=modelname+'.pickle'\r\n\t\tjsonfilename=modelname+'.json'\r\n\r\n\t\t# from sklearn.datasets import load_boston\r\n\t\t# dataset = load_boston()\r\n\t\t# df = {\"train\" : pd.DataFrame(dataset.data), \"target\" : pd.Series(dataset.target)}\r\n\t\t# print(df['train'][0])\r\n\t\t# print(type(df['train'][0]))\r\n\t\t# data = Drift_thresholder().fit_transform(df) #deleting non-stable variables\r\n\r\n\t\tspace = {\r\n\r\n\t\t\t\t'ne__numerical_strategy' : {\"space\" : [0, 'mean']},\r\n\r\n\t\t\t\t'ce__strategy' : {\"space\" : [\"label_encoding\", \"random_projection\", \"entity_embedding\"]},\r\n\r\n\t\t\t\t'fs__strategy' : {\"space\" : [\"variance\", \"rf_feature_importance\"]},\r\n\t\t\t\t'fs__threshold': {\"search\" : \"choice\", \"space\" : [0.1, 0.2, 0.3]},\r\n\r\n\t\t\t\t'est__strategy' : {\"space\" : [\"LightGBM\"]},\r\n\t\t\t\t'est__max_depth' : {\"search\" : \"choice\", \"space\" : [5,6]},\r\n\t\t\t\t'est__subsample' : {\"search\" : \"uniform\", \"space\" : [0.6,0.9]}\r\n\r\n\t\t\t\t}\r\n\r\n\t\tbest = Optimiser().optimise(space, df, max_evals = 5)\r\n\t\tmse_ =Optimiser().evaluate(best, df)\r\n\t\tpipeline = Predictor().fit_predict(best, df)\r\n\r\n\t\tprint(best)\r\n\t\tprint(mse_)\r\n\r\n\t\t# saving model\r\n\t\tprint('saving model')\r\n\t\tmodelfile=open(model_name,'wb')\r\n\t\tpickle.dump(pipeline, modelfile)\r\n\t\tmodelfile.close()\r\n\r\n\t\t# SAVE JSON FILE \r\n\t\tprint('saving .JSON file (%s)'%(jsonfilename))\r\n\t\tjsonfile=open(jsonfilename,'w')\r\n\r\n\t\tdata={'sample type': problemtype,\r\n\t\t\t'feature_set':default_features,\r\n\t\t\t'model name':jsonfilename[0:-5]+'.pickle',\r\n\t\t\t'accuracy':accuracy,\r\n\t\t\t'model type':'mlblocks_regression',\r\n\t\t\t'settings': settings,\r\n\t\t}\r\n\r\n\t\tjson.dump(data,jsonfile)\r\n\t\tjsonfile.close()\r\n\r\n\tif mtype=='r': \r\n\r\n\t\t# rename files with regression\r\n\t\tmodelname=modelname+'_regression'\r\n\t\tmodel_name=modelname+'.pickle'\r\n\t\tjsonfilename=modelname+'.json'\r\n\r\n\t\tparams = {\"ne__numerical_strategy\" : 0,\r\n\t\t\t\t\"ce__strategy\" : \"label_encoding\",\r\n\t\t\t\t\"fs__threshold\" : 0.1,\r\n\t\t\t\t\"stck__base_estimators\" : [Regressor(strategy=\"RandomForest\"), Regressor(strategy=\"ExtraTrees\")],\r\n\t\t\t\t\"est__strategy\" : \"Linear\"}\r\n\r\n\t\tbest = Optimiser().optimise(params, df, max_evals = 5)\r\n\t\tmse_error =Optimiser().evaluate(best, df)\r\n\r\n\t\t# saving model\r\n\t\tprint('saving model')\r\n\t\tmodelfile=open(model_name,'wb')\r\n\t\tpickle.dump(pipeline, modelfile)\r\n\t\tmodelfile.close()\r\n\r\n\t\t# save JSON\r\n\t\tprint('saving .JSON file (%s)'%(jsonfilename))\r\n\t\tjsonfile=open(jsonfilename,'w')\r\n\r\n\t\tdata={'sample type': problemtype,\r\n\t\t\t'feature_set':default_features,\r\n\t\t\t'model name':jsonfilename[0:-5]+'.pickle',\r\n\t\t\t'mse_error':mse_error,\r\n\t\t\t'model type':'mlblocks_regression',\r\n\t\t\t'settings': settings,\r\n\t\t}\r\n\r\n\t\tjson.dump(data,jsonfile)\r\n\t\tjsonfile.close()\r\n\r\n\tcur_dir2=os.getcwd()\r\n\ttry:\r\n\t\tos.chdir(problemtype+'_models')\r\n\texcept:\r\n\t\tos.mkdir(problemtype+'_models')\r\n\t\tos.chdir(problemtype+'_models')\r\n\r\n\t# now move all the files over to proper model directory \r\n\tshutil.copy(cur_dir2+'/'+model_name, os.getcwd()+'/'+model_name)\r\n\tshutil.copy(cur_dir2+'/'+jsonfilename, os.getcwd()+'/'+jsonfilename)\r\n\tos.remove(cur_dir2+'/'+model_name)\r\n\tos.remove(cur_dir2+'/'+jsonfilename)\r\n\r\n\t# get model directory\r\n\tmodel_dir=os.getcwd()\r\n\r\n\treturn model_name, model_dir"
] | [
[
"pandas.DataFrame",
"sklearn.model_selection.train_test_split"
]
] |
marlene09/napari | [
"d3284b5df2efc0fad2664f954cbc52cca9daa105"
] | [
"napari/layers/labels/_labels_utils.py"
] | [
"from functools import lru_cache\n\nimport numpy as np\n\n\ndef interpolate_coordinates(old_coord, new_coord, brush_size):\n \"\"\"Interpolates coordinates depending on brush size.\n\n Useful for ensuring painting is continuous in labels layer.\n\n Parameters\n ----------\n old_coord : np.ndarray, 1x2\n Last position of cursor.\n new_coord : np.ndarray, 1x2\n Current position of cursor.\n brush_size : float\n Size of brush, which determines spacing of interpolation.\n\n Returns\n -------\n coords : np.array, Nx2\n List of coordinates to ensure painting is continuous\n \"\"\"\n num_step = round(\n max(abs(np.array(new_coord) - np.array(old_coord))) / brush_size * 4\n )\n coords = [\n np.linspace(old_coord[i], new_coord[i], num=int(num_step + 1))\n for i in range(len(new_coord))\n ]\n coords = np.stack(coords).T\n if len(coords) > 1:\n coords = coords[1:]\n\n return coords\n\n\n@lru_cache(maxsize=64)\ndef sphere_indices(radius, scale):\n \"\"\"Generate centered indices within circle or n-dim ellipsoid.\n\n Parameters\n -------\n radius : float\n Radius of circle/sphere\n scale : tuple of float\n The scaling to apply to the sphere along each axis\n\n Returns\n -------\n mask_indices : array\n Centered indices within circle/sphere\n \"\"\"\n ndim = len(scale)\n abs_scale = np.abs(scale)\n scale_normalized = np.asarray(abs_scale, dtype=float) / np.min(abs_scale)\n # Create multi-dimensional grid to check for\n # circle/membership around center\n r_normalized = radius / scale_normalized + 0.5\n slices = [\n slice(-int(np.ceil(r)), int(np.floor(r)) + 1) for r in r_normalized\n ]\n\n indices = np.mgrid[slices].T.reshape(-1, ndim)\n distances_sq = np.sum((indices * scale_normalized) ** 2, axis=1)\n # Use distances within desired radius to mask indices in grid\n mask_indices = indices[distances_sq <= radius ** 2].astype(int)\n\n return mask_indices\n\n\ndef indices_in_shape(idxs, shape):\n \"\"\"Return idxs after filtering out indices that are not in given shape.\n\n Parameters\n ----------\n idxs : tuple of array of int, or 2D array of int\n The input coordinates. These should be in one of two formats:\n\n - a tuple of 1D arrays, as for NumPy fancy indexing, or\n - a 2D array of shape (ncoords, ndim), as a list of coordinates\n\n shape : tuple of int\n The shape in which all indices must fit.\n\n Returns\n -------\n idxs_filtered : tuple of array of int, or 2D array of int\n The subset of the input idxs that falls within shape.\n\n Examples\n --------\n >>> idxs0 = (np.array([5, 45, 2]), np.array([6, 5, -5]))\n >>> indices_in_shape(idxs0, (10, 10))\n (array([5]), array([6]))\n >>> idxs1 = np.transpose(idxs0)\n >>> indices_in_shape(idxs1, (10, 10))\n array([[5, 6]])\n \"\"\"\n np_index = isinstance(idxs, tuple)\n if np_index: # normalize to 2D coords array\n idxs = np.transpose(idxs)\n keep_coords = np.logical_and(\n np.all(idxs >= 0, axis=1), np.all(idxs < np.array(shape), axis=1)\n )\n filtered = idxs[keep_coords]\n if np_index: # convert back to original format\n filtered = tuple(filtered.T)\n return filtered\n\n\ndef get_dtype(layer):\n \"\"\"Returns dtype of layer data\n\n Parameters\n ----------\n layer : Labels\n Labels layer (may be multiscale)\n\n Returns\n -------\n dtype\n dtype of Layer data\n \"\"\"\n layer_data = layer.data\n if not isinstance(layer_data, list):\n layer_data = [layer_data]\n layer_data_level = layer_data[0]\n if hasattr(layer_data_level, 'dtype'):\n layer_dtype = layer_data_level[0].dtype\n else:\n layer_dtype = type(layer_data_level)\n\n return layer_dtype\n"
] | [
[
"numpy.sum",
"numpy.transpose",
"numpy.ceil",
"numpy.abs",
"numpy.asarray",
"numpy.floor",
"numpy.all",
"numpy.min",
"numpy.stack",
"numpy.array"
]
] |
LouisDumont/Projet-Opti-Controle | [
"7dd9346759e55c62b604ce423c29040b51d83384"
] | [
"src/bfgs.py"
] | [
"#!/usr/bin/python\n\nimport numpy as np\nfrom numpy.linalg import norm\nfrom time import process_time\n\nfrom .wolfe_skel import *\nfrom .visualize import visualize\n\n# Resolution d'un probleme d'optimisation sans contrainte\n# Methode pseudo-newtonienne: BFGS\n\ndef bfgs(oracle, x0, iter_max = 5000, threshold = 0.000001, visual=True, verbose=False):\n # Initialisation des variables\n gradient_norm_list = []\n gradient_step_list = []\n loss_list = []\n \n # Pour calculer le temps de la descente de gradient\n time_start = process_time()\n\n # Boucle sur les iterations\n size = x0.size\n x = x0\n x_previous = x\n W_n = np.eye(size)\n loss, gradient, hess = oracle(x)\n d_n = -np.dot(W_n, gradient)\n alpha, ok = wolfe(1, x, d_n, oracle)\n x = x_previous + alpha * d_n\n for k in range(iter_max):\n # Calcul de la perte et du gradient\n loss_previous, gradient_previous = loss, gradient\n loss, gradient, hess = oracle(x)\n # Calcul des écarts précédents\n delta_x = x - x_previous\n delta_grad = gradient - gradient_previous\n # Calcul de l'approximée de la hessienne\n aux_xg = np.outer(delta_x, delta_grad)/np.vdot(delta_grad, delta_x)\n aux_gx = np.outer(delta_grad, delta_x)/np.vdot(delta_grad, delta_x)\n aux_xx = np.outer(delta_x, delta_x)/np.vdot(delta_grad, delta_x)\n W_n = np.dot(np.dot(np.eye(size) - aux_xg, W_n), np.eye(size) - aux_gx) + aux_xx\n # Calcul de la direction de descente\n d_n = - np.dot(W_n, gradient)\n # Calcul du pas de gradient\n gradient_step, ok = wolfe(1, x, d_n, oracle)\n # Mise à jour du point\n x_previous = x\n x = x_previous + gradient_step * d_n\n \n\n # Historique de l'évolution du gradient, du pas, et du critère\n gradient_norm = np.linalg.norm(gradient)\n if verbose:\n print('Iter :', k, '; gradient_step={}'.format(gradient_step), '; gradient_norm={}'.format(gradient_norm))\n gradient_norm_list.append(gradient_norm)\n gradient_step_list.append(gradient_step)\n loss_list.append(loss)\n \n # Test de convergence\n if gradient_norm <= threshold:\n break\n \n # Resultat de l'optimisation\n loss_opt = loss\n x_opt = x\n gradient_opt = gradient\n time_cpu = process_time() - time_start\n print('Iteration :', k)\n print('Temps CPU :', time_cpu)\n print('Critere optimal :', loss_opt)\n print('Norme du gradient :', norm(gradient_opt))\n print('X optimal :', x_opt)\n \n # Visualisation de la convergence\n if visual:\n visualize(gradient_norm_list, gradient_step_list, loss_list)\n \n return loss_opt, x_opt, gradient_opt\n \n"
] | [
[
"numpy.eye",
"numpy.linalg.norm",
"numpy.dot",
"numpy.vdot",
"numpy.outer"
]
] |
louism33/rl-starter-files | [
"032a65ab583aff0dc75e14d2faa897be387a83d6"
] | [
"scripts/postProcessFiles.py"
] | [
"import argparse\nimport collections\nimport math\nimport os\n\nimport matplotlib.pyplot as plt\nimport pandas as pd\n\ndef my_plot_function(showGraph=False, x_axis=\"episodes\", algo=\"ppo\", env=''):\n masterDataFrameList = {}\n\n dfs = []\n divBy = 0\n avg = None\n\n for subdir, dirs, files in os.walk(os.path.join(storagePath, args.dir)):\n for sd in dirs:\n df_ = pd.read_csv(os.path.join(storagePath, args.dir, sd, \"log.csv\"), sep=\",\")\n dfs.append(df_)\n\n if avg is None:\n avg = df_.copy()\n\n for header in list(df_.copy()):\n masterDataFrameList[header] = df_[ [header, x_axis]]\n\n else:\n avg += df_.copy()\n\n for header in list(df_.copy()):\n masterDataFrameList[header][header+str(len(dfs))] = df_[header]\n\n divBy += 1\n\n avg = avg / divBy\n\n for index, whatToPlot in enumerate(separate_graphs):\n if len(whatToPlot) == 0:\n continue\n\n biggestLastY = -100000000\n smallestLastY = 100000000\n\n ax = None\n\n horizontalLine1 = None\n horizontalLine2 = None\n\n desiredTitle = \"untitled\"\n\n def sort_(x):\n if whatToPlot.get(x[0], {}).get(\"secondary_y\", 0):\n return 1\n return 0\n # we order the dict, because if we graph a separate_y before a regular one, the std shading is broken :'(\n # so we try to graph separate_y last\n masterDataFrameList = collections.OrderedDict(sorted(masterDataFrameList.items(), key=lambda x:sort_(x)))\n\n for colName in masterDataFrameList:\n if colName == x_axis or colName not in whatToPlot or whatToPlot[colName].get('ignore', False):\n continue\n\n if whatToPlot[colName].get('desiredTitle', False):\n desiredTitle = whatToPlot[colName]['desiredTitle']\n\n if whatToPlot[colName].get('horizontalLine1', None) is not None:\n horizontalLine1 = whatToPlot[colName].get('horizontalLine1', False)\n\n if whatToPlot[colName].get('horizontalLine2', None) is not None:\n horizontalLine2 = whatToPlot[colName].get('horizontalLine2', False)\n\n thisCompoundDf = masterDataFrameList[colName]\n\n plotMe = thisCompoundDf.loc[:,[c for c in thisCompoundDf.columns if c != x_axis]].mean(axis=1).to_frame()\n plotMe.columns = [colName]\n std = thisCompoundDf.loc[:, [c for c in thisCompoundDf.columns if c != x_axis]].std(axis=1)\n\n if whatToPlot[colName]['normalise']:\n plotMe[colName] = (plotMe[colName] - plotMe[colName].min()) / (\n plotMe[colName].max() - plotMe[colName].min())\n\n assert len(thisCompoundDf[colName]) == len(std)\n\n addedValues = plotMe[colName].add(std).values\n plotMe = plotMe.assign(stdPLUS=addedValues)\n plotMe = plotMe.assign(justSTD=std)\n subbedValues = plotMe[colName].subtract(std).values\n plotMe = plotMe.assign(stdMINUS=subbedValues)\n\n if x_axis == \"episodes\":\n plotMe = plotMe.assign(episodes=thisCompoundDf[x_axis].values)\n elif x_axis == \"frames\":\n plotMe = plotMe.assign(frames=thisCompoundDf[x_axis].values)\n\n annotateAllChanges = whatToPlot[colName]['annotateAllChanges'] if not ONLY_LAST_VALUE_OVERWRITE else False\n\n # https://stackoverflow.com/questions/8409095/set-markers-for-individual-points-on-a-line-in-matplotlib\n percentilesPretty = [colName]\n\n plot_kwargs = {\n 'x': x_axis,\n 'y': percentilesPretty,\n 'figsize':(12, 8),\n 'label': [whatToPlot.get(n, {}).get('alias', n) for n in percentilesPretty]\n }\n if ax is not None: plot_kwargs['ax'] = ax\n if whatToPlot[colName].get('secondary_y', False): plot_kwargs['secondary_y'] = True\n if whatToPlot[colName].get('desiredColour', False): plot_kwargs['color'] = whatToPlot[colName]['desiredColour']\n\n ax = plotMe.plot(**plot_kwargs)\n\n fill_between_kwargs = {\n 'alpha': 0.2,\n }\n if whatToPlot[colName].get('desiredColour', False): fill_between_kwargs['color'] = whatToPlot[colName][\n 'desiredColour']\n plt.fill_between(plotMe[x_axis], plotMe['stdPLUS'], plotMe['stdMINUS'], **fill_between_kwargs)\n\n prev = None\n for pi, colNamePretty in enumerate(percentilesPretty):\n\n for i, (a, b) in enumerate(zip(plotMe[x_axis], plotMe[colNamePretty])):\n\n lastValue = i+1 == len(plotMe[x_axis])\n if b != prev or lastValue:\n plusSTD = round(plotMe['justSTD'][i], 2)\n\n if whatToPlot[colName].get('hidePlusMinus', False):\n writeMeOnGraph = str(round(b, 2))\n else:\n writeMeOnGraph = str(round(b, 2)) + \" (+-\" + str(plusSTD) + \")\"\n\n if annotateAllChanges or lastValue:\n ### simple annotation\n if not NO_NUMBERS and not whatToPlot[colName].get('hideValue', False):\n plt.annotate(writeMeOnGraph, xy=(a, b))\n if lastValue:\n biggestLastY = max(biggestLastY, b)\n smallestLastY = min(smallestLastY, b)\n prev = b\n\n\n if horizontalLine1 is not None:\n plt.axhline(y=horizontalLine1, color='firebrick', linestyle='--', label=\"Random Full\")\n if horizontalLine2 is not None:\n plt.axhline(y=horizontalLine2, color='midnightblue', linestyle=':', label=\"Random Button\")\n\n plt.title(desiredTitle + \", \" + algo + \" \" + env)\n\n ### axis modification\n axes = plt.gca()\n\n plt.grid(True)\n\n plt.savefig(os.path.join(storagePath, args.dir, \"graph\" + str(index) + \"_\" + desiredTitle + \"_\" + algo + \"_\" + env + \".pdf\"))\n\n if showGraph:\n plt.show()\n\nif __name__ == '__main__':\n parser = argparse.ArgumentParser()\n parser.add_argument(\"--dir\", required=True,\n help=\"folder name\")\n parser.add_argument(\"--x_axis\", default=\"frames\",\n help=\"x_axis\")\n parser.add_argument(\"--algo\", default=\"ppo\",\n help=\"which algo to save under\")\n parser.add_argument(\"--env\", default=False,\n help=\"which env to save under\")\n parser.add_argument(\"--storagePath\", required=True, default=True,\n help=\"storagePath\")\n parser.add_argument(\"--showGraph\", required=False, default=True, type=int,\n help=\"plot.show() or not\")\n\n args = parser.parse_args()\n\n storagePath = args.storagePath\n\n horizontal = -2\n horizontal3 = -1/2\n\n x_axis = args.x_axis\n x_axis = \"frames\"\n x_axis = \"episodes\"\n\n algo = args.algo\n algo = \"ppo\"\n # algo = \"dqn\"\n\n env = args.env if args.env else ''\n env = \"(2, 2, 1, 2, 1)\"\n\n ONLY_LAST_VALUE_OVERWRITE = True\n ONLY_LAST_VALUE_OVERWRITE = False\n NO_NUMBERS = True\n NO_NUMBERS = False\n\n realGraph0Perf = {\n \"X_all_performance_full\" : { # data += [(finalTestPerformanceFull + finalTrainingPerformanceFull)/2]\n \"desiredTitle\": \"performance graph\",\n\n \"alias\": \"performance_full\",\n \"normalise\": False,\n \"annotateAllChanges\": False,\n\n 'desiredColour': u'#1f77b4', # blue\n\n \"horizontalLine1\": horizontal,\n \"horizontalLine2\": 0,\n \"horizontalLine3\": horizontal3,\n },\n \"X_all_performance\" : { # data += [(finalTestPerformance + finalTrainingPerformance)/2]\n \"alias\": \"performance_button\",\n \"normalise\": False,\n \"annotateAllChanges\": False,\n\n 'desiredColour': u'#ff7f0e', # orange\n },\n \"X_performance_full\" : {\n \"alias\": \"performance_button\",\n \"normalise\": False,\n \"annotateAllChanges\": False,\n\n 'desiredColour': u'#ff7f0e', # orange\n },\n }\n # colours not done\n realGraph1Training = {\n \"X_TRAINtest_reward\" : {\n \"desiredTitle\": \"reward, entropy and buttons in training\",\n\n \"alias\": \"return\",\n \"normalise\": False,\n \"annotateAllChanges\": False,\n \"secondary_y\": True,\n },\n \"X_epsilon\": {\n \"desiredTitle\": \"reward, entropy and buttons in training\",\n\n \"alias\": \"epsilon\",\n \"normalise\": False,\n \"annotateAllChanges\": False,\n \"hideValue\": True,\n \"hidePlusMinus\": True,\n },\n \"entropy\" : {\n \"alias\": \"entropy\",\n \"normalise\": False,\n \"annotateAllChanges\": False,\n \"hideValue\": True,\n \"hidePlusMinus\": True,\n },\n \"buttons_mean\" : { # ppo\n \"alias\": \"training_buttons\",\n \"normalise\": False,\n \"annotateAllChanges\": False\n },\n \"X_buttons_mean\" : { # dqn\n \"alias\": \"training_buttons\",\n \"normalise\": False,\n \"annotateAllChanges\": False,\n\n 'desiredColour': '#9467bd', # purple\n },\n \"X_TRAINtest_buttons\" : {\n \"desiredTitle\": \"reward, entropy and buttons in training\",\n \"alias\": \"test_buttons\",\n \"normalise\": False,\n \"annotateAllChanges\": False,\n\n 'desiredColour': '#9467bd', # purple\n },\n }\n # colours not done\n realGraph2TrainingPerfAndReward = {\n \"X_TRAINtest_reward\": {\n \"desiredTitle\": \"reward and performances in training graph\",\n\n \"alias\": \"training_reward\",\n \"normalise\": False,\n \"annotateAllChanges\": False,\n \"secondary_y\": True,\n },\n \"X_TRAINtest_performance\": {\n \"desiredTitle\": \"reward and performances in training graph\",\n\n \"alias\": \"training_performance_button\",\n \"normalise\": False,\n \"annotateAllChanges\": False,\n\n \"ignore\": False,\n },\n \"X_TRAINtest_performance_full\": {\n \"alias\": \"training_performance_full\",\n \"normalise\": False,\n \"annotateAllChanges\": False\n },\n\n }\n # colours not done\n realGraph3TestPerfAndReward = {\n \"X_test_reward\": {\n \"desiredTitle\": \"reward and performances in test graph\",\n\n \"alias\": \"test_reward\",\n \"normalise\": False,\n \"annotateAllChanges\": False,\n \"secondary_y\": True,\n },\n \"X_test_performance\": {\n \"alias\": \"test_performance_button\",\n \"normalise\": False,\n \"annotateAllChanges\": False\n },\n \"X_test_performance_full\": {\n \"alias\": \"test_performance_full\",\n \"normalise\": False,\n \"annotateAllChanges\": False\n },\n }\n\n realGraph4TrainingPerfVSTestBreakdown = {\n \"X_test_performance_full\": {\n \"desiredTitle\": \"training and test performance breakdown\",\n\n \"alias\": \"test_performance_full\",\n \"normalise\": False,\n \"annotateAllChanges\": False,\n # \"secondary_y\": True,\n\n \"horizontalLine1\": horizontal,\n \"horizontalLine2\": 0,\n\n 'desiredColour': u'#1f77b4', # blue\n },\n \"X_test_performance\": {\n \"alias\": \"test_performance_button\",\n \"normalise\": False,\n \"annotateAllChanges\": False,\n\n 'desiredColour': u'#ff7f0e', # orange\n },\n\n \"X_TRAINtest_performance_full\": {\n \"alias\": \"training_performance_full\",\n \"normalise\": False,\n \"annotateAllChanges\": False,\n\n 'desiredColour': '#17becf', # light blue\n },\n\n \"X_TRAINtest_performance\": {\n \"alias\": \"training_performance_button\",\n \"normalise\": False,\n \"annotateAllChanges\": False,\n\n 'desiredColour': '#FFA500', # orange\n },\n }\n # colours not done\n realGraph5Buttons = {\n \"buttons_mean\" : { # ppo\n \"alias\": \"training_buttons\",\n \"normalise\": False,\n \"annotateAllChanges\": False\n },\n \"X_buttons_mean\" : { # dqn\n \"alias\": \"training_buttons\",\n \"normalise\": False,\n \"annotateAllChanges\": False\n },\n \"X_TRAINtest_buttons\" : {\n \"alias\": \"test_buttons\",\n \"normalise\": False,\n \"annotateAllChanges\": False\n },\n \"X_epsilon\": {\n \"desiredTitle\": \"graph of buttons\",\n\n \"alias\": \"epsilon\",\n \"normalise\": False,\n \"annotateAllChanges\": False\n },\n \"entropy\": {\n \"desiredTitle\": \"graph of buttons\",\n\n \"alias\": \"entropy\",\n \"normalise\": False,\n \"annotateAllChanges\": False\n },\n }\n #colours not done\n realGraph6Phones = {\n\n \"buttons_mean\" : { # ppo\n \"desiredTitle\": \"graph of phones\",\n\n \"alias\": \"training_buttons\",\n \"normalise\": False,\n \"annotateAllChanges\": False\n },\n \"X_buttons_mean\" : { # dqn\n \"alias\": \"training_buttons\",\n \"normalise\": False,\n \"annotateAllChanges\": False\n },\n \"X_TRAINtest_buttons\" : {\n \"desiredTitle\": \"graph of phones\",\n \"alias\": \"test_buttons\",\n \"normalise\": False,\n \"annotateAllChanges\": False\n },\n\n \"X_TRAINtest_phones\": {\n \"alias\": \"training_phones\",\n \"normalise\": False,\n \"annotateAllChanges\": False\n },\n\n \"X_test_phones\" : {\n \"alias\": \"test_phones\",\n \"normalise\": False,\n \"annotateAllChanges\": False\n },\n }\n\n realGraph7PhonesButtonDirtTraining = {\n \"X_TRAINtest_phones\": {\n \"desiredTitle\": \"graph of phones, dirts and buttons in training\",\n \"alias\": \"training_phones\",\n \"normalise\": False,\n \"annotateAllChanges\": False,\n\n 'desiredColour': '#d62728', # red\n },\n \"X_TRAINtest_buttons\": {\n \"alias\": \"training_buttons\",\n \"normalise\": False,\n \"annotateAllChanges\": False,\n\n 'desiredColour': '#9467bd', #purple\n },\n\n \"X_TRAINtest_dirts\": {\n \"alias\": \"training_dirts\",\n \"normalise\": False,\n \"annotateAllChanges\": False,\n\n 'desiredColour': '#2ca02c', #green\n },\n \"X_TRAINtest_messes\": {\n \"alias\": \"training_messes\",\n \"normalise\": False,\n \"annotateAllChanges\": False,\n\n 'desiredColour': '#7f7f7f', # grey\n },\n }\n\n realGraph8PhonesButtonDirtTest = {\n \"X_test_phones\": {\n \"desiredTitle\": \"graph of phones, dirts and buttons on the test set\",\n \"alias\": \"test_phones\",\n \"normalise\": False,\n \"annotateAllChanges\": False,\n\n 'desiredColour': '#d62728', # red\n },\n\n \"X_test_buttons\": {\n \"alias\": \"test_buttons\",\n \"normalise\": False,\n \"annotateAllChanges\": False,\n\n 'desiredColour': '#9467bd', # purple\n },\n \"X_test_dirts\": {\n \"alias\": \"test_dirts\",\n \"normalise\": False,\n \"annotateAllChanges\": False,\n\n 'desiredColour': '#2ca02c', # green\n },\n\n \"X_test_messes\": {\n \"alias\": \"test_messes\",\n \"normalise\": False,\n \"annotateAllChanges\": False,\n\n 'desiredColour': '#7f7f7f', # grey\n },\n\n }\n\n realGraph9PhonesButtonDirtAll = {\n \"X_TRAINtest_phones\": {\n \"desiredTitle\": \"graph of phones, dirts and buttons in training and on the test set\",\n \"alias\": \"training_phones\",\n \"normalise\": False,\n \"annotateAllChanges\": False,\n\n 'desiredColour': '#ff7f0e', # orange (related to red)\n },\n \"X_test_phones\": {\n \"alias\": \"test_phones\",\n \"normalise\": False,\n \"annotateAllChanges\": False,\n\n 'desiredColour': '#d62728', # red\n },\n\n \"X_TRAINtest_buttons\": {\n \"alias\": \"training_buttons\",\n \"normalise\": False,\n \"annotateAllChanges\": False ,\n\n 'desiredColour': '#e377c2', # pink (related to purple)\n },\n \"X_test_buttons\": {\n \"alias\": \"test_buttons\",\n \"normalise\": False,\n \"annotateAllChanges\": False,\n\n 'desiredColour': '#9467bd', # purple\n },\n\n \"X_TRAINtest_dirts\": {\n \"alias\": \"training_dirts\",\n \"normalise\": False,\n \"annotateAllChanges\": False,\n\n 'desiredColour': '#bcbd22', # light green/yellow (related to green)\n },\n \"X_test_dirts\": {\n \"alias\": \"test_dirts\",\n \"normalise\": False,\n \"annotateAllChanges\": False,\n\n 'desiredColour': '#2ca02c', # green\n },\n\n \"X_TRAINtest_messes\": {\n \"alias\": \"training_messes\",\n \"normalise\": False,\n \"annotateAllChanges\": False,\n\n 'desiredColour': '#8c564b', # brown (related to grey)\n },\n \"X_test_messes\": {\n \"alias\": \"test_messes\",\n \"normalise\": False,\n \"annotateAllChanges\": False,\n\n 'desiredColour': '#7f7f7f', # grey\n },\n\n }\n\n\n separate_graphs = [\n realGraph0Perf,\n realGraph1Training,\n realGraph2TrainingPerfAndReward,\n realGraph3TestPerfAndReward,\n realGraph4TrainingPerfVSTestBreakdown,\n realGraph5Buttons,\n realGraph6Phones,\n realGraph7PhonesButtonDirtTraining,\n realGraph8PhonesButtonDirtTest,\n realGraph9PhonesButtonDirtAll,\n ]\n\n showGraph = False if args.showGraph == 0 else True\n\n my_plot_function(showGraph=showGraph, x_axis=x_axis, algo=algo, env=env)"
] | [
[
"matplotlib.pyplot.grid",
"matplotlib.pyplot.gca",
"matplotlib.pyplot.axhline",
"matplotlib.pyplot.annotate",
"matplotlib.pyplot.title",
"matplotlib.pyplot.show",
"matplotlib.pyplot.fill_between"
]
] |
Nilesh-Das/SalaryPredictor | [
"99fa6cb82657457d88d07a52525e507518f5b279"
] | [
"model.py"
] | [
"# Importing the libraries\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport pandas as pd\nimport pickle\n\ndataset = pd.read_csv('hiring.csv')\n\ndataset['experience'].fillna(0, inplace=True)\n\ndataset['test_score'].fillna(dataset['test_score'].mean(), inplace=True)\n\nX = dataset.iloc[:, :3]\n\n# Converting words to integer values\ndef convert_to_int(word):\n word_dict = {'one':1, 'two':2, 'three':3, 'four':4, 'five':5, 'six':6, 'seven':7, 'eight':8,\n 'nine':9, 'ten':10, 'eleven':11, 'twelve':12, 'zero':0, 0: 0}\n return word_dict[word]\n\nX['experience'] = X['experience'].apply(lambda x : convert_to_int(x))\n\ny = dataset.iloc[:, -1]\n\n#Splitting Training and Test Set\nfrom sklearn.linear_model import LinearRegression\nregressor = LinearRegression()\n\n#Fitting model with trainig data\nregressor.fit(X, y)\n\n# Saving model to disk\npickle.dump(regressor, open('model.pkl','wb'))\n\n# Loading model to compare the results\nmodel = pickle.load(open('model.pkl','rb'))\nprint(model.predict([[2, 9, 6]]))\n"
] | [
[
"pandas.read_csv",
"sklearn.linear_model.LinearRegression"
]
] |
smallguoan/tonic | [
"245bf781952d418d39dda300e92afc2c47b661a3"
] | [
"tonic/torch/agents/trpo.py"
] | [
"import torch\n\nfrom tonic import logger # noqa\nfrom tonic.torch import agents, updaters\n\n\ndef default_actor_updater():\n return updaters.TrustRegionPolicyGradient(\n optimizer=updaters.ConjugateGradient(\n constraint_threshold=0.01, damping_coefficient=0.1,\n conjugate_gradient_steps=10, backtrack_steps=10,\n backtrack_coefficient=0.8))\n\n\nclass TRPO(agents.A2C):\n '''Trust Region Policy Optimization.\n TRPO: https://arxiv.org/pdf/1502.05477.pdf\n '''\n\n def __init__(\n self, model=None, replay=None, actor_updater=None, critic_updater=None\n ):\n actor_updater = actor_updater or default_actor_updater()\n super().__init__(\n model=model, replay=replay, actor_updater=actor_updater,\n critic_updater=critic_updater)\n\n def step(self, observations):\n # Sample actions and get their log-probabilities for training.\n actions, log_probs, locs, scales = self._step(observations)\n actions = actions.numpy()\n log_probs = log_probs.numpy()\n locs = locs.numpy()\n scales = scales.numpy()\n\n # Keep some values for the next update.\n self.last_observations = observations.copy()\n self.last_actions = actions.copy()\n self.last_log_probs = log_probs.copy()\n self.last_locs = locs.copy()\n self.last_scales = scales.copy()\n\n return actions\n\n def update(self, observations, rewards, resets, terminations):\n # Store the last transitions in the replay.\n self.replay.store(\n observations=self.last_observations, actions=self.last_actions,\n next_observations=observations, rewards=rewards, resets=resets,\n terminations=terminations, log_probs=self.last_log_probs,\n locs=self.last_locs, scales=self.last_scales)\n\n # Prepare to update the normalizers.\n if self.model.observation_normalizer:\n self.model.observation_normalizer.record(self.last_observations)\n if self.model.return_normalizer:\n self.model.return_normalizer.record(rewards)\n\n # Update the model if the replay is ready.\n if self.replay.ready():\n self._update()\n\n def _step(self, observations):\n observations = torch.as_tensor(observations)\n with torch.no_grad():\n distributions = self.model.actor(observations)\n if hasattr(distributions, 'sample_with_log_prob'):\n actions, log_probs = distributions.sample_with_log_prob()\n else:\n actions = distributions.sample()\n log_probs = distributions.log_prob(actions)\n log_probs = log_probs.sum(axis=-1)\n locs = distributions.loc\n scales = distributions.stddev\n return actions, log_probs, locs, scales\n\n def _update(self):\n # Compute the lambda-returns.\n batch = self.replay.get_full('observations', 'next_observations')\n values, next_values = self._evaluate(**batch)\n values, next_values = values.numpy(), next_values.numpy()\n self.replay.compute_returns(values, next_values)\n\n actor_keys = ('observations', 'actions', 'log_probs', 'locs',\n 'scales', 'advantages')\n actor_batch = self.replay.get_full(*actor_keys)\n actor_infos = self.actor_updater(**actor_batch)\n for k, v in actor_infos.items():\n logger.store('actor/' + k, v.numpy())\n\n critic_keys = 'observations', 'returns'\n critic_iterations = 0\n for critic_batch in self.replay.get(*critic_keys):\n critic_infos = self.critic_updater(**critic_batch)\n critic_iterations += 1\n for k, v in critic_infos.items():\n logger.store('critic/' + k, v.numpy())\n logger.store('critic/iterations', critic_iterations)\n\n # Update the normalizers.\n if self.model.observation_normalizer:\n self.model.observation_normalizer.update()\n if self.model.return_normalizer:\n self.model.return_normalizer.update()\n"
] | [
[
"torch.as_tensor",
"torch.no_grad"
]
] |
RI-imaging/nrefocus | [
"18d520ffa3d13a31255fdee30d48258d61adfb6b"
] | [
"nrefocus/iface/rf_numpy.py"
] | [
"import numpy as np\n\nfrom .. import pad\n\nfrom .base import Refocus\n\n\nclass RefocusNumpy(Refocus):\n \"\"\"Refocusing with numpy-based Fourier transform\n\n .. versionadded:: 0.3.0\n \"\"\"\n def _init_fft(self, field, padding):\n \"\"\"Perform initial Fourier transform of the input field\n\n Parameters\n ----------\n field: 2d complex-valued ndarray\n Input field to be refocused\n padding: bool\n Whether or not to perform zero-padding\n\n Returns\n -------\n fft_field0: 2d complex-valued ndarray\n Fourier transform the the initial field\n \"\"\"\n if padding:\n field = pad.pad_add(field)\n return np.fft.fft2(field)\n\n def propagate(self, distance):\n fft_kernel = self.get_kernel(distance=distance)\n refoc = np.fft.ifft2(self.fft_origin * fft_kernel)\n if self.padding:\n refoc = pad.pad_rem(refoc)\n return refoc\n"
] | [
[
"numpy.fft.ifft2",
"numpy.fft.fft2"
]
] |
mariecpereira/Extracao-de-Caracteristicas-Corpo-Caloso | [
"f094c706db815f91cf61d1d501c2a9030b9b54d3"
] | [
"deliver/ia369/iah2percentile.py"
] | [
"# -*- encoding: utf-8 -*-\n# Module iah2percentile\n\ndef iah2percentile(h,p):\n\n import numpy as np\n s = h.sum()\n k = ((s-1) * p/100.)+1\n dw = np.floor(k)\n up = np.ceil(k)\n hc = np.cumsum(h)\n if isinstance(p, int):\n k1 = np.argmax(hc>=dw)\n k2 = np.argmax(hc>=up)\n else:\n k1 = np.argmax(hc>=dw[:,np.newaxis],axis=1)\n k2 = np.argmax(hc>=up[:,np.newaxis],axis=1)\n d0 = k1 * (up-k)\n d1 = k2 * (k -dw)\n return np.where(dw==up,k1,d0+d1)\n\n"
] | [
[
"numpy.cumsum",
"numpy.ceil",
"numpy.floor",
"numpy.argmax",
"numpy.where"
]
] |
cicorias/supv-ml-py | [
"f7e030206efe5bb2c49433ae18e115ca0fcfc5cb"
] | [
"packtml/utils/linalg.py"
] | [
"# -*- coding: utf-8 -*-\n\nfrom __future__ import absolute_import\n\nfrom numpy import linalg as la\n\n__all__ = [\n 'l2_norm'\n]\n\n\ndef l2_norm(X, axis=0):\n \"\"\"Compute the L2 (Euclidean) norm of a matrix.\n\n Computes the L2 norm along the specified axis. If axis is 0,\n computes the norms along the columns. If 1, computes along the\n rows.\n\n Parameters\n ----------\n X : array-like, shape=(n_samples, n_features)\n The matrix on which to compute the norm.\n\n axis : int, optional (default=0)\n The axis along which to compute the norm. 0 is for columns,\n 1 is for rows.\n \"\"\"\n return la.norm(X, ord=None, axis=axis)\n"
] | [
[
"numpy.linalg.norm"
]
] |
SimonCarozza/autolrn | [
"d0875844a3e9b4fc22510ef320aa498e339b6192"
] | [
"autolrn/encoding/labelenc.py"
] | [
"\"\"\"Label encode and One-Hot encode dataframes.\"\"\"\n\nfrom sklearn.preprocessing import LabelEncoder\nfrom pandas import get_dummies\nfrom pandas import DataFrame\nfrom pandas import Series\nfrom pandas import concat\nfrom pandas import merge\nimport numpy as np\n\n\n# Auto encodes any dataframe column of type category or object.\ndef dummy_encode(df):\n \"\"\"\n Encode any dataframe column of type category or object.\n\n ---\n df: pandas dataframe\n \"\"\"\n columnsToEncode = list(\n df.select_dtypes(include=['category', 'object']))\n\n df1 = df.copy()\n\n for feature in columnsToEncode:\n le = LabelEncoder()\n try:\n df1[feature] = le.fit_transform(df[feature].astype(str))\n except Exception as e:\n print(e)\n print('Error encoding ' + feature)\n return df1\n\n\n#######\n\ndef le_encode_column(column):\n \"\"\"Label-encode pandas DataFrame column or Series\"\"\"\n le = LabelEncoder()\n le_column = le.fit_transform(column.astype(str))\n if isinstance(column, DataFrame):\n le_column = Series(le_column).to_frame(column.name)\n # equivalent to:\n # le_column = DataFrame(le_column, columns=[df_column.name])\n elif isinstance(column, Series):\n le_column = Series(le_column)\n else:\n raise TypeError(\n \"'column' should be of type pandas.DataFrame/Series\")\n\n return le_column\n\n\ndef encode_df_column(df_column):\n \"\"\"Convert dataframe column 'df_column' into df w dummy variables.\"\"\"\n # print(\"column name: \", df_column.name)\n\n # if df_column.isin([' ']):\n # df_column = df_column.str.replace(' ', '_')\n\n try:\n enc_df_column = get_dummies(\n df_column, prefix=df_column.name, prefix_sep='_')\n except MemoryError as me:\n print(me)\n print(\"MemoryError! Column: \" + df_column.name)\n print(\"Proceed to label-encoding\")\n enc_df_column = le_encode_column(df_column)\n except KeyError as ke:\n print(ke)\n print(\"KeyError! Column: \" + df_column.name)\n except ValueError as ve:\n print(ve)\n print(\"ValueError! Column: \" + df_column.name)\n except Exception:\n print('Error encoding feature ' + df_column.name)\n\n # print(\"column head\", enc_df_column.head(1))\n\n assert (len(enc_df_column) == len(df_column)), \\\n \"Ouch! Encoded column's different length than original's!\"\n\n return enc_df_column\n\n\ndef get_date_features(df, freqs=None):\n \"\"\"\n Get dates objects from dataframe.\n\n ---\n df: pandas Dataframe\n freqs: frequencies of datetime objects\n \"\"\"\n new_df = DataFrame()\n\n if freqs is None:\n freqs = ['Year', 'Month', 'Day', 'Week', 'hour', 'min']\n else:\n for f in freqs:\n if f not in ('Year', 'Month', 'Day', 'Week', 'hour', 'min'):\n raise ValueError(\n \"'%s' is not a valid value. Valid values are:\"\n \"['Year', 'Month', 'Day', 'hour', 'min']\"\n % f)\n\n for feature in df.columns:\n if df[feature].dtype == 'datetime64[ns]':\n for f in freqs:\n try:\n if f == 'Year':\n new_df[f] = df[feature].dt.year\n elif f == 'Month':\n new_df[f] = df[feature].dt.month\n elif f == 'Day':\n new_df[f] = df[feature].dt.day\n elif f == 'Week':\n new_df[f] = df[feature].dt.week\n elif f == 'hour':\n new_df[f] = df[feature].dt.hour\n else:\n new_df[f] = df[feature].dt.minute\n except KeyError as ke:\n print(ke)\n print(\"KeyError! Column: \" + feature)\n except ValueError as ve:\n print(ve)\n print(\"ValueError! Column: \" + feature)\n except Exception as e:\n raise e\n else:\n new_df[feature] = df[feature]\n\n assert (len(new_df.index) == len(df.index)), \\\n \"Ouch, encoded dataframe's different length than original's!\"\n\n # remove 0-columns\n new_df = new_df.loc[:, (new_df != 0).any(axis=0)]\n\n return new_df\n\n\ndef get_dummies_or_label_encode(df, target=None, dummy_cols=10, ohe_dates=False):\n \"\"\"\n Label or One-Hot encode columns.\n\n ---\n df: pandas Dataframe\n\n ohe_dates: enable one-hot encoding of eventual date features\n \"\"\"\n df.reset_index(drop=True, inplace=True)\n if target is None:\n new_df = DataFrame()\n cols = df.columns\n else:\n new_df = df[target].to_frame(name=target)\n cols = df.drop([target], axis=1).columns\n\n # print()\n # print(\"New df's columns:\\n\", cols)\n # print()\n\n original_length = len(df.index)\n\n columns_to_encode = list(\n df.select_dtypes(include=['category', 'object', 'int64']))\n\n for feature in cols:\n col = df[feature]\n if df[feature].dtype in (np.int64, 'object'):\n col = col.astype('category')\n nr_uniques = len(col.unique())\n # print(\"%s's nr_uniques:\" % feature, nr_uniques)\n # if df[feature].dtype.name in column_types:\n if feature in columns_to_encode:\n try:\n if new_df.empty:\n # print(\"new_df is empty\")\n if ohe_dates:\n if feature in ('Year', 'Month', 'Day', 'Week', 'hour', 'min'):\n new_df = encode_df_column(col)\n else:\n new_df = le_encode_column(col).to_frame(feature)\n else:\n if nr_uniques < dummy_cols:\n new_df = encode_df_column(col)\n else:\n new_df = le_encode_column(col)\n if isinstance(new_df, Series):\n new_df = new_df.to_frame(feature)\t# you forgot this\n else:\n # merge() more efficient than concat\n if ohe_dates:\n if feature in ('Year', 'Month', 'Day', 'Week', 'hour', 'min'):\n new_df = merge(\n new_df, encode_df_column(col), left_index=True, \n right_index=True)\n else:\n new_df = merge(\n new_df, le_encode_column(col).to_frame(feature), \n left_index=True, right_index=True)\n else:\n new_df = merge(\n new_df, \n encode_df_column(col) if len(col.unique()) < dummy_cols \\\n else le_encode_column(col).to_frame(feature),\n left_index=True, right_index=True)\n # new_df = concat([\n # new_df, \n # encode_df_column(col) if len(col.unique()) < dummy_cols \\\n # else le_encode_column(col).to_frame(feature)], axis=1)\n except KeyError as ke:\n print(ke)\n print(\"KeyError! Column: \" + feature)\n except ValueError as ve:\n print(ve)\n print(\"ValueError! Column: \" + feature)\n except Exception as e:\n raise e\n else:\n if new_df.empty:\n # print(\"new_df is empty\")\n new_df = col.to_frame(feature)\n else:\n # more efficient than concat\n new_df = merge(\n new_df, col.to_frame(feature), \n left_index=True, right_index=True)\n # new_df = concat(\n # [new_df, col.to_frame(feature)], axis=1)\n # print(\"New df's head:\\n\", new_df.head())\n # print(\"New df's length:\", len(new_df.index))\n\n assert (len(new_df.index) == original_length), \\\n \"Ouch, encoded dataframe's different length than original's!\"\n\n print()\n print(\"New final df's head:\\n\", new_df.head(3))\n print(\"New df's tail:\\n\", new_df.tail(3))\n # print(\"New df's columns:\", list(new_df.columns))\n # print(\"New df's length:\", len(new_df.index))\n # print(\"Old df's length:\", original_length)\n\n return new_df\n\n\n"
] | [
[
"pandas.Series",
"pandas.get_dummies",
"pandas.DataFrame",
"sklearn.preprocessing.LabelEncoder"
]
] |
mganahl/jax | [
"a6b2c371d28f49a972814ffec03addb6773621b7"
] | [
"jax/interpreters/partial_eval.py"
] | [
"# Copyright 2018 Google LLC\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# https://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport itertools as it\nfrom collections import namedtuple\nimport contextlib\nimport functools\nfrom typing import (Any, Callable, Dict, NamedTuple, Optional, Sequence, Tuple,\n List, Union, cast, Type, no_type_check)\nfrom weakref import ref\n\nimport numpy as np\n\nfrom .. import core\nfrom .. import dtypes\nfrom .. import linear_util as lu\nfrom ..ad_util import Zero\nfrom .._src.util import (unzip2, safe_zip, safe_map, toposort, partial,\n split_list, cache, as_hashable_function)\nfrom ..core import (Trace, Tracer, Jaxpr, Literal, get_aval, AbstractValue,\n unit, unitvar, abstract_unit, ClosedJaxpr, new_jaxpr_eqn,\n dropvar, ConcreteArray, raise_to_shaped)\nfrom jax._src import source_info_util\nfrom ..config import config\n\nmap = safe_map\nzip = safe_zip\ndef identity(x): return x\n\nclass PartialVal(tuple):\n \"\"\"Partial value: either a known value or an unknown (abstract) value.\n\n Represented as a pair `(aval_opt, const)` of one of two kinds:\n * `(None, <Constant>)` indicates a known value, either a Python regular\n value, or a Tracer.\n * `(<AbstractValue>, *)` indicates an unknown value characterized by an\n abstract value.\n \"\"\"\n def __new__(cls, xs: Tuple[Optional[AbstractValue], core.Value]):\n pv, const = xs\n if not core.skip_checks:\n # type checks\n assert isinstance(pv, (AbstractValue, type(None))), xs\n assert isinstance(const, core.Tracer) or type(const) is Zero or core.valid_jaxtype(const), xs\n # invariant checks\n if isinstance(pv, AbstractValue):\n assert get_aval(const) == core.abstract_unit, xs\n return tuple.__new__(cls, xs)\n\n @classmethod\n def known(cls, const: core.Value) -> 'PartialVal':\n return PartialVal((None, const))\n\n @classmethod\n def unknown(cls, aval: AbstractValue) -> 'PartialVal':\n return PartialVal((aval, core.unit))\n\n def is_known(self) -> bool:\n return self[0] is None\n\n def get_known(self) -> Optional[core.Value]:\n \"\"\"Get the known value, if known, else None.\"\"\"\n return self[1] if self[0] is None else None\n\n def get_aval(self) -> AbstractValue:\n \"\"\"Get AbstractValue directly (if unknown) or from the constant (known).\"\"\"\n known = self.get_known()\n if known is not None:\n return get_aval(known)\n else:\n return self[0]\n\n def merge_with_known(self, val: core.Value) -> core.Value:\n \"\"\"Either the stored known value, or the given 'val'.\"\"\"\n known = self.get_known()\n return known if known is not None else val\n\n\nclass JaxprTrace(Trace):\n def pure(self, val) -> 'JaxprTracer':\n return self.new_const(val)\n\n def lift(self, val) -> 'JaxprTracer':\n return self.new_const(val)\n\n def sublift(self, val) -> 'JaxprTracer':\n return JaxprTracer(self, val.pval, FreeVar(val))\n\n def new_const(self, val) -> 'JaxprTracer':\n if isinstance(val, Tracer) and val._trace.level == self.level:\n raise Exception\n return JaxprTracer(self, PartialVal.known(val), unit)\n\n def new_instantiated_literal(self, val) -> 'JaxprTracer':\n return JaxprTracer(self, PartialVal.unknown(get_aval(val)), Literal(val))\n\n def new_instantiated_const(self, val) -> 'JaxprTracer':\n return JaxprTracer(self, PartialVal.unknown(get_aval(val)), ConstVar(val))\n\n def new_arg(self, pval: PartialVal) -> 'JaxprTracer':\n const = pval.get_known()\n if const is None:\n return JaxprTracer(self, pval, LambdaBinding())\n else:\n return self.new_const(const)\n\n def instantiate_const(self, tracer) -> Tracer:\n const = tracer.pval.get_known()\n if const is None:\n return tracer\n else:\n if type(const) in core.literalable_types and np.shape(const) == ():\n return self.new_instantiated_literal(const)\n else:\n return self.new_instantiated_const(const)\n\n def instantiate_const_abstracted(self, tracer) -> 'JaxprTracer':\n const = tracer.pval.get_known()\n if const is None:\n return tracer\n else:\n aval = raise_to_shaped(get_aval(const), np.isscalar(const))\n return JaxprTracer(self, PartialVal.unknown(aval), ConstVar(const))\n\n def process_primitive(self, primitive, tracers, params):\n if primitive in custom_partial_eval_rules:\n return custom_partial_eval_rules[primitive](self, *tracers, **params)\n else:\n return self.default_process_primitive(primitive, tracers, params)\n\n def default_process_primitive(self, primitive, tracers, params):\n \"\"\"By default, if all the input tracers are known, then execute the primitive\n and all the ouputs are known. Otherwise, all the outputs are unknown.\"\"\"\n consts = [t.pval.get_known() for t in tracers]\n if all(c is not None for c in consts):\n return primitive.bind(*consts, **params)\n tracers = map(self.instantiate_const, tracers)\n avals = [t.aval for t in tracers]\n out_aval = primitive.abstract_eval(*avals, **params)\n source = source_info_util.current()\n if primitive.multiple_results:\n out_tracers = [JaxprTracer(self, PartialVal.unknown(aval), None)\n for aval in out_aval]\n eqn = new_eqn_recipe(tracers, out_tracers, primitive, params, source)\n for t in out_tracers: t.recipe = eqn\n return out_tracers\n else:\n out_tracer = JaxprTracer(self, PartialVal.unknown(out_aval), None)\n out_tracer.recipe = new_eqn_recipe(tracers, [out_tracer], primitive,\n params, source)\n return out_tracer\n\n # We use process_call to handle both call and map primitives.\n def process_call(self, primitive, f: lu.WrappedFun, tracers, params):\n if not config.omnistaging_enabled:\n if (self.main.trace_type is StagingJaxprTrace # type: ignore\n and primitive in staged_out_calls): # type: ignore\n tracers = map(self.instantiate_const_abstracted, tracers)\n\n if primitive in call_partial_eval_rules:\n return call_partial_eval_rules[primitive](self, primitive, f, tracers, params)\n\n in_pvals = [t.pval for t in tracers]\n if primitive.map_primitive:\n mapped_aval = partial(core.mapped_aval, params['axis_size'])\n in_pvals = [pval if pval.is_known() or in_axis is None\n else PartialVal.unknown(mapped_aval(in_axis, pval[0]))\n for pval, in_axis in zip(in_pvals, params['in_axes'])]\n\n def app(f, *args):\n f, num_outputs = count_outputs(f)\n out_axes_thunk = params['out_axes_thunk']\n @as_hashable_function(closure=out_axes_thunk)\n def new_out_axes_thunk():\n out_axes = out_axes_thunk()\n return out_axes + (0,) * (num_outputs() - len(out_axes))\n pe_params = dict(params, out_axes_thunk=new_out_axes_thunk)\n return primitive.bind(f, *args, **pe_params)\n else:\n app = partial(primitive.bind, **params)\n jaxpr, out_pvals, consts, env_tracers = self.partial_eval(\n f, in_pvals, app, instantiate=False)\n if primitive.map_primitive:\n unmapped_aval = partial(core.unmapped_aval, params['axis_size'])\n out_axes = params['out_axes_thunk']()\n out_pvals = [pval if pval.is_known() else\n PartialVal.unknown(unmapped_aval(out_axis, pval[0])) if out_axis is not None else\n PartialVal.unknown(pval[0])\n for pval, out_axis in zip(out_pvals, out_axes)]\n\n # Skip known invars and outvars, and lift constants as regular invars\n in_knowns = tuple(t.pval.is_known() for t in it.chain(env_tracers, tracers))\n out_unknowns = tuple(not pval.is_known() for pval in out_pvals)\n jaxpr = _drop_invars(jaxpr, in_knowns)\n jaxpr = _dce_open_jaxpr(jaxpr, out_unknowns, drop_outputs=True)\n\n # Known tracers get propagated as if they were constants\n known_tracers_out = [self.new_const(pval.get_known()) for pval in out_pvals\n if pval.is_known()]\n\n # Unknown tracers need to have the jaxpr set up as their recipe\n unknown_tracers_out = [JaxprTracer(self, pval, None) for pval in out_pvals\n if not pval.is_known()]\n unknown_tracers_in = [t for t in tracers if not t.pval.is_known()]\n const_tracers = map(self.new_instantiated_const, consts)\n in_tracers = (*const_tracers, *env_tracers, *unknown_tracers_in)\n\n # Set up new params\n new_params = dict(params, call_jaxpr=convert_constvars_jaxpr(jaxpr))\n if primitive.map_primitive:\n in_axes = params['in_axes']\n # NOTE: const_tracers are added as map outputs, and we always map them\n # along axis 0 (see `new_out_axes_thunk` above).\n new_in_axes = ((0,) * len(const_tracers) +\n (None,) * len(env_tracers) +\n tuple(axis for axis, t in zip(in_axes, tracers)\n if not t.pval.is_known()))\n new_out_axes = tuple(axis for axis, pval in zip(out_axes, out_pvals)\n if not pval.is_known())\n new_params = dict(new_params, in_axes=new_in_axes, out_axes=new_out_axes)\n del new_params['out_axes_thunk']\n update_params = call_param_updaters.get(primitive)\n if update_params:\n new_params = update_params(new_params, [not t.pval.is_known() for t in tracers])\n\n eqn = new_eqn_recipe(in_tracers, unknown_tracers_out, primitive, new_params,\n source_info_util.current())\n for t in unknown_tracers_out: t.recipe = eqn\n return _zip_knowns(known_tracers_out, unknown_tracers_out, out_unknowns)\n\n process_map = process_call\n\n # We use post_process_call to handle both call and map primitives.\n def post_process_call(self, primitive, out_tracers, params):\n jaxpr, consts, env = tracers_to_jaxpr([], out_tracers)\n out_pvs, out_pv_consts = unzip2(t.pval for t in out_tracers)\n out = out_pv_consts + consts\n nconsts = len(consts)\n del consts, out_pv_consts\n main = self.main\n\n if primitive.map_primitive:\n out_axes = params['out_axes_thunk']()\n sz = params['axis_size']\n out_pvs = [None if pv is None else core.unmapped_aval(sz, ax, pv)\n for pv, ax in zip(out_pvs, out_axes)]\n\n def todo(x):\n n = len(jaxpr.outvars)\n out_pv_consts, consts = x[:n], x[n:]\n trace = JaxprTrace(main, core.cur_sublevel())\n const_tracers = map(trace.new_instantiated_const, consts)\n out_tracers = [JaxprTracer(trace, PartialVal((out_pv, out_pv_const)), None)\n for out_pv, out_pv_const in zip(out_pvs, out_pv_consts)]\n in_tracers = (*const_tracers, *map(trace.full_raise, env))\n\n new_params = dict(params, call_jaxpr=convert_constvars_jaxpr(jaxpr))\n if primitive.map_primitive:\n # NOTE: We've assigned axis 0 to const tracers below, in out_axes_transform.\n new_in_axes = (0,) * len(const_tracers) + (None,) * len(env)\n new_params = dict(new_params, in_axes=new_in_axes, out_axes=out_axes)\n del new_params['out_axes_thunk']\n update_params = call_param_updaters.get(primitive)\n if update_params:\n new_params = update_params(new_params, [])\n\n eqn = new_eqn_recipe(in_tracers, out_tracers, primitive, new_params,\n source_info_util.current())\n for t in out_tracers:\n t.recipe = eqn\n return out_tracers\n\n if primitive.map_primitive:\n def out_axes_transform(out_axes):\n return out_axes + (0,) * nconsts\n todo = (todo, out_axes_transform)\n\n return out, todo\n\n post_process_map = post_process_call\n\n def partial_eval(self, f: lu.WrappedFun, pvals: Sequence[PartialVal],\n app: Callable[[lu.WrappedFun, Tuple[core.Value, ...]], Tuple[core.Value]],\n instantiate: bool):\n \"\"\"Partially evaluate f on a sequence of PartialVals.\"\"\"\n in_avals, in_consts = unzip2(pvals)\n f = trace_to_subjaxpr(f, self.main, instantiate)\n f, aux = partial_eval_wrapper(f, tuple(in_avals))\n out_flat, (out_avals, jaxpr, env) = app(f, *in_consts), aux()\n out_consts, consts = split_list(out_flat, [len(out_flat)-len(jaxpr.constvars)])\n out_pvs = map(PartialVal, zip(out_avals, out_consts))\n env_tracers = map(self.full_raise, env)\n return jaxpr, out_pvs, consts, env_tracers\n\n def process_custom_jvp_call(self, prim, fun, jvp, tracers):\n tracers = map(self.instantiate_const_abstracted, tracers)\n in_avals, in_consts = unzip2(t.pval for t in tracers) # in_consts are units\n fun = trace_to_subjaxpr(fun, self.main, True)\n fun, aux = partial_eval_wrapper(fun, tuple(in_avals))\n out_flat = prim.bind(fun, jvp, *in_consts)\n out_avals, jaxpr, env = aux()\n out_consts, consts = split_list(out_flat, [len(out_flat)-len(jaxpr.constvars)])\n out_pvals = map(PartialVal, zip(out_avals, out_consts)) # out_consts are units\n env_tracers = map(self.full_raise, env)\n out_tracers = [JaxprTracer(self, pval, None) for pval in out_pvals]\n const_tracers = map(self.new_instantiated_const, consts)\n in_tracers = (*const_tracers, *env_tracers, *tracers)\n closed_jaxpr = core.ClosedJaxpr(convert_constvars_jaxpr(jaxpr), ())\n\n @_memoize\n def jvp_jaxpr_thunk():\n jvp_ = trace_to_subjaxpr(jvp, self.main, True)\n jvp_, aux = partial_eval_wrapper(jvp_, tuple(in_avals) * 2)\n out_flat = jvp_.call_wrapped(*(in_consts * 2)) # in_consts are units\n out_avals, jaxpr, env = aux()\n _, consts = split_list(out_flat, [len(out_flat)-len(jaxpr.constvars)])\n converted_jaxpr = convert_envvars_to_constvars(jaxpr, len(env))\n return converted_jaxpr, (*consts, *env)\n\n eqn = new_eqn_recipe(in_tracers, out_tracers, prim.initial_style,\n dict(fun_jaxpr=closed_jaxpr,\n jvp_jaxpr_thunk=jvp_jaxpr_thunk,\n num_consts=len(consts) + len(env)),\n source_info_util.current())\n for t in out_tracers: t.recipe = eqn\n return out_tracers\n\n def post_process_custom_jvp_call(self, out_tracers, params):\n # This path should only be reachable if we expose a partial eval API\n # unrelated to autodiff, since we raise an error when differentiation with\n # respect to values over which a custom_jvp function closes is detected.\n raise NotImplementedError # TODO(mattjj)\n\n def process_custom_vjp_call(self, prim, fun, fwd, bwd, tracers, out_trees):\n tracers = map(self.instantiate_const_abstracted, tracers)\n in_avals, in_consts = unzip2(t.pval for t in tracers) # in_consts are units\n fun = trace_to_subjaxpr(fun, self.main, True)\n fun, aux = partial_eval_wrapper(fun, tuple(in_avals))\n out_flat = prim.bind(fun, fwd, bwd, *in_consts, out_trees=out_trees)\n out_avals, jaxpr, env = aux()\n out_consts, consts = split_list(out_flat, [len(out_flat)-len(jaxpr.constvars)])\n out_pvals = map(PartialVal, zip(out_avals, out_consts)) # out_consts are units\n env_tracers = map(self.full_raise, env)\n out_tracers = [JaxprTracer(self, pval, None) for pval in out_pvals]\n const_tracers = map(self.new_instantiated_const, consts)\n in_tracers = (*const_tracers, *env_tracers, *tracers)\n closed_jaxpr = core.ClosedJaxpr(convert_constvars_jaxpr(jaxpr), ())\n\n @_memoize\n def fwd_jaxpr_thunk():\n fwd_ = trace_to_subjaxpr(fwd, self.main, True)\n fwd_, aux = partial_eval_wrapper(fwd_, tuple(in_avals))\n out_flat = fwd_.call_wrapped(*in_consts) # in_consts are units\n out_avals, jaxpr, env = aux()\n _, consts = split_list(out_flat, [len(out_flat)-len(jaxpr.constvars)])\n converted_jaxpr = convert_envvars_to_constvars(jaxpr, len(env))\n return converted_jaxpr, (*consts, *env)\n\n eqn = new_eqn_recipe(in_tracers, out_tracers, prim.initial_style,\n dict(fun_jaxpr=closed_jaxpr,\n fwd_jaxpr_thunk=fwd_jaxpr_thunk,\n num_consts=len(consts) + len(env),\n bwd=bwd, out_trees=out_trees),\n source_info_util.current())\n for t in out_tracers: t.recipe = eqn\n return out_tracers\n\n def post_process_custom_vjp_call(self, out_tracers, params):\n # This path should only be reachable if we expose a partial eval API\n # unrelated to autodiff, since we raise an error when differentiation with\n # respect to values over which a custom_vjp function closes is detected.\n raise NotImplementedError # TODO(mattjj)\n\n\[email protected]_with_aux\ndef partial_eval_wrapper(pvs: Sequence[Optional[AbstractValue]], *consts):\n py_args = map(PartialVal, zip(pvs, consts))\n jaxpr, (out_pvals, consts, env) = yield (py_args,), {}\n out_pvs, out_consts = unzip2(out_pvals)\n out = tuple(out_consts) + tuple(consts)\n yield out, (out_pvs, jaxpr, env)\n\[email protected]_with_aux\ndef count_outputs(*args, **kwargs):\n ans = yield args, kwargs\n yield ans, len(ans)\n\ncustom_partial_eval_rules: Dict[core.Primitive, Callable] = {}\ncall_partial_eval_rules: Dict[core.Primitive, Callable] = {}\ncall_param_updaters: Dict[core.Primitive, Callable] = {}\n\n\ndef abstract_eval_fun(fun, *avals, **params):\n if config.omnistaging_enabled:\n _, avals_out, _ = trace_to_jaxpr_dynamic(lu.wrap_init(fun, params), avals)\n else:\n pvals_in = [PartialVal.unknown(a) for a in avals]\n _, pvals_out, _ = trace_to_jaxpr(lu.wrap_init(fun, params), pvals_in,\n instantiate=True, stage_out=True) # type: ignore\n avals_out, _ = unzip2(pvals_out)\n for aval_out in avals_out:\n assert isinstance(aval_out, AbstractValue) # instantiate=True\n return avals_out\n\n\nJaxprTracerRecipe = Union['JaxprEqnRecipe', 'LambdaBinding', 'FreeVar',\n 'ConstVar', Literal, core.Unit]\n\nclass JaxprTracer(Tracer):\n __slots__ = ['pval', 'recipe']\n\n def __init__(self, trace: JaxprTrace, pval: PartialVal,\n recipe: Optional[JaxprTracerRecipe]):\n assert isinstance(pval, PartialVal)\n pv, const = pval\n if isinstance(const, Tracer) and const._trace.level >= trace.level:\n raise core.escaped_tracer_error(\n const, \"Tracer from a higher level: {} in trace {}\".format(const, trace))\n self._trace = trace\n self.pval = pval\n self.recipe = recipe\n\n def __repr__(self):\n return 'Traced<{}:{}>'.format(self.aval, self._trace)\n\n @property\n def aval(self) -> AbstractValue:\n return self.pval.get_aval()\n\n @property\n def parents(self) -> Sequence['JaxprTracer']:\n if isinstance(self.recipe, JaxprEqnRecipe):\n return self.recipe.invars\n else:\n return []\n\n def full_lower(self):\n known = self.pval.get_known()\n if known is not None:\n return core.full_lower(known)\n else:\n return self\n\n def is_known(self):\n return self.pval.is_known()\n\n# TODO(necula): this could return a ClosedJaxpr with out_pvals\ndef trace_to_jaxpr(fun: lu.WrappedFun, pvals: Sequence[PartialVal],\n instantiate: Union[bool, Sequence[bool]] = False,\n ) -> Tuple[Jaxpr, Tuple[PartialVal, ...], Tuple[core.Value, ...]]:\n \"\"\"Traces a function into a Jaxpr, given PartialVals for inputs.\n\n Returns (`jaxpr`, `out_pvals`, `consts`). The `jaxpr` contains only the\n computation that depends on unknown inputs. The `out_pvals` are the PartialVal\n for the outputs. The intermediate values that depend only on known inputs and\n are needed to compute the output of `jaxpr` are in `consts` and are passed in\n as the constvars of the `jaxpr`. The handling of the known outputs depends on\n `instantiate`.\n\n For example, given `fun` defined as follows::\n\n def fun(ki, ui): # ki will be a known input in this example\n ka = ki + 2\n kb = ka + 3\n return (kb, ui + ka)\n\n with `ki` the known PartialVal `1.`, and `ui` an unknown PartialVal. The only\n computation that depends on unknown inputs is `ui + ka` and will be the only\n computation in the body of the `jaxpr`. This computation depends on the known\n intermediate value `ka`, which will be computed statically. Currently, such\n constants are either embedded in the Jaxpr if they are scalars, or passed as a\n constvar to `jaxpr`, and then the value of the actual constant will be in\n `consts`:\n\n When `instantiate=False` we get::\n\n jaxpr =\n { lambda ka ; ki ui.\n let c = add ui ka\n in (*, c) } # known outputs are `*`\n out_pvals = [PartialVal.known(6), PartialVal.unknown(ShapedArray)]\n consts = [3] # the constant for `ka`\n\n When `instantiate=True` we get::\n\n jaxpr =\n { lambda ka kb ; ki ui.\n let c = add ui ka\n in (kb, c) } # known output are explicit\n out_pvals = [PartialVal.unknown(ConcreteArray(6)), PartialVal.unknown(ShapedArray)]\n consts = [3, 6] # values for `ka` and `kb` constvars\n \"\"\"\n with core.new_main(JaxprTrace) as main:\n fun = trace_to_subjaxpr(fun, main, instantiate)\n jaxpr, (out_pvals, consts, env) = fun.call_wrapped(pvals)\n assert not env\n del main, fun, env\n\n return jaxpr, out_pvals, consts\n\n\[email protected]\ndef trace_to_subjaxpr(main: core.MainTrace, instantiate: Union[bool, Sequence[bool]],\n pvals: Sequence[PartialVal]):\n assert all([isinstance(pv, PartialVal) for pv in pvals]), pvals\n trace = JaxprTrace(main, core.cur_sublevel())\n in_tracers = map(trace.new_arg, pvals)\n ans = yield in_tracers, {}\n assert isinstance(ans, (list, tuple)), (\n f\"Got unexpected return type when tracing function to jaxpr: {ans}\")\n assert all(isinstance(x, core.Tracer) or core.valid_jaxtype(x) for x in ans), (\n f\"Got unexpected return type when tracing function to jaxpr: {ans}\")\n instantiate = [instantiate] * len(ans) if isinstance(instantiate, bool) else instantiate\n out_tracers = map(trace.full_raise, map(core.full_lower, ans))\n out_tracers = map(partial(instantiate_const_at, trace), instantiate, out_tracers)\n jaxpr, consts, env = tracers_to_jaxpr(in_tracers, out_tracers)\n out_pvals = [t.pval for t in out_tracers]\n del trace, in_tracers, out_tracers\n yield jaxpr, (out_pvals, consts, env)\n\ndef instantiate_const_at(trace: JaxprTrace, instantiate: bool, tracer):\n if instantiate:\n return trace.instantiate_const(trace.full_raise(tracer))\n else:\n return tracer\n\n\nFreeVar = namedtuple('FreeVar', ['val'])\nConstVar = namedtuple('ConstVar', ['val'])\nLambdaBinding = namedtuple('LambdaBinding', [])\nclass JaxprEqnRecipe(NamedTuple):\n eqn_id: object\n invars: Sequence[JaxprTracer]\n outvars: 'Sequence[ref[JaxprTracer]]'\n primitive: core.Primitive\n params: Dict[str, Any]\n source_info: Optional[source_info_util.Traceback]\n\ndef new_eqn_recipe(invars: Sequence[JaxprTracer],\n outvars: Sequence[JaxprTracer],\n primitive: core.Primitive,\n params: Dict[str, Any],\n source_info: Optional[source_info_util.Traceback]\n ) -> JaxprEqnRecipe:\n \"\"\"Constructs a new JaxEqnRecipe.\n\n Params:\n invars: the tracers for the primitive inputs.\n outvars: the tracers for the primitive outputs.\n primitive: the primitive.\n params: the primitive params\n \"\"\"\n # TODO(necula): move these checks to core.check_jaxpr, and call in more places\n if primitive.call_primitive or primitive.map_primitive:\n assert \"call_jaxpr\" in params\n if primitive.map_primitive:\n assert (\"in_axes\" in params and\n len(params[\"in_axes\"]) == len(params[\"call_jaxpr\"].invars))\n assert (\"donated_invars\" in params and\n len(params[\"donated_invars\"]) == len(params[\"call_jaxpr\"].invars))\n return JaxprEqnRecipe(object(), tuple(invars), map(ref, outvars), primitive,\n params, source_info)\n\n\ndef recipe_to_eqn(getvar: Callable[[JaxprTracer], core.Atom],\n recipe: JaxprEqnRecipe) -> core.JaxprEqn:\n _, in_tracers, out_tracer_refs, primitive, params, source_info = recipe\n out_tracers = [t_ref() for t_ref in out_tracer_refs]\n invars = [getvar(t) for t in in_tracers]\n outvars = [core.dropvar if t is None else cast(core.Var, getvar(t))\n for t in out_tracers]\n return new_jaxpr_eqn(invars, outvars, primitive, params, source_info)\n\ndef tracers_to_jaxpr(\n in_tracers: Sequence[JaxprTracer],\n out_tracers: Sequence[JaxprTracer]\n ) -> Tuple[Jaxpr, Tuple[Any, ...], Tuple[Any, ...]]:\n \"\"\"Constructs Jaxpr given tracers for inputs and outputs.\n\n Params:\n in_tracers: the tracers that were created for the function inputs\n out_tracers: the tracers that were output by the function.\n\n Returns: a triple of a `Jaxpr`, a list of constant values corresponding to\n the `constvars` in the returned Jaxps, and a list of environment values.\n The vars for the environment values have been prepended to the Jaxpr's\n `invars`.\n \"\"\"\n newvar = core.gensym()\n t_to_var: Dict[int, core.Atom] = {}\n def getvar(t: JaxprTracer) -> core.Atom:\n var = t_to_var.get(id(t))\n if var is None:\n aval = t.pval.get_aval() if not t.pval.is_known() else abstract_unit\n var = t_to_var[id(t)] = newvar(aval)\n return var\n sorted_tracers = toposort(out_tracers)\n invars = map(getvar, in_tracers)\n eqns: List[core.JaxprEqn] = []\n env: Dict[core.Var, Any] = {}\n consts: Dict[core.Var, Any] = {}\n const_to_var: Dict[int, core.Var] = {}\n def getconstvar(c):\n var = const_to_var.get(id(c))\n if var is None:\n var = const_to_var[id(c)] = newvar(get_aval(c))\n return var\n processed_eqn_ids = set()\n for t in sorted_tracers:\n recipe = t.recipe\n if isinstance(recipe, JaxprEqnRecipe):\n if recipe.eqn_id not in processed_eqn_ids:\n eqns.append(recipe_to_eqn(getvar, recipe))\n processed_eqn_ids.add(recipe.eqn_id)\n elif isinstance(recipe, LambdaBinding):\n if not any(t is in_tracer for in_tracer in in_tracers):\n raise core.escaped_tracer_error(\n t, \"Tracer not among input tracers {}\".format(t))\n assert in_tracers, \"Lambda binding with no args\"\n elif isinstance(recipe, FreeVar):\n env[cast(core.Var, getvar(t))] = recipe.val\n elif isinstance(recipe, ConstVar):\n v = t_to_var[id(t)] = getconstvar(recipe.val)\n consts[v] = recipe.val\n elif isinstance(recipe, Literal):\n t_to_var[id(t)] = recipe\n elif recipe is unit:\n t_to_var[id(t)] = unitvar\n else:\n raise TypeError(recipe)\n\n env_vars, env_vals = unzip2(env.items())\n const_vars, const_vals = unzip2(consts.items())\n # The env_vars are pre-pended to the invars\n jaxpr = Jaxpr(const_vars, [*env_vars, *invars], map(getvar, out_tracers), eqns)\n core.skip_checks or core.check_jaxpr(jaxpr)\n return jaxpr, const_vals, env_vals\n\n@cache()\ndef convert_constvars_jaxpr(jaxpr: Jaxpr):\n \"\"\"Moves the constvars to the start of invars.\"\"\"\n core.skip_checks or core.check_jaxpr(jaxpr)\n lifted_jaxpr = Jaxpr(constvars=(),\n invars=jaxpr.constvars + jaxpr.invars,\n outvars=jaxpr.outvars, eqns=jaxpr.eqns)\n core.skip_checks or core.check_jaxpr(lifted_jaxpr)\n return lifted_jaxpr\n\ndef convert_envvars_to_constvars(jaxpr: Jaxpr, num_env_vars: int):\n core.skip_checks or core.check_jaxpr(jaxpr)\n env_vars, invars = split_list(jaxpr.invars, [num_env_vars])\n converted_jaxpr = Jaxpr(constvars=jaxpr.constvars + env_vars,\n invars=invars, outvars=jaxpr.outvars, eqns=jaxpr.eqns)\n core.skip_checks or core.check_jaxpr(converted_jaxpr)\n return converted_jaxpr\n\n\ndef _split_aval(unknown: bool, aval: AbstractValue) -> Tuple[AbstractValue, AbstractValue]:\n return (abstract_unit, aval) if unknown else (aval, abstract_unit)\n\ndef partial_eval_jaxpr(jaxpr: ClosedJaxpr, unknowns: Sequence[bool],\n instantiate: Union[bool, Sequence[bool]],\n ) -> Tuple[ClosedJaxpr, ClosedJaxpr, Sequence[bool]]:\n \"\"\"Specializes a Jaxpr given an indication of which inputs are known.\n\n Returns: (jaxpr_known, jaxpr_unknown, out_unknowns).\n\n `out_unknowns` specifies which outputs are unknown (depend on some unknown inputs).\n `jaxpr_known` takes the same inputs as `jaxpr`, ignores the unknown inputs,\n and performs *all* the computation in `jaxpr` that depends only on the known inputs.\n Outputs correspond to those of `jaxpr`, with the unknown ones replaced with `*`,\n appended with the known residuals (the intermediate computations in `jaxpr`\n that depend only on known inputs and that are needed to compute the unknown outputs).\n\n `jaxpr_unknown` takes the same inputs as `jaxpr` along with the known residuals\n computed by `jaxpr_known` and returns the same outputs as `jaxpr` with the known\n outputs replaced by `*`.\n\n Roughly, `jaxpr(ki, ui)` is decomposed assuming `ki` and `ui` are the known and respectively\n unknown inputs into:\n\n jaxpr(ki, ui) = let kout, _, kresidual = jaxpr_known(kin, *)\n let _, uout = jaxpr_unknown(ki, ui, kresidual)\n in (kout, uout)\n\n For example, if `jaxpr` is lambda ki, ui: let ka = ki + 2\n in (ki + 3, ui + ka)\"\n then\n `jaxpr_known` = lambda ki, ui: let ka = ki + 2\n in (ki + 3, *, ka)\n 'jaxpr_unknown` = lambda ki, ui, ka: (*, ui + ka)\n\n Note that if instantiate is True for a given output, then jaxpr_known always returns a\n unit in its place. So when instantiate is True, the expectation is the one doesn't\n run `jaxpr_known` for any of its outputs, but only to generate residuals that will allow\n to obtain the full outputs once `jaxpr_unknown` is ran. Outputs known ahead of time will\n simply get passed as residual constants and returned immediately.\n \"\"\"\n f = lu.wrap_init(core.jaxpr_as_fun(jaxpr))\n\n cell = []\n def fun(*vals):\n pvals = [PartialVal.unknown(aval) if uk else PartialVal.known(val)\n for aval, val, uk in zip(jaxpr.in_avals, vals, unknowns)]\n jaxpr_2, out_pvals_2, consts_2 = trace_to_jaxpr(f, pvals, instantiate=instantiate)\n out_pvs_2, out_consts_2 = unzip2(out_pvals_2)\n cell.append((out_pvs_2, jaxpr_2, len(consts_2)))\n return out_consts_2 + consts_2\n\n # For jaxpr_known we pass core.unit for the unknown inputs, and known PartialVal for the\n # known inputs.\n in_avals = [abstract_unit if uk else a for a, uk in zip(jaxpr.in_avals, unknowns)]\n jaxpr_1, out_avals, consts_1 = trace_to_jaxpr_dynamic(lu.wrap_init(fun), in_avals)\n (out_pvs_2, jaxpr_2, num_res), = cell\n assert len(jaxpr_2.constvars) == num_res\n\n # jaxpr :: a -> b\n # jaxpr_1 :: a1 -> [b1, res]\n # jaxpr_2 :: res | a2 -> b2\n # jaxpr_2 :: [a2, res] -> b2\n jaxpr_2 = convert_constvars_jaxpr(jaxpr_2)\n jaxpr_2.invars = jaxpr_2.invars[num_res:] + jaxpr_2.invars[:num_res]\n for var, unknown in zip(jaxpr_2.invars[:len(unknowns)], unknowns):\n if not unknown:\n var.aval = abstract_unit\n\n uk_out = [pv is not None for pv in out_pvs_2]\n\n in_avals_1, in_avals_2 = unzip2(map(_split_aval, unknowns, jaxpr.in_avals))\n out_avals_1, out_avals_2 = unzip2(map(_split_aval, uk_out, jaxpr.out_avals))\n # out_avals_1 and in_avals_2 need the residuals added\n res_avals = out_avals[len(jaxpr.out_avals):]\n assert len(res_avals) == num_res\n out_avals_1 = [*out_avals_1, *res_avals]\n in_avals_2 = [*in_avals_2, *res_avals]\n\n return ClosedJaxpr(jaxpr_1, consts_1), ClosedJaxpr(jaxpr_2, ()), uk_out\n\n\nremat_call_p: core.Primitive = core.CallPrimitive('remat_call')\nremat_call = remat_call_p.bind\nremat_call_p.def_impl(core.call_impl)\n\ndef _remat_partial_eval(trace, _, f, tracers, params):\n concrete = params['concrete']\n\n # Unlike JaxprTrace.process_call, we want to form a jaxpr for the entirety of\n # the function being called, not just for the unknown parts. To do that, we\n # instantiate all the input tracers as constants in the jaxpr being formed.\n # Those tracers might have concrete avals, and doing abstract interpretation\n # on concrete avals engenders a tradeoff: it allows data-dependent Python\n # control flow to work, but it can in some cases lead to redundant FLOPs (done\n # both in the `bind` call below and the `core.jaxpr_as_fun` call). We use the\n # `concrete` parameter to switch this behavior, and if `concrete` is False\n # then we raise the avals to the Shaped level.\n if concrete:\n instantiated_tracers = map(trace.instantiate_const, tracers)\n else:\n instantiated_tracers = map(trace.instantiate_const_abstracted, tracers)\n\n # Using the instantiated tracers, run call_bind like JaxprTrace.process_call.\n in_pvals = [t.pval for t in instantiated_tracers]\n if config.omnistaging_enabled:\n jaxpr, eval_out_pvals, consts, env_tracers = trace.partial_eval(\n f, in_pvals, partial(remat_call_p.bind, **params), instantiate=False)\n else:\n with core.initial_style_staging(): # type: ignore\n jaxpr, eval_out_pvals, consts, env_tracers = trace.partial_eval(\n f, in_pvals, partial(remat_call_p.bind, **params), instantiate=False)\n\n # Convert consts to inputs, since they may contain Tracer instances.\n jaxpr = convert_constvars_jaxpr(jaxpr)\n const_tracers = map(trace.new_instantiated_const, consts)\n\n # Since we traced with everything marked as unknown, but we need to know which\n # outputs are known/unknown, we use partial_eval_jaxpr to get out_unknowns.\n closed_jaxpr = core.ClosedJaxpr(jaxpr, ())\n in_unknowns = ([False] * len(consts) +\n [not t.is_known() for t in it.chain(env_tracers, tracers)])\n if config.omnistaging_enabled:\n jaxpr_known, jaxpr_unknown, out_unknowns = partial_eval_jaxpr(\n closed_jaxpr, in_unknowns, instantiate=False) # type: ignore\n else:\n jaxpr_known, jaxpr_unknown, out_unknowns = partial_eval_jaxpr(\n closed_jaxpr, in_unknowns, instantiate=False, trace_type=trace.main.trace_type) # type: ignore\n out_knowns = [not b for b in out_unknowns]\n out_known_pvals, out_unknown_pvals = _partition_knowns(eval_out_pvals, out_unknowns)\n\n # Next, we need values for the outputs that should be known. Since consts\n # weren't passed through Python for evaluation, we need to evaluate jaxpr_known,\n # minus the residual outputs that we don't need. When `concrete=True`, as an\n # optimization we can avoid redoing *some* redundant FLOPs, namely those that\n # produced concrete avals at the output, simply by using those as computed\n # values. For the use case of inverse-mode ad in op-by-op (\"eager mode\")\n # evaluation, all the primal outputs should be concrete (thus not recomputed).\n to_compute = [type(pval[0]) is not ConcreteArray\n for uk, pval in zip(out_unknowns, eval_out_pvals) if not uk]\n num_outputs = len(jaxpr_unknown.out_avals)\n num_res = len(jaxpr_known.out_avals) - num_outputs\n jaxpr_known_nores = _dce_jaxpr(jaxpr_known, out_knowns + [False] * num_res, drop_outputs=True)\n jaxpr_known_comp = _dce_jaxpr(jaxpr_known_nores, to_compute)\n _, in_consts = unzip2(t.pval for t in it.chain(env_tracers, tracers))\n reconstructed_consts = core.jaxpr_as_fun(jaxpr_known_comp)(*consts, *in_consts)\n out_known_pvals = map(_reconstruct_pval, out_known_pvals, reconstructed_consts)\n\n # Known outputs should keep propagating as constants\n assert all(pv.is_known() for pv in out_known_pvals)\n known_output_tracers = [trace.new_const(pval.get_known())\n for pval in out_known_pvals]\n # Unknown outputs get wrapped in tracers with the appropriate recipe\n unknown_output_tracers = [JaxprTracer(trace, out_pval, None)\n for out_pval in out_unknown_pvals]\n\n # dce jaxpr outputs\n new_jaxpr = _dce_jaxpr(closed_jaxpr, out_unknowns, drop_outputs=True).jaxpr\n new_params = dict(params, call_jaxpr=new_jaxpr)\n\n # set up eqn for unknown outputs\n in_tracers = (*const_tracers, *env_tracers, *instantiated_tracers)\n eqn = new_eqn_recipe(in_tracers, unknown_output_tracers, remat_call_p, new_params,\n source_info_util.current())\n for t in unknown_output_tracers: t.recipe = eqn\n return _zip_knowns(known_output_tracers, unknown_output_tracers, out_unknowns)\ncall_partial_eval_rules[remat_call_p] = _remat_partial_eval\n\ndef _partition_knowns(pvals, unknowns: Sequence[bool]):\n return ([e for e, unknown in zip(pvals, unknowns) if not unknown],\n [e for e, unknown in zip(pvals, unknowns) if unknown])\n\ndef _zip_knowns(known_list, unknown_list, which_unknown: Sequence[bool]):\n known_iter, unknown_iter = iter(known_list), iter(unknown_list)\n return [next(unknown_iter) if uk else next(known_iter) for uk in which_unknown]\n\n\ndef _dce_jaxpr(closed_jaxpr: ClosedJaxpr, outputs: Sequence[bool], drop_outputs=False) -> ClosedJaxpr:\n new_jaxpr = _dce_open_jaxpr(closed_jaxpr.jaxpr, tuple(outputs), drop_outputs)\n return core.ClosedJaxpr(new_jaxpr, closed_jaxpr.consts)\n\n@cache()\ndef _dce_open_jaxpr(jaxpr: Jaxpr, outputs: Tuple[bool, ...], drop_outputs=False) -> Jaxpr:\n # This dead-code elimination is pretty rudimentary, and in particular doesn't\n # nontrivially DCE through scan, call, or other higher-order primitives.\n # TODO(mattjj): better DCE\n if drop_outputs:\n new_outvars = [var for var, output in zip(jaxpr.outvars, outputs) if output]\n else:\n new_outvars = [var if output else unitvar\n for var, output in zip(jaxpr.outvars, outputs)]\n\n needed_vars = {v for v in new_outvars if type(v) is not Literal}\n new_eqns = []\n for eqn in jaxpr.eqns[::-1]:\n if set(eqn.outvars) & needed_vars:\n new_eqns.append(eqn)\n needed_vars.update(v for v in eqn.invars if type(v) is not Literal)\n new_eqns = new_eqns[::-1]\n return core.Jaxpr(jaxpr.constvars, jaxpr.invars,\n new_outvars, new_eqns)\n\n@cache()\ndef _drop_invars(jaxpr: Jaxpr, drop: Tuple[bool, ...]):\n return core.Jaxpr(jaxpr.constvars, [v for v, d in zip(jaxpr.invars, drop) if not d],\n jaxpr.outvars, jaxpr.eqns)\n\n\ndef _reconstruct_pval(pval1: PartialVal, const2: core.Value):\n pv1, _ = pval1\n if pval1.is_known():\n return pval1\n else:\n if type(pv1) is ConcreteArray:\n return PartialVal.known(pv1.val) # pytype: disable=attribute-error\n else:\n return PartialVal.known(const2)\n\n\ndef move_binders_to_front(closed_jaxpr: ClosedJaxpr, to_move: Sequence[bool]) -> ClosedJaxpr:\n \"\"\"Reorder the `invars` to move to front the ones for which `to_move` is True.\"\"\"\n assert not closed_jaxpr.jaxpr.constvars\n assert len(closed_jaxpr.in_avals) == len(to_move)\n new_invars = _move_to_front(closed_jaxpr.jaxpr.invars, to_move)\n new_jaxpr = core.Jaxpr((), new_invars, closed_jaxpr.jaxpr.outvars,\n closed_jaxpr.jaxpr.eqns)\n new_closed_jaxpr = core.ClosedJaxpr(new_jaxpr, closed_jaxpr.consts)\n return new_closed_jaxpr\n\ndef _move_to_front(lst: Sequence, to_move: Sequence[bool]) -> Sequence:\n return ([elt for elt, move in zip(lst, to_move) if move] +\n [elt for elt, move in zip(lst, to_move) if not move])\n\n\nclass DynamicJaxprTracer(core.Tracer):\n __slots__ = ['aval']\n\n def __init__(self, trace, aval, line_info=None):\n self._trace = trace\n self._line_info = line_info\n self.aval = aval\n\n def full_lower(self):\n return self\n\n def _contents(self):\n return ()\n\n def _origin_msg(self):\n invar_pos, progenitor_eqns = self._trace.frame.find_progenitors(self)\n if invar_pos:\n origin = (f\"While tracing the function {self._trace.main.source_info}, \"\n \"this concrete value was not available in Python because it \"\n \"depends on the value of the arguments to \"\n f\"{self._trace.main.source_info} at flattened positions {invar_pos}, \"\n \"and the computation of these values is being staged out \"\n \"(that is, delayed rather than executed eagerly).\\n\\n\"\n \"You can use transformation parameters such as `static_argnums` \"\n \"for `jit` to avoid tracing particular arguments of transformed \"\n \"functions, though at the cost of more recompiles.\")\n elif progenitor_eqns:\n msts = [f\" operation {core.pp_eqn(eqn, print_shapes=True)}\\n\"\n f\" from line {source_info_util.summarize(eqn.source_info)}\"\n for eqn in progenitor_eqns]\n origin = (f\"While tracing the function {self._trace.main.source_info}, \"\n \"this value became a tracer due to JAX operations on these lines:\"\n \"\\n\\n\" + \"\\n\\n\".join(msts))\n else:\n origin = (\"The error occured while tracing the function \"\n f\"{self._trace.main.source_info}.\")\n return origin\n\n def _assert_live(self) -> None:\n if not self._trace.main.jaxpr_stack: # type: ignore\n raise core.escaped_tracer_error(self, None)\n\nclass JaxprStackFrame:\n __slots__ = ['gensym', 'tracer_to_var', 'constid_to_var', 'constvar_to_val',\n 'tracers', 'eqns', 'invars']\n\n def __init__(self):\n self.gensym = core.gensym()\n self.tracer_to_var = {}\n self.constid_to_var = {}\n self.constvar_to_val = {}\n self.tracers = [] # circ refs, frame->tracer->trace->main->frame,\n self.eqns = [] # cleared when we pop frame from main\n self.invars = []\n\n def to_jaxpr(self, in_tracers, out_tracers):\n invars = [self.tracer_to_var[id(t)] for t in in_tracers]\n outvars = [self.tracer_to_var[id(t)] for t in out_tracers]\n constvars, constvals = unzip2(self.constvar_to_val.items())\n jaxpr = Jaxpr(constvars, invars, outvars, self.eqns)\n jaxpr, constvals = _inline_literals(jaxpr, constvals)\n out_avals = [t.aval for t in out_tracers]\n return jaxpr, out_avals, constvals\n\n def newvar(self, aval):\n return self.gensym(aval)\n\n def find_progenitors(self, tracer):\n var = self.tracer_to_var.get(id(tracer))\n if not var:\n return None, None\n active_vars = {var}\n for eqn in self.eqns[::-1]:\n produced = set(eqn.outvars) & active_vars\n if produced:\n active_vars.difference_update(produced)\n active_vars.update(eqn.invars)\n invar_positions = [i for i, v in enumerate(self.invars) if v in active_vars]\n constvars = active_vars & set(self.constvar_to_val)\n const_eqns = [eqn for eqn in self.eqns if set(eqn.invars) & constvars]\n return invar_positions, const_eqns\n\ndef _inline_literals(jaxpr, constvals):\n consts = dict(zip(jaxpr.constvars, constvals))\n newvar = core.gensym()\n class var(dict):\n def __missing__(self, v):\n new_v = self[v] = newvar(v.aval)\n return new_v\n var = var()\n\n def lit(var: core.Var) -> Optional[Any]:\n val = consts.get(var)\n if type(val) in core.literalable_types and not np.shape(val):\n return Literal(val)\n else:\n return None\n\n used = {v for eqn in jaxpr.eqns for v in eqn.invars} | set(jaxpr.outvars)\n new_constvars = [var[v] for v in jaxpr.constvars if not lit(v)]\n new_constvals = [c for v, c in zip(jaxpr.constvars, constvals) if not lit(v)]\n new_invars = [var[v] for v in jaxpr.invars]\n new_eqns = [new_jaxpr_eqn([lit(v) or var[v] for v in eqn.invars],\n [var[v] if v in used else dropvar for v in eqn.outvars],\n eqn.primitive, eqn.params, eqn.source_info)\n for eqn in jaxpr.eqns]\n new_outvars = [lit(v) or var[v] for v in jaxpr.outvars]\n new_jaxpr = Jaxpr(new_constvars, new_invars, new_outvars, new_eqns)\n return new_jaxpr, new_constvals\n\nclass DynamicJaxprTrace(core.Trace):\n __slots__ = [] # type: ignore\n\n @property\n def frame(self):\n return self.main.jaxpr_stack[-1] # pytype: disable=attribute-error\n\n def new_arg(self, aval):\n tracer = DynamicJaxprTracer(self, aval, source_info_util.current())\n self.frame.tracers.append(tracer)\n self.frame.tracer_to_var[id(tracer)] = var = self.frame.newvar(aval)\n self.frame.invars.append(var)\n return tracer\n\n def new_const(self, val):\n aval = raise_to_shaped(get_aval(val), weak_type=dtypes.is_weakly_typed(val))\n tracer = DynamicJaxprTracer(self, aval, source_info_util.current())\n self.frame.tracers.append(tracer)\n var = self.frame.tracer_to_var[id(tracer)] = self.getconstvar(val)\n self.frame.constvar_to_val[var] = val\n return tracer\n\n pure = lift = sublift = new_const\n\n def getvar(self, tracer):\n var = self.frame.tracer_to_var.get(id(tracer))\n if var is None:\n raise core.escaped_tracer_error(tracer)\n return var\n\n def makevar(self, tracer):\n var = self.frame.tracer_to_var.get(id(tracer))\n assert var is None, \"a jaxpr variable must be created only once per tracer\"\n self.frame.tracers.append(tracer)\n var = self.frame.tracer_to_var[id(tracer)] = self.frame.newvar(tracer.aval)\n return var\n\n def getconstvar(self, c):\n var = self.frame.constid_to_var.get(id(c))\n if var is None:\n var = self.frame.constid_to_var[id(c)] = self.frame.newvar(get_aval(c))\n return var\n\n def instantiate_const(self, val):\n if (isinstance(val, Tracer) and val._trace.main is self.main\n and val._trace.sublevel == self.sublevel):\n return val\n else:\n return self.new_const(val)\n\n def process_primitive(self, primitive, tracers, params):\n avals = [t.aval for t in tracers]\n out_avals = primitive.abstract_eval(*avals, **params)\n out_avals = [out_avals] if not primitive.multiple_results else out_avals\n source_info = source_info_util.current()\n out_tracers = [DynamicJaxprTracer(self, a, source_info) for a in out_avals]\n invars = map(self.getvar, tracers)\n outvars = map(self.makevar, out_tracers)\n eqn = new_jaxpr_eqn(invars, outvars, primitive, params, source_info)\n self.frame.eqns.append(eqn)\n return out_tracers if primitive.multiple_results else out_tracers.pop()\n\n def process_call(self, call_primitive, f, tracers, params):\n in_avals = [t.aval for t in tracers]\n jaxpr, out_avals, consts = trace_to_subjaxpr_dynamic(f, self.main, in_avals)\n if not jaxpr.eqns:\n return core.eval_jaxpr(jaxpr, consts, *tracers)\n source_info = source_info_util.current()\n out_tracers = [DynamicJaxprTracer(self, a, source_info) for a in out_avals]\n invars = map(self.getvar, tracers)\n constvars = map(self.getvar, map(self.instantiate_const, consts))\n outvars = map(self.makevar, out_tracers)\n new_params = dict(params, call_jaxpr=convert_constvars_jaxpr(jaxpr))\n update_params = call_param_updaters.get(call_primitive)\n if update_params:\n new_params = update_params(new_params, [True] * len(tracers))\n eqn = new_jaxpr_eqn([*constvars, *invars], outvars, call_primitive,\n new_params, source_info)\n self.frame.eqns.append(eqn)\n return out_tracers\n\n def post_process_call(self, call_primitive, out_tracers, params):\n assert False # unreachable\n\n def process_map(self, map_primitive, f, tracers, params):\n in_avals = [t.aval for t in tracers]\n axis_name, axis_size = params['axis_name'], params['axis_size']\n reduced_in_avals = [core.mapped_aval(axis_size, in_axis, a)\n if in_axis is not None else a\n for a, in_axis in zip(in_avals, params['in_axes'])]\n with core.extend_axis_env(axis_name, axis_size, None): # type: ignore\n jaxpr, reduced_out_avals, consts = trace_to_subjaxpr_dynamic(\n f, self.main, reduced_in_avals)\n out_axes = params['out_axes_thunk']()\n out_avals = [core.unmapped_aval(params['axis_size'], out_axis, a)\n if out_axis is not None else a\n for a, out_axis in zip(reduced_out_avals, out_axes)]\n source_info = source_info_util.current()\n out_tracers = [DynamicJaxprTracer(self, a, source_info) for a in out_avals]\n invars = map(self.getvar, tracers)\n constvars = map(self.getvar, map(self.instantiate_const, consts))\n outvars = map(self.makevar, out_tracers)\n new_in_axes = (None,) * len(consts) + params['in_axes']\n # extending the axis env here is necessary for type checking that may happen\n # in convert_constvars_jaxpr\n # TODO(mattjj): remove the need for extend_axis_env here\n with core.extend_axis_env(axis_name, axis_size, None): # type: ignore\n new_params = dict(params, in_axes=new_in_axes, out_axes=out_axes,\n call_jaxpr=convert_constvars_jaxpr(jaxpr))\n del new_params['out_axes_thunk']\n update_params = call_param_updaters.get(map_primitive)\n if update_params:\n new_params = update_params(new_params, [True] * len(tracers))\n eqn = new_jaxpr_eqn([*constvars, *invars], outvars, map_primitive,\n new_params, source_info)\n self.frame.eqns.append(eqn)\n return out_tracers\n\n def post_process_map(self, map_primitive, out_tracers, params):\n assert False # unreachable\n\n def process_custom_jvp_call(self, prim, fun, jvp, tracers):\n in_avals = [t.aval for t in tracers]\n fun_jaxpr, out_avals, consts = trace_to_subjaxpr_dynamic(fun, self.main, in_avals)\n closed_fun_jaxpr = core.ClosedJaxpr(convert_constvars_jaxpr(fun_jaxpr), ())\n jvp_jaxpr_thunk = _memoize(\n lambda: trace_to_subjaxpr_dynamic(jvp, self.main, 2 * in_avals)[::2])\n out_tracers = [DynamicJaxprTracer(self, a) for a in out_avals]\n invars = map(self.getvar, tracers)\n constvars = map(self.getvar, map(self.instantiate_const, consts))\n outvars = map(self.makevar, out_tracers)\n eqn = new_jaxpr_eqn([*constvars, *invars], outvars, prim.initial_style,\n dict(fun_jaxpr=closed_fun_jaxpr,\n jvp_jaxpr_thunk=jvp_jaxpr_thunk,\n num_consts=len(consts)),\n source_info_util.current())\n self.frame.eqns.append(eqn)\n return out_tracers\n\n def post_process_custom_jvp_call(self, out_tracers, params):\n assert False # unreachable\n\n def process_custom_vjp_call(self, prim, fun, fwd, bwd, tracers, out_trees):\n in_avals = [t.aval for t in tracers]\n fun_jaxpr, out_avals, consts = trace_to_subjaxpr_dynamic(fun, self.main, in_avals)\n closed_fun_jaxpr = core.ClosedJaxpr(convert_constvars_jaxpr(fun_jaxpr), ())\n fwd_jaxpr_thunk = _memoize(\n lambda: trace_to_subjaxpr_dynamic(fwd, self.main, in_avals)[::2])\n out_tracers = [DynamicJaxprTracer(self, a) for a in out_avals]\n invars = map(self.getvar, tracers)\n constvars = map(self.getvar, map(self.instantiate_const, consts))\n outvars = map(self.makevar, out_tracers)\n eqn = new_jaxpr_eqn([*constvars, *invars], outvars, prim.initial_style,\n dict(fun_jaxpr=closed_fun_jaxpr,\n fwd_jaxpr_thunk=fwd_jaxpr_thunk,\n num_consts=len(consts),\n bwd=bwd, out_trees=out_trees),\n source_info_util.current())\n self.frame.eqns.append(eqn)\n return out_tracers\n\n def post_process_custom_vjp_call(self, out_tracers, params):\n assert False # unreachable\n\ndef _memoize(thunk):\n cell = []\n saved_state = core.thread_local_state.trace_state.copy()\n def memoized():\n if not cell:\n prev_state = core.thread_local_state.trace_state\n core.thread_local_state.trace_state = saved_state\n try:\n cell.append(thunk())\n finally:\n core.thread_local_state.trace_state = prev_state\n return cell[0]\n return memoized\n\n\ndef trace_to_jaxpr_dynamic(fun: lu.WrappedFun, in_avals: Sequence[AbstractValue]):\n assert config.omnistaging_enabled\n with core.new_main(DynamicJaxprTrace, dynamic=True) as main: # type: ignore\n main.source_info = fun_sourceinfo(fun.f) # type: ignore\n main.jaxpr_stack = () # type: ignore\n jaxpr, out_avals, consts = trace_to_subjaxpr_dynamic(fun, main, in_avals)\n del main, fun\n return jaxpr, out_avals, consts\n\ndef trace_to_subjaxpr_dynamic(fun: lu.WrappedFun, main: core.MainTrace,\n in_avals: Sequence[AbstractValue]):\n frame = JaxprStackFrame()\n with extend_jaxpr_stack(main, frame):\n trace = DynamicJaxprTrace(main, core.cur_sublevel())\n in_tracers = map(trace.new_arg, in_avals)\n ans = fun.call_wrapped(*in_tracers)\n out_tracers = map(trace.full_raise, ans)\n jaxpr, out_avals, consts = frame.to_jaxpr(in_tracers, out_tracers)\n del fun, main, trace, frame, in_tracers, out_tracers, ans\n return jaxpr, out_avals, consts\n\[email protected]\ndef extend_jaxpr_stack(main, frame):\n main.jaxpr_stack = main.jaxpr_stack + (frame,)\n try:\n yield\n finally:\n assert frame is main.jaxpr_stack[-1]\n main.jaxpr_stack = main.jaxpr_stack[:-1]\n\ndef trace_to_jaxpr_final(fun: lu.WrappedFun, in_avals: Sequence[AbstractValue]):\n assert config.omnistaging_enabled\n with core.new_base_main(DynamicJaxprTrace) as main: # type: ignore\n main.source_info = fun_sourceinfo(fun.f) # type: ignore\n main.jaxpr_stack = () # type: ignore\n jaxpr, out_avals, consts = trace_to_subjaxpr_dynamic(fun, main, in_avals)\n del fun, main\n return jaxpr, out_avals, consts\n\ndef partial_eval_to_jaxpr_dynamic(fun: lu.WrappedFun, in_pvals: Sequence[PartialVal]):\n # This function provides a partial evaluation behavior used by Flax. We can't\n # use trace_to_jaxpr directly because of an interaction with the curent\n # custom_derivatives.py, which we work around by adding the EvalTrace.\n # TODO(mattjj): alias to trace_to_jaxpr after revising custom_derivatives.py\n assert config.omnistaging_enabled\n with core.new_main(core.EvalTrace, dynamic=True) as _: # type: ignore\n return trace_to_jaxpr(fun, in_pvals)\n\ndef fun_sourceinfo(fun):\n if isinstance(fun, functools.partial):\n fun = fun.func\n try:\n filename = fun.__code__.co_filename\n lineno = fun.__code__.co_firstlineno\n return f\"{fun.__name__} at {filename}:{lineno}\"\n except AttributeError:\n return \"<unknown>\"\n\n\[email protected]_omnistaging_disabler\n@no_type_check\ndef omnistaging_disabler() -> None:\n global trace_to_jaxpr, partial_eval_jaxpr, staged_out_calls, StagingJaxprTrace\n\n def trace_to_jaxpr(fun: lu.WrappedFun, pvals: Sequence[PartialVal],\n instantiate: Union[bool, Sequence[bool]] = False,\n stage_out=False, bottom=False,\n trace_type: Optional[Type[Trace]] = None,\n ) -> Tuple[Jaxpr, Tuple[PartialVal, ...], Tuple[core.Value, ...]]:\n \"\"\"Traces a function into a Jaxpr, given PartialVals for inputs.\n\n Returns (`jaxpr`, `out_pvals`, `consts`). The `jaxpr` contains only the\n computation that depends on unknown inputs. The `out_pvals` are the PartialVal\n for the outputs. The intermediate values that depend only on known inputs and\n are needed to compute the output of `jaxpr` are in `consts` and are passed in\n as the constvars of the `jaxpr`. The handling of the known outputs depends on\n `instantiate`.\n\n For example, given `fun` defined as follows::\n\n def fun(ki, ui): # ki will be a known input in this example\n ka = ki + 2\n kb = ka + 3\n return (kb, ui + ka)\n\n with `ki` the known PartialVal `1.`, and `ui` an unknown PartialVal. The only\n computation that depends on unknown inputs is `ui + ka` and will be the only\n computation in the body of the `jaxpr`. This computation depends on the known\n intermediate value `ka`, which will be computed statically. Currently, such\n constants are either embedded in the Jaxpr if they are scalars, or passed as a\n constvar to `jaxpr`, and then the value of the actual constant will be in\n `consts`:\n\n When `instantiate=False` we get::\n\n jaxpr =\n { lambda ka ; ki ui.\n let c = add ui ka\n in (*, c) } # known outputs are `*`\n out_pvals = [PartialVal.known(6), PartialVal.unknown(ShapedArray)]\n consts = [3] # the constant for `ka`\n\n When `instantiate=True` we get::\n\n jaxpr =\n { lambda ka kb ; ki ui.\n let c = add ui ka\n in (kb, c) } # known output are explicit\n out_pvals = [PartialVal.unknown(ConcreteArray(6)), PartialVal.unknown(ShapedArray)]\n consts = [3, 6] # values for `ka` and `kb` constvars\n \"\"\"\n trace_type = trace_type or (StagingJaxprTrace if stage_out else JaxprTrace)\n with core.new_main(trace_type, bottom=bottom) as main:\n fun = trace_to_subjaxpr(fun, main, instantiate)\n jaxpr, (out_pvals, consts, env) = fun.call_wrapped(pvals)\n assert not env\n del main\n\n return jaxpr, out_pvals, consts\n\n def partial_eval_jaxpr(jaxpr: ClosedJaxpr, unknowns: Sequence[bool],\n instantiate: Union[bool, Sequence[bool]],\n trace_type: Optional[Type[core.Trace]]\n ) -> Tuple[ClosedJaxpr, ClosedJaxpr, Sequence[bool]]:\n f = lu.wrap_init(core.jaxpr_as_fun(jaxpr))\n\n cell = []\n def fun(*vals):\n pvals = [PartialVal.unknown(aval) if uk else PartialVal.known(val)\n for aval, val, uk in zip(jaxpr.in_avals, vals, unknowns)]\n jaxpr_2, out_pvals_2, consts_2 = trace_to_jaxpr(f, pvals, instantiate=instantiate,\n trace_type=trace_type)\n out_pvs_2, out_consts_2 = unzip2(out_pvals_2)\n cell.append((out_pvs_2, jaxpr_2, len(consts_2)))\n return out_consts_2 + consts_2\n\n # The abstract_unit here doesn't really matter, because trace_to_jaxpr completely ignores\n # the avals, and it will never actually reach any primitives, because the `fun` above will\n # execute the jaxpr with the right avals (it reconstructs `pvals` inside).\n pvals = [PartialVal.unknown(abstract_unit) if uk else PartialVal.unknown(aval)\n for aval, uk in zip(jaxpr.in_avals, unknowns)]\n jaxpr_1, out_pvals, consts_1 = trace_to_jaxpr(lu.wrap_init(fun), pvals, instantiate=True)\n (out_pvs_2, jaxpr_2, num_res), = cell\n assert len(jaxpr_2.constvars) == num_res\n\n # jaxpr :: a -> b\n # jaxpr_1 :: a1 -> [b1, res]\n # jaxpr_2 :: res | a2 -> b2\n # jaxpr_2 :: [a2, res] -> b2\n jaxpr_2 = convert_constvars_jaxpr(jaxpr_2)\n jaxpr_2.invars = jaxpr_2.invars[num_res:] + jaxpr_2.invars[:num_res]\n for var, unknown in zip(jaxpr_2.invars[:len(unknowns)], unknowns):\n if not unknown:\n var.aval = abstract_unit\n\n uk_out = [pv is not None for pv in out_pvs_2]\n\n return ClosedJaxpr(jaxpr_1, consts_1), ClosedJaxpr(jaxpr_2, ()), uk_out\n\n def process_custom_jvp_call(self, prim, fun, jvp, tracers):\n # See comment at top of `JaxprTrace`. This method should be reachable\n # only when we stage out, and in that case we drop the custom differentiation\n # rules, because we do not need them.\n if not config.omnistaging_enabled:\n assert self.main.trace_type is StagingJaxprTrace\n return fun.call_wrapped(*tracers)\n JaxprTrace.process_custom_jvp_call = process_custom_jvp_call\n\n def process_custom_vjp_call(self, prim, fun, fwd, bwd, tracers, out_trees):\n # See comment in the above process_custom_jvp_call method.\n if not config.omnistaging_enabled:\n assert self.main.trace_type is StagingJaxprTrace\n return fun.call_wrapped(*tracers)\n JaxprTrace.process_custom_vjp_call = process_custom_vjp_call\n\n staged_out_calls = set()\n\n class StagingJaxprTrace(JaxprTrace): pass\n"
] | [
[
"numpy.isscalar",
"numpy.shape"
]
] |
adityapatkar/covid-detection | [
"59797402bb4359d6070558d40597f7fce3958a0d"
] | [
"detect.py"
] | [
"import os\nimport torch\nfrom torch.utils.data import Dataset, random_split, DataLoader\nfrom PIL import Image\nimport torchvision.models as models\nimport matplotlib.pyplot as plt\nimport torchvision.transforms as transforms\n\n# from sklearn.metrics import f1_score\nimport torch.nn.functional as F\nimport torch.nn as nn\nfrom torchvision.utils import make_grid\nfrom torchvision.datasets import ImageFolder\n\n\nclass ImageClassificationBase(nn.Module):\n def training_step(self, batch):\n images, labels = batch\n out = self(images) # Generate predictions\n loss = F.cross_entropy(out, labels) # Calculate loss\n return loss\n\n def validation_step(self, batch):\n images, labels = batch\n out = self(images) # Generate predictions\n loss = F.cross_entropy(out, labels) # Calculate loss\n acc = accuracy(out, labels) # Calculate accuracy\n return {\"val_loss\": loss.detach(), \"val_acc\": acc}\n\n def validation_epoch_end(self, outputs):\n batch_losses = [x[\"val_loss\"] for x in outputs]\n epoch_loss = torch.stack(batch_losses).mean() # Combine losses\n batch_accs = [x[\"val_acc\"] for x in outputs]\n epoch_acc = torch.stack(batch_accs).mean() # Combine accuracies\n return {\"val_loss\": epoch_loss.item(), \"val_acc\": epoch_acc.item()}\n\n def epoch_end(self, epoch, result):\n print(\n \"Epoch [{}], val_loss: {:.4f}, val_acc: {:.4f}\".format(\n epoch, result[\"val_loss\"], result[\"val_acc\"]\n )\n )\n\n\ndef conv_block(in_channels, out_channels, pool=False):\n layers = [\n nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1),\n nn.BatchNorm2d(out_channels),\n nn.ReLU(inplace=True),\n ]\n if pool:\n layers.append(nn.MaxPool2d(2))\n return nn.Sequential(*layers)\n\n\nclass ResNet9(ImageClassificationBase):\n def __init__(self, in_channels, num_classes):\n super().__init__()\n\n self.conv1 = conv_block(in_channels, 64)\n self.conv2 = conv_block(64, 128, pool=True) # 128*32\n self.res1 = nn.Sequential(conv_block(128, 128), conv_block(128, 128))\n\n self.conv3 = conv_block(128, 256, pool=True) # 256*16\n self.conv4 = conv_block(256, 512, pool=True) # 512*8\n self.res2 = nn.Sequential(conv_block(512, 512), conv_block(512, 512))\n self.conv5 = conv_block(512, 1024, pool=True) # 1024*4\n self.res3 = nn.Sequential(conv_block(1024, 1024), conv_block(1024, 1024))\n\n self.classifier = nn.Sequential(\n nn.MaxPool2d(4), nn.Flatten(), nn.Dropout(0.2), nn.Linear(1024, num_classes)\n )\n\n def forward(self, xb):\n out = self.conv1(xb)\n out = self.conv2(out)\n out = self.res1(out) + out\n out = self.conv3(out)\n out = self.conv4(out)\n out = self.res2(out) + out\n out = self.conv5(out)\n\n out = self.res3(out) + out\n out = self.classifier(out)\n return out\n\n\ndef get_default_device():\n \"\"\"Pick GPU if available, else CPU\"\"\"\n if torch.cuda.is_available():\n return torch.device(\"cuda\")\n else:\n return torch.device(\"cpu\")\n\n\ndef to_device(data, device):\n \"\"\"Move tensor(s) to chosen device\"\"\"\n if isinstance(data, (list, tuple)):\n return [to_device(x, device) for x in data]\n return data.to(device, non_blocking=True)\n\n\nclass DeviceDataLoader:\n \"\"\"Wrap a dataloader to move data to a device\"\"\"\n\n def __init__(self, dl, device):\n self.dl = dl\n self.device = device\n\n def __iter__(self):\n \"\"\"Yield a batch of data after moving it to device\"\"\"\n for b in self.dl:\n yield to_device(b, self.device)\n\n def __len__(self):\n \"\"\"Number of batches\"\"\"\n return len(self.dl)\n\n\ndef preprocess(image):\n transformations = transforms.Compose(\n [transforms.Resize((64, 64)), transforms.ToTensor()]\n )\n image = transformations(image)\n return image\n\n\nclass z:\n \"\"\"Wrap a dataloader to move data to a device\"\"\"\n\n classes = []\n\n def __init__(self):\n self.classes = [\"COVID\", \"Lung_Opacity\", \"Normal\", \"Viral Pneumonia\"]\n\n\ndef predict_image(img, model):\n device = get_default_device()\n # Convert to a batch of 1\n xb = to_device(img.unsqueeze(0), device)\n # xb = img.unsqueeze(0)\n # Get predictions from model\n yb = model(xb)\n # Pick index with highest probability\n prob, preds = torch.max(yb, dim=1)\n print(preds)\n dataset = z()\n # Retrieve the class label\n return dataset.classes[preds[0].item()]\n"
] | [
[
"torch.nn.BatchNorm2d",
"torch.nn.MaxPool2d",
"torch.stack",
"torch.nn.Linear",
"torch.nn.Flatten",
"torch.device",
"torch.cuda.is_available",
"torch.nn.Conv2d",
"torch.nn.functional.cross_entropy",
"torch.nn.Sequential",
"torch.max",
"torch.nn.ReLU",
"torch.nn.Dropout"
]
] |
adhika/NavPy | [
"57130633adcb611cee0dbdfbbee758ca21552cc9"
] | [
"navpy/utils/utils.py"
] | [
"\"\"\"\nUtilities Functions.\n\nCopyright (c) 2014 NavPy Developers. All rights reserved.\nUse of this source code is governed by a BSD-style license that can be found in\nLICENSE.txt\n\"\"\"\n\nimport numpy as _np\nimport sys\n\ndef input_check_Nx1(x):\n \"\"\"\n Check x to be of dimension Nx1 and reshape it as a 1-D array\n\n Adhika Lie\n \"\"\"\n x = _np.atleast_1d(x)\n theSize = _np.shape(x)\n\n if(len(theSize) > 1):\n # 1. Input must be of size N x 1\n if ((theSize[0] != 1) & (theSize[1] != 1)):\n raise ValueError('Not an N x 1 array')\n # 2. Make it into a 1-D array\n x = x.reshape(_np.size(x))\n elif (theSize[0] == 1):\n x = x[0]\n\n return x, _np.size(x)\n\n\ndef input_check_Nx3(x):\n \"\"\"\n Check x to be of dimension Nx3\n\n Adhika Lie\n \"\"\"\n x = _np.atleast_2d(x)\n theSize = _np.shape(x)\n\n if(len(theSize) > 1):\n # 1. Input must be of size N x 3\n if ((theSize[0] != 3) & (theSize[1] != 3)):\n raise ValueError('Not a N x 3 array')\n # 2. Make it into a Nx3 array\n if (theSize[1] != 3):\n x = x.T\n N = x.shape[0]\n # 3. If N == 1, make it into a 1-D array\n if (x.shape[0] == 1):\n x = x.reshape(x.shape[1])\n\n return x, N\n\n\ndef loadtxt2dic(filename):\n \"\"\"\n Loads text file of key:value pairs into a dictionary.\n Usage notes:\n -Lines begining with '#' are treated as comments and skipped.\n -Blank lines are also skipped\n -Keys and values should be separated by '=' or ':', extra spaces are fine.\n -A matrix/scalar are stored floats ONLY if the text has a decimal\n\n Hamid M. (original)\n Adhika Lie\n \"\"\"\n fid = open(filename, 'r')\n param = {}\n prev_line = ''\n\n for line in fid:\n # Remove Extra Spaces\n line = prev_line + line.strip()\n print(line)\n # Skip lines beginning with # or blank\n # Note: Python treats '' as False\n if(line.startswith('#') or line.startswith('\\n') or (not line)):\n continue\n\n # If line ends with a comma, it continues to the next line.\n if(line.endswith(',')):\n prev_line = line.strip()\n continue\n else:\n prev_line = ''\n\n # Split item\n item = line.split('#', 1)[0].strip() # May have comment after the line\n item = item.replace(':', ' ').replace('=', ' ').split(None, 1)\n\n if(len(item) == 0):\n continue\n\n try:\n param[item[0]] = eval(item[1])\n\n if(type(eval(item[1])) == list):\n param[item[0]] = _np.array(eval(item[1]))\n\n except NameError:\n param[item[0]] = item[1]\n\n fid.close()\n return param\n\n\ndef ask_ok(prompt, retries=4, complaint='Yes or no, please!'):\n \"\"\"\n Prompt user for for 'yes' or 'no' response\n Taken from Python Documentation with small modifications\n http://docs.python.org/tutorial/controlflow.html\n\n Example:\n >>> ask_ok('Do you really want to quit?')\n\n Hamid M. May 2012\n \"\"\"\n while True:\n\n ok = raw_input(prompt).lower()\n\n if ok in ('y', 'ye', 'yes', '1'):\n return True\n if ok in ('n', 'no', 'nop', 'nope', '0'):\n return False\n retries = retries - 1\n if retries < 0:\n raise IOError('refusenik user')\n print(complaint)\n\n\ndef status_update(i, drl, message, bar_length=20):\n \"\"\"\n To create progress bar + short error message\n\n Parameters\n ----------\n i is the counter of where you are in the \"count\"\n drl is the total data record length\n message is your message line (keep it short!)\n\n Adhika Lie\n \"\"\"\n percent = float(i) / drl\n hashes = '#' * int(round(percent * bar_length))\n spaces = ' ' * (bar_length - len(hashes))\n\n mmsg = message\n if(len(mmsg) > 0):\n if(mmsg[-1] != '\\n'):\n mmsg = mmsg + '\\n'\n\n sys.stdout.write(\"\\r[%s] %3d%% :: %s\" %\n (hashes + spaces, int(round(percent * 100)), mmsg))\n sys.stdout.flush()\n"
] | [
[
"numpy.size",
"numpy.atleast_2d",
"numpy.shape",
"numpy.atleast_1d"
]
] |
Sriram94/DMFG | [
"9206d4302350bed165e6812e8874041335ecf8a8"
] | [
"waterworld/pettingzoosislwaterworldDMFGACexecution.py"
] | [
"from pettingzoo.sisl.waterworld import waterworld\nfrom RL_dmfgac import Actor\nimport csv\nimport numpy as np \nimport tensorflow.compat.v1 as tf\ntf.disable_v2_behavior()\n\n\n\n\ndef run_waterworld(parallel_env):\n \n n_actions = 25\n \n num_episode = 0 \n while num_episode < 100:\n observation = parallel_env.reset()\n\n\n accumulated_reward = 0\n max_cycles = 500\n actions = {}\n number_caught = 0\n for step in range(max_cycles):\n \n for agent in parallel_env.agents:\n agent_observation = observation[agent]\n \n action = actor[agent].choose_action(agent_observation)\n actions[agent] = action \n new_observation, rewards, dones, infos = parallel_env.step(actions) \n \n number_caught = number_caught + parallel_env.return_number_caught()\n\n if not parallel_env.agents: \n break\n \n\n\n\n\n \n for agent in parallel_env.agents: \n \n accumulated_reward = accumulated_reward + rewards[agent]\n \n \n observation = new_observation\n \n \n \n print(\"The step we are at is\", step)\n\n\n print(\"the total food captured is\", number_caught)\n num_episode = num_episode + 1 \n print(\"The episode is\", num_episode)\n\n \n \n\n \n print('game over')\n\n\nif __name__ == \"__main__\":\n parallel_env = waterworld.parallel_env(n_pursuers=25, n_evaders=25, encounter_reward=1)\n parallel_env.seed(1)\n parallel_env.reset()\n\n actor = {}\n sess = tf.Session()\n size = len(parallel_env.agents)\n action_bound = [-1, 1]\n for agent in parallel_env.agents:\n name = agent\n\n actor[agent] = Actor(sess, n_features=212, action_bound = action_bound, lr=0.00001, name = name)\n \n actor[agent].restore_model(\"./\"+agent+\"/dmfgacactormodel.ckpt\") \n \n sess.run(tf.global_variables_initializer())\n run_waterworld(parallel_env)\n\n\n"
] | [
[
"tensorflow.compat.v1.disable_v2_behavior",
"tensorflow.compat.v1.Session",
"tensorflow.compat.v1.global_variables_initializer"
]
] |
vickyyu90/maxnet | [
"38c49c39dbe77b2984d8cdb2f4087310b2220593"
] | [
"explanations.py"
] | [
"import numpy as np\nimport torch\nimport torch.nn as nn\nfrom skimage.transform import resize\nfrom tqdm import tqdm\n\n\nclass RISE(nn.Module):\n \"\"\"A RISE class that computes saliency maps with RISE.\n\n \"\"\"\n def __init__(self, model, input_size, N, p1, gpu_batch=100):\n super(RISE, self).__init__()\n self.model = model\n self.input_size = input_size\n self.gpu_batch = gpu_batch\n self.N = N\n self.p1 = p1\n\n def generate_masks(self, N, s, p1, savepath='masks.npy'):\n cell_size = np.ceil(np.array(self.input_size) / s)\n up_size = (s + 1) * cell_size\n\n grid = np.random.rand(N, s, s, s) < p1\n grid = grid.astype('float32')\n\n self.masks = np.empty((N, *self.input_size))\n\n for i in tqdm(range(N), desc='Generating filters'):\n # Random shifts\n x = np.random.randint(0, cell_size[0])\n y = np.random.randint(0, cell_size[1])\n z = np.random.randint(0, cell_size[2])\n # Linear upsampling and cropping\n self.masks[i, :, :, :] = resize(grid[i], up_size, order=1, mode='reflect',anti_aliasing=False)[x:x + self.input_size[0], y:y + self.input_size[1], z:z + self.input_size[2]]\n np.save(savepath, self.masks)\n self.masks = torch.from_numpy(self.masks).float()\n self.masks = self.masks.cuda()\n\n def load_masks(self, filepath):\n self.masks = np.load(filepath)\n self.masks = torch.from_numpy(self.masks).float()\n self.N = self.masks.shape[0]\n\n def forward(self, x):\n N = self.N\n _, L, H, W = x.size()\n # Apply array of filters to the image\n stack = torch.mul(self.masks, x.data)\n stack = torch.unsqueeze(stack, 1)\n stack = stack.to(torch.float32)\n\n # p = nn.Softmax(dim=1)(model(stack)) processed in batches\n p = []\n for i in range(0, N, self.gpu_batch):\n pred, _, _, _ = self.model(stack[i:min(i + self.gpu_batch, N)])\n p.append(nn.Softmax(dim=1)(pred))\n p = torch.cat(p)\n # Number of classes\n CL = p.size(1)\n sal = torch.matmul(p.data.transpose(0, 1), self.masks.view(N, H * W * L))\n sal = sal.view((CL, L, H, W))\n sal = sal / N / self.p1\n return sal\n\n"
] | [
[
"torch.unsqueeze",
"numpy.save",
"numpy.load",
"numpy.empty",
"torch.nn.Softmax",
"torch.mul",
"torch.from_numpy",
"numpy.random.rand",
"numpy.array",
"numpy.random.randint",
"torch.cat"
]
] |
xjdrlabs/google-research | [
"f753c392312d4ca1437f80dc9592b6c1461e63a0"
] | [
"non_semantic_speech_benchmark/export_model/tflite_conversion.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# pylint:disable=line-too-long\nr\"\"\"Converts distilled models to TFLite by iterating over experiment folders.\n\nThe aim of this file is:\n\n1. To get TFLite models corresponding to the trained models, but only returning\nthe embedding (and not the target output used during training).\n\n\"\"\"\n# pylint:enable=line-too-long\n\nimport os\n\nfrom absl import app\nfrom absl import flags\nfrom absl import logging\n\nimport numpy as np\nimport tensorflow as tf\n\nfrom non_semantic_speech_benchmark.data_prep import audio_to_embeddings_beam_utils\nfrom non_semantic_speech_benchmark.distillation import models\nfrom non_semantic_speech_benchmark.distillation.compression_lib import compression_op as compression\nfrom non_semantic_speech_benchmark.distillation.compression_lib import compression_wrapper\n\nflags.DEFINE_string(\n 'experiment_dir', None,\n '(CNS) Directory containing directories with parametrized names like '\n '\"1-al=1.0,ap=False,bd=2048,cop=False,lr=0.0001,ms=small,qat=False,tbs=512\". '\n 'Note that only the mentioned hyper-params are supported right now.')\nflags.DEFINE_string('output_dir', None, 'Place to write models to.')\nflags.DEFINE_string('checkpoint_number', None, 'Optional checkpoint number to '\n 'use, instead of most recent.')\nflags.DEFINE_boolean('quantize', False,\n 'Whether to quantize converted models if possible.')\nflags.DEFINE_boolean('include_frontend', False, 'Whether to include frontend.')\n\nFLAGS = flags.FLAGS\n\n\ndef get_params(experiment_dir_str):\n \"\"\"Extracts hyperparams from experiment directory string.\n\n Args:\n experiment_dir_str: The folder-name for the set of hyperparams. Eg:\n '1-al=1.0,ap=False,bd=2048,cop=False,lr=0.0001,ms=small,qat=False,tbs=512'\n\n Returns:\n A dict mapping param key (str) to eval'ed value (float/eval/string).\n \"\"\"\n parsed_params = {}\n start_idx = experiment_dir_str.find('-') + 1\n for kv in experiment_dir_str[start_idx:].split(','):\n key, value = kv.split('=')\n try:\n value = eval(value) # pylint: disable=eval-used\n except: # pylint: disable=bare-except\n pass\n parsed_params[key] = value\n return parsed_params\n\n\ndef get_default_compressor():\n compression_params = compression.CompressionOp.get_default_hparams().parse('')\n compressor = compression_wrapper.get_apply_compression(\n compression_params, global_step=0)\n return compressor\n\n\ndef get_tflite_friendly_model(checkpoint_folder_path, params,\n checkpoint_number=None, include_frontend=False):\n \"\"\"Given folder & training params, exports SavedModel without frontend.\"\"\"\n compressor = None\n if params['cop']:\n compressor = get_default_compressor()\n static_model = models.get_keras_model(\n bottleneck_dimension=params['bd'],\n output_dimension=0, # Don't include the unnecessary final layer.\n alpha=params['al'],\n mobilenet_size=params['ms'],\n frontend=include_frontend,\n avg_pool=params['ap'],\n compressor=compressor,\n quantize_aware_training=params['qat'],\n tflite=True)\n checkpoint = tf.train.Checkpoint(model=static_model)\n if checkpoint_number:\n checkpoint_to_load = os.path.join(\n checkpoint_folder_path, f'ckpt-{checkpoint_number}')\n assert tf.train.load_checkpoint(checkpoint_to_load)\n else:\n checkpoint_to_load = tf.train.latest_checkpoint(checkpoint_folder_path)\n checkpoint.restore(checkpoint_to_load).expect_partial()\n return static_model\n\n\ndef convert_tflite_model(model, quantize, model_path):\n \"\"\"Uses TFLiteConverter to convert a Keras Model.\n\n Args:\n model: Keras model obtained from get_tflite_friendly_model.\n quantize: Whether to quantize TFLite model using dynamic quantization. See:\n https://www.tensorflow.org/lite/performance/post_training_quant\n model_path: Path for TFLite file.\n \"\"\"\n converter = tf.lite.TFLiteConverter.from_keras_model(model)\n converter.target_spec.supported_ops = [\n tf.lite.OpsSet.TFLITE_BUILTINS, # enable TensorFlow Lite ops.\n # There is a GatherV2 op in the frontend that isn't supported by TFLite\n # as a builtin op. (It works as a TFLite builtin only if the sample size\n # to the frontend is a constant)\n # However, TFLite supports importing some relevant operators from TF,\n # at the cost of binary size (~ a few MB).\n # See: https://www.tensorflow.org/lite/guide/ops_select\n # NOTE: This has no effect on the model/binary size if the graph does not\n # required the extra TF ops (for example, for no-frontend versio\n tf.lite.OpsSet.SELECT_TF_OPS # enable TensorFlow ops.\n ]\n if quantize:\n converter.optimizations = [tf.lite.Optimize.DEFAULT]\n tflite_buffer = converter.convert()\n\n with tf.io.gfile.GFile(model_path, 'wb') as f:\n f.write(tflite_buffer)\n\n\ndef main(_):\n tf.compat.v2.enable_v2_behavior()\n if not tf.io.gfile.exists(FLAGS.output_dir):\n tf.io.gfile.makedirs(FLAGS.output_dir)\n\n # Get experiment dirs names.\n # NOTE: This assumes that only folders with hyperparams in their name occur\n # in the working dict.\n if not tf.io.gfile.exists(FLAGS.experiment_dir):\n raise ValueError(f'Experiment dir doesn\\'t exist: {FLAGS.experiment_dir}')\n subdirs = tf.io.gfile.walk(FLAGS.experiment_dir)\n for subdir in subdirs:\n if subdir[0] == FLAGS.experiment_dir:\n experiment_dirs = subdir[1]\n break\n\n # Generate params & TFLite experiment dir names.\n experiment_dir_to_params = {}\n # Maps experiment dir name to [float model, quantized model] paths.\n experiment_dir_to_model = {}\n i = 0\n for experiment_dir in experiment_dirs:\n logging.info('Working on hyperparams: %s', experiment_dir)\n i += 1\n params = get_params(experiment_dir)\n experiment_dir_to_params[experiment_dir] = params\n folder_path = os.path.join(FLAGS.experiment_dir, experiment_dir)\n\n # Export SavedModel & convert to TFLite\n # Note that we keep over-writing the SavedModel while converting experiments\n # to TFLite, since we only care about the final flatbuffer models.\n static_model = get_tflite_friendly_model(\n checkpoint_folder_path=folder_path,\n params=params,\n checkpoint_number=FLAGS.checkpoint_number,\n include_frontend=FLAGS.include_frontend)\n quantize = params['qat']\n model_path = os.path.join(FLAGS.output_dir, 'model_{}.tflite'.format(i))\n convert_tflite_model(\n static_model, quantize=quantize, model_path=model_path)\n experiment_dir_to_model[experiment_dir] = model_path\n if quantize:\n logging.info('Exported INT8 TFLite model')\n else:\n logging.info('Exported FP32 TFLite model')\n\n logging.info('Sanity checking...')\n interpreter = audio_to_embeddings_beam_utils.build_tflite_interpreter(\n model_path)\n if FLAGS.include_frontend:\n model_input = np.zeros([1, 32000], dtype=np.float32)\n expected_output_shape = (7, params['bd'])\n else:\n model_input = np.zeros([1, 96, 64, 1], dtype=np.float32)\n expected_output_shape = (1, params['bd'])\n output = audio_to_embeddings_beam_utils.samples_to_embedding_tflite(\n model_input, sample_rate=16000, interpreter=interpreter, output_key='0')\n np.testing.assert_array_equal(output.shape, expected_output_shape)\n logging.info('Model \"%s\" worked.', model_path)\n\n logging.info('Total TFLite models generated: %i', i)\n\n\nif __name__ == '__main__':\n flags.mark_flags_as_required(['experiment_dir', 'output_dir'])\n app.run(main)\n"
] | [
[
"tensorflow.train.load_checkpoint",
"tensorflow.io.gfile.exists",
"tensorflow.io.gfile.makedirs",
"tensorflow.io.gfile.GFile",
"numpy.zeros",
"numpy.testing.assert_array_equal",
"tensorflow.train.latest_checkpoint",
"tensorflow.compat.v2.enable_v2_behavior",
"tensorflow.io.gfile.walk",
"tensorflow.train.Checkpoint",
"tensorflow.lite.TFLiteConverter.from_keras_model"
]
] |
wvu-irl/smart-2 | [
"b39b6d477b5259b3bf0d96180a154ee1dafae0ac"
] | [
"temp/src/TF_publisher.py"
] | [
"#!/usr/bin/env python\n\nimport rospy\nimport numpy as np\nfrom sensor_msgs.msg import Image\nfrom std_msgs.msg import String\nimport math\nimport tf\nimport sys\nfrom localization.msg import Marker\nfrom tf import transformations as t\n\nclass TF_marker_publisher():\n def __init__(self):\n\n rospy.init_node(\"TF_marker_publisher\",anonymous=True)\n self.marker = Marker()\n self.marker1 = Marker()\n self.br = tf.TransformBroadcaster()\n rospy.loginfo(\"TF publisher node is on\")\n self.r = rospy.Rate(200)\n rospy.on_shutdown(self.shutdown)\n self.publish()\n def publish(self):\n while not rospy.is_shutdown():\n self.static_frames()\n self.r.sleep()\n self.dynamic_frames()\n def static_frames(self):\n self.br.sendTransform((1.8, 0, 0),(t.quaternion_from_euler(math.radians(90),0,math.radians(-90))),rospy.Time.now(),\"Marker1\",\"world\")\n self.br.sendTransform((-1.8, 0, 0),(t.quaternion_from_euler(math.radians(90),0,math.radians(90))),rospy.Time.now(),\"Marker2\",\"world\")\n self.br.sendTransform((0, 1.2, 0),(t.quaternion_from_euler(math.radians(90),0,0)),rospy.Time.now(),\"Marker3\",\"world\")\n self.br.sendTransform((0, -1.2, 0),(t.quaternion_from_euler(math.radians(90),0,math.radians(180))),rospy.Time.now(),\"Marker4\",\"world\")\n def dynamic_frames(self):\n self.marker=rospy.wait_for_message(\"aruco_markers\", Marker)\n rospy.loginfo(self.marker.id)\n if self.marker.id==1:\n T_matrix_ = t.translation_matrix((self.marker.tvec.x,self.marker.tvec.y,self.marker.tvec.z))\n R_matrix_ = t.euler_matrix(self.marker.rvec.x,self.marker.rvec.y,self.marker.rvec.z)\n R_matrix_ = np.transpose(R_matrix_)\n Quaternion_ = t.quaternion_from_matrix(R_matrix_)\n Translation_ = (self.marker.tvec.x,self.marker.tvec.y,self.marker.tvec.z)\n self.br.sendTransform(Translation_, Quaternion_, rospy.Time.now(),\"base_camera\", \"Marker1\")\n\n if self.marker.id==2:\n T_matrix_ = t.translation_matrix((self.marker.tvec.x,self.marker.tvec.y,self.marker.tvec.z))\n R_matrix_ = t.euler_matrix(self.marker.rvec.x,self.marker.rvec.y,self.marker.rvec.z)\n R_matrix_ = np.transpose(R_matrix_)\n Quaternion_ = t.quaternion_from_matrix(R_matrix_)\n Translation_ = (self.marker.tvec.x,self.marker.tvec.y,self.marker.tvec.z)\n self.br.sendTransform(Translation_, Quaternion_, rospy.Time.now(),\"base_camera\", \"Marker2\")\n\n if self.marker.id==4:\n T_matrix_ = t.translation_matrix((self.marker.tvec.x,self.marker.tvec.y,self.marker.tvec.z))\n R_matrix_ = t.euler_matrix(self.marker.rvec.x,self.marker.rvec.y,self.marker.rvec.z)\n R_matrix_ = np.transpose(R_matrix_)\n Quaternion_ = t.quaternion_from_matrix(R_matrix_)\n Translation_ = (self.marker.tvec.x,self.marker.tvec.y,self.marker.tvec.z)\n self.br.sendTransform(Translation_, Quaternion_, rospy.Time.now(),\"base_camera\", \"Marker3\")\n\n if self.marker.id==3:\n T_matrix_ = t.translation_matrix((self.marker.tvec.x,self.marker.tvec.y,self.marker.tvec.z))\n R_matrix_ = t.euler_matrix(self.marker.rvec.x,self.marker.rvec.y,self.marker.rvec.z)\n R_matrix_ = np.transpose(R_matrix_)\n Quaternion_ = t.quaternion_from_matrix(R_matrix_)\n Translation_ = (self.marker.tvec.x,self.marker.tvec.y,self.marker.tvec.z)\n self.br.sendTransform(Translation_, Quaternion_, rospy.Time.now(),\"base_camera\", \"Marker4\")\n\n\n def shutdown(self):\n # stop turtlebot\n rospy.loginfo(\"TF Marker Publisher Node is shutdown\")\n rospy.sleep(1)\n\ndef main():\n try:\n TF_static_Publisher = TF_marker_publisher()\n except rospy.ROSInterruptException:\n pass\n\nif __name__ == '__main__':\n main()\n"
] | [
[
"numpy.transpose"
]
] |
edmundwsy/IEEE-RAS-slam-winter-school-project-9 | [
"da94c5e08acd4efc90b4061871f6afe31e6268b3"
] | [
"src/layers.py"
] | [
"from keras.engine.topology import Layer, InputSpec\nimport keras.utils.conv_utils as conv_utils\nimport tensorflow as tf\nimport keras.backend as K\n\ndef normalize_data_format(value):\n if value is None:\n value = K.image_data_format()\n data_format = value.lower()\n if data_format not in {'channels_first', 'channels_last'}:\n raise ValueError('The `data_format` argument must be one of '\n '\"channels_first\", \"channels_last\". Received: ' +\n str(value))\n return data_format\n \n\nclass BilinearUpSampling2D(Layer):\n def __init__(self, size=(2, 2), data_format=None, **kwargs):\n super(BilinearUpSampling2D, self).__init__(**kwargs)\n self.data_format = normalize_data_format(data_format)\n self.size = conv_utils.normalize_tuple(size, 2, 'size')\n self.input_spec = InputSpec(ndim=4)\n\n def compute_output_shape(self, input_shape):\n if self.data_format == 'channels_first':\n height = self.size[0] * input_shape[2] if input_shape[2] is not None else None\n width = self.size[1] * input_shape[3] if input_shape[3] is not None else None\n return (input_shape[0],\n input_shape[1],\n height,\n width)\n elif self.data_format == 'channels_last':\n height = self.size[0] * input_shape[1] if input_shape[1] is not None else None\n width = self.size[1] * input_shape[2] if input_shape[2] is not None else None\n return (input_shape[0],\n height,\n width,\n input_shape[3])\n\n def call(self, inputs):\n input_shape = K.shape(inputs)\n if self.data_format == 'channels_first':\n height = self.size[0] * input_shape[2] if input_shape[2] is not None else None\n width = self.size[1] * input_shape[3] if input_shape[3] is not None else None\n elif self.data_format == 'channels_last':\n height = self.size[0] * input_shape[1] if input_shape[1] is not None else None\n width = self.size[1] * input_shape[2] if input_shape[2] is not None else None\n \n return tf.image.resize(inputs, [height, width], method=tf.image.ResizeMethod.BILINEAR)\n\n def get_config(self):\n config = {'size': self.size, 'data_format': self.data_format}\n base_config = super(BilinearUpSampling2D, self).get_config()\n return dict(list(base_config.items()) + list(config.items()))\n"
] | [
[
"tensorflow.image.resize"
]
] |
myarist/Codecademy | [
"f82939a411484311171465591455880c8e354750",
"f82939a411484311171465591455880c8e354750"
] | [
"Data Scientist Career Path/8. Hypothesis Testing/3. Experimental Design/2. Simulation/4. estimate.py",
"Data Scientist Career Path/7. Summary Statistics/1. Variable Types/6. alter.py"
] | [
"import numpy as np\nimport pandas as pd\nfrom scipy.stats import chi2_contingency\n\n# preset values\nsignificance_threshold = 0.05\nsample_size = 100\nlift = .3\ncontrol_rate = .5\nname_rate = (1 + lift) * control_rate\n\n# initialize an empty list of results\nresults = []\n\n# start the loop\nfor i in range(100):\n # simulate data:\n sample_control = np.random.choice(['yes', 'no'], size=int(sample_size/2), p=[control_rate, 1-control_rate])\n sample_name = np.random.choice(['yes', 'no'], size=int(sample_size/2), p=[name_rate, 1-name_rate])\n group = ['control']*int(sample_size/2) + ['name']*int(sample_size/2)\n outcome = list(sample_control) + list(sample_name)\n sim_data = {\"Email\": group, \"Opened\": outcome}\n sim_data = pd.DataFrame(sim_data)\n\n # run the test\n ab_contingency = pd.crosstab(np.array(sim_data.Email), np.array(sim_data.Opened))\n chi2, pval, dof, expected = chi2_contingency(ab_contingency)\n result = ('significant' if pval < significance_threshold else 'not significant')\n\n # append the result to our results list here:\n results.append(result)\n\n# calculate proportion of significant results here:\nprint(\"Proportion of significant results:\")\nresults = np.array(results)\nprint(np.sum(results == 'significant')/100)\n",
"import codecademylib3\n\n# Import pandas with alias\nimport pandas as pd\n\n# Import dataset as a Pandas Dataframe\nmovies = pd.read_csv(\"movie_show.csv\", index_col=0)\n\n# Print the first five rows of the dataframe\nprint(movies.head())\n\n# Print the data types of the dataframe\nprint(movies.dtypes)\n\n# Replace any missing values in release_year with 2019\nmovies['release_year'] = movies['release_year'].replace(['missing'], 2019)\n\n# Change the data type of release_year to int\nmovies['release_year'] = pd.to_numeric(movies['release_year'])\n\n# Recheck the data types with .dtypes.\nprint(movies.dtypes)\n\n# Calculate the mean of release_year\nprint(movies['release_year'].mean())"
] | [
[
"numpy.array",
"numpy.sum",
"pandas.DataFrame",
"scipy.stats.chi2_contingency"
],
[
"pandas.read_csv",
"pandas.to_numeric"
]
] |
carnby/aurora | [
"f31e3de28694fd5763643d90ee91e99a55d4ec97"
] | [
"django_project/virtualornithology/timelines/filtering.py"
] | [
"from collections import Counter\nimport numpy as np\nimport random\nimport math\nimport difflib\n\n\nclass TimelineFilter(object):\n def __init__(self, characterizer, skip_fields=None, max_entropy_percentile=100.0, time_bucket_size=10,\n start_strategy=None, pick_strategy=None, approve_tweet_fn=None,\n min_date=None, allow_repeated_users=False, allow_repeated_urls=False, similarity_threshold=0.85,\n n_candidates=None, target_entropy=0.99):\n self.characterizer = characterizer\n self.skip_fields = skip_fields\n self.time_bucket_size = time_bucket_size\n self.max_entropy_percentile = max_entropy_percentile\n self.min_date = min_date\n self.allow_repeated_users = allow_repeated_users\n self.allow_repeated_urls = allow_repeated_urls\n self.similarity_threshold = similarity_threshold\n\n if start_strategy is None:\n self.start_strategy = TimelineFilter.starting_tweet\n else:\n self.start_strategy = start_strategy\n\n if pick_strategy is None:\n self.pick_strategy = TimelineFilter.select_tweet\n else:\n self.pick_strategy = pick_strategy\n\n if approve_tweet_fn is None:\n self.approve_tweet_fn = lambda x: True\n else:\n self.approve_tweet_fn = approve_tweet_fn\n\n\n if skip_fields is not None:\n self.feature_keys = [p for p in ['popularity', 'followers', 'friends', 'n_tweets', 'hub', 'diffusion', 'reply', 'geography', 'time', 'url', 'topics']\n if p not in skip_fields]\n else:\n self.feature_keys = ['popularity', 'followers', 'friends', 'n_tweets', 'hub', 'diffusion', 'reply', 'geography', 'time', 'url', 'topics']\n\n self.timeline = []\n self.timeline_ids = set()\n self.user_ids = set()\n self.timeline_urls = set()\n self.timeline_feature_vectors = []\n self.feature_vector_counts = Counter()\n self.discarded_ids = set()\n self.sequence_matcher = difflib.SequenceMatcher()\n self.n_candidates = n_candidates\n self.target_entropy = target_entropy\n\n def reset(self):\n del self.timeline[:]\n del self.timeline_feature_vectors[:]\n self.feature_vector_counts = Counter()\n self.timeline_ids.clear()\n self.user_ids.clear()\n self.timeline_urls.clear()\n self.discarded_ids.clear()\n\n def __iter__(self):\n return self.timeline.__iter__()\n\n def __add_tweet__(self, tweet):\n self.timeline.append(tweet)\n self.timeline_ids.add(tweet['pk'])\n self.user_ids.add(tweet['user__internal_id'])\n self.timeline_feature_vectors.append(tweet['__feature_vector__'])\n self.feature_vector_counts.update([tweet['__feature_vector__']])\n self.timeline_urls.update(tweet['char']['links'])\n \n print(['tweet', len(self), tweet['text']])\n\n def __call__(self, tweets):\n if not self.timeline:\n first = self.start_strategy(tweets)\n if first:\n self.__add_tweet__(first)\n return first\n\n pairs = []\n\n for tweet in tweets:\n if tweet['pk'] in self.timeline_ids or tweet['pk'] in self.discarded_ids:\n continue\n\n if self.allow_repeated_users == False and tweet['user__internal_id'] in self.user_ids:\n self.discarded_ids.add(tweet['pk'])\n continue\n\n if self.allow_repeated_urls == False and tweet['char']['links'] & self.timeline_urls:\n self.discarded_ids.add(tweet['pk'])\n continue\n\n if not self.approve_tweet_fn(tweet):\n continue\n\n too_similar = False\n for added_tweet in self.timeline:\n self.sequence_matcher.set_seqs(added_tweet['text'], tweet['text'])\n similarity = self.sequence_matcher.quick_ratio()\n if similarity > self.similarity_threshold:\n print('tweet too similar to a previously added one')\n print(similarity, [added_tweet['text'], tweet['text']])\n print('ALREADY ADDED', [added_tweet['text']])\n print('CANDIDATE', [tweet['text']])\n self.discarded_ids.add(tweet['pk'])\n too_similar = True\n break\n\n if too_similar:\n continue\n\n self.feature_vector_counts.update([tweet['__feature_vector__']])\n tweet_entropy = self.__estimate_entropy__()\n self.feature_vector_counts.subtract([tweet['__feature_vector__']])\n \n if self.feature_vector_counts[tweet['__feature_vector__']] <= 0:\n del self.feature_vector_counts[tweet['__feature_vector__']]\n\n if tweet_entropy >= self.target_entropy:\n pairs.append((tweet_entropy, tweet))\n\n if self.n_candidates and len(pairs) >= self.n_candidates:\n break\n\n candidates = [p[1] for p in pairs]\n print('entropies', [p[0] for p in pairs])\n selected = self.pick_strategy(candidates)\n\n if selected:\n self.__add_tweet__(selected)\n\n return selected\n\n def __len__(self):\n return len(self.timeline)\n\n def shout_score(self, text):\n uppercase_count = float(sum([1 for c in text if c.isupper()]))\n upper_fraction = uppercase_count / len(text)\n return upper_fraction\n\n def prepare_tweet(self, tweet):\n if 'char' not in tweet:\n tweet['char'] = self.characterizer.characterize_text(tweet['text'])\n\n tweet['buckets'] = {\n 'followers': int(math.log(tweet['user__followers_count'] + 1)),\n 'friends': int(math.log(tweet['user__friends_count'] + 1)),\n 'n_tweets': int(math.log(tweet['user__statuses_count'] + 1)),\n 'url': bool(tweet['char']['links']),\n 'reply': bool(tweet['characterization__is_reply']),\n 'diffusion': bool(tweet['characterization__manual_rt']),\n 'popularity': int(math.log(tweet['popularity'] + 1))\n }\n\n if not self.skip_field('geography'):\n tweet['buckets']['geography'] = tweet['geography'],\n\n if tweet['buckets']['friends'] == 0 or tweet['buckets']['followers'] == 0:\n tweet['buckets']['hub'] = 0\n else:\n hub_relation = float(tweet['buckets']['followers']) / tweet['buckets']['friends']\n tweet['buckets']['hub'] = int(math.log(hub_relation))\n\n delta = tweet['datetime'] - self.min_date\n total_minutes = int(delta.total_seconds() / 60.0)\n time_bucket = total_minutes / self.time_bucket_size\n tweet['buckets']['time'] = time_bucket\n\n if not self.skip_field('topics'):\n if tweet['char']['hashtags']:\n ht = tweet['char']['hashtags'][0]\n else:\n ht = None\n\n tweet['buckets']['topics'] = ht\n\n tweet['__feature_vector__'] = self.__feature_vector__(tweet)\n tweet['__shout_score__'] = self.shout_score(tweet['text'])\n\n def feature_vector_keys(self):\n keys = []\n for field in self.feature_keys:\n if self.skip_field(field):\n continue\n\n keys.append(field)\n\n return keys\n\n def __feature_vector__(self, tweet):\n vec = []\n for field in self.feature_keys:\n if self.skip_field(field):\n continue\n\n vec.append(tweet['buckets'][field])\n\n return tuple(vec)\n\n def __estimate_entropy__(self):\n counts = self.feature_vector_counts #Counter(self.timeline_feature_vectors)\n #print counts\n #N = float(sum(counts.values()))\n N = float(len(self.timeline) + 1)\n max_H = np.log(float(len(list(filter(lambda x: x, counts)))))\n\n if np.equal(max_H, 0.0):\n return 0.0\n\n entropy = 0.0\n\n for key in counts.keys():\n if counts[key] > 0:\n key_probability = counts[key] / N\n entropy += -(key_probability * np.log(key_probability))\n\n entropy /= max_H\n\n #print u'N={0}, |counts|={3}, max_H={1}, entropy={2}, counter={4}'.format(N, max_H, entropy, len(counts), counts)\n return entropy\n\n def skip_field(self, x):\n return bool(self.skip_fields and x in self.skip_fields)\n\n @classmethod\n def select_tweet(cls, tweets):\n return max(tweets, key=lambda x: x['popularity'])\n\n @classmethod\n def select_popular_bucketed(cls, tweets):\n max_popularity = max([t['buckets']['popularity'] for t in tweets])\n popular = [t for t in tweets if t['buckets']['popularity'] == max_popularity]\n return random.choice(popular)\n\n @classmethod\n def select_tweet_and_sideline(cls, pick, categories, turns=5):\n sidelined = dict([(c, 0) for c in categories])\n state = {'output': False}\n\n def decrement_counts(selected=None):\n for key in sidelined.keys():\n if selected and key == selected['geography']:\n sidelined[key] = turns\n else:\n sidelined[key] -= 1\n\n print('sideline counts', sidelined)\n\n def is_sidelined(tweet):\n return sidelined[tweet['geography']] <= 0\n\n def sideline(tweets):\n if not state['output']:\n #print [t['text'] for t in tweets[0:3]]\n state['output'] = True\n\n if not tweets:\n return None\n\n filtered = list(filter(is_sidelined, tweets))\n\n if not filtered:\n print('all candidate tweets sidelined')\n decrement_counts()\n selected = sideline(tweets)\n else:\n selected = pick(filtered)\n decrement_counts(selected=selected)\n sidelined[selected['geography']] = turns\n\n return selected\n\n return sideline, is_sidelined\n\n @classmethod\n def starting_tweet(cls, tweets):\n max_rt_count = max(tweets, key=lambda e: e['popularity'])['popularity']\n candidates = [t for t in tweets if t['popularity'] == max_rt_count]\n selected = random.choice(candidates)\n return selected\n"
] | [
[
"numpy.equal",
"numpy.log"
]
] |
mili7522/GGCNN | [
"c0a4cec6dd4d4f8836d2cffd98f5d97d96bea418"
] | [
"src/Data/2. AddBridges-SA2.py"
] | [
"import pandas as pd\r\nimport os\r\n\r\nos.chdir('Data')\r\n\r\n# Bridges identified using http://stat.abs.gov.au/itt/r.jsp?ABSMaps\r\n\r\nneighbours = [(117031337,121041417, 'Sydney - Haymarket - The Rocks', 'North Sydney - Lavender Bay'),\r\n (121041415, 122011418, 'Mosman', 'Balgowlah - Clontarf - Seaforth'),\r\n (121031408, 122031427, 'Lindfield - Roseville', 'Forestville - Killarney Heights'),\r\n (122031431, 122021423, 'Narrabeen - Collaroy', 'Warriewood - Mona Vale'),\r\n (121021404, 102011030, 'Berowra - Brooklyn - Cowan', 'Calga - Kulnura'),\r\n (120021389, 120011385, 'Lilyfield - Rozelle', 'Drummoyne - Rodd Point'),\r\n (120011385, 126021498, 'Drummoyne - Rodd Point', 'Gladesville - Huntleys Point'),\r\n (126021499, 121011400, 'Hunters Hill - Woolwich', 'Lane Cove - Greenwich'),\r\n (120011384, 126021591, 'Concord West - North Strathfield', 'Ryde'),\r\n (120011384, 125011473, 'Concord West - North Strathfield', 'Homebush Bay - Silverwater'),\r\n (128011531, 119041382, 'Sylvania - Taren Point', 'Sans Souci - Ramsgate'),\r\n (128011531, 119031374, 'Sylvania - Taren Point', 'South Hurstville - Blakehurst'),\r\n (128021536, 119031371, 'Oyster Bay - Como - Jannali', 'Oatley - Hurstville Grove'),\r\n (128021536, 128021535, 'Oyster Bay - Como - Jannali', 'Menai - Lucas Heights - Woronora'),\r\n (128021534, 119011358, 'llawong - Alfords Point', 'Padstow'),\r\n (119031372, 119011358, 'Peakhurst - Lugarno', 'Padstow'),\r\n (107031143, 107011547, 'Warilla', 'Windang - Primbee'),\r\n (111011212, 111011207, 'Swansea - Caves Beach', 'Belmont South - Blacksmiths'),\r\n (112031254, 112031552, 'Tweed Heads', 'Tweed Heads South')]\r\n\r\n\r\nneighbouring_suburbs = pd.read_csv('Geography/SA2_2016_NEIGHBOURS_expanded.csv', index_col = 0, names = ['src_SA2_MAIN16', 'nbr_SA2_MAIN16'], header = 0)\r\n\r\nadditional_neighbours = pd.DataFrame(neighbours, columns = ['src_SA2_MAIN16', 'nbr_SA2_MAIN16', 'src_SA2_NAME16', 'nbr_SA2_NAME16'])\r\n\r\n\r\nneighbours_with_bridges = pd.concat((neighbouring_suburbs, additional_neighbours), ignore_index = True)\r\n\r\nneighbours_with_bridges[['src_SA2_MAIN16', 'nbr_SA2_MAIN16']].to_csv('Geography/2018-09-01-SA2Neighbouring_Suburbs_With_Bridges.csv', index = False)\r\n"
] | [
[
"pandas.read_csv",
"pandas.DataFrame",
"pandas.concat"
]
] |
jvdoorn/SpectrumAnalyzer | [
"264afaa795bd7246da2967d49b176361c454746e"
] | [
"tests/aquisition/test_measure.py"
] | [
"import unittest\n\nimport numpy as np\n\nfrom specc.analysis.analyzer import CircuitTester\nfrom specc.aquisition.daq import DataAcquisitionInterface\nfrom specc.data.results import SignalResponse\nfrom tests.utils import ACCEPTABLE_ERROR, TEST_AMPLITUDE, TEST_DF, TEST_FREQUENCY, TEST_SAMPLES, TEST_SAMPLE_RATE\n\n\nclass TestDAQSampleRate(unittest.TestCase):\n def test_sample_rate_limits(self):\n minimum_sample_rate = 10\n maximum_sample_rate = 100\n\n class DAQInterfaceMock(DataAcquisitionInterface):\n MINIMUM_SAMPLE_RATE = minimum_sample_rate\n MAXIMUM_SAMPLE_RATE = maximum_sample_rate\n\n self.assertRaises(AssertionError, lambda: DAQInterfaceMock(minimum_sample_rate - 1))\n self.assertRaises(AssertionError, lambda: DAQInterfaceMock(maximum_sample_rate + 1))\n\n def test_sample_rate_value(self):\n initalization_sample_rate = 10\n updated_sample_rate = 20\n\n daq = DataAcquisitionInterface(initalization_sample_rate)\n self.assertEqual(daq.sample_rate, initalization_sample_rate)\n\n daq.sample_rate = updated_sample_rate\n self.assertEqual(daq.sample_rate, updated_sample_rate)\n\n\nclass TestDAQTimeArray(unittest.TestCase):\n def setUp(self) -> None:\n self.daq = DataAcquisitionInterface(TEST_SAMPLE_RATE)\n self.time_array = self.daq.calculate_time_array(TEST_SAMPLES)\n\n def test_time_array_dimensions(self):\n self.assertEqual(1, len(self.time_array.shape), \"The time array is not a 1D-ndarray.\")\n self.assertEqual((TEST_SAMPLES,), self.time_array.shape)\n\n def test_time_array_values(self):\n expected_end_time = TEST_SAMPLES / TEST_SAMPLE_RATE\n\n self.assertEqual(0, self.time_array[0], \"Time array did not start at 0.\")\n self.assertEqual(expected_end_time, self.time_array[-1], f\"Time array did not end at {expected_end_time}.\")\n\n\nclass TestDAQAnalyzerRead(unittest.TestCase):\n def setUp(self):\n class DAQMock(DataAcquisitionInterface):\n MOCK_OUTPUT_PHASE = np.pi / 4\n\n def read(self, channels: np.ndarray, samples: int) -> np.ndarray:\n end_time = samples / self.sample_rate\n\n time_array = np.linspace(0, end_time, samples)\n\n if len(channels) == 1:\n signal = TEST_AMPLITUDE * np.sin(2 * np.pi * TEST_FREQUENCY * time_array)\n elif len(channels) == 2:\n signal = np.asarray([\n TEST_AMPLITUDE * np.sin(2 * np.pi * TEST_FREQUENCY * time_array),\n TEST_AMPLITUDE * np.sin(2 * np.pi * TEST_FREQUENCY * time_array + self.MOCK_OUTPUT_PHASE),\n ])\n else:\n raise NotImplementedError\n\n return signal\n\n self.daq = DAQMock(TEST_SAMPLE_RATE)\n self.analyzer = CircuitTester(self.daq, 'empty', 'empty')\n\n def test_measuring_single(self):\n response = self.analyzer.measure_single(TEST_SAMPLES)\n\n self.assertTrue(isinstance(response, SignalResponse))\n\n self.assertAlmostEqual(self.daq.MOCK_OUTPUT_PHASE, response.relative_phase(TEST_FREQUENCY),\n delta=ACCEPTABLE_ERROR)\n self.assertAlmostEqual(1, response.relative_intensity(TEST_FREQUENCY, TEST_DF), delta=ACCEPTABLE_ERROR)\n\n\nif __name__ == '__main__':\n unittest.main()\n"
] | [
[
"numpy.sin",
"numpy.linspace"
]
] |
mpambasange/MachineLearning | [
"8b813345264513a57934317b01e1311628dc5b01"
] | [
"group_lectures/01_intro/05_plotting.py"
] | [
"#!/usr/bin/env python3\n# author: github.com/olehermanse\n\n# import libraries used for plotting and mathematical operations:\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n# Define a mathematical expression as a function:\ndef f(x):\n return x**3\n\nx = np.linspace(-3, 3, 100) # Make array of 100 values between -2 and 3 (linear)\nplt.plot(x,f(x)) # Plot the function\nplt.show() # Show all subplots in new window\n"
] | [
[
"matplotlib.pyplot.show",
"numpy.linspace"
]
] |
ksajan/iis-ms-del | [
"6339f639d674fedb88454b43dcd64493be2a4558"
] | [
"IsThisAValidTeamName/stats/agent_copy.py"
] | [
"import pkg_resources\nimport types\nimport pkg_resources\nimport types\nimport time\n\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nsns.set()\n\nfrom pandas_datareader import data as pdr\nimport yfinance as yf\nyf.pdr_override()\ncompany = input(\"Enter Company Name : \")\ndf_full = pdr.get_data_yahoo(company, start=\"2019-01-01\").reset_index()\ndf_full.to_csv('output/'+company+'.csv',index=False)\ndf_full = pd.read_csv('output/'+company+'.csv')\n\ndf= df_full.copy()\nname = 'AutoTrading'\n\nclass Deep_Evolution_Strategy:\n\n inputs = None\n\n def __init__(\n self, weights, reward_function, population_size, sigma, learning_rate\n ):\n self.weights = weights\n self.reward_function = reward_function\n self.population_size = population_size\n self.sigma = sigma\n self.learning_rate = learning_rate\n\n def _get_weight_from_population(self, weights, population):\n weights_population = []\n for index, i in enumerate(population):\n jittered = self.sigma * i\n weights_population.append(weights[index] + jittered)\n return weights_population\n\n def get_weights(self):\n return self.weights\n\n def train(self, epoch = 100, print_every = 1):\n lasttime = time.time()\n for i in range(epoch):\n population = []\n rewards = np.zeros(self.population_size)\n for k in range(self.population_size):\n x = []\n for w in self.weights:\n x.append(np.random.randn(*w.shape))\n population.append(x)\n for k in range(self.population_size):\n weights_population = self._get_weight_from_population(\n self.weights, population[k]\n )\n rewards[k] = self.reward_function(weights_population)\n rewards = (rewards - np.mean(rewards)) / (np.std(rewards) + 1e-7)\n for index, w in enumerate(self.weights):\n A = np.array([p[index] for p in population])\n self.weights[index] = (\n w\n + self.learning_rate\n / (self.population_size * self.sigma)\n * np.dot(A.T, rewards).T\n )\n if (i + 1) % print_every == 0:\n print('iter %d. reward: %f'% (i + 1, self.reward_function(self.weights)))\n print('time taken to train:', time.time() - lasttime, 'seconds')\n\n\nclass Model:\n def __init__(self, input_size, layer_size, output_size):\n self.weights = [\n np.random.randn(input_size, layer_size),\n np.random.randn(layer_size, output_size),\n np.random.randn(1, layer_size),\n ]\n\n def predict(self, inputs):\n feed = np.dot(inputs, self.weights[0]) + self.weights[-1]\n decision = np.dot(feed, self.weights[1])\n return decision\n\n def get_weights(self):\n return self.weights\n\n def set_weights(self, weights):\n self.weights = weights\n\n\nclass Agent:\n POPULATION_SIZE = 15\n SIGMA = 0.1\n LEARNING_RATE = 0.03\n\n def __init__(self, model, window_size, trend, skip, initial_money):\n self.model = model\n self.window_size = window_size\n self.half_window = window_size // 2\n self.trend = trend\n self.skip = skip\n self.initial_money = initial_money\n self.es = Deep_Evolution_Strategy(\n self.model.get_weights(),\n self.get_reward,\n self.POPULATION_SIZE,\n self.SIGMA,\n self.LEARNING_RATE,\n )\n\n def act(self, sequence):\n decision = self.model.predict(np.array(sequence))\n return np.argmax(decision[0])\n\n def get_state(self, t):\n window_size = self.window_size + 1\n d = t - window_size + 1\n block = self.trend[d: t + 1] if d >= 0 else -d * [self.trend[0]] + self.trend[0: t + 1]\n res = []\n for i in range(window_size - 1):\n res.append(block[i + 1] - block[i])\n return np.array([res])\n\n def get_reward(self, weights):\n initial_money = self.initial_money\n starting_money = initial_money\n self.model.weights = weights\n state = self.get_state(0)\n inventory = []\n quantity = 0\n for t in range(0, len(self.trend) - 1, self.skip):\n action = self.act(state)\n next_state = self.get_state(t + 1)\n\n if action == 1 and starting_money >= self.trend[t]:\n inventory.append(self.trend[t])\n starting_money -= close[t]\n\n elif action == 2 and len(inventory):\n bought_price = inventory.pop(0)\n starting_money += self.trend[t]\n\n state = next_state\n return ((starting_money - initial_money) / initial_money) * 100\n\n def fit(self, iterations, checkpoint):\n self.es.train(iterations, print_every=checkpoint)\n\n def buy(self):\n initial_money = self.initial_money\n state = self.get_state(0)\n starting_money = initial_money\n states_sell = []\n states_buy = []\n inventory = []\n for t in range(0, len(self.trend) - 1, self.skip):\n action = self.act(state)\n next_state = self.get_state(t + 1)\n\n if action == 1 and initial_money >= self.trend[t]:\n inventory.append(self.trend[t])\n initial_money -= self.trend[t]\n states_buy.append(t)\n print('day %d: buy 1 unit at price %f, total balance %f' % (t, self.trend[t], initial_money))\n\n elif action == 2 and len(inventory):\n bought_price = inventory.pop(0)\n initial_money += self.trend[t]\n states_sell.append(t)\n try:\n invest = ((close[t] - bought_price) / bought_price) * 100\n except:\n invest = 0\n print(\n 'day %d, sell 1 unit at price %f, investment %f %%, total balance %f,'\n % (t, close[t], invest, initial_money)\n )\n state = next_state\n\n invest = ((initial_money - starting_money) / starting_money) * 100\n total_gains = initial_money - starting_money\n return states_buy, states_sell, total_gains, invest, inventory\n\nclose = df.Close.values.tolist()\nwindow_size = 30\nskip = 1\ninitial_money = 10000\n\nmodel = Model(input_size = window_size, layer_size = 500, output_size = 3)\nagent = Agent(model = model,\n window_size = window_size,\n trend = close,\n skip = skip,\n initial_money = initial_money)\nagent.fit(iterations = 50, checkpoint = 10)\n\nstates_buy, states_sell, total_gains, invest, inventory = agent.buy()\nfig = plt.figure(figsize = (15,5))\nplt.plot(close, color='r', lw=2.)\nplt.plot(close, '^', markersize=10, color='m', label = 'buying signal', markevery = states_buy)\nplt.plot(close, 'v', markersize=10, color='k', label = 'selling signal', markevery = states_sell)\nplt.title('total gains %f, total investment %f%%'%(total_gains, invest))\nplt.legend()\nplt.savefig('output/'+name+'.png')\nplt.show()"
] | [
[
"matplotlib.pyplot.legend",
"numpy.zeros",
"pandas.read_csv",
"matplotlib.pyplot.figure",
"matplotlib.pyplot.savefig",
"numpy.random.randn",
"numpy.std",
"numpy.argmax",
"matplotlib.pyplot.title",
"matplotlib.pyplot.show",
"numpy.array",
"matplotlib.pyplot.plot",
"numpy.dot",
"numpy.mean"
]
] |
igordub/enm-research-project | [
"c5c52f2a6b415bd871800bcf725fda23cb3fd542"
] | [
"src/structure/process_pdb.py"
] | [
"# -*- coding: utf-8 -*-\nimport click\nimport logging\nfrom pathlib import Path\nfrom dotenv import find_dotenv, load_dotenv\n\nimport os\nimport pandas as pd\nfrom biopandas.pdb import PandasPdb\nfrom copy import deepcopy\nimport src.utilities as utils\n\[email protected]()\[email protected]('input_dir', type=click.Path(exists=True))\[email protected]('output_dir', type=click.Path())\ndef main_commandline(input_dir, output_dir):\n \"\"\" Proccesses interim PDB structures (from pdb/interim/) and creates PDB \n structural forms for simulations (saved in pdb/processed/).\n \"\"\"\n logger = logging.getLogger(__name__)\n logger.info('making processed PDB forms from interim PDB structures')\n main(input_dir, output_dir)\n\ndef main(input_dir, output_dir):\n \"\"\" Proccesses interim PDB structures (from pdb/interim/) and creates PDB \n structural forms for simulations (saved in pdb/processed/).\n \"\"\"\n config = utils.read_config()\n pdb_code = config['pdb']['id']\n\n # Data import\n pdb_struct = load_structure(pdb_code, input_dir, file_extension=\"pdb\") \n\n # Data processing\n # Delete residues 1 and 216\n # pdb_struct.df['ATOM'] = pdb_struct.df['ATOM'][(pdb_struct.df['ATOM']['residue_number'] != 1) \\\n # & (pdb_struct.df['ATOM']['residue_number'] != 216)]\n\n # Create structural forms\n pdb_0 = create_form(pdb_struct, form_idx=0)\n pdb_1 = create_form(pdb_struct, form_idx=1)\n pdb_2 = create_form(pdb_struct, form_idx=2)\n\n # Save processed data\n save_structure(pdb_0, 0, output_dir)\n save_structure(pdb_1, 1, output_dir)\n save_structure(pdb_2, 2, output_dir)\n\n\n\ndef load_structure(pdb_code, input_dir, file_extension=\"pdb\"):\n \"\"\" Loads PDB file inot BioPandas object.\n \"\"\"\n pdb_filepath = os.path.join(input_dir, \"{}.{}\".format(pdb_code, file_extension))\n return PandasPdb().read_pdb(pdb_filepath)\n\ndef create_form(data, form_idx=0):\n \"\"\" Creates PDB structure forms.\n form_idx = 0 is apo; 1 - holo1; and 2 - holo2\n Note: Only works for homodimers.\n \"\"\"\n # Make a deep copy of BioPandas object to make changes\n data_out = deepcopy(data)\n \n # If form_idx == 2 that's holo2 already\n if form_idx == 1:\n hetatm_record_len = data_out.df['HETATM'].shape[0]\n # Keep only one ligand\n data_out.df['HETATM'] = data_out.df['HETATM'][:int(hetatm_record_len/2)]\n \n elif form_idx == 0:\n # Delete all 'HETATM' records\n data_out.df['HETATM'] = pd.DataFrame(columns=data_out.df['HETATM'].columns)\n\n return data_out\n\ndef save_structure(data, form_idx, output_dir):\n \"\"\" Save BioPandas object as a PDB record file.\n \"\"\"\n output_filename = \"{}.pdb\".format(form_idx)\n\n data.to_pdb(path=os.path.join(output_dir, output_filename),\n records=['ATOM', 'HETATM'],\n gz=False,\n append_newline=True)\n \nif __name__ == '__main__':\n log_fmt = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'\n logging.basicConfig(level=logging.INFO, format=log_fmt)\n\n # not used in this stub but often useful for finding various files\n project_dir = Path(__file__).resolve().parents[2]\n\n # find .env automagically by walking up directories until it's found, then\n # load up the .env entries as environment variables\n load_dotenv(find_dotenv())\n\n main_commandline()\n"
] | [
[
"pandas.DataFrame"
]
] |
matt-peters/allennlp-models | [
"cdd505ed539fdc2b82e4cc0a23eae4bfd3368e7e"
] | [
"allennlp_models/lm/models/masked_language_model.py"
] | [
"from typing import Dict\n\nfrom overrides import overrides\nimport torch\n\nfrom allennlp.common.checks import check_dimensions_match\nfrom allennlp.data import TextFieldTensors, Vocabulary\nfrom allennlp.models.model import Model\nfrom allennlp.modules import Seq2SeqEncoder, TextFieldEmbedder\nfrom allennlp.nn import util, InitializerApplicator\nfrom allennlp.training.metrics import Perplexity\nfrom allennlp_models.lm.modules.language_model_heads import LanguageModelHead\n\n\[email protected](\"masked_language_model\")\nclass MaskedLanguageModel(Model):\n \"\"\"\n The `MaskedLanguageModel` embeds some input tokens (including some which are masked),\n contextualizes them, then predicts targets for the masked tokens, computing a loss against\n known targets.\n\n NOTE: This was developed for use in a demo, not for training. It's possible that it will still\n work for training a masked LM, but it is very likely that some other code would be much more\n efficient for that. This `does` compute correct gradients of the loss, because we use that in\n our demo, so in principle it should be able to train a model, we just don't necessarily endorse\n that use.\n\n # Parameters\n\n vocab : `Vocabulary`\n text_field_embedder : `TextFieldEmbedder`\n Used to embed the indexed tokens we get in `forward`.\n language_model_head : `LanguageModelHead`\n The `torch.nn.Module` that goes from the hidden states output by the contextualizer to\n logits over some output vocabulary.\n contextualizer : `Seq2SeqEncoder`, optional (default=`None`)\n Used to \"contextualize\" the embeddings. This is optional because the contextualization\n might actually be done in the text field embedder.\n target_namespace : `str`, optional (default=`'bert'`)\n Namespace to use to convert predicted token ids to strings in\n `Model.make_output_human_readable`.\n dropout : `float`, optional (default=`0.0`)\n If specified, dropout is applied to the contextualized embeddings before computation of\n the softmax. The contextualized embeddings themselves are returned without dropout.\n \"\"\"\n\n def __init__(\n self,\n vocab: Vocabulary,\n text_field_embedder: TextFieldEmbedder,\n language_model_head: LanguageModelHead,\n contextualizer: Seq2SeqEncoder = None,\n target_namespace: str = \"bert\",\n dropout: float = 0.0,\n initializer: InitializerApplicator = None,\n **kwargs,\n ) -> None:\n super().__init__(vocab, **kwargs)\n self._text_field_embedder = text_field_embedder\n self._contextualizer = contextualizer\n if contextualizer:\n check_dimensions_match(\n text_field_embedder.get_output_dim(),\n contextualizer.get_input_dim(),\n \"text field embedder output\",\n \"contextualizer input\",\n )\n self._language_model_head = language_model_head\n self._target_namespace = target_namespace\n self._perplexity = Perplexity()\n self._dropout = torch.nn.Dropout(dropout)\n\n if initializer is not None:\n initializer(self)\n\n def forward( # type: ignore\n self,\n tokens: TextFieldTensors,\n mask_positions: torch.BoolTensor,\n target_ids: TextFieldTensors = None,\n ) -> Dict[str, torch.Tensor]:\n \"\"\"\n # Parameters\n\n tokens : `TextFieldTensors`\n The output of `TextField.as_tensor()` for a batch of sentences.\n mask_positions : `torch.LongTensor`\n The positions in `tokens` that correspond to [MASK] tokens that we should try to fill\n in. Shape should be (batch_size, num_masks).\n target_ids : `TextFieldTensors`\n This is a list of token ids that correspond to the mask positions we're trying to fill.\n It is the output of a `TextField`, purely for convenience, so we can handle wordpiece\n tokenizers and such without having to do crazy things in the dataset reader. We assume\n that there is exactly one entry in the dictionary, and that it has a shape identical to\n `mask_positions` - one target token per mask position.\n \"\"\"\n\n targets = None\n if target_ids is not None:\n # A bit of a hack to get the right targets out of the TextField output...\n if len(target_ids) != 1:\n targets = target_ids[\"bert\"][\"token_ids\"]\n else:\n targets = list(target_ids.values())[0][\"tokens\"]\n mask_positions = mask_positions.squeeze(-1)\n batch_size, num_masks = mask_positions.size()\n if targets is not None and targets.size() != mask_positions.size():\n raise ValueError(\n f\"Number of targets ({targets.size()}) and number of masks \"\n f\"({mask_positions.size()}) are not equal\"\n )\n\n # Shape: (batch_size, num_tokens, embedding_dim)\n embeddings = self._text_field_embedder(tokens)\n\n # Shape: (batch_size, num_tokens, encoding_dim)\n if self._contextualizer:\n mask = util.get_text_field_mask(embeddings)\n contextual_embeddings = self._contextualizer(embeddings, mask)\n else:\n contextual_embeddings = embeddings\n\n # Does advanced indexing to get the embeddings of just the mask positions, which is what\n # we're trying to predict.\n batch_index = torch.arange(0, batch_size).long().unsqueeze(1)\n mask_embeddings = contextual_embeddings[batch_index, mask_positions]\n\n target_logits = self._language_model_head(self._dropout(mask_embeddings))\n\n vocab_size = target_logits.size(-1)\n probs = torch.nn.functional.softmax(target_logits, dim=-1)\n k = min(vocab_size, 5) # min here largely because tests use small vocab\n top_probs, top_indices = probs.topk(k=k, dim=-1)\n\n output_dict = {\"probabilities\": top_probs, \"top_indices\": top_indices}\n\n output_dict[\"token_ids\"] = util.get_token_ids_from_text_field_tensors(tokens)\n\n if targets is not None:\n target_logits = target_logits.view(batch_size * num_masks, vocab_size)\n targets = targets.view(batch_size * num_masks)\n loss = torch.nn.functional.cross_entropy(target_logits, targets)\n self._perplexity(loss)\n output_dict[\"loss\"] = loss\n\n return output_dict\n\n def get_metrics(self, reset: bool = False):\n return {\"perplexity\": self._perplexity.get_metric(reset=reset)}\n\n @overrides\n def make_output_human_readable(\n self, output_dict: Dict[str, torch.Tensor]\n ) -> Dict[str, torch.Tensor]:\n top_words = []\n for instance_indices in output_dict[\"top_indices\"]:\n top_words.append(\n [\n [\n self.vocab.get_token_from_index(\n index.item(), namespace=self._target_namespace\n )\n for index in mask_positions\n ]\n for mask_positions in instance_indices\n ]\n )\n output_dict[\"words\"] = top_words\n tokens = []\n for instance_tokens in output_dict[\"token_ids\"]:\n tokens.append(\n [\n self.vocab.get_token_from_index(\n token_id.item(), namespace=self._target_namespace\n )\n for token_id in instance_tokens\n ]\n )\n output_dict[\"tokens\"] = tokens\n\n return output_dict\n\n default_predictor = \"masked_language_model\"\n"
] | [
[
"torch.nn.functional.softmax",
"torch.arange",
"torch.nn.Dropout",
"torch.nn.functional.cross_entropy"
]
] |
mossjacob/alfi-paper | [
"9c5650db852d6a0ff97a5c4292d647c300274082"
] | [
"experiments/hafner_comparison.py"
] | [
"\r\nimport torch\r\nimport numpy as np\r\n\r\nfrom torch.nn import Parameter\r\nfrom gpytorch.optim import NGD\r\nfrom torch.optim import Adam\r\nfrom matplotlib import pyplot as plt\r\nfrom gpytorch.constraints import Positive, Interval\r\nfrom gpytorch.distributions import MultitaskMultivariateNormal, MultivariateNormal\r\n\r\nfrom alfi.configuration import VariationalConfiguration\r\nfrom alfi.models import OrdinaryLFM, MultiOutputGP, generate_multioutput_rbf_gp\r\nfrom alfi.plot import Plotter1d, Colours, tight_kwargs\r\nfrom alfi.trainers import VariationalTrainer, PreEstimator\r\nfrom alfi.utilities.data import hafner_ground_truth\r\nfrom alfi.datasets import HafnerData\r\nfrom alfi.utilities.torch import softplus\r\nfrom experiments.variational import TranscriptionLFM\r\n\r\n\r\nplt.rcParams.update({'font.size': 82})\r\nplt.rc('font', size=15) # controls default text sizes\r\nplt.rc('axes', titlesize=15) # fontsize of the axes title\r\nplt.rc('axes', labelsize=15) # fontsize of the x and y labels\r\nplt.rc('xtick', labelsize=14) # fontsize of the tick labels\r\nplt.rc('ytick', labelsize=14) # fontsize of the tick labels\r\nplt.rc('legend', fontsize=20) # legend fontsize\r\nplt.rc('figure', titlesize=20) # fontsize of the figure title\r\n\r\n\r\nclass ConstrainedTrainer(VariationalTrainer):\r\n def after_epoch(self):\r\n with torch.no_grad():\r\n sens = torch.tensor(4.2)\r\n dec = torch.tensor(0.21)\r\n self.lfm.raw_sensitivity[6] = self.lfm.positivity.inverse_transform(sens)\r\n self.lfm.raw_decay[6] = self.lfm.positivity.inverse_transform(dec)\r\n super().after_epoch()\r\n\r\n\r\nclass SoftplusTranscriptionLFM(TranscriptionLFM):\r\n def __init__(self, num_outputs, gp_model, config: VariationalConfiguration, **kwargs):\r\n super().__init__(num_outputs, gp_model, config, **kwargs)\r\n self.positivity = Positive()\r\n # self.decay_constraint = Interval(0, 1)\r\n self.raw_decay = Parameter(0.1 + torch.rand(torch.Size([self.num_outputs, 1]), dtype=torch.float64))\r\n self.raw_basal = Parameter(torch.rand(torch.Size([self.num_outputs, 1]), dtype=torch.float64))\r\n self.raw_sensitivity = Parameter(8 + torch.rand(torch.Size([self.num_outputs, 1]), dtype=torch.float64))\r\n\r\n def G(self, f):\r\n # I = 1 so just repeat for num_outputs\r\n return softplus(f).repeat(1, self.num_outputs, 1)\r\n\r\n def predict_f(self, t_predict, **kwargs):\r\n # Sample from the latent distribution\r\n q_f = super().predict_f(t_predict)\r\n f = q_f.sample(torch.Size([500])).permute(0, 2, 1) # (S, I, T)\r\n print(f.shape)\r\n # This is a hack to wrap the latent function with the nonlinearity. Note we use the same variance.\r\n f = torch.mean(self.G(f), dim=0)[0].unsqueeze(0)\r\n print(f.shape, q_f.mean.shape, q_f.scale_tril.shape)\r\n batch_mvn = MultivariateNormal(f, q_f.covariance_matrix.unsqueeze(0))\r\n print(batch_mvn)\r\n return MultitaskMultivariateNormal.from_batch_mvn(batch_mvn, task_dim=0)\r\n\r\n\r\ndataset = HafnerData(replicate=0, data_dir='./data/', extra_targets=False)\r\nground_truth = hafner_ground_truth()\r\nnum_inducing = 12\r\nuse_natural = False\r\nnum_times = dataset[0][0].shape[0]\r\nnum_replicates = 1\r\nnum_genes = len(dataset.gene_names)\r\nnum_tfs = 1\r\nt_inducing = torch.linspace(0, 12, num_times, dtype=torch.float64)\r\nt_observed = torch.linspace(0, 12, num_times)\r\nt_predict = torch.linspace(0, 15, 80, dtype=torch.float32)\r\n\r\nconfig = VariationalConfiguration(\r\n num_samples=70,\r\n initial_conditions=False\r\n)\r\n\r\ninducing_points = torch.linspace(0, 12, num_inducing).repeat(num_tfs, 1).view(num_tfs, num_inducing, 1)\r\nstep_size = 5e-1\r\nnum_training = dataset.m_observed.shape[-1]\r\ngp_model = generate_multioutput_rbf_gp(num_tfs, inducing_points,\r\n zero_mean=False,\r\n initial_lengthscale=2,\r\n gp_kwargs=dict(natural=use_natural))\r\nlfm = TranscriptionLFM(num_genes, gp_model, config, num_training_points=num_training)\r\nplotter = Plotter1d(lfm, dataset.gene_names, style='seaborn')\r\n\r\ntrack_parameters = [\r\n 'raw_basal',\r\n 'raw_decay',\r\n 'raw_sensitivity',\r\n 'gp_model.covar_module.raw_lengthscale',\r\n]\r\nif use_natural:\r\n variational_optimizer = NGD(lfm.variational_parameters(), num_data=num_training, lr=0.1)\r\n parameter_optimizer = Adam(lfm.nonvariational_parameters(), lr=0.02)\r\n optimizers = [variational_optimizer, parameter_optimizer]\r\nelse:\r\n optimizers = [Adam(lfm.parameters(), lr=0.05)]\r\n\r\n\r\ntrainer = VariationalTrainer(lfm, optimizers, dataset, track_parameters=track_parameters)\r\n\r\n\r\nlfm.train()\r\n# trainer = Trainer(optimizer)\r\noutput = trainer.train(500, step_size=5e-1, report_interval=10)\r\n\r\ntight_kwargs = dict(bbox_inches='tight', pad_inches=0)\r\nt_predict = torch.linspace(0, 15, 80, dtype=torch.float32)\r\n\r\nlfm.eval()\r\nq_m = lfm.predict_m(t_predict, step_size=1e-1)\r\nq_f = lfm.predict_f(t_predict)\r\n\r\nplotter.plot_losses(trainer, last_x=200)\r\nnrows = 3\r\nncols = 3\r\nfig, axes = plt.subplots(nrows=nrows, ncols=ncols, figsize=(10, 6))\r\n\r\nrow = col = 0\r\nfor i in range(8):\r\n if i == (row+1) * 3:\r\n row += 1\r\n col = 0\r\n ax = axes[row, col]\r\n plotter.plot_gp(q_m, t_predict, replicate=0, ax=ax,# ylim=(-2, 25.2),\r\n color=Colours.line_color, shade_color=Colours.shade_color,\r\n t_scatter=dataset.t_observed, y_scatter=dataset.m_observed,\r\n only_plot_index=i, num_samples=0)\r\n col += 1\r\n ax.set_title(dataset.gene_names[i])\r\nplotter.plot_gp(q_f, t_predict, ax=axes[nrows-1, ncols-1],\r\n # ylim=(-1, 5),\r\n transform=softplus,\r\n num_samples=3,\r\n color=Colours.line2_color,\r\n shade_color=Colours.shade2_color)\r\naxes[nrows-1, ncols-1].set_title('Latent force (p53)')\r\nfor col in range(ncols):\r\n axes[nrows-1, col].set_xlabel('Time (h)')\r\n\r\nplt.tight_layout()\r\nplt.savefig('./experiments/hafner-multi.pdf', **tight_kwargs)\r\n\r\n\r\nfig, axes = plt.subplots(nrows=2, ncols=4, figsize=(9, 2.9),\r\n gridspec_kw=dict(width_ratios=[1, 1, 0.5, 1.9], wspace=0, hspace=0.75))\r\nrow = col = 0\r\nplots = [2, 4, 7, 6]\r\nlbs = [2, 0, 2, 5]\r\nfor i in range(4):\r\n if i == (row+1) * 2:\r\n row += 1\r\n col = 0\r\n ax = axes[row, col]\r\n plotter.plot_gp(q_m, t_predict, replicate=0, ax=ax,# ylim=(-2, 25.2),\r\n color=Colours.line_color, shade_color=Colours.shade_color,\r\n t_scatter=dataset.t_observed, y_scatter=dataset.m_observed,\r\n only_plot_index=plots[i], num_samples=0)\r\n ax.set_title(dataset.gene_names[plots[i]])\r\n mean = q_m.mean.detach().transpose(0, 1)[plots[i]]\r\n lb = torch.floor(mean.min()-1)\r\n ub = torch.ceil(mean.max() + 1)\r\n brange = ub - lb\r\n ub = int(lb + brange*1.1)\r\n lb = lbs[i]\r\n ax.set_ylim(lb, ub)\r\n ax.set_xlim(0, 15)\r\n ax.set_yticks([lb, ub])\r\n ax.figure.subplotpars.wspace = 0\r\n if col > 0:\r\n ax.set_yticks([])\r\n ax.set_xticks([5, 10, 15])\r\n\r\n col += 1\r\ny = [1.5, 4.8, 13.7, 5, 2, 1.4, 3.2, 4, 1.4, 1.5]\r\n# y = y/np.mean(y)*np.mean(p) * 1.75-0.16\r\n# y = scaler.fit_transform(np.expand_dims(y, 0))\r\naxes[0, 3].plot(np.linspace(0, 10, len(y)), y, color=Colours.line2_color)\r\naxes[0, 3].set_ylim(0, 15)\r\naxes[0, 3].set_ylabel('Fold change')\r\naxes[0, 3].set_yticks([0.0, 15.0])\r\naxes[0, 3].set_title('Western blot (Hafner et al., 2017)')\r\nt_temp = torch.linspace(0, 10, 80, dtype=torch.float32)\r\nq_f = lfm.predict_f(t_temp)\r\nplotter.plot_gp(q_f, t_temp, ax=axes[1, 3],\r\n transform=softplus,\r\n num_samples=3,\r\n color=Colours.line2_color,\r\n shade_color=Colours.shade2_color)\r\naxes[1, 3].set_yticks([0, 4])\r\nfor i in range(2):\r\n axes[i, 3].set_xlim(0, 10)\r\n axes[i, 2].set_visible(False)\r\n\r\naxes[1, 3].set_title('Latent force inference (ours)')\r\naxes[1, 3].set_xlabel('Time (h)')\r\naxes[1, 3].set_ylabel('FPKM $\\ell_2$')\r\naxes[1, 3].set_yticks([0.0, 6.0])\r\naxes[1, 3].set_ylim(0.0, 6)\r\n# axes[1, 3].yaxis.set_major_formatter(FormatStrFormatter(' %.0f'))\r\n\r\nfig.tight_layout()\r\n\r\nplt.savefig('./experiments/hafner-combined.pdf', **tight_kwargs)\r\n\r\nlabels = ['Basal rates', 'Sensitivities', 'Decay rates']\r\nkeys = ['raw_basal', 'raw_sensitivity', 'raw_decay']\r\nconstraints = [lfm.positivity, lfm.positivity, lfm.positivity]\r\nkinetics = list()\r\nfor i, key in enumerate(keys):\r\n kinetics.append(\r\n constraints[i].transform(trainer.parameter_trace[key][-1].squeeze()).numpy())\r\n\r\nkinetics = np.array(kinetics)\r\nplotter.plot_double_bar(kinetics, titles=labels,\r\n figsize=(9, 3),\r\n ground_truths=hafner_ground_truth())\r\n # yticks=[\r\n # np.linspace(0, 0.12, 5),\r\n # np.linspace(0, 1.2, 4),\r\n # np.arange(0, 1.1, 0.2),\r\n # ])\r\nplt.tight_layout()\r\n# plt.savefig('./hafner-kinetics.pdf', **tight_kwargs)\r\n\r\n# plotter.plot_convergence(trainer)\r\n\r\n\r\n# print(lfm.decay_rate)\r\nprint(lfm.sensitivity[6])\r\nfor i in range(20):\r\n plt.plot(lfm.positivity.transform(torch.stack(trainer.parameter_trace['raw_sensitivity'])[:, i]))\r\n"
] | [
[
"torch.stack",
"torch.Size",
"matplotlib.pyplot.rc",
"matplotlib.pyplot.savefig",
"torch.linspace",
"matplotlib.pyplot.tight_layout",
"torch.no_grad",
"torch.tensor",
"matplotlib.pyplot.subplots",
"matplotlib.pyplot.rcParams.update",
"numpy.array"
]
] |
hvarS/AmazonPrivacy | [
"d3c975e428d8ac80dbe4b4e7a2e33082eec89524"
] | [
"scraping_2/com-4/reviewsprofiles/reviewsprofiles/spiders/lgbt4scraper.py"
] | [
"import scrapy\nimport pandas as pd\nimport time\nimport os\n\ncategory_name = \"LGBT\"\ncategory_num = 4\n\nclass QuotesSpider(scrapy.Spider):\n name = category_name.lower() + str(category_num) + \"spider\"\n\n def start_requests(self):\n list_of_urls = []\n parent_dir = \"./reviewpages\"\n link_file = parent_dir + \"/\" + category_name + str(category_num) + '_reviewpages.csv'\n df1 = pd.read_csv(link_file)\n length = df1.shape[0]\n\n for i in range(length):\n list_of_urls.append(df1.iat[i, 0])\n \n urls = list_of_urls\n\n for url in urls:\n yield scrapy.Request(url=url, callback=self.parse)\n\n def parse(self, response):\n parent_dir1 = \"./user_profiles\"\n parent_dir2 = \"./user_reviews\"\n fn1 = parent_dir1 + \"/\" + category_name + str(category_num) + '_profiles.csv'\n fn2 = parent_dir2 + \"/\" + category_name + str(category_num) + '_reviews.csv'\n\n profile_links = []\n for block in response.xpath('//a[@class=\"a-profile\"]'):\n l = block.attrib['href']\n l1 = 'https://www.amazon.com' + l\n # print(l1)\n profile_links.append(l1)\n\n reviews = []\n for block in response.xpath('//div[@class=\"a-row a-spacing-small review-data\"]'):\n r = block.xpath('string(.)').get().strip()\n # print(r)\n reviews.append(r)\n \n dict1 = {'Profile': profile_links}\n df1 = pd.DataFrame(dict1)\n\n dict2 = {'Review': reviews}\n df2 = pd.DataFrame(dict2)\n\n isExist1 = os.path.exists(fn1)\n if isExist1 == False:\n df1.to_csv(fn1, mode='w', index=False)\n else:\n df1.to_csv(fn1, mode='a', index=False, header=False)\n\n isExist2 = os.path.exists(fn2)\n if isExist2 == False:\n df2.to_csv(fn2, mode='w', index=False)\n else:\n df2.to_csv(fn2, mode='a', index=False, header=False)\n\n time.sleep(10)"
] | [
[
"pandas.read_csv",
"pandas.DataFrame"
]
] |
fkemeth/emergent_pdes | [
"d0501f21c9eb569543a19d4d95d6c91a9ccb11fe"
] | [
"examples/cgle_periodic/run.py"
] | [
"\"\"\"\nRun CGLE example using specified config file.\n\"\"\"\nimport int.cgle as cint\nimport tests\nimport lpde\nimport os\nimport pickle\nimport shutil\nimport configparser\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nimport tqdm\nimport torch\nfrom torch.utils.tensorboard import SummaryWriter\n\nimport utils_cgle\n\nfrom scipy.spatial.distance import cdist\n\n\ntorch.set_default_dtype(torch.float32)\n\n\nPOINTS_W = 397.48499\n\nplt.set_cmap('plasma')\n\n\ndef integrate_system(config, n, path, verbose=False, n_min=0):\n \"\"\"Integrate complex Ginzburg-Landau equation.\"\"\"\n pars = {}\n pars[\"c1\"] = float(config[\"c1\"])\n pars[\"c2\"] = float(config[\"c2\"])\n pars[\"c3\"] = float(config[\"c3\"])\n pars[\"mu\"] = float(config[\"mu\"])\n pars[\"L\"] = float(config[\"L\"])\n data_dict = cint.integrate(pars=pars,\n dt=float(config[\"dt\"]), N=int(config[\"N_int\"]), T=int(config[\"T\"]),\n tmin=float(config[\"tmin\"]), tmax=float(config[\"tmax\"]),\n append_init=True)\n\n if verbose:\n fig = plt.figure()\n ax = fig.add_subplot(111)\n ax.plot(data_dict[\"xx\"], data_dict[\"data\"][-1].real, label='real')\n ax.plot(data_dict[\"xx\"], data_dict[\"data\"][-1].imag, label='imag')\n ax.set_xlabel(r'$\\omega$')\n plt.title('snapshot')\n plt.legend()\n plt.show()\n\n for i in range(n_min, n):\n for p in [0, -1, 1]:\n data_perturbed = cint.integrate(pars=pars,\n dt=data_dict[\"dt\"], N=data_dict[\"N\"], T=data_dict[\"T\"],\n tmin=0, tmax=data_dict[\"tmax\"]-data_dict[\"tmin\"],\n ic='manual',\n Ainit=data_dict[\"data\"][int(i*int(config[\"T_off\"]))] +\n p*float(config[\"eps\"]) *\n data_dict[\"data\"][int(i*int(config[\"T_off\"]))],\n append_init=True)\n data_perturbed[\"data\"] = data_perturbed[\"data\"][:, ::int(\n int(config[\"N_int\"])/int(config[\"N\"]))]\n data_perturbed[\"xx\"] = data_perturbed[\"xx\"][::int(\n int(config[\"N_int\"])/int(config[\"N\"]))]\n data_perturbed[\"N\"] = int(config[\"N\"])\n output = open(path + 'run'+str(i)+'_p_'+str(p)+'.pkl', 'wb')\n pickle.dump(data_perturbed, output)\n output.close()\n\n\ndef make_plot_paper(config):\n \"\"\"Plot CGLE simulation results.\"\"\"\n pkl_file = open(config[\"GENERAL\"][\"save_dir\"]+'/dat/run' +\n config[\"TRAINING\"][\"n_train\"]+'_p_'+str(0)+'.pkl', 'rb')\n data_dict = pickle.load(pkl_file)\n pkl_file.close()\n\n # t_off = 2000\n t_off = 0\n\n idxs = np.arange(data_dict[\"N\"])\n np.random.shuffle(idxs)\n\n fig = plt.figure(figsize=(POINTS_W/72, 0.9*POINTS_W/72))\n ax1 = fig.add_subplot(321)\n pl1 = ax1.pcolor(data_dict[\"xx\"], data_dict[\"tt\"][::10]+t_off,\n data_dict[\"data_org\"][1::10].real, vmin=-1, vmax=1,\n rasterized=True, cmap='plasma')\n ax1.set_xlabel('$x$', labelpad=-2)\n ax1.set_ylabel('$t$', labelpad=0)\n ax1.set_xlim((0, data_dict[\"L\"]))\n ax1.set_ylim((data_dict[\"tmin\"]+t_off, data_dict[\"tmax\"]+t_off))\n cbar1 = plt.colorbar(pl1)\n cbar1.set_label('Re $W$', labelpad=-3)\n ax2 = fig.add_subplot(322)\n pl2 = ax2.pcolor(np.arange(data_dict[\"N\"]), data_dict[\"tt\"][::10]+t_off,\n data_dict[\"data_org\"][1::10, idxs].real, vmin=-1, vmax=1,\n rasterized=True, cmap='plasma')\n ax2.set_xlabel('$i$', labelpad=-2)\n ax2.set_ylabel('$t$', labelpad=0)\n ax2.set_xlim((0, data_dict[\"N\"]))\n ax2.set_ylim((data_dict[\"tmin\"]+t_off, data_dict[\"tmax\"]+t_off))\n cbar2 = plt.colorbar(pl2)\n cbar2.set_label('Re $W$', labelpad=-3)\n ax3 = fig.add_subplot(323)\n v_scaled = np.load(config[\"GENERAL\"][\"save_dir\"]+'/v_scaled.npy')\n pl3 = ax3.scatter(np.arange(data_dict[\"N\"]), v_scaled[idxs], s=2, c=data_dict[\"xx\"][idxs],\n cmap='plasma')\n\n ax3.set_xlabel('$i$', labelpad=-2)\n ax3.set_xlim((0, data_dict[\"N\"]))\n ax3.set_ylabel(r'$\\phi_1$', labelpad=-3)\n cbar3 = plt.colorbar(pl3)\n cbar3.set_label('$x$', labelpad=0)\n ax4 = fig.add_subplot(324)\n pl4 = ax4.pcolor(v_scaled, data_dict[\"tt\"][::10]+t_off,\n data_dict[\"data_org\"][1::10].real, vmin=-1, vmax=1,\n rasterized=True, cmap='plasma')\n ax4.set_ylim((data_dict[\"tmin\"]+t_off, data_dict[\"tmax\"]+t_off))\n ax4.set_xlabel(r'$\\phi_1$', labelpad=0)\n ax4.set_xlim((-1, 1))\n ax4.set_ylabel(r'$t$', labelpad=0)\n cbar4 = plt.colorbar(pl4)\n cbar4.set_label('Re $W$', labelpad=-3)\n dataset_train = utils_cgle.Dataset(0, int(config[\"TRAINING\"][\"n_train\"]), config[\"MODEL\"],\n path=config[\"GENERAL\"][\"save_dir\"])\n\n dataset_test = utils_cgle.Dataset(int(config[\"TRAINING\"][\"n_train\"]),\n int(config[\"TRAINING\"][\"n_train\"]) +\n int(config[\"TRAINING\"][\"n_test\"]),\n config[\"MODEL\"],\n path=config[\"GENERAL\"][\"save_dir\"])\n\n dataloader_train = torch.utils.data.DataLoader(\n dataset_train, batch_size=int(config[\"TRAINING\"]['batch_size']), shuffle=True,\n num_workers=int(config[\"TRAINING\"]['num_workers']), pin_memory=True)\n dataloader_test = torch.utils.data.DataLoader(\n dataset_test, batch_size=int(config[\"TRAINING\"]['batch_size']), shuffle=False,\n num_workers=int(config[\"TRAINING\"]['num_workers']), pin_memory=True)\n\n network = lpde.network.Network(config[\"MODEL\"], n_vars=2)\n\n model = lpde.model.Model(dataloader_train, dataloader_test, network, config[\"TRAINING\"],\n path=config[\"GENERAL\"][\"save_dir\"]+'/')\n\n model.load_network('test.model')\n num_pars = sum(p.numel() for p in model.net.parameters() if p.requires_grad)\n print(num_pars)\n\n pkl_file = open(config[\"GENERAL\"][\"save_dir\"]+'/dat/run' +\n config[\"TRAINING\"][\"n_train\"]+'_p_'+str(0)+'.pkl', 'rb')\n data_unperturbed = pickle.load(pkl_file)\n pkl_file.close()\n\n pkl_file = open(config[\"GENERAL\"][\"save_dir\"]+'/dat/run' +\n config[\"TRAINING\"][\"n_train\"]+'_p_'+str(-1)+'.pkl', 'rb')\n data_perturbed_neg = pickle.load(pkl_file)\n pkl_file.close()\n\n prediction = model.integrate_svd(dataset_test, dataset_train.svd, 0, data_unperturbed[\"T\"])\n\n print(\"Calculating closest distances....\")\n dists_neg = cdist(np.append(data_perturbed_neg[\"data\"].real, data_perturbed_neg[\"data\"].imag,\n axis=1), np.append(\n data_unperturbed[\"data\"].real, data_unperturbed[\"data\"].imag, axis=1))\n\n dists_learned = cdist(np.append(prediction[:, 0], prediction[:, 1], axis=1), np.append(\n data_unperturbed[\"data\"].real, data_unperturbed[\"data\"].imag, axis=1))\n\n phi_arr = np.linspace(-1, 1, data_unperturbed[\"N\"])\n t_off = 0\n\n ax5 = fig.add_subplot(325)\n pl5 = ax5.pcolor(phi_arr, data_unperturbed[\"tt\"][::10]+t_off,\n prediction[1::10, 0], vmin=-1, vmax=1,\n rasterized=True)\n ax5.axvline(x=(phi_arr[3]+phi_arr[4])/2, ymin=0, ymax=1, color='white', lw=1)\n ax5.axvline(x=(phi_arr[-4]+phi_arr[-5])/2, ymin=0, ymax=1, color='white', lw=1)\n ax5.set_xlabel(r'$\\phi_1$', labelpad=0)\n ax5.set_ylabel(r'$t$', labelpad=0)\n ax5.set_xlim((-1, 1))\n ax5.set_ylim((data_unperturbed[\"tmin\"]+t_off, data_unperturbed[\"tmax\"]+t_off))\n cbar5 = plt.colorbar(pl5)\n cbar5.set_label('Re $W$', labelpad=-3)\n ax6 = fig.add_subplot(326)\n ax6.plot(data_unperturbed[\"tt\"]+t_off, np.min(dists_neg, axis=1)[:-1], label='$d$ true')\n ax6.plot(data_unperturbed[\"tt\"]+t_off, np.min(dists_learned, axis=1)\n [:-1], '--', label='$d$ learned')\n plt.legend()\n ax6.set_xlabel('$t$', labelpad=0)\n ax6.set_ylabel('$d$', labelpad=0)\n # plt.subplots_adjust(top=0.94, wspace=0.35, right=0.98, bottom=0.18, left=0.08)\n ax1.text(-0.25, 1., r'$\\mathbf{a}$', transform=ax1.transAxes, weight='bold', fontsize=12)\n ax2.text(-0.25, 1., r'$\\mathbf{b}$', transform=ax2.transAxes, weight='bold', fontsize=12)\n ax3.text(-0.25, 1., r'$\\mathbf{c}$', transform=ax3.transAxes, weight='bold', fontsize=12)\n ax4.text(-0.25, 1., r'$\\mathbf{d}$', transform=ax4.transAxes, weight='bold', fontsize=12)\n ax5.text(-0.25, 1., r'$\\mathbf{e}$', transform=ax5.transAxes, weight='bold', fontsize=12)\n ax6.text(-0.25, 1., r'$\\mathbf{f}$', transform=ax6.transAxes, weight='bold', fontsize=12)\n plt.subplots_adjust(top=0.96, wspace=0.35, right=0.95, bottom=0.09, hspace=0.31, left=0.08)\n plt.show()\n\n\ndef main(config):\n \"\"\"Integrate system and train model.\"\"\"\n\n verbose = config[\"GENERAL\"].getboolean(\"verbose\")\n\n # Create data folders\n if not os.path.exists(config[\"GENERAL\"][\"save_dir\"]):\n os.makedirs(config[\"GENERAL\"][\"save_dir\"])\n if not os.path.exists(config[\"GENERAL\"][\"save_dir\"]+'/tests'):\n os.makedirs(config[\"GENERAL\"][\"save_dir\"]+'/tests')\n\n # Create training and test data\n if not os.path.exists(config[\"GENERAL\"][\"save_dir\"]+'/dat'):\n os.makedirs(config[\"GENERAL\"][\"save_dir\"]+'/dat')\n if config[\"MODEL\"].getboolean(\"use_param\"):\n raise NotImplementedError\n else:\n integrate_system(config[\"SYSTEM\"], int(config[\"TRAINING\"][\"n_train\"]) +\n int(config[\"TRAINING\"][\"n_test\"]),\n config[\"GENERAL\"][\"save_dir\"]+'/dat/',\n verbose=verbose)\n\n # Create Dataset\n dataset_train = utils_cgle.Dataset(0, int(config[\"TRAINING\"][\"n_train\"]), config[\"MODEL\"],\n path=config[\"GENERAL\"][\"save_dir\"], verbose=verbose)\n dataset_test = utils_cgle.Dataset(int(config[\"TRAINING\"][\"n_train\"]),\n int(config[\"TRAINING\"][\"n_train\"]) +\n int(config[\"TRAINING\"][\"n_test\"]),\n config[\"MODEL\"],\n path=config[\"GENERAL\"][\"save_dir\"], verbose=verbose)\n\n if config[\"GENERAL\"].getboolean(\"use_dmaps\"):\n utils_cgle.dmaps_transform(int(config[\"TRAINING\"][\"n_train\"]) +\n int(config[\"TRAINING\"][\"n_test\"]), dataset_train,\n path=config[\"GENERAL\"][\"save_dir\"], verbose=verbose)\n dataset_train = utils_cgle.Dataset(0, int(config[\"TRAINING\"][\"n_train\"]), config[\"MODEL\"],\n path=config[\"GENERAL\"][\"save_dir\"], verbose=verbose)\n dataset_test = utils_cgle.Dataset(int(config[\"TRAINING\"][\"n_train\"]),\n int(config[\"TRAINING\"][\"n_train\"]) +\n int(config[\"TRAINING\"][\"n_test\"]),\n config[\"MODEL\"],\n path=config[\"GENERAL\"][\"save_dir\"], verbose=verbose)\n\n if verbose:\n tests.test_perturbation(path=config[\"GENERAL\"][\"save_dir\"], idx=0)\n tests.test_dt(cint.f, path=config[\"GENERAL\"][\"save_dir\"], idx=0)\n tests.test_dataset(dataset_train, path=config[\"GENERAL\"][\"save_dir\"])\n if dataset.train.svd:\n tests.test_svd(dataset_train, dataset_test, path=config[\"GENERAL\"][\"save_dir\"])\n\n # Create Dataloader\n dataloader_train = torch.utils.data.DataLoader(\n dataset_train, batch_size=int(config[\"TRAINING\"]['batch_size']), shuffle=True,\n num_workers=int(config[\"TRAINING\"]['num_workers']), pin_memory=True)\n dataloader_test = torch.utils.data.DataLoader(\n dataset_test, batch_size=int(config[\"TRAINING\"]['batch_size']), shuffle=False,\n num_workers=int(config[\"TRAINING\"]['num_workers']), pin_memory=True)\n\n network = lpde.network.Network(config[\"MODEL\"], n_vars=2)\n\n delta_x = float(config[\"SYSTEM\"][\"L\"])/int(config[\"SYSTEM\"][\"N\"]) * \\\n float(config[\"MODEL\"][\"rescale_dx\"])\n\n if verbose:\n tests.test_fd_coeffs(network, path=config[\"GENERAL\"][\"save_dir\"])\n tests.test_derivs(network, torch.tensor(dataset_train.x_data[:1],\n dtype=torch.get_default_dtype()),\n torch.tensor([delta_x], dtype=torch.get_default_dtype()),\n path=config[\"GENERAL\"][\"save_dir\"])\n\n model = lpde.model.Model(dataloader_train, dataloader_test, network, config[\"TRAINING\"],\n path=config[\"GENERAL\"][\"save_dir\"]+'/')\n\n if not os.path.exists(config[\"GENERAL\"][\"save_dir\"]+'/log'):\n os.makedirs(config[\"GENERAL\"][\"save_dir\"]+'/log')\n else:\n shutil.rmtree(config[\"GENERAL\"][\"save_dir\"]+'/log')\n os.makedirs(config[\"GENERAL\"][\"save_dir\"]+'/log')\n\n logger = SummaryWriter(config[\"GENERAL\"][\"save_dir\"]+'/log/')\n\n progress_bar = tqdm.tqdm(range(0, int(config[\"TRAINING\"]['epochs'])),\n total=int(config[\"TRAINING\"]['epochs']),\n leave=True, desc=lpde.utils.progress(0, 0))\n\n if config[\"GENERAL\"].getboolean('proceed_training'):\n model.load_network('test.model')\n\n for epoch in progress_bar:\n train_loss = model.train()\n val_loss = model.validate()\n\n progress_bar.set_description(lpde.utils.progress(train_loss, val_loss))\n\n logger.add_scalar('Loss/train', train_loss, epoch)\n logger.add_scalar('Loss/val', val_loss, epoch)\n logger.add_scalar('learning rate', model.optimizer.param_groups[-1][\"lr\"], epoch)\n\n model.save_network('test.model')\n\n if verbose:\n model = lpde.model.Model(dataloader_train, dataloader_test, network, config[\"TRAINING\"],\n path=config[\"GENERAL\"][\"save_dir\"]+'/')\n model.load_network('test.model')\n tests.test_learned_dt(model, dataset_test, cint.f,\n path=config[\"GENERAL\"][\"save_dir\"], idx=0)\n tests.test_learned_dt(model, dataset_test, cint.f,\n path=config[\"GENERAL\"][\"save_dir\"], idx=2500)\n tests.test_learned_dt(model, dataset_test, cint.f,\n path=config[\"GENERAL\"][\"save_dir\"], idx=4500)\n _ = tests.test_integration(model, dataset_test, dataset_train.svd, 1000, 4000,\n path=config[\"GENERAL\"][\"save_dir\"])\n\n tests.test_transient_dynamics(model, dataset_test, dataset_train.svd,\n idx=int(config[\"TRAINING\"][\"n_train\"]), t_off=0,\n path=config[\"GENERAL\"][\"save_dir\"])\n\n\nif __name__ == \"__main__\":\n config = configparser.ConfigParser()\n config.read('config/config.cfg')\n main(config)\n\n make_plot_paper(config)\n"
] | [
[
"numpy.load",
"numpy.random.shuffle",
"matplotlib.pyplot.legend",
"numpy.append",
"torch.get_default_dtype",
"matplotlib.pyplot.figure",
"matplotlib.pyplot.set_cmap",
"torch.set_default_dtype",
"numpy.arange",
"matplotlib.pyplot.title",
"matplotlib.pyplot.subplots_adjust",
"matplotlib.pyplot.show",
"numpy.min",
"torch.utils.tensorboard.SummaryWriter",
"matplotlib.pyplot.colorbar",
"numpy.linspace"
]
] |
belosthomas/socr-text | [
"6aa143abbc62ca1f8f582eecb3b6e0b055c1aadb"
] | [
"dataset/iam_handwriting_word_database.py"
] | [
"import os\nfrom os.path import isfile\n\nfrom lxml import etree\n\nimport torch\nfrom PIL import Image\nfrom torch.utils.data.dataset import Dataset\n\nfrom utils.image import image_pillow_to_numpy\n\n\nclass IAMHandwritingWordDatabase(Dataset):\n\n def __init__(self, path, height=32, loss=None):\n self.height = height\n self.loss = loss\n\n self.images_path = os.path.join(path, \"words\")\n self.xmls_path = os.path.join(path, \"xml\")\n\n for xml_name in os.listdir(self.xmls_path):\n self.parse_xml(os.path.join(self.xmls_path, xml_name))\n\n def parse_xml(self, xml_path):\n tree = etree.parse(xml_path)\n self.parse_xml_tree(xml_path, tree.getroot())\n\n def parse_xml_tree(self, xml_path, root):\n\n for children in root.getchildren():\n if children.tag.title() == \"Line\":\n root_dict = {}\n for name, value in children.attrib.items():\n root_dict[name] = value\n\n self.parse_xml_tree_line(children)\n else:\n self.parse_xml_tree(xml_path, children)\n\n def parse_xml_tree_line(self, root):\n text_lines = []\n\n for children in root.getchildren():\n if children.tag.title() == \"Word\":\n text, id = self.parse_xml_tree_word(children)\n\n ids = id.split(\"-\")\n image_path = os.path.join(self.images_path,\n ids[0] + \"/\" + ids[0] + \"-\" + ids[1] + \"/\" + ids[0] + \"-\" + ids[1] + \"-\" +\n ids[2] + \"-\" + ids[3] + \".png\")\n\n if isfile(image_path):\n try:\n image = Image.open(image_path)\n self.labels.append((id, text))\n except Exception:\n pass\n\n def parse_xml_tree_word(self, root):\n root_dict = {}\n for name, value in root.attrib.items():\n root_dict[name] = value\n\n return root_dict[\"text\"], root_dict[\"id\"]\n\n def get_corpus(self):\n corpus = \"\"\n for id, text in self.labels:\n if corpus == \"\":\n corpus = text\n else:\n corpus = corpus + \". \" + text\n return corpus\n\n def __getitem__(self, index):\n id, text = self.labels[index]\n ids = id.split(\"-\")\n image_path = os.path.join(self.images_path, ids[0] + \"/\" + ids[0] + \"-\" + ids[1] + \"/\" + ids[0] + \"-\" + ids[1] + \"-\" + ids[2] + \"-\" + ids[3] + \".png\")\n\n # Load the image\n image = Image.open(image_path).convert('RGB')\n width, height = image.size\n\n image = image.resize((width * self.height // height, self.height), Image.ANTIALIAS)\n\n image = image_pillow_to_numpy(image)\n\n return torch.from_numpy(image), (self.loss.preprocess_label(text, width * self.height // height), text, image.shape[2])\n\n def __len__(self):\n return len(self.labels)\n"
] | [
[
"torch.from_numpy"
]
] |
DanielMartinAlarcon/TwitOff | [
"b3686714d28756b3abdb537b86b79ada6ce43aa5"
] | [
"twitoff/predict.py"
] | [
"\"\"\"Prediction of Users based on Tweet embeddings.\"\"\"\nimport numpy as np\nfrom sklearn.linear_model import LogisticRegression\nfrom .models import User\nfrom .twitter import BASILICA\n\n\ndef predict_user(user1_name, user2_name, tweet_text, cache=None):\n \"\"\"Determine and return which user is more likely to say a given Tweet.\"\"\"\n user1 = User.query.filter(User.name == user1_name).one()\n user2 = User.query.filter(User.name == user2_name).one()\n user1_embeddings = np.array([tweet.embedding for tweet in user1.tweets])\n user2_embeddings = np.array([tweet.embedding for tweet in user2.tweets])\n embeddings = np.vstack([user1_embeddings, user2_embeddings])\n labels = np.concatenate([np.zeros(len(user1.tweets)),\n np.ones(len(user2.tweets))])\n log_reg = LogisticRegression().fit(embeddings, labels)\n tweet_embedding = BASILICA.embed_sentence(tweet_text, model='twitter')\n return log_reg.predict_proba(np.array(tweet_embedding).reshape(1, -1))"
] | [
[
"numpy.array",
"numpy.vstack",
"sklearn.linear_model.LogisticRegression"
]
] |
AdamWang00/yolov3-tf2 | [
"956ebe38d3a90de585444b33fa1c01259434f701"
] | [
"train.py"
] | [
"from absl import app, flags, logging\nfrom absl.flags import FLAGS\n\nimport tensorflow as tf\nimport numpy as np\nimport cv2\nfrom tensorflow.keras.callbacks import (\n ReduceLROnPlateau,\n EarlyStopping,\n ModelCheckpoint,\n TensorBoard\n)\nfrom yolov3_tf2.models import (\n YoloV3, YoloV3Tiny, YoloLoss,\n yolo_anchors, yolo_anchor_masks,\n yolo_tiny_anchors, yolo_tiny_anchor_masks\n)\nfrom yolov3_tf2.utils import freeze_all\nimport yolov3_tf2.dataset as dataset\n\nflags.DEFINE_string('dataset', '', 'path to dataset')\nflags.DEFINE_string('val_dataset', '', 'path to validation dataset')\nflags.DEFINE_boolean('tiny', False, 'yolov3 or yolov3-tiny')\nflags.DEFINE_string('weights', './checkpoints/yolov3.tf',\n 'path to weights file')\nflags.DEFINE_string('classes', './data/coco.names', 'path to classes file')\nflags.DEFINE_enum('mode', 'fit', ['fit', 'eager_fit', 'eager_tf'],\n 'fit: model.fit, '\n 'eager_fit: model.fit(run_eagerly=True), '\n 'eager_tf: custom GradientTape')\nflags.DEFINE_enum('transfer', 'none',\n ['none', 'darknet', 'no_output', 'frozen', 'fine_tune'],\n 'none: Training from scratch, '\n 'darknet: Transfer darknet, '\n 'no_output: Transfer all but output, '\n 'frozen: Transfer and freeze all, '\n 'fine_tune: Transfer all and freeze darknet only')\nflags.DEFINE_integer('size', 416, 'image size')\nflags.DEFINE_integer('epochs', 2, 'number of epochs')\nflags.DEFINE_integer('batch_size', 8, 'batch size')\nflags.DEFINE_float('learning_rate', 1e-3, 'learning rate')\nflags.DEFINE_integer('num_classes', 80, 'number of classes in the model')\nflags.DEFINE_integer('weights_num_classes', None, 'specify num class for `weights` file if different, '\n 'useful in transfer learning with different number of classes')\n\n\ndef main(_argv):\n physical_devices = tf.config.experimental.list_physical_devices('GPU')\n for physical_device in physical_devices:\n tf.config.experimental.set_memory_growth(physical_device, True)\n\n if FLAGS.tiny:\n model = YoloV3Tiny(FLAGS.size, training=True,\n classes=FLAGS.num_classes)\n anchors = yolo_tiny_anchors\n anchor_masks = yolo_tiny_anchor_masks\n else:\n model = YoloV3(FLAGS.size, training=True, classes=FLAGS.num_classes)\n anchors = yolo_anchors\n anchor_masks = yolo_anchor_masks\n\n if FLAGS.dataset:\n train_dataset = dataset.load_tfrecord_dataset(\n FLAGS.dataset, FLAGS.classes, FLAGS.size)\n else:\n train_dataset = dataset.load_fake_dataset()\n train_dataset = train_dataset.shuffle(buffer_size=512)\n train_dataset = train_dataset.batch(FLAGS.batch_size)\n train_dataset = train_dataset.map(lambda x, y: (\n dataset.transform_images(x, FLAGS.size),\n dataset.transform_targets(y, anchors, anchor_masks, FLAGS.size)))\n train_dataset = train_dataset.prefetch(\n buffer_size=tf.data.experimental.AUTOTUNE)\n\n if FLAGS.val_dataset:\n val_dataset = dataset.load_tfrecord_dataset(\n FLAGS.val_dataset, FLAGS.classes, FLAGS.size)\n else:\n val_dataset = dataset.load_fake_dataset()\n val_dataset = val_dataset.batch(FLAGS.batch_size)\n val_dataset = val_dataset.map(lambda x, y: (\n dataset.transform_images(x, FLAGS.size),\n dataset.transform_targets(y, anchors, anchor_masks, FLAGS.size)))\n\n # Configure the model for transfer learning\n if FLAGS.transfer == 'none':\n pass # Nothing to do\n elif FLAGS.transfer in ['darknet', 'no_output']:\n # Darknet transfer is a special case that works\n # with incompatible number of classes\n\n # reset top layers\n if FLAGS.tiny:\n model_pretrained = YoloV3Tiny(\n FLAGS.size, training=True, classes=FLAGS.weights_num_classes or FLAGS.num_classes)\n else:\n model_pretrained = YoloV3(\n FLAGS.size, training=True, classes=FLAGS.weights_num_classes or FLAGS.num_classes)\n model_pretrained.load_weights(FLAGS.weights)\n\n if FLAGS.transfer == 'darknet':\n model.get_layer('yolo_darknet').set_weights(\n model_pretrained.get_layer('yolo_darknet').get_weights())\n freeze_all(model.get_layer('yolo_darknet'))\n\n elif FLAGS.transfer == 'no_output':\n for l in model.layers:\n if not l.name.startswith('yolo_output'):\n l.set_weights(model_pretrained.get_layer(\n l.name).get_weights())\n freeze_all(l)\n\n else:\n # All other transfer require matching classes\n model.load_weights(FLAGS.weights)\n if FLAGS.transfer == 'fine_tune':\n # freeze darknet and fine tune other layers\n darknet = model.get_layer('yolo_darknet')\n freeze_all(darknet)\n elif FLAGS.transfer == 'frozen':\n # freeze everything\n freeze_all(model)\n\n optimizer = tf.keras.optimizers.Adam(learning_rate=FLAGS.learning_rate)\n loss = [YoloLoss(anchors[mask], classes=FLAGS.num_classes)\n for mask in anchor_masks]\n\n if FLAGS.mode == 'eager_tf':\n # Eager mode is great for debugging\n # Non eager graph mode is recommended for real training\n avg_loss = tf.keras.metrics.Mean('loss', dtype=tf.float32)\n avg_val_loss = tf.keras.metrics.Mean('val_loss', dtype=tf.float32)\n\n for epoch in range(1, FLAGS.epochs + 1):\n for batch, (images, labels) in enumerate(train_dataset):\n with tf.GradientTape() as tape:\n outputs = model(images, training=True)\n regularization_loss = tf.reduce_sum(model.losses)\n pred_loss = []\n for output, label, loss_fn in zip(outputs, labels, loss):\n pred_loss.append(loss_fn(label, output))\n total_loss = tf.reduce_sum(pred_loss) + regularization_loss\n\n grads = tape.gradient(total_loss, model.trainable_variables)\n optimizer.apply_gradients(\n zip(grads, model.trainable_variables))\n\n logging.info(\"{}_train_{}, {}, {}\".format(\n epoch, batch, total_loss.numpy(),\n list(map(lambda x: np.sum(x.numpy()), pred_loss))))\n avg_loss.update_state(total_loss)\n\n for batch, (images, labels) in enumerate(val_dataset):\n outputs = model(images)\n regularization_loss = tf.reduce_sum(model.losses)\n pred_loss = []\n for output, label, loss_fn in zip(outputs, labels, loss):\n pred_loss.append(loss_fn(label, output))\n total_loss = tf.reduce_sum(pred_loss) + regularization_loss\n\n logging.info(\"{}_val_{}, {}, {}\".format(\n epoch, batch, total_loss.numpy(),\n list(map(lambda x: np.sum(x.numpy()), pred_loss))))\n avg_val_loss.update_state(total_loss)\n\n logging.info(\"{}, train: {}, val: {}\".format(\n epoch,\n avg_loss.result().numpy(),\n avg_val_loss.result().numpy()))\n\n avg_loss.reset_states()\n avg_val_loss.reset_states()\n model.save_weights(\n 'checkpoints/yolov3_train_{}.tf'.format(epoch))\n else:\n model.compile(optimizer=optimizer, loss=loss,\n run_eagerly=(FLAGS.mode == 'eager_fit'))\n\n callbacks = [\n ReduceLROnPlateau(verbose=1),\n EarlyStopping(patience=3, verbose=1),\n ModelCheckpoint('checkpoints/yolov3_train_{epoch}.tf',\n verbose=1, save_weights_only=True),\n TensorBoard(log_dir='logs')\n ]\n\n history = model.fit(train_dataset,\n epochs=FLAGS.epochs,\n callbacks=callbacks,\n validation_data=val_dataset)\n\n\nif __name__ == '__main__':\n try:\n app.run(main)\n except SystemExit:\n pass\n"
] | [
[
"tensorflow.config.experimental.set_memory_growth",
"tensorflow.keras.optimizers.Adam",
"tensorflow.keras.callbacks.TensorBoard",
"tensorflow.keras.callbacks.ModelCheckpoint",
"tensorflow.GradientTape",
"tensorflow.keras.callbacks.EarlyStopping",
"tensorflow.config.experimental.list_physical_devices",
"tensorflow.keras.metrics.Mean",
"tensorflow.reduce_sum",
"tensorflow.keras.callbacks.ReduceLROnPlateau"
]
] |
xidchen/MONAI | [
"4eae383f1abbbb62a69e054c016a3b4e53af3ea7"
] | [
"monai/transforms/croppad/array.py"
] | [
"# Copyright 2020 MONAI Consortium\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n# http://www.apache.org/licenses/LICENSE-2.0\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\"\"\"\nA collection of \"vanilla\" transforms for crop and pad operations\nhttps://github.com/Project-MONAI/MONAI/wiki/MONAI_Design\n\"\"\"\n\nfrom typing import Optional, Callable\n\nimport numpy as np\n\nfrom monai.data.utils import get_random_patch, get_valid_patch_size\nfrom monai.transforms.compose import Transform, Randomizable\nfrom monai.transforms.utils import generate_spatial_bounding_box\nfrom monai.utils.misc import ensure_tuple, ensure_tuple_rep\n\n\nclass SpatialPad(Transform):\n \"\"\"Performs padding to the data, symmetric for all sides or all on one side for each dimension.\n Uses np.pad so in practice, a mode needs to be provided. See numpy.lib.arraypad.pad\n for additional details.\n\n Args:\n spatial_size (list): the spatial size of output data after padding.\n method (str): pad image symmetric on every side or only pad at the end sides. default is 'symmetric'.\n mode (str): one of the following string values or a user supplied function: {'constant', 'edge', 'linear_ramp',\n 'maximum', 'mean', 'median', 'minimum', 'reflect', 'symmetric', 'wrap', 'empty', <function>}\n for more details, please check: https://docs.scipy.org/doc/numpy/reference/generated/numpy.pad.html\n \"\"\"\n\n def __init__(self, spatial_size, method: str = \"symmetric\", mode: str = \"constant\"):\n self.spatial_size = ensure_tuple(spatial_size)\n assert method in (\"symmetric\", \"end\"), \"unsupported padding type.\"\n self.method = method\n assert isinstance(mode, str), \"mode must be str.\"\n self.mode = mode\n\n def _determine_data_pad_width(self, data_shape):\n if self.method == \"symmetric\":\n pad_width = list()\n for i in range(len(self.spatial_size)):\n width = max(self.spatial_size[i] - data_shape[i], 0)\n pad_width.append((width // 2, width - (width // 2)))\n return pad_width\n else:\n return [(0, max(self.spatial_size[i] - data_shape[i], 0)) for i in range(len(self.spatial_size))]\n\n def __call__(self, img, mode: Optional[str] = None): # type: ignore # see issue #495\n data_pad_width = self._determine_data_pad_width(img.shape[1:])\n all_pad_width = [(0, 0)] + data_pad_width\n img = np.pad(img, all_pad_width, mode=mode or self.mode)\n return img\n\n\nclass SpatialCrop(Transform):\n \"\"\"General purpose cropper to produce sub-volume region of interest (ROI).\n It can support to crop ND spatial (channel-first) data.\n Either a spatial center and size must be provided, or alternatively if center and size\n are not provided, the start and end coordinates of the ROI must be provided.\n The sub-volume must sit the within original image.\n Note: This transform will not work if the crop region is larger than the image itself.\n \"\"\"\n\n def __init__(self, roi_center=None, roi_size=None, roi_start=None, roi_end=None):\n \"\"\"\n Args:\n roi_center (list or tuple): voxel coordinates for center of the crop ROI.\n roi_size (list or tuple): size of the crop ROI.\n roi_start (list or tuple): voxel coordinates for start of the crop ROI.\n roi_end (list or tuple): voxel coordinates for end of the crop ROI.\n \"\"\"\n if roi_center is not None and roi_size is not None:\n roi_center = np.asarray(roi_center, dtype=np.uint16)\n roi_size = np.asarray(roi_size, dtype=np.uint16)\n self.roi_start = np.subtract(roi_center, np.floor_divide(roi_size, 2))\n self.roi_end = np.add(self.roi_start, roi_size)\n else:\n assert roi_start is not None and roi_end is not None, \"roi_start and roi_end must be provided.\"\n self.roi_start = np.asarray(roi_start, dtype=np.uint16)\n self.roi_end = np.asarray(roi_end, dtype=np.uint16)\n\n assert np.all(self.roi_start >= 0), \"all elements of roi_start must be greater than or equal to 0.\"\n assert np.all(self.roi_end > 0), \"all elements of roi_end must be positive.\"\n assert np.all(self.roi_end >= self.roi_start), \"invalid roi range.\"\n\n def __call__(self, img):\n max_end = img.shape[1:]\n sd = min(len(self.roi_start), len(max_end))\n assert np.all(max_end[:sd] >= self.roi_start[:sd]), \"roi start out of image space.\"\n assert np.all(max_end[:sd] >= self.roi_end[:sd]), \"roi end out of image space.\"\n\n slices = [slice(None)] + [slice(s, e) for s, e in zip(self.roi_start[:sd], self.roi_end[:sd])]\n return img[tuple(slices)]\n\n\nclass CenterSpatialCrop(Transform):\n \"\"\"\n Crop at the center of image with specified ROI size.\n\n Args:\n roi_size (list, tuple): the spatial size of the crop region e.g. [224,224,128]\n \"\"\"\n\n def __init__(self, roi_size):\n self.roi_size = roi_size\n\n def __call__(self, img):\n center = [i // 2 for i in img.shape[1:]]\n cropper = SpatialCrop(roi_center=center, roi_size=self.roi_size)\n return cropper(img)\n\n\nclass RandSpatialCrop(Randomizable, Transform):\n \"\"\"\n Crop image with random size or specific size ROI. It can crop at a random position as center\n or at the image center. And allows to set the minimum size to limit the randomly generated ROI.\n This transform assumes all the expected fields specified by `keys` have same shape.\n\n Args:\n roi_size (list, tuple): if `random_size` is True, the spatial size of the minimum crop region.\n if `random_size` is False, specify the expected ROI size to crop. e.g. [224, 224, 128]\n random_center (bool): crop at random position as center or the image center.\n random_size (bool): crop with random size or specific size ROI.\n The actual size is sampled from `randint(roi_size, img_size)`.\n \"\"\"\n\n def __init__(self, roi_size, random_center: bool = True, random_size: bool = True):\n self.roi_size = roi_size\n self.random_center = random_center\n self.random_size = random_size\n\n def randomize(self, img_size):\n self._size = ensure_tuple_rep(self.roi_size, len(img_size))\n if self.random_size:\n self._size = [self.R.randint(low=self._size[i], high=img_size[i] + 1) for i in range(len(img_size))]\n if self.random_center:\n valid_size = get_valid_patch_size(img_size, self._size)\n self._slices = ensure_tuple(slice(None)) + get_random_patch(img_size, valid_size, self.R)\n\n def __call__(self, img):\n self.randomize(img.shape[1:])\n if self.random_center:\n return img[self._slices]\n else:\n cropper = CenterSpatialCrop(self._size)\n return cropper(img)\n\n\nclass CropForeground(Transform):\n \"\"\"\n Crop an image using a bounding box. The bounding box is generated by selecting foreground using select_fn\n at channels channel_indexes. margin is added in each spatial dimension of the bounding box.\n The typical usage is to help training and evaluation if the valid part is small in the whole medical image.\n Users can define arbitrary function to select expected foreground from the whole image or specified channels.\n And it can also add margin to every dim of the bounding box of foreground object.\n For example:\n\n .. code-block:: python\n\n image = np.array(\n [[[0, 0, 0, 0, 0],\n [0, 1, 2, 1, 0],\n [0, 1, 3, 2, 0],\n [0, 1, 2, 1, 0],\n [0, 0, 0, 0, 0]]]) # 1x5x5, single channel 5x5 image\n cropper = CropForeground(select_fn=lambda x: x > 1, margin=0)\n print(cropper(image))\n [[[2, 1],\n [3, 2],\n [2, 1]]]\n\n \"\"\"\n\n def __init__(self, select_fn: Callable = lambda x: x > 0, channel_indexes=None, margin: int = 0):\n \"\"\"\n Args:\n select_fn (Callable): function to select expected foreground, default is to select values > 0.\n channel_indexes (int, tuple or list): if defined, select foreground only on the specified channels\n of image. if None, select foreground on the whole image.\n margin: add margin to all dims of the bounding box.\n \"\"\"\n self.select_fn = select_fn\n self.channel_indexes = ensure_tuple(channel_indexes) if channel_indexes is not None else None\n self.margin = margin\n\n def __call__(self, img):\n box_start, box_end = generate_spatial_bounding_box(img, self.select_fn, self.channel_indexes, self.margin)\n cropper = SpatialCrop(roi_start=box_start, roi_end=box_end)\n return cropper(img)\n"
] | [
[
"numpy.floor_divide",
"numpy.asarray",
"numpy.add",
"numpy.all",
"numpy.pad"
]
] |
Yuri-Njathi/Dash_Temperature_Plot | [
"d911755fdf179a592df3e1683af91f60e68f5f65"
] | [
"Autoupdate/scatterinfluxtemp.py"
] | [
"import dash\nimport dash_core_components as dcc \nimport dash_html_components as html \nimport pandas as pd\nfrom influxdb import InfluxDBClient\nfrom pandas import DataFrame, Series\nfrom pandas.io.json import json_normalize\nfrom influxdb import InfluxDBClient\nfrom datetime import datetime, timedelta\nimport plotly.graph_objs as go \n\n\ndef plotdatapoints() : \n\tclient = InfluxDBClient(host='localhost', port=8086)\n\tclient.switch_database('indaba_session')\n\tresult = client.query('select * from \"Indaba Session\" where time > now() - 100h group by \"wanyama01\"')#'select last(\"Temperature\") from \"Indaba Session\"')\n\tdf = list(result.get_points())\n\t# turn to pandas dataframe\n\tdf = pd.DataFrame(df)\n\t# make time a datetime object\n\tdf['time'] = df['time'].apply(pd.to_datetime)\n\treturn df\n\n\n#df = plotdatapoints()\n\napp = dash.Dash()\n\napp.layout = html.Div([\n\n\tdcc.Graph(\n\t\tid = 'scatter1',\n\t\tfigure=go.Figure(layout=go.Layout(\n\t\t\t\t\t\t\t\t\t)\n ),),\n\tdcc.Interval(\n id = 'interval-component',\n interval = 1 * 1000,\n n_intervals = 0\n )\n\t])\n\[email protected](dash.dependencies.Output('scatter1', 'figure'),\n [dash.dependencies.Input('interval-component', 'n_intervals')])\ndef format_current_temp(interval):\n\tdf = plotdatapoints()\n\ttrace = go.Scatter(\n\t\t\t\t\tx = list(df['time']),\n\t\t\t\t\ty = list(df['Temperature']),\n\t\t\t\t\tmode = \"markers\"\n\n\t\t\t\t\t),\n\tlayout=go.Layout(\n\t\t\t\t\ttitle = 'Scatter Plot of Temperature points',\n\t\t\t\t\txaxis = {'title' :\"Time values\"},\n\t\t\t\t\tyaxis = {'title' :\"Temperature values\"}\n\t\t\t\t\t)\n\n\treturn go.Figure(data=trace, layout=layout)\n\n\n\nif __name__ == '__main__' : \n\tapp.run_server(port = 8050)"
] | [
[
"pandas.DataFrame"
]
] |
parthsharma2/augur | [
"6d59c8c80f3c21eb97bfa4ea4817908ea9a7d10b"
] | [
"augur/housekeeper/housekeeper.py"
] | [
"import logging\nimport requests\nfrom multiprocessing import Process, Queue\nimport time\nimport sqlalchemy as s\nimport pandas as pd\nimport os\nimport zmq\nlogging.basicConfig(filename='housekeeper.log')\n\nclass Housekeeper:\n\n def __init__(self, jobs, broker, broker_port, user, password, host, port, dbname):\n\n self.broker_port = broker_port\n self.broker = broker\n DB_STR = 'postgresql://{}:{}@{}:{}/{}'.format(\n user, password, host, port, dbname\n )\n\n dbschema='augur_data'\n self.db = s.create_engine(DB_STR, poolclass=s.pool.NullPool,\n connect_args={'options': '-csearch_path={}'.format(dbschema)})\n\n helper_schema = 'augur_operations'\n self.helper_db = s.create_engine(DB_STR, poolclass = s.pool.NullPool,\n connect_args={'options': '-csearch_path={}'.format(helper_schema)})\n\n repoUrlSQL = s.sql.text(\"\"\"\n SELECT repo_git FROM repo\n \"\"\")\n\n rs = pd.read_sql(repoUrlSQL, self.db, params={})\n\n all_repos = rs['repo_git'].values.tolist()\n\n # List of tasks that need periodic updates\n self.__updatable = self.prep_jobs(jobs)\n\n self.__processes = []\n self.__updater()\n\n @staticmethod\n def updater_process(broker_port, broker, model, given, delay, repos, repo_group_id):\n \"\"\"\n Controls a given plugin's update process\n :param name: name of object to be updated \n :param delay: time needed to update\n :param shared: shared object that is to also be updated\n \"\"\"\n logging.info('Housekeeper spawned {} model updater process for subsection {} with PID {}'.format(model, repo_group_id, os.getpid()))\n try:\n compatible_worker_found = False\n # Waiting for compatible worker\n while True:\n for worker in list(broker._getvalue().keys()):\n if model in broker[worker]['models'] and given in broker[worker]['given']:\n compatible_worker_found = True\n if compatible_worker_found:\n logging.info(\"Housekeeper recognized that the broker has a worker that \" + \n \"can handle the {} model... beginning to distribute maintained tasks\".format(model))\n time.sleep(4)\n while True:\n logging.info('Housekeeper updating {} model for subsection: {} with given {}...'.format(\n model, repo_group_id, given[0]))\n \n if given[0] == 'git_url':\n for repo in repos:\n task = {\n \"job_type\": \"MAINTAIN\", \n \"models\": [model], \n \"display_name\": \"{} model for git url: {}\".format(model, repo['repo_git']),\n \"given\": {\n \"git_url\": repo['repo_git']\n }\n }\n if \"focused_task\" in repo:\n task[\"focused_task\"] = repo['focused_task']\n try:\n requests.post('http://localhost:{}/api/unstable/task'.format(\n broker_port), json=task, timeout=10)\n except Exception as e:\n logging.info(\"Error encountered: {}\".format(e))\n\n time.sleep(0.5)\n elif given[0] == 'repo_group':\n task = {\n \"job_type\": \"MAINTAIN\", \n \"models\": [model], \n \"display_name\": \"{} model for repo group id: {}\".format(model, repo_group_id),\n \"given\": {\n \"repo_group\": repos\n }\n }\n try:\n requests.post('http://localhost:{}/api/unstable/task'.format(\n broker_port), json=task, timeout=10)\n except Exception as e:\n logging.info(\"Error encountered: {}\".format(e))\n\n logging.info(\"Housekeeper finished sending {} tasks to the broker for it to distribute to your worker(s)\".format(len(repos)))\n time.sleep(delay)\n break\n time.sleep(3)\n \n except KeyboardInterrupt:\n os.kill(os.getpid(), 9)\n os._exit(0)\n except:\n raise\n\n def __updater(self, updates=None):\n \"\"\"\n Starts update processes\n \"\"\"\n logging.info(\"Starting update processes...\")\n if updates is None:\n updates = self.__updatable\n for update in updates:\n up = Process(target=self.updater_process, args=(self.broker_port, self.broker, update['model'], \n update['given'], update['delay'], update['repos'], update['repo_group_id']), daemon=True)\n up.start()\n self.__processes.append(up)\n\n def update_all(self):\n \"\"\"\n Updates all plugins\n \"\"\"\n for updatable in self.__updatable:\n updatable['update']()\n\n def schedule_updates(self):\n \"\"\"\n Schedules updates\n \"\"\"\n # don't use this, \n logging.debug('Scheduling updates...')\n self.__updater()\n\n def join_updates(self):\n \"\"\"\n Join to the update processes\n \"\"\"\n for process in self.__processes:\n process.join()\n\n def shutdown_updates(self):\n \"\"\"\n Ends all running update processes\n \"\"\"\n for process in self.__processes:\n process.terminate()\n\n def prep_jobs(self, jobs):\n\n for job in jobs:\n if job['repo_group_id'] != 0:\n # Query all repos and last repo id\n repoUrlSQL = s.sql.text(\"\"\"\n SELECT repo_git, repo_id FROM repo WHERE repo_group_id = {} ORDER BY repo_id ASC\n \"\"\".format(job['repo_group_id']))\n else:\n repoUrlSQL = s.sql.text(\"\"\"\n SELECT repo_git, repo_id FROM repo ORDER BY repo_id ASC\n \"\"\".format(job['repo_group_id']))\n rs = pd.read_sql(repoUrlSQL, self.db, params={})\n if len(rs) == 0:\n logging.info(\"Trying to send tasks for repo group with id: {}, but the repo group does not contain any repos\".format(job['repo_group_id']))\n continue\n\n if 'starting_repo_id' in job:\n last_id = job['starting_repo_id']\n else:\n repoIdSQL = s.sql.text(\"\"\"\n SELECT since_id_str FROM gh_worker_job\n WHERE job_model = '{}'\n \"\"\".format(job['model']))\n\n job_df = pd.read_sql(repoIdSQL, self.helper_db, params={})\n\n # If a last id is not recorded, start from beginning of repos \n # (first id is not necessarily 0)\n try:\n last_id = int(job_df.iloc[0]['since_id_str'])\n except:\n last_id = 0\n\n jobHistorySQL = s.sql.text(\"\"\"\n SELECT max(history_id) AS history_id, status FROM gh_worker_history\n GROUP BY status\n LIMIT 1\n \"\"\")\n\n history_df = pd.read_sql(jobHistorySQL, self.helper_db, params={})\n\n finishing_task = False\n if len(history_df.index) != 0:\n if history_df.iloc[0]['status'] == 'Stopped':\n self.history_id = int(history_df.iloc[0]['history_id'])\n finishing_task = True\n # last_id += 1 #update to match history tuple val rather than just increment\n\n\n # Rearrange repos so the one after the last one that \n # was completed will be ran first\n before_repos = rs.loc[rs['repo_id'].astype(int) < last_id]\n after_repos = rs.loc[rs['repo_id'].astype(int) >= last_id]\n\n reorganized_repos = after_repos.append(before_repos)\n\n if 'all_focused' in job:\n reorganized_repos['focused_task'] = job['all_focused']\n\n reorganized_repos = reorganized_repos.to_dict('records')\n \n if finishing_task:\n reorganized_repos[0]['focused_task'] = 1\n job['repos'] = reorganized_repos\n return jobs\n\n"
] | [
[
"pandas.read_sql"
]
] |
issa-project/knowledge-graph | [
"e3f70de3248534672a32fbdc7d3768db1a0122e5"
] | [
"src/text_corpus/util.py"
] | [
"# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Thu Apr 8 16:35:35 2021\n\n@author: abobashe\n\"\"\"\nimport os\nimport datetime\nimport logging\n\nimport sys\n\n#%%\ndef always_log_exceptions(exctype, value, tb):\n \n #read last element in hope that this is the one we need\n #TODO:refactor\n logger=[logging.getLogger(name) for name in logging.root.manager.loggerDict][-1]\n \n logger.exception('Uncaught exception', exc_info=(exctype, value, tb))\n \n \n#%%\ndef open_timestamp_logger(log_prefix=None, log_dir=None, \n first_line=None, \n console_level=logging.INFO, file_level=logging.DEBUG):\n \n logger = logging.getLogger(log_prefix)\n logger.setLevel(file_level)\n \n # remove all previously created streams to begin a new ones \n if logger.hasHandlers():\n for i in range(len(logger.handlers)-1, -1, -1) :\n handler = logger.handlers[i]\n handler.close()\n logger.removeHandler(handler)\n \n # create console handler with a higher log level\n console = logging.StreamHandler()\n console.setLevel(console_level)\n logger.addHandler(console)\n \n # create log dir\n if log_dir is not None:\n if not os.path.exists(log_dir):\n os.makedirs(log_dir)\n \n # create file handler with lower log level\n if log_prefix is not None:\n fname = '%s_%s.log' % (log_prefix, datetime.datetime.now().strftime('%Y%m%d_%H%M%S'))\n log_file = logging.FileHandler(os.path.join(log_dir, fname) )\n log_file.setLevel(file_level)\n log_file.setFormatter(logging.Formatter('%(asctime)s %(levelname)-8s %(message)s', datefmt='%d/%m/%Y %H:%M:%S'))\n logger.addHandler(log_file)\n\n # output a line\n if first_line is not None:\n logger.info(first_line)\n \n sys.excepthook=always_log_exceptions\n \n return logger\n\ndef close_timestamp_logger(logger):\n logging.shutdown()\n \n#%%\nimport ast\nimport pandas as pd\n\ndef read_metadata(filePath):\n \"\"\"\n Read raw or processed metadata file converting columns into lists when\n nesessary\n\n Parameters\n ----------\n filename : string\n TSV file generated by download_agritrop_metadata.py script .\n\n Returns\n -------\n df : pd.DataFrame\n\n \"\"\"\n df = pd.read_csv(filePath, sep='\\t', encoding='utf-8')\n \n #for (col, _) in multi_field_map.items():\n for col in df.columns:\n try:\n #convert some columns to lists\n df[col] = df[col].apply(ast.literal_eval)\n except: \n pass\n\n return df\n\ndef save_metadata(df, filePath):\n \"\"\"\n Save processed DataFrame to a TSV file\n\n \"\"\"\n if filePath is not None: \n \n if not os.path.exists(os.path.dirname(filePath)):\n os.makedirs(os.path.dirname(filePath))\n \n df.to_csv(filePath, sep='\\t', encoding='utf-8', index=False)\n \n return df\n\n#%%\nimport json\ndef read_paper_json(json_path):\n json_path = os.path.realpath(os.path.normpath(json_path))\n with open(json_path) as json_file:\n json_dict = json.load(json_file)\n \n return json_dict\n\ndef save_paper_json(json_path, json_dict): \n json_path = os.path.realpath(os.path.normpath(json_path))\n \n with open(json_path, 'w' , encoding='utf-8') as json_file:\n json.dump(json_dict, json_file, indent=4, ensure_ascii=False) \n \n \n#%%\nimport shutil\n\ndef copy_file(file_path, to_folder ):\n\n dest_file_path = os.path.join(to_folder, os.path.basename(file_path))\n shutil.copyfile(file_path, dest_file_path) \n \n return dest_file_path\n\ndef _remove_readonly(func, path, _):\n \"Clear the readonly bit and reattempt the removal\"\n #os.chmod(path, stat.S_IWRITE)\n func(path)\n \n#%%\ntry:\n import pycld2 as cld2\nexcept:\n # Fake it on Windows\n class cld2(object):\n def detect(text, hintLanguage=None, bestEffort=False):\n isReliable = True\n textBytesFound = len(text)\n details = (('ENGLISH', 'en', 99, 100.0), ('Unknown', 'un', 0, 0.0), ('Unknown', 'un', 0, 0.0) )\n return isReliable, textBytesFound, details\n \n\ndef detect_lang(text, hint_language=None, best_effort=False,\n all_details=False, return_score=False,\n logger=None):\n \"\"\"\n Detect language of the text using pycld2 \n\n Parameters\n ----------\n text : string\n Text to detect language for.\n all_details : bool, optional\n If True and more thaan one language is detetced return all of the\n languages separated by comma. \n If False alsways return the first detected language The default is False.\n logger: logging.Logger, optional \n If specified then the details of language detection will be logged. \n The defaoult is None\n \n Returns\n -------\n lang : str or None\n If detection is reliable then return string of detected language code \n in ISO 639-1 format.\n\n \"\"\"\n \n isReliable, textBytesFound, details = cld2.detect(text, hintLanguage=hint_language)\n \n #isReliable, textBytesFound, details = (True, len(text), (('ENGLISH', 'en', 99, 1157.0), ('Unknown', 'un', 0, 0.0), ('Unknown', 'un', 0, 0.0)))\n \n if logger:\n logger.debug(text[:500])\n logger.debug(details)\n \n if not isReliable and best_effort: \n isReliable, textBytesFound, details = cld2.detect(text, hintLanguage=hint_language, bestEffort=True)\n if logger:\n logger.debug('best effort')\n logger.debug(details)\n \n lang=None\n score=None\n \n if isReliable:\n lang = details[0][1]\n score = details[0][2]/100.0\n \n #typically the first language is good enough to return if more details\n #are needed use the details parameter\n if all_details and details[1][2] > 0:\n lang = ','.join([lang, details[1][1], details[2][1]])\n \n \n if return_score:\n return lang , score\n else:\n return lang\n\n#%%\ndef get_nestted_dict_value(nested_dict, path_list):\n \"\"\"\n FEtch the value from a dictionary provided the path as list of strings \n and indecies\n\n Parameters\n ----------\n nested_dict : dict\n\n path_list : list\n list of list of strings and/or indecies\n\n Returns\n -------\n value : any type\n \"\"\"\n \n value = nested_dict\n for k in path_list:\n value = value[k] \n \n return value\n \ndef set_nested_dict_value(nested_dict, path_list, value):\n \"\"\"\n Assign value to a key mapped by path as list of strings and indecies.\n Creates list if an index in a path os 0 but nested value is empty.\n In other cases if index is out of range then exception will be thrown.\n\n Parameters\n ----------\n nested_dict : dict\n\n path_list : list \n list of list of strings and/or indecies\n\n value : any type\n value to assign\n Returns\n -------\n nested_dict : dict\n updated dictionary\n\n \"\"\"\n\n d = nested_dict\n for k in path_list[:-1]:\n if k == 0 and len(d) == 0:\n # create list for index=0 if list does not exist\n d = []\n d = d[k] \n \n d[path_list[-1]] = value \n \n return nested_dict "
] | [
[
"pandas.read_csv"
]
] |
tylerdave/stravaio | [
"a2de2ef68ef59b906d53e6f3086ff10ffba4f507"
] | [
"stravaio.py"
] | [
"import swagger_client\nfrom swagger_client.rest import ApiException\nimport maya\nimport os\nimport json\nimport datetime\nimport pandas as pd\nimport glob\nimport datetime\nfrom loguru import logger\nimport requests\nimport socket\nimport urllib\nimport webbrowser\nfrom http.server import BaseHTTPRequestHandler, HTTPServer\n\n\nclass StravaIO():\n\n def __init__(self, access_token=None):\n if access_token is None:\n access_token = os.getenv('STRAVA_ACCESS_TOKEN')\n self.configuration = swagger_client.Configuration()\n self.configuration.access_token = access_token\n self._api_client = swagger_client.ApiClient(self.configuration)\n self.athletes_api = swagger_client.AthletesApi(self._api_client)\n self.activities_api = swagger_client.ActivitiesApi(self._api_client)\n self.streams_api = swagger_client.StreamsApi(self._api_client)\n\n def get_logged_in_athlete(self):\n \"\"\"Get logged in athlete\n \n Returns\n -------\n athlete: Athlete object\n \"\"\"\n\n try:\n rv = Athlete(self.athletes_api.get_logged_in_athlete())\n except ApiException as e:\n logger.error(f\"\"\"\"\n Error in strava_swagger_client.AthletesApi! \n STRAVA_ACCESS_TOKEN is likely out of date!\n Check the https://github.com/sladkovm/strava-oauth for help.\n Returning None.\n Original Error:\n {e}\"\"\")\n rv = None\n return rv \n\n def local_athletes(self):\n \"\"\"List local athletes\n \n Returns\n -------\n athletes: generator of JSON friendly dicts\n \"\"\"\n for f_name in glob.glob(os.path.join(dir_stravadata(), 'athlete*.json')):\n with open(f_name) as f:\n yield json.load(f)\n\n\n def get_activity_by_id(self, id):\n \"\"\"Get activity by ID\n \n Returns\n -------\n activity: Activity ojbect\n \"\"\"\n return Activity(self.activities_api.get_activity_by_id(id))\n\n def get_logged_in_athlete_activities(self, after=0, list_activities=None):\n \"\"\"List all activities after a given date\n \n Parameters\n ----------\n after: int, str or datetime object\n If integer, the time since epoch is assumed\n If str, the maya.parse() compatible date string is expected e.g. iso8601 or 2018-01-01 or 20180101\n If datetime, the datetime object is expected\n\n Returns\n -------\n list_activities: list\n List of SummaryActivity objects\n \"\"\"\n if list_activities is None:\n list_activities = []\n after = date_to_epoch(after)\n _fetched = self.activities_api.get_logged_in_athlete_activities(after=after)\n if len(_fetched) > 0:\n print(f\"Fetched {len(_fetched)}, the latests is on {_fetched[-1].start_date}\")\n list_activities.extend(_fetched)\n if len(_fetched) == 30:\n last_after = list_activities[-1].start_date\n return self.get_logged_in_athlete_activities(after=last_after, list_activities=list_activities)\n else:\n print(\"empty list\")\n \n return list_activities\n \n\n\n def local_activities(self, athlete_id):\n \"\"\"List local activities\n \n Parameters\n ----------\n athlete_id: int\n\n Returns\n -------\n activities: generator of JSON friendly dicts\n \"\"\"\n dir_activities = os.path.join(dir_stravadata(), f\"activities_{athlete_id}\")\n for f_name in glob.glob(os.path.join(dir_activities, '*.json')):\n with open(f_name) as f:\n yield json.load(f)\n\n\n def local_streams(self, athlete_id):\n \"\"\"List local streams\n \n Parameters\n ----------\n athlete_id: int\n\n Returns\n -------\n streams: generator of dataframes\n \"\"\"\n dir_streams = os.path.join(dir_stravadata(), f\"streams_{athlete_id}\")\n for f_name in glob.glob(os.path.join(dir_streams, '*.parquet')):\n yield pd.read_parquet(f_name)\n\n\n def get_activity_streams(self, id, athlete_id, local=True):\n \"\"\"Get activity streams by ID\n \n Parameters\n ----------\n id: int\n activity_id\n athlete_id: int\n athlete_id\n local: bool (default=True)\n if the streams is already storred, return the local version\n\n Returns\n -------\n streams: Streams ojbect (remote) or pd.Dataframe (local)\n \"\"\"\n if local:\n dir_streams = os.path.join(dir_stravadata(), f\"streams_{athlete_id}\")\n f_name = f\"streams_{id}.parquet\"\n f_path = os.path.join(dir_streams, f_name)\n if f_path in glob.glob(f_path):\n return pd.read_parquet(f_path)\n keys = ['time', 'distance', 'latlng', 'altitude', 'velocity_smooth',\n 'heartrate', 'cadence', 'watts', 'temp', 'moving', 'grade_smooth']\n api_response = self.streams_api.get_activity_streams(id, keys, key_by_type=True)\n return Streams(api_response, id, athlete_id)\n\n\nclass Athlete():\n\n def __init__(self, api_response):\n \"\"\"\n Parameters\n ----------\n api_response: swagger_client.get...() object\n e.g. athletes_api.get_logged_in_athlete()\n \"\"\"\n self.api_response = api_response\n self.id = self.api_response.id\n\n def __str__(self):\n return self._stringify()\n\n def __repr__(self):\n return self._stringify()\n\n def to_dict(self):\n _dict = self.api_response.to_dict()\n _dict = convert_datetime_to_iso8601(_dict)\n return _dict\n\n def store_locally(self):\n strava_dir = dir_stravadata()\n f_name = f\"athlete_{self.api_response.id}.json\"\n with open(os.path.join(strava_dir, f_name), 'w') as fp:\n json.dump(self.to_dict(), fp)\n\n def _stringify(self):\n return json.dumps(self.to_dict(), indent=2)\n\n\nclass Activity():\n\n def __init__(self, api_response, client=None):\n self.api_response = api_response\n self.athlete_id = self.api_response.athlete.id\n self.id = self.api_response.id\n if client:\n self.streams_api = client.streams_api\n else:\n client = None\n\n def __repr__(self):\n return f\"Activity: {self.id}, Date: {self.api_response.start_date}, Name: {self.api_response.name}\"\n\n def to_dict(self):\n _dict = self.api_response.to_dict()\n _dict = convert_datetime_to_iso8601(_dict)\n return _dict\n\n def store_locally(self):\n strava_dir = dir_stravadata()\n athlete_id = self.api_response.athlete.id\n activities_dir = os.path.join(strava_dir, f\"activities_{athlete_id}\")\n if not os.path.exists(activities_dir):\n os.mkdir(activities_dir)\n f_name = f\"activity_{self.api_response.id}.json\"\n with open(os.path.join(activities_dir, f_name), 'w') as fp:\n json.dump(self.to_dict(), fp)\n\n\nclass Streams():\n\n ACCEPTED_KEYS = ['time', 'distance', 'altitude', 'velocity_smooth', 'heartrate', 'cadence', 'watts', 'temp', 'moving', 'grade_smooth', 'lat', 'lng']\n\n def __init__(self, api_response, activity_id, athlete_id):\n self.api_response = api_response\n self.activity_id = activity_id\n self.athlete_id = athlete_id\n\n def __repr__(self):\n return f\"\"\"Streams for {self.activity_id}\\nKeys: {list(self.to_dict().keys())}\\nAccess: obj.key or obj.to_dict() to load into a pd.DataFrame()\"\"\"\n\n def to_dict(self):\n _dict = self.api_response.to_dict()\n r = {}\n for k, v in _dict.items():\n if v is not None:\n r.update({k: v['data']})\n if r.get('latlng', None):\n latlng = r.pop('latlng')\n _r = list(zip(*latlng))\n r.update({'lat': list(_r[0])})\n r.update({'lng': list(_r[1])}) \n return r\n\n def store_locally(self):\n _df = pd.DataFrame(self.to_dict())\n strava_dir = dir_stravadata()\n streams_dir = os.path.join(strava_dir, f\"streams_{self.athlete_id}\")\n if not os.path.exists(streams_dir):\n os.mkdir(streams_dir)\n f_name = f\"streams_{self.activity_id}.parquet\"\n _df.to_parquet(os.path.join(streams_dir, f_name))\n\n @property\n def time(self):\n return self._get_stream_by_name('time')\n\n @property\n def distance(self):\n return self._get_stream_by_name('distance')\n\n @property\n def altitude(self):\n return self._get_stream_by_name('altitude')\n\n @property\n def velocity_smooth(self):\n return self._get_stream_by_name('velocity_smooth')\n\n @property\n def heartrate(self):\n return self._get_stream_by_name('heartrate')\n\n @property\n def cadence(self):\n return self._get_stream_by_name('cadence')\n\n @property\n def watts(self):\n return self._get_stream_by_name('watts')\n\n @property\n def grade_smooth(self):\n return self._get_stream_by_name('grade_smooth')\n\n @property\n def moving(self):\n return self._get_stream_by_name('moving')\n \n @property\n def lat(self):\n return self._get_stream_by_name('lat')\n\n @property\n def lng(self):\n return self._get_stream_by_name('lng')\n\n\n def _get_stream_by_name(self, key):\n \n if key not in self.ACCEPTED_KEYS:\n raise KeyError(f\"key must be one of {self.ACCEPTED_KEYS}\")\n \n try:\n rv = self.to_dict()[key]\n except KeyError:\n logger.warning(f\"Stream does not contain {key}\")\n rv = None\n return rv\n\n\ndef strava_oauth2(client_id=None, client_secret=None):\n \"\"\"Run strava authorization flow. This function will open a default system\n browser alongside starting a local webserver. The authorization procedure will be completed in the browser.\n\n The access token will be returned in the browser in the format ready to copy to the .env file.\n \n Parameters:\n -----------\n client_id: int, if not provided will be retrieved from the STRAVA_CLIENT_ID env viriable\n client_secret: str, if not provided will be retrieved from the STRAVA_CLIENT_SECRET env viriable\n \"\"\"\n if client_id is None:\n client_id = os.getenv('STRAVA_CLIENT_ID', None)\n if client_id is None:\n raise ValueError('client_id is None')\n if client_secret is None:\n client_secret = os.getenv('STRAVA_CLIENT_SECRET', None)\n if client_secret is None:\n raise ValueError('client_secret is None')\n \n port = 8000\n _request_strava_authorize(client_id, port)\n\n logger.info(f\"serving at port {port}\")\n\n token = run_server_and_wait_for_token(\n port=port,\n client_id=client_id,\n client_secret=client_secret\n )\n\n return token\n\n\ndef _request_strava_authorize(client_id, port):\n params_oauth = {\n \"client_id\": client_id,\n \"response_type\": \"code\",\n \"redirect_uri\": f\"http://localhost:{port}/authorization_successful\",\n \"scope\": \"read,profile:read_all,activity:read\",\n \"state\": 'https://github.com/sladkovm/strava-http',\n \"approval_prompt\": \"force\"\n }\n values_url = urllib.parse.urlencode(params_oauth)\n base_url = 'https://www.strava.com/oauth/authorize'\n rv = base_url + '?' + values_url\n webbrowser.get().open(rv)\n return None\n\n\ndef run_server_and_wait_for_token(port, client_id, client_secret):\n with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:\n s.bind(('127.0.0.1', port))\n s.listen()\n conn, addr = s.accept()\n\n request_bytes = b''\n with conn:\n while True:\n chunk = conn.recv(512)\n request_bytes += chunk\n\n if request_bytes.endswith(b'\\r\\n\\r\\n'):\n break\n conn.sendall(b'HTTP/1.1 200 OK\\r\\n\\r\\nsuccess\\r\\n')\n\n request = request_bytes.decode('utf-8')\n status_line = request.split('\\n', 1)[0]\n \n method, raw_url, protocol_version = status_line.split(' ')\n \n url = urllib.parse.urlparse(raw_url)\n query_string = url.query\n query_params = urllib.parse.parse_qs(query_string, keep_blank_values=True)\n\n if url.path == \"/authorization_successful\":\n code = query_params.get('code')[0]\n logger.debug(f\"code: {code}\")\n params = {\n \"client_id\": client_id,\n \"client_secret\": client_secret,\n \"code\": code,\n \"grant_type\": \"authorization_code\"\n }\n r = requests.post(\"https://www.strava.com/oauth/token\", params)\n data = r.json()\n logger.debug(f\"Authorized athlete: {data.get('access_token', 'Oeps something went wrong!')}\")\n else:\n data = url.path.encode()\n \n return data\n\n\ndef convert_datetime_to_iso8601(d):\n for k, v in d.items():\n if isinstance(v, dict):\n convert_datetime_to_iso8601(v)\n elif isinstance(v, list):\n for i in v:\n if isinstance(i, dict):\n convert_datetime_to_iso8601(i)\n else:\n if isinstance(v, datetime.datetime):\n d[k] = maya.parse(v).iso8601()\n return d\n\n\ndef dir_stravadata():\n home_dir = os.path.expanduser('~')\n strava_dir = os.path.join(home_dir, '.stravadata')\n if not os.path.exists(strava_dir):\n os.mkdir(strava_dir)\n return strava_dir\n\n\ndef date_to_epoch(date):\n \"\"\"Convert a date to epoch representation\"\"\"\n rv = None\n if isinstance(date, int):\n rv = date\n if isinstance(date, datetime.datetime):\n _ = maya.parse(date)\n rv = _.epoch\n if isinstance(date, str):\n _ = maya.when(date)\n rv = _.epoch\n if rv is None:\n raise TypeError('date must be epoch int, datetime obj or the string')\n return rv\n"
] | [
[
"pandas.read_parquet"
]
] |
JoshKarpel/simulacra | [
"e5770ced1bef860caec25ce8c77a61ff0bb78907"
] | [
"dev/gaussian_beam.py"
] | [
"import logging\n\nfrom pathlib import Path\n\nimport numpy as np\n\nimport simulacra as si\nimport simulacra.units as u\n\nimport matplotlib.pyplot as plt\n\nFILE_NAME = Path(__file__).stem\nOUT_DIR = Path(__file__).parent / \"out\" / FILE_NAME\n\n\ndef w(z, w_0, z_0):\n return w_0 * np.sqrt(1 + ((z / z_0) ** 2))\n\n\ndef R(z, z_0):\n return z * (1 + ((z_0 / z) ** 2))\n\n\ndef guoy_phase(z, z_0):\n return np.arctan(z / z_0)\n\n\ndef field(x, z, w_0, wavelength):\n z_0 = u.pi * (w_0 ** 2) / wavelength\n k = u.twopi / wavelength\n w_z = w(z, w_0, z_0)\n amplitude = (w_0 / w_z) * np.exp(-((x / w_z) ** 2))\n phase = np.exp(1j * k * (x ** 2) / (2 * R(z, z_0))) * np.exp(\n -1j * guoy_phase(z, z_0)\n )\n\n return amplitude * phase\n\n\nif __name__ == \"__main__\":\n with si.utils.LogManager(\n \"simulacra\", stdout_logs=True, stdout_level=logging.DEBUG\n ) as logger:\n w_0 = 1 * u.um\n wavelength = 500 * u.nm\n\n x_lim = 10 * u.um\n z_lim = 50 * u.um\n\n pnts = 500\n\n x = np.linspace(-x_lim, x_lim, pnts)\n z = np.linspace(-z_lim, z_lim, pnts)\n\n x_mesh, z_mesh = np.meshgrid(x, z, indexing=\"ij\")\n field_mesh = field(x_mesh, z_mesh, w_0=w_0, wavelength=wavelength)\n\n si.vis.xyz_plot(\n f\"gaussian_beam\",\n z_mesh,\n x_mesh,\n field_mesh,\n title=rf\"Gaussian Beam w/ $\\lambda = {wavelength / u.nm:.1f} \\, \\mathrm{{nm}}, \\, w_0 = {w_0 / u.um:.1f} \\, \\mathrm{{\\mu m}}$\",\n x_label=\"z\",\n y_label=\"x\",\n x_unit=\"um\",\n y_unit=\"um\",\n colormap=plt.get_cmap(\"richardson\"),\n richardson_equator_magnitude=0.1,\n target_dir=OUT_DIR,\n )\n"
] | [
[
"numpy.arctan",
"numpy.exp",
"matplotlib.pyplot.get_cmap",
"numpy.sqrt",
"numpy.meshgrid",
"numpy.linspace"
]
] |
obfrap/sqlalchemy-challenge | [
"54dd0a62c7bf05012e48307fc2799abcc2dde30a"
] | [
"app.py"
] | [
"#matplotlib inline\nfrom matplotlib import style\nstyle.use('fivethirtyeight')\nimport matplotlib.pyplot as plt\n\nimport numpy as np\nimport pandas as pd\nimport datetime as dt\nimport sqlalchemy\nfrom sqlalchemy.ext.automap import automap_base\nfrom sqlalchemy.orm import Session\nfrom sqlalchemy import create_engine, func\nfrom sqlalchemy import desc\n\n\n##############################################################\n# Database setup\nengine = create_engine(\"sqlite:///Resources/hawaii.sqlite\")\n\n# reflect an existing database into a new model\nBase=automap_base()\n\n# reflect the tables|\nBase.prepare(engine, reflect=True)\n# We can view all of the classes that automap found\nBase.classes.keys()\n# Save references to each table\nMeasurement = Base.classes.measurement\nStation = Base.classes.station\n\n\n\n\n\n\n\n##############################################################\n# Flask Setup\n# Import Flask\nfrom flask import Flask\nfrom flask import jsonify\n\n# Create app\napp = Flask(__name__)\n\n# Home route\[email protected](\"/\")\ndef home():\n print(\"Server received request for 'Home' page...\")\n return (\n f\"This is the homepage for SQLAlchemy Challenge Climate App!<br/>\"\n f\"Available Routes:<br/>\"\n f\"/api/v1.0/precipitation<br/>\"\n f\"/api/v1.0/stations<br/>\"\n f\"/api/v1.0/tobs<br/>\"\n f\"<br/>\"\n f\"Enter start date or end date at end of url below to search for Min, Average and Max temperatures over time range <br/>\"\n f\"/api/v1.0/<start><br/>\"\n f\"/api/v1.0/<start>/<end><br/>\"\n f\"Format Examples:<br/>\"\n f\"/api/v1.0/2010-01-18<br/>\"\n f\"/api/v1.0/2010-01-18/2017-08-17\"\n )\[email protected](\"/api/v1.0/precipitation\")\ndef precipitation():\n \n # Create session\n session = Session(engine)\n\n # Run query\n results=session.query(Measurement.date, Measurement.prcp).all()\n\n session.close()\n\n #Create Dictionary of results\n date_precip = []\n for date, prcp in results:\n prcp_dict = {}\n prcp_dict[\"date\"] = date\n prcp_dict[\"prcp\"] = prcp\n date_precip.append(prcp_dict)\n\n return jsonify(date_precip)\n\[email protected](\"/api/v1.0/stations\")\ndef stations():\n # Create session\n session = Session(engine)\n\n # Run query\n results=session.query(Station.station, Station.name).all()\n\n session.close()\n\n #Create Dictionary of results\n station_name = []\n for station, name in results:\n station_dict = {}\n station_dict[\"Station\"] = station\n station_dict[\"Name\"] = name\n station_name.append(station_dict)\n\n return jsonify(station_name)\n\[email protected](\"/api/v1.0/tobs\")\ndef tobs():\n # Create session\n session = Session(engine)\n\n # Run query\n station_inf = session.query(Measurement.station, \n func.count(Measurement.station).label(\"total_count\"),\n )\n session.close()\n station_inf = station_inf.group_by(Measurement.station).order_by(desc(\"total_count\"))\n var = station_inf[0][0]\n \n #Create new session and query to pull all results for var my variable\n session = Session(engine)\n\n # Calculate the date 1 year ago from the last data point in the database\n last_row = session.query(Measurement).order_by(Measurement.date.desc()).first()\n lastrow_convert = dt.datetime.strptime(last_row.date, '%Y-%m-%d')\n end_date=lastrow_convert\n # Subtract 365 days\n start_date = lastrow_convert - pd.Timedelta('365 days')\n #Convert back to format that data table is using for query purposes\n start_date_conv=dt.datetime.strftime(start_date, '%Y-%m-%d')\n start_date_conv\n session.close()\n\n session = Session(engine)\n\n station_temp=session.query(Measurement.station, Measurement.date, Measurement.tobs).filter(Measurement.station == var).filter(Measurement.date >= start_date_conv).filter(Measurement.date <= end_date).order_by(Measurement.date).all()\n session.close()\n return jsonify(station_temp)\n\[email protected](\"/api/v1.0/<start>\")\ndef start(start=None):\n # Start new session\n session = Session(engine)\n \n #Query to pull in dates and temps for <start> range to end of dataset.\n from_start = session.query(Measurement.date, func.min(Measurement.tobs).label(\"Min\"), func.avg(Measurement.tobs).label(\"Avg\"),\n func.max(Measurement.tobs).label(\"Max\")).filter(Measurement.date >= start).group_by(\n Measurement.date).all()\n \n session.close()\n # Return results\n return jsonify(from_start)\n\[email protected](\"/api/v1.0/<start>/<end>\")\ndef start_end(start=None, end=None):\n #Start new session\n session = Session(engine)\n #Query to pull in dates and temps for <start> range to <end> range given\n start_to_end = session.query(Measurement.date, func.min(Measurement.tobs).label(\"Min\"), func.avg(Measurement.tobs).label(\"Avg\"),\n func.max(Measurement.tobs).label(\"Max\")).filter(Measurement.date >= start).filter(\n Measurement.date <= end).group_by(Measurement.date).all()\n \n session.close()\n # Return results \n return jsonify(start_to_end) \n\n\nif __name__ == \"__main__\":\n app.run(debug=True)"
] | [
[
"matplotlib.style.use",
"pandas.Timedelta"
]
] |
lightconeWJA/amc_with_annotation | [
"3fadc69944e7e6692c37949309ab03e37d2e30a2"
] | [
"env/channel_pruning_env.py"
] | [
"# Code for \"AMC: AutoML for Model Compression and Acceleration on Mobile Devices\"\n# Yihui He*, Ji Lin*, Zhijian Liu, Hanrui Wang, Li-Jia Li, Song Han\n# {jilin, songhan}@mit.edu\n\nimport time\nimport torch\nimport torch.nn as nn\nfrom lib.utils import AverageMeter, accuracy, prGreen\nfrom lib.data import get_split_dataset\nfrom env.rewards import *\nimport math\n\nimport numpy as np\nimport copy\n\n\nclass ChannelPruningEnv:\n \"\"\"\n Env for channel pruning search\n \"\"\"\n def __init__(self, model, checkpoint, data, preserve_ratio, args, n_data_worker=4,\n batch_size=256, export_model=False, use_new_input=False):\n # default setting\n self.prunable_layer_types = [torch.nn.modules.conv.Conv2d, torch.nn.modules.linear.Linear]\n\n # save options\n self.model = model\n self.checkpoint = checkpoint\n self.n_data_worker = n_data_worker\n self.batch_size = batch_size\n self.data_type = data\n self.preserve_ratio = preserve_ratio\n\n # options from args\n self.args = args\n self.lbound = args.lbound\n self.rbound = args.rbound\n\n self.use_real_val = args.use_real_val\n\n self.n_calibration_batches = args.n_calibration_batches\n self.n_points_per_layer = args.n_points_per_layer\n self.channel_round = args.channel_round\n self.acc_metric = args.acc_metric\n self.data_root = args.data_root\n\n self.export_model = export_model\n self.use_new_input = use_new_input\n\n # sanity check\n assert self.preserve_ratio > self.lbound, 'Error! You can make achieve preserve_ratio smaller than lbound!'\n\n # prepare data\n self._init_data()\n\n # build indexs\n # 初始化可剪通道的网络模块对应索引的集合\n # 同时初始化buffer_idx，即所有depthwise层对应索引的集合\n self._build_index()\n\n # 此变量表示可剪通道的网络层的数目\n self.n_prunable_layer = len(self.prunable_idx)\n\n # extract information for preparing\n # 针对每个prunable layer进行信息记录，输入输出记录/采样\n self._extract_layer_information()\n\n # build embedding (static part)\n self._build_state_embedding()\n\n # build reward\n self.reset() # restore weight\n self.org_acc = self._validate(self.val_loader, self.model)\n print('=> original acc: {:.3f}%'.format(self.org_acc))\n self.org_model_size = sum(self.wsize_list)\n print('=> original weight size: {:.4f} M param'.format(self.org_model_size * 1. / 1e6))\n self.org_flops = sum(self.flops_list)\n print('=> FLOPs:')\n print([self.layer_info_dict[idx]['flops']/1e6 for idx in sorted(self.layer_info_dict.keys())])\n print('=> original FLOPs: {:.4f} M'.format(self.org_flops * 1. / 1e6))\n\n self.expected_preserve_computation = self.preserve_ratio * self.org_flops\n\n self.reward = eval(args.reward)\n\n # 初始化：最优reward为负无穷，最优策略为空，最优维度为空\n self.best_reward = -math.inf\n self.best_strategy = None\n self.best_d_prime_list = None\n\n # 初始化参数量，之前算过\n self.org_w_size = sum(self.wsize_list)\n\n # 根据DDPG agent所选择的action进行一次模拟剪枝，并记录剪枝后的reward\n # 并不会真的剪枝，记录好reward后便会恢复模型，只有在最后一次episode时候才会进行真正的剪枝\n # 第一次使用此函数的上下文：\n # self.cur_ind 在 resset() 中置为0\n # self.strategy_dict 在_build_index()中变为{2: [1, 0.2], ... , 52:[0.2, 0.2], ..., 98:[0.2, 1]}形式\n # self.prunable_idx 在 _build_index里已经存好了所有可prunable layer的index\n # self.index_buffer 空的\n def step(self, action):\n # Pseudo prune and get the corresponding statistics. The real pruning happens till the end of all pseudo pruning\n if self.visited[self.cur_ind]:\n action = self.strategy_dict[self.prunable_idx[self.cur_ind]][0]\n preserve_idx = self.index_buffer[self.cur_ind]\n else:\n action = self._action_wall(action) # percentage to preserve\n preserve_idx = None\n\n # prune and update action\n # 调用完成后，对应的layer的weight已经经过剪枝\n # 通道被剪部分对应权重已经变为0\n # 返回\n # action：本层对应的压缩率 \n # d_prime：被压缩的通道，压缩后的通道数\n # preserve_idx：保留的这些个通道\n action, d_prime, preserve_idx = self.prune_kernel(self.prunable_idx[self.cur_ind], action, preserve_idx)\n\n # 这部分不会执行，因为self.shared_idx永远是空的\n if not self.visited[self.cur_ind]:\n for group in self.shared_idx:\n if self.cur_ind in group: # set the shared ones\n for g_idx in group:\n self.strategy_dict[self.prunable_idx[g_idx]][0] = action\n self.strategy_dict[self.prunable_idx[g_idx - 1]][1] = action\n self.visited[g_idx] = True\n self.index_buffer[g_idx] = preserve_idx.copy()\n\n # 要想看看更多的信息其实 if ture: 也行\n if self.export_model: # export checkpoint\n print('# Pruning {}: ratio: {}, d_prime: {}'.format(self.cur_ind, action, d_prime))\n\n # 保存本层的压缩率与保留的通道数\n self.strategy.append(action) # save action to strategy\n self.d_prime_list.append(d_prime)\n\n self.strategy_dict[self.prunable_idx[self.cur_ind]][0] = action\n if self.cur_ind > 0:\n self.strategy_dict[self.prunable_idx[self.cur_ind - 1]][1] = action\n\n # all the actions are made\n if self._is_final_layer():\n assert len(self.strategy) == len(self.prunable_idx)\n current_flops = self._cur_flops()\n acc_t1 = time.time()\n acc = self._validate(self.val_loader, self.model)\n acc_t2 = time.time()\n self.val_time = acc_t2 - acc_t1\n compress_ratio = current_flops * 1. / self.org_flops\n info_set = {'compress_ratio': compress_ratio, 'accuracy': acc, 'strategy': self.strategy.copy()}\n reward = self.reward(self, acc, current_flops)\n\n if reward > self.best_reward:\n self.best_reward = reward\n self.best_strategy = self.strategy.copy()\n self.best_d_prime_list = self.d_prime_list.copy()\n prGreen('New best reward: {:.4f}, acc: {:.4f}, compress: {:.4f}'.format(self.best_reward, acc, compress_ratio))\n prGreen('New best policy: {}'.format(self.best_strategy))\n prGreen('New best d primes: {}'.format(self.best_d_prime_list))\n\n obs = self.layer_embedding[self.cur_ind, :].copy() # actually the same as the last state\n done = True\n if self.export_model: # export state dict\n torch.save(self.model.state_dict(), self.export_path)\n return None, None, None, None\n return obs, reward, done, info_set\n\n info_set = None\n reward = 0\n done = False\n self.visited[self.cur_ind] = True # set to visited\n self.cur_ind += 1 # the index of next layer\n # build next state (in-place modify)\n self.layer_embedding[self.cur_ind][-3] = self._cur_reduced() * 1. / self.org_flops # reduced\n self.layer_embedding[self.cur_ind][-2] = sum(self.flops_list[self.cur_ind + 1:]) * 1. / self.org_flops # rest\n self.layer_embedding[self.cur_ind][-1] = self.strategy[-1] # last action\n obs = self.layer_embedding[self.cur_ind, :].copy()\n\n return obs, reward, done, info_set\n\n\n def reset(self):\n # restore env by loading the checkpoint\n self.model.load_state_dict(self.checkpoint)\n self.cur_ind = 0\n self.strategy = [] # pruning strategy\n self.d_prime_list = []\n self.strategy_dict = copy.deepcopy(self.min_strategy_dict)\n # reset layer embeddings\n self.layer_embedding[:, -1] = 1.\n self.layer_embedding[:, -2] = 0.\n self.layer_embedding[:, -3] = 0.\n obs = self.layer_embedding[0].copy()\n obs[-2] = sum(self.wsize_list[1:]) * 1. / sum(self.wsize_list)\n self.extract_time = 0\n self.fit_time = 0\n self.val_time = 0\n # for share index\n self.visited = [False] * len(self.prunable_idx)\n self.index_buffer = {}\n return obs\n\n def set_export_path(self, path):\n self.export_path = path\n\n \n # action, d_prime, preserve_idx = self.prune_kernel(self.prunable_idx[self.cur_ind], action, preserve_idx)\n # op_idx (operation index) <-> self.prunable_idx[self.cur_ind]：调用此func时候处理的prunable layer的index\n # action <-> preserve_ratio：actor网络输出的或者随机选取的压缩比\n # preserve_idx <-> preserve_idx：\n def prune_kernel(self, op_idx, preserve_ratio, preserve_idx=None):\n '''Return the real ratio'''\n # 取得 operation index 所指代的需要裁剪的 layer，此函数中用 op 引用\n m_list = list(self.model.modules())\n op = m_list[op_idx]\n \n assert (preserve_ratio <= 1.)\n\n if preserve_ratio == 1: # do not prune\n return 1., op.weight.size(1), None # TODO: should be a full index\n # n, c, h, w = op.weight.size()\n # mask = np.ones([c], dtype=bool)\n\n def format_rank(x):\n rank = int(np.around(x)) # 四舍五入\n return max(rank, 1)\n\n # 例如一个 op 为 Conv2d(32, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n # 那么 op.weight.shape = [64, 32, 1, 1] 即为 [N, C, H, W]\n n, c = op.weight.size(0), op.weight.size(1)\n\n # 计算压缩后卷积核的channel数量，并保证了一定大于1\n d_prime = format_rank(c * preserve_ratio)\n\n # np.ceil() 向上取整, np.floor() 向下取整\n # 即把 d_prime 搞成channel_round的整数倍，且保证d_prime <= c\n d_prime = int(np.ceil(d_prime * 1. / self.channel_round) * self.channel_round)\n if d_prime > c:\n d_prime = int(np.floor(c * 1. / self.channel_round) * self.channel_round)\n\n # 提取信息\n # X：op_idx对应layer的input_feat\n # Y：op_idx对应layer的output_feat\n # weight：op_idx对应layer的weight，用于挑选需要剪的通道\n extract_t1 = time.time()\n if self.use_new_input: # this is slow and may lead to overfitting\n self._regenerate_input_feature()\n X = self.layer_info_dict[op_idx]['input_feat'] # input after pruning of previous ops\n Y = self.layer_info_dict[op_idx]['output_feat'] # fixed output from original model\n weight = op.weight.data.cpu().numpy()\n # conv [C_out, C_in, ksize, ksize]\n # fc [C_out, C_in]\n op_type = 'Conv2D'\n if len(weight.shape) == 2:\n op_type = 'Linear'\n weight = weight[:, :, None, None] # [out, in] 变成了 [out, in, 1, 1]\n extract_t2 = time.time()\n self.extract_time += extract_t2 - extract_t1\n fit_t1 = time.time()\n\n # preserve_idx 在 self.visited[self.cur_ind] == 0 时候 为 None\n # 沿着维度C_in(输入通道数)进行sum操作\n # np.argsort()会进行排序后返回排序的下标结果\n # 这部分就是把weight沿着sum相加后最小的一部分channel给去掉\n # 因为是 取绝对值->取反->排序，能保证去掉的都是绝对值的和最小的一部分\n # 得到的preserve_idx就是拟剪枝后保留的这些通道\n if preserve_idx is None: # not provided, generate new\n importance = np.abs(weight).sum((0, 2, 3))\n sorted_idx = np.argsort(-importance) # sum magnitude along C_in, sort descend\n preserve_idx = sorted_idx[:d_prime] # to preserve index\n assert len(preserve_idx) == d_prime\n \n # 根据保留的通道设定mask数组，一个通道对应一个元素\n # 其中保留的部分设定为True，要剪的设定为false\n mask = np.zeros(weight.shape[1], bool)\n mask[preserve_idx] = True\n\n # reconstruct, X, Y <= [N, C]\n # 进行剪枝后使用线性回归对参数进行重新调整\n # 根据之前new_forward()所记录的'input_feat' 与 'output_feat' \n # 来对模拟剪通道以后的layer进行初步调整来尽量模拟之前的输入输出的函数\n # conv情况 [C_out, C_in, ksize, ksize]，ksize == 1\n # fc情况 [C_out, C_in, 1, 1]\n masked_X = X[:, mask]\n if weight.shape[2] == 1: # 1x1 conv or fc\n from lib.utils import least_square_sklearn\n rec_weight = least_square_sklearn(X=masked_X, Y=Y)\n rec_weight = rec_weight.reshape(-1, 1, 1, d_prime) # (C_out, K_h, K_w, C_in')\n rec_weight = np.transpose(rec_weight, (0, 3, 1, 2)) # (C_out, C_in', K_h, K_w)\n else:\n raise NotImplementedError('Current code only supports 1x1 conv now!')\n # 一个episode走下来后每层对应的rec_weight.shape差不多是这个鸟样：\n # (64, 8, 1, 1)\n # (128, 24, 1, 1)\n # (128, 112, 1, 1)\n # (256, 104, 1, 1)\n # (256, 112, 1, 1)\n # (512, 112, 1, 1)\n # (512, 104, 1, 1)\n # (512, 216, 1, 1)\n # (512, 440, 1, 1)\n # (512, 296, 1, 1)\n # (512, 216, 1, 1)\n # (1024, 144, 1, 1)\n # (1024, 848, 1, 1)\n # (1000, 944, 1, 1)\n \n # 参数默认情况下会执行\n # 相当于将需要裁剪的所有通道的权重变为0\n if not self.export_model: # pad, pseudo compress\n rec_weight_pad = np.zeros_like(weight) # 搞一个和weight相同shape的全0矩阵\n rec_weight_pad[:, mask, :, :] = rec_weight\n rec_weight = rec_weight_pad\n\n # 针对fc层重新变回正确的shape\n if op_type == 'Linear':\n rec_weight = rec_weight.squeeze()\n assert len(rec_weight.shape) == 2\n \n fit_t2 = time.time()\n self.fit_time += fit_t2 - fit_t1\n # now assign\n op.weight.data = torch.from_numpy(rec_weight).cuda()\n action = np.sum(mask) * 1. / len(mask) # calculate the ratio\n\n # 这部分暂时不用看\n if self.export_model: # prune previous buffer ops\n prev_idx = self.prunable_idx[self.prunable_idx.index(op_idx) - 1]\n for idx in range(prev_idx, op_idx):\n m = m_list[idx]\n if type(m) == nn.Conv2d: # depthwise\n m.weight.data = torch.from_numpy(m.weight.data.cpu().numpy()[mask, :, :, :]).cuda()\n if m.groups == m.in_channels:\n m.groups = int(np.sum(mask))\n elif type(m) == nn.BatchNorm2d:\n m.weight.data = torch.from_numpy(m.weight.data.cpu().numpy()[mask]).cuda()\n m.bias.data = torch.from_numpy(m.bias.data.cpu().numpy()[mask]).cuda()\n m.running_mean.data = torch.from_numpy(m.running_mean.data.cpu().numpy()[mask]).cuda()\n m.running_var.data = torch.from_numpy(m.running_var.data.cpu().numpy()[mask]).cuda()\n \n return action, d_prime, preserve_idx\n\n def _is_final_layer(self):\n return self.cur_ind == len(self.prunable_idx) - 1\n\n def _action_wall(self, action):\n # self.startegy 负责储存每个episode中每一个prunable layer的preserve ratio\n # 因此这个列表的长度应该和 cur_ind应该同时更新并保持一致\n assert len(self.strategy) == self.cur_ind\n\n action = float(action)\n action = np.clip(action, 0, 1)\n\n # this_comp（this prunable layer compression） 为遍历中的 prunable layer 的flops\n # other_comp 为除了this_comp 对应的层外其他的层的flops之和\n other_comp = 0\n this_comp = 0\n\n # 这里self.layer_info_dict[idx]['flops'] 在_extract_layer_information()定义\n # 并且其中包含了所有的 prunable_idx 与 buffer_idx 所有层的信息\n # 包括 input_feat, output_feat, randx, randy, params, flops\n # _extract_layer_information() 调用 new_forward()\n # new_forward() 调用 measure_layer_for_pruning 对每个layer增加了flops与param两个成员\n for i, idx in enumerate(self.prunable_idx):\n flop = self.layer_info_dict[idx]['flops']\n buffer_flop = self._get_buffer_flops(idx)\n\n # 针对不同layer所处位置的不同情况计算 this_comp 和 other_comp\n if i == self.cur_ind - 1: # TODO: add other member in the set\n this_comp += flop * self.strategy_dict[idx][0]\n # add buffer (but not influenced by ratio)\n other_comp += buffer_flop * self.strategy_dict[idx][0]\n elif i == self.cur_ind:\n this_comp += flop * self.strategy_dict[idx][1]\n # also add buffer here (influenced by ratio)\n this_comp += buffer_flop\n else:\n other_comp += flop * self.strategy_dict[idx][0] * self.strategy_dict[idx][1]\n # add buffer\n other_comp += buffer_flop * self.strategy_dict[idx][0] # only consider input reduction\n\n self.expected_min_preserve = other_comp + this_comp * action\n max_preserve_ratio = (self.expected_preserve_computation - other_comp) * 1. / this_comp\n\n action = np.minimum(action, max_preserve_ratio)\n action = np.maximum(action, self.strategy_dict[self.prunable_idx[self.cur_ind]][0]) # impossible (should be)\n\n return action\n\n # 从buffer_dict中取得某个prunable layer的所有buffer layer\n # 之后对所有的buffer layer 的 flops 求和并返回\n def _get_buffer_flops(self, idx):\n buffer_idx = self.buffer_dict[idx]\n buffer_flop = sum([self.layer_info_dict[_]['flops'] for _ in buffer_idx])\n return buffer_flop\n\n def _cur_flops(self):\n flops = 0\n for i, idx in enumerate(self.prunable_idx):\n c, n = self.strategy_dict[idx] # input, output pruning ratio\n flops += self.layer_info_dict[idx]['flops'] * c * n\n # add buffer computation\n flops += self._get_buffer_flops(idx) * c # only related to input channel reduction\n return flops\n\n def _cur_reduced(self):\n # return the reduced weight\n reduced = self.org_flops - self._cur_flops()\n return reduced\n\n def _init_data(self):\n # split the train set into train + val\n # for CIFAR, split 5k for val\n # for ImageNet, split 3k for val\n val_size = 5000 if 'cifar' in self.data_type else 3000\n self.train_loader, self.val_loader, n_class = get_split_dataset(self.data_type, self.batch_size,\n self.n_data_worker, val_size,\n data_root=self.data_root,\n use_real_val=self.use_real_val,\n shuffle=False) # same sampling\n if self.use_real_val: # use the real val set for eval, which is actually wrong\n print('*** USE REAL VALIDATION SET!')\n\n # 定义一堆杂七杂八的dict，用于之后的剪通道操作\n # strategy_dict 作为一个字典\n # 以prunalbe layer 的 index 作为 key\n # 以prunable layer 的输入输出的“保留值”（即裁剪后还留多少）的list[输入保留， 输出保留] 作为value\n def _build_index(self):\n self.prunable_idx = [] # 记录可剪枝网络模块所对应的索引号\n self.prunable_ops = [] # 没用，记录prunable_idx对应的网络模块\n self.layer_type_dict = {} # 没用，可看作是上面两个变量合起来后的字典\n self.strategy_dict = {} \n self.buffer_dict = {}\n this_buffer_list = []\n self.org_channels = []\n\n # build index and the min strategy dict\n # modules()会采用bfs(广度优先，即逐层遍历)方式返回所有网络的迭代器\n # 结果中会有网络本身，网络的子模块，子模块的子模块......\n # 和bfs略有不同的是，modules()只返回“模块级”的部分\n # 意思是如果有完全相同的conv2D或者Linear，则只返回一次\n # 此循环的任务就是找到最底层的子模块(可以理解为叶子节点)中只包含一个卷积层或全连接层的部分，找到后进行记录\n # i 就是 idx，代表不同模块的编号\n # m 就是不同的网络模块\n for i, m in enumerate(self.model.modules()):\n # 本模型只负责2d卷积以及全连接\n # 从prunable_layer_types定义可看出返回网络的种类定义规则\n if type(m) in self.prunable_layer_types:\n # depth-wise(深度分离)卷积\n # 当 gruops == in_channels，意味着每个输入channel都对应单独的一组滤波器\n # 这时候就是深度分离卷积的情况，会将其单独放在buffer_idx中\n # 针对其余卷积层与全连接层，会将其放入prunable_idx中，表示可剪通道\n # 进行遍历的过程中，每遇到一个深度卷积就放进this_buffer_list中暂存\n # 遍历到普通卷积或者全连接后，就将this_buffer_list中暂存的都作为此prunable layer的buffer\n # 之后清空this_buffer_list\n if type(m) == nn.Conv2d and m.groups == m.in_channels: # depth-wise conv, buffer\n this_buffer_list.append(i)\n else: # really prunable\n self.prunable_idx.append(i)\n self.prunable_ops.append(m)\n self.layer_type_dict[i] = type(m)\n self.buffer_dict[i] = this_buffer_list\n # 清空this_buffer_list同时并不会影响buffer_dict()\n # 这时候咋又不出deep_copy之类的幺蛾子了......\n this_buffer_list = [] # empty\n self.org_channels.append(m.in_channels if type(m) == nn.Conv2d else m.in_features)\n\n self.strategy_dict[i] = [self.lbound, self.lbound]\n\n self.strategy_dict[self.prunable_idx[0]][0] = 1 # modify the input\n self.strategy_dict[self.prunable_idx[-1]][1] = 1 # modify the output\n\n self.shared_idx = []\n if self.args.model == 'mobilenetv2': # TODO: to be tested! Share index for residual connection\n connected_idx = [4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32] # to be partitioned\n last_ch = -1\n share_group = None\n for c_idx in connected_idx:\n if self.prunable_ops[c_idx].in_channels != last_ch: # new group\n last_ch = self.prunable_ops[c_idx].in_channels\n if share_group is not None:\n self.shared_idx.append(share_group)\n share_group = [c_idx]\n else: # same group\n share_group.append(c_idx)\n print('=> Conv layers to share channels: {}'.format(self.shared_idx))\n\n self.min_strategy_dict = copy.deepcopy(self.strategy_dict)\n\n self.buffer_idx = []\n for k, v in self.buffer_dict.items():\n self.buffer_idx += v\n\n print('=> Prunable layer idx: {}'.format(self.prunable_idx))\n print('=> Buffer layer idx: {}'.format(self.buffer_idx))\n print('=> Initial min strategy dict: {}'.format(self.min_strategy_dict))\n\n # added for supporting residual connections during pruning\n # 将所有可剪通道对应的网络模块ID的visited数组置为false，完成初始化\n self.visited = [False] * len(self.prunable_idx)\n self.index_buffer = {}\n\n def _extract_layer_information(self):\n m_list = list(self.model.modules())\n\n self.data_saver = []\n self.layer_info_dict = dict()\n self.wsize_list = []\n self.flops_list = []\n\n from lib.utils import measure_layer_for_pruning\n\n # extend the forward fn to record layer info\n # 使用新成员 old_forward 来存放原来的forward函数\n # 使用新成员 new_forward 来存放扩展过功能的forward函数\n # 这里搞了个 new_forward 这么复杂的函数套函数是为了实现闭包\n # 因为在改写forward过程中，必然会涉及到对新的forward外部作用域内变量的引用\n # 上面一行所说的外部作用域的变量包括layer本身的成员\n # 闭包每次运行是能记住引用的外部作用域的变量的值，正式我们需要的\n def new_forward(m):\n def lambda_forward(x):\n m.input_feat = x.clone()\n measure_layer_for_pruning(m, x)\n y = m.old_forward(x)\n m.output_feat = y.clone()\n return y\n\n return lambda_forward\n\n # 改写所有的conv2d与linear层的forward函数\n for idx in self.prunable_idx + self.buffer_idx: # get all\n m = m_list[idx]\n m.old_forward = m.forward\n m.forward = new_forward(m)\n\n print('=> Extracting information...')\n with torch.no_grad():\n for i_b, (input, target) in enumerate(self.train_loader):\n if i_b == self.n_calibration_batches:\n break\n self.data_saver.append((input.clone(), target.clone()))\n input_var = torch.autograd.Variable(input).cuda()\n\n # inference and collect stats\n # 就是用input_var来过一遍模型 \n # 并不关心输出\n _ = self.model(input_var)\n\n # 第一个batch的操作：\n # 将layer_info_dict搞成一个二维dict\n # 里面存prunable和buffer的参数量与计算量两个信息 \n # 并用wsize_list和flops_list 分开再存一次\n if i_b == 0: # first batch\n for idx in self.prunable_idx + self.buffer_idx:\n self.layer_info_dict[idx] = dict()\n self.layer_info_dict[idx]['params'] = m_list[idx].params\n self.layer_info_dict[idx]['flops'] = m_list[idx].flops\n self.wsize_list.append(m_list[idx].params)\n self.flops_list.append(m_list[idx].flops)\n \n # 针对每个batch推理完成后，每一个prunable layer进行操作\n for idx in self.prunable_idx:\n # 类型转换，就是提取出input feature与output feature\n # 这两个变量就是input与output的clone()结果\n f_in_np = m_list[idx].input_feat.data.cpu().numpy()\n f_out_np = m_list[idx].output_feat.data.cpu().numpy()\n\n # 针对当前层为卷积的情况\n # 对于第一个卷积层不做记录，因为第一层需要保留原通道保证正常输入\n # 对于“通常”的卷积层，直接存进layer_info_dict\n if len(f_in_np.shape) == 4: # conv\n if self.prunable_idx.index(idx) == 0: # first conv\n f_in2save, f_out2save = None, None\n elif m_list[idx].weight.size(3) > 1: # normal conv\n f_in2save, f_out2save = f_in_np, f_out_np\n else: \n # 1x1 conv\n # assert f_out_np.shape[2] == f_in_np.shape[2] # now support k=3\n # input格式: [N, C, H, W]\n # 针对1*1卷积进行的则是采样处理(总体数据量太大？)\n # n_points_per_layer的含义就是针对每个batch的每个特征图进行采样点的数量\n # randx与randy可以理解成每个采样点的横纵坐标\n randx = np.random.randint(0, f_out_np.shape[2] - 0, self.n_points_per_layer)\n randy = np.random.randint(0, f_out_np.shape[3] - 0, self.n_points_per_layer)\n\n # 顺便记录每个采样点的位置(我猜这个之后也不会再用)\n self.layer_info_dict[idx][(i_b, 'randx')] = randx.copy()\n self.layer_info_dict[idx][(i_b, 'randy')] = randy.copy()\n\n # 将每个batch摊平\n # 例如之前是[40, 32, 112, 112]，分别对应[N, C, H, W]\n # 采样后就会变成[40, 32, 10]，10 对应的就是 112*112 特征图中的采样点\n # 当然在剪mobilenetV1过程中，剪的是 kernel = 1*1\n # 最后存储格式为[400, 32]，batchsize与采样数量合并\n f_in2save = f_in_np[:, :, randx, randy].copy().transpose(0, 2, 1)\\\n .reshape(self.batch_size * self.n_points_per_layer, -1)\n\n f_out2save = f_out_np[:, :, randx, randy].copy().transpose(0, 2, 1) \\\n .reshape(self.batch_size * self.n_points_per_layer, -1)\n else:\n assert len(f_in_np.shape) == 2\n f_in2save = f_in_np.copy()\n f_out2save = f_out_np.copy()\n if 'input_feat' not in self.layer_info_dict[idx]:\n self.layer_info_dict[idx]['input_feat'] = f_in2save\n self.layer_info_dict[idx]['output_feat'] = f_out2save\n else:\n self.layer_info_dict[idx]['input_feat'] = np.vstack(\n (self.layer_info_dict[idx]['input_feat'], f_in2save))\n self.layer_info_dict[idx]['output_feat'] = np.vstack(\n (self.layer_info_dict[idx]['output_feat'], f_out2save))\n\n\n def _regenerate_input_feature(self):\n # only re-generate the input feature\n m_list = list(self.model.modules())\n\n # delete old features\n for k, v in self.layer_info_dict.items():\n if 'input_feat' in v:\n v.pop('input_feat')\n\n # now let the image flow\n print('=> Regenerate features...')\n\n with torch.no_grad():\n for i_b, (input, target) in enumerate(self.data_saver):\n input_var = torch.autograd.Variable(input).cuda()\n\n # inference and collect stats\n _ = self.model(input_var)\n\n for idx in self.prunable_idx:\n f_in_np = m_list[idx].input_feat.data.cpu().numpy()\n if len(f_in_np.shape) == 4: # conv\n if self.prunable_idx.index(idx) == 0: # first conv\n f_in2save = None\n else:\n randx = self.layer_info_dict[idx][(i_b, 'randx')]\n randy = self.layer_info_dict[idx][(i_b, 'randy')]\n f_in2save = f_in_np[:, :, randx, randy].copy().transpose(0, 2, 1)\\\n .reshape(self.batch_size * self.n_points_per_layer, -1)\n else: # fc\n assert len(f_in_np.shape) == 2\n f_in2save = f_in_np.copy()\n if 'input_feat' not in self.layer_info_dict[idx]:\n self.layer_info_dict[idx]['input_feat'] = f_in2save\n else:\n self.layer_info_dict[idx]['input_feat'] = np.vstack(\n (self.layer_info_dict[idx]['input_feat'], f_in2save))\n\n # 顾名思义，我猜是确定强化学习中statues初始化相关的部分\n # embedding格式：\n # [\n # prunable_layer的index,\n # layer的类型(0是卷积，1是全连接)，\n # 输入大小(in_features是全连接输入大小，in_channels是卷积输入通道数)，\n # 输出大小(参考上面)，\n # 每层的步长stride(当然全连接层没有，设定为0)，\n # 每层的kernel_size(全连接层设定为1)，\n # 本层的压缩率，\n # 剩余的压缩率指标，\n # 上一层的压缩率\n # ] \n def _build_state_embedding(self):\n # build the static part of the state embedding\n # 函数内的临时变量，函数结束时会放进类成员中\n layer_embedding = []\n\n # 又是对prunable layer的遍历过程\n module_list = list(self.model.modules())\n for i, ind in enumerate(self.prunable_idx):\n m = module_list[ind]\n this_state = []\n if type(m) == nn.Conv2d:\n this_state.append(i) # index\n this_state.append(0) # layer type, 0 for conv\n this_state.append(m.in_channels) # in channels\n this_state.append(m.out_channels) # out channels\n this_state.append(m.stride[0]) # stride\n this_state.append(m.kernel_size[0]) # kernel size\n this_state.append(np.prod(m.weight.size())) # weight size\n elif type(m) == nn.Linear:\n this_state.append(i) # index\n this_state.append(1) # layer type, 1 for fc\n this_state.append(m.in_features) # in channels\n this_state.append(m.out_features) # out channels\n this_state.append(0) # stride\n this_state.append(1) # kernel size\n this_state.append(np.prod(m.weight.size())) # weight size\n\n # this 3 features need to be changed later\n this_state.append(0.) # reduced\n this_state.append(0.) # rest\n this_state.append(1.) # a_{t-1}\n layer_embedding.append(np.array(this_state))\n\n # normalize the state\n layer_embedding = np.array(layer_embedding, 'float')\n print('=> shape of embedding (n_layer * n_dim): {}'.format(layer_embedding.shape))\n assert len(layer_embedding.shape) == 2, layer_embedding.shape\n for i in range(layer_embedding.shape[1]):\n fmin = min(layer_embedding[:, i])\n fmax = max(layer_embedding[:, i])\n if fmax - fmin > 0:\n layer_embedding[:, i] = (layer_embedding[:, i] - fmin) / (fmax - fmin)\n\n self.layer_embedding = layer_embedding\n\n def _validate(self, val_loader, model, verbose=False):\n '''\n Validate the performance on validation set\n :param val_loader:\n :param model:\n :param verbose:\n :return:\n '''\n batch_time = AverageMeter()\n losses = AverageMeter()\n top1 = AverageMeter()\n top5 = AverageMeter()\n\n criterion = nn.CrossEntropyLoss().cuda()\n # switch to evaluate mode\n model.eval()\n end = time.time()\n\n t1 = time.time()\n with torch.no_grad():\n for i, (input, target) in enumerate(val_loader):\n target = target.cuda(non_blocking=True)\n input_var = torch.autograd.Variable(input).cuda()\n target_var = torch.autograd.Variable(target).cuda()\n\n # compute output\n output = model(input_var)\n loss = criterion(output, target_var)\n\n # measure accuracy and record loss\n prec1, prec5 = accuracy(output.data, target, topk=(1, 5))\n losses.update(loss.item(), input.size(0))\n top1.update(prec1.item(), input.size(0))\n top5.update(prec5.item(), input.size(0))\n\n # measure elapsed time\n batch_time.update(time.time() - end)\n end = time.time()\n t2 = time.time()\n if verbose:\n print('* Test loss: %.3f top1: %.3f top5: %.3f time: %.3f' %\n (losses.avg, top1.avg, top5.avg, t2 - t1))\n if self.acc_metric == 'acc1':\n return top1.avg\n elif self.acc_metric == 'acc5':\n return top5.avg\n else:\n raise NotImplementedError\n"
] | [
[
"numpy.sum",
"torch.no_grad",
"numpy.argsort",
"numpy.vstack",
"numpy.transpose",
"torch.autograd.Variable",
"numpy.abs",
"torch.from_numpy",
"numpy.around",
"numpy.minimum",
"numpy.ceil",
"numpy.zeros",
"numpy.maximum",
"numpy.zeros_like",
"numpy.floor",
"torch.nn.CrossEntropyLoss",
"numpy.clip",
"numpy.array",
"numpy.random.randint"
]
] |
LeonardII/KitCarFork | [
"b2802c5b08cc8250446ce3731cb622af064db4ca"
] | [
"simulation/utils/machine_learning/cycle_gan/models/cycle_gan_model.py"
] | [
"import torch\nfrom torch import Tensor, nn\nfrom torch.nn.functional import mse_loss\n\nfrom simulation.utils.machine_learning.data.image_pool import ImagePool\nfrom simulation.utils.machine_learning.models.helper import set_requires_grad\n\nfrom .base_model import BaseModel\nfrom .cycle_gan_stats import CycleGANStats\n\n\nclass CycleGANModel(BaseModel):\n \"\"\"This class implements the CycleGAN model, for learning image-to-image translation\n without paired data.\n\n CycleGAN paper: https://arxiv.org/pdf/1703.10593.pdf\n \"\"\"\n\n def __init__(\n self,\n netg_a_to_b: nn.Module,\n netg_b_to_a: nn.Module,\n netd_a: nn.Module = None,\n netd_b: nn.Module = None,\n is_train: bool = True,\n cycle_noise_stddev: int = 0,\n pool_size: int = 50,\n beta1: float = 0.5,\n lr: float = 0.0002,\n lr_policy: str = \"linear\",\n lambda_idt_a: int = 10,\n lambda_idt_b: int = 10,\n lambda_cycle: float = 0.5,\n optimizer_type: str = \"adam\",\n is_l1: bool = False,\n ):\n \"\"\"Initialize the CycleGAN class.\n\n Args:\n is_train: enable or disable training mode\n cycle_noise_stddev: Standard deviation of noise added to the cycle input.\n Mean is 0.\n pool_size: the size of image buffer that stores previously generated images\n beta1: momentum term of adam\n lr: initial learning rate for adam\n lr_policy: linear #learning rate policy. [linear | step | plateau | cosine]\n lambda_idt_a: weight for loss of domain A\n lambda_idt_b: weight for loss of domain B\n lambda_cycle: weight for loss identity\n optimizer_type: Name of the optimizer that will be used\n \"\"\"\n super().__init__(\n netg_a_to_b,\n netg_b_to_a,\n netd_a,\n netd_b,\n is_train,\n lambda_cycle,\n lambda_idt_a,\n lambda_idt_b,\n is_l1,\n optimizer_type,\n lr_policy,\n beta1,\n lr,\n cycle_noise_stddev,\n )\n\n if is_train:\n self.fake_a_pool = ImagePool(\n pool_size\n ) # create image buffer to store previously generated images\n self.fake_b_pool = ImagePool(\n pool_size\n ) # create image buffer to store previously generated images\n\n # define loss functions\n def gan_loss(prediction: torch.Tensor, is_real: bool):\n target = torch.tensor(\n 1.0 if is_real else 0.0, device=prediction.device\n ).expand_as(prediction)\n return mse_loss(prediction, target)\n\n self.criterionGAN = gan_loss\n\n def backward_d_basic(\n self, netd: nn.Module, real: torch.Tensor, fake: torch.Tensor\n ) -> Tensor:\n \"\"\"Calculate GAN loss for the discriminator.\n\n We also call loss_d.backward() to calculate the gradients.\n\n Return:\n Discriminator loss.\n\n Args:\n netd (nn.Module): the discriminator network\n real (torch.Tensor): the real image\n fake (torch.Tensor): the fake image\n \"\"\"\n # Real\n pred_real = netd(real)\n loss_d_real = self.criterionGAN(pred_real, True)\n # Fake\n pred_fake = netd(fake.detach())\n loss_d_fake = self.criterionGAN(pred_fake, False)\n # Combined loss and calculate gradients\n loss_d = (loss_d_real + loss_d_fake) * 0.5\n loss_d.backward()\n return loss_d\n\n def backward_d_a(self, real_a, fake_a) -> float:\n \"\"\"Calculate GAN loss for discriminator D_B.\"\"\"\n fake_a = self.fake_a_pool.query(fake_a)\n loss_d_a = self.backward_d_basic(self.networks.d_a, real_a, fake_a).item()\n return loss_d_a\n\n def backward_d_b(self, real_b, fake_b) -> float:\n \"\"\"Calculate GAN loss for discriminator D_b.\"\"\"\n fake_b = self.fake_b_pool.query(fake_b)\n loss_d_b = self.backward_d_basic(self.networks.d_b, real_b, fake_b).item()\n return loss_d_b\n\n def do_iteration(self, batch_a: torch.Tensor, batch_b: torch.Tensor):\n \"\"\"Calculate losses, gradients, and update network weights; called in every training\n iteration.\"\"\"\n real_a = batch_a\n real_b = batch_b\n # forward\n fake_a, fake_b, rec_a, rec_b = self.forward(\n real_a, real_b\n ) # compute fake images and reconstruction images.\n # G_A and G_B\n set_requires_grad(\n [self.networks.d_a, self.networks.d_b], False\n ) # Ds require no gradients when optimizing Gs\n self.optimizer_g.zero_grad() # set G_A and G_B's gradients to zero\n\n # Identity loss\n idt_a = self.networks.g_b_to_a(real_a)\n idt_b = self.networks.g_a_to_b(real_b)\n loss_idt_a = self.criterionIdt(idt_a, real_a) * self.lambda_idt_a\n loss_idt_b = self.criterionIdt(idt_b, real_b) * self.lambda_idt_b\n\n # GAN loss\n loss_g_a_to_b = self.criterionGAN(self.networks.d_b(fake_b), True)\n loss_g_b_to_a = self.criterionGAN(self.networks.d_a(fake_a), True)\n\n # Forward cycle loss\n loss_cycle_a = self.criterionCycle(rec_a, real_a) * self.lambda_cycle\n # Backward cycle loss\n loss_cycle_b = self.criterionCycle(rec_b, real_b) * self.lambda_cycle\n # combined loss and calculate gradients\n loss_g = (\n loss_g_a_to_b\n + loss_g_b_to_a\n + loss_cycle_a\n + loss_cycle_b\n + loss_idt_a\n + loss_idt_b\n )\n loss_g.backward()\n self.optimizer_g.step() # update G_A and G_B's weights\n\n # D_A and D_B\n set_requires_grad([self.networks.d_a, self.networks.d_b], True)\n self.optimizer_d.zero_grad() # set D_A and D_B's gradients to zero\n loss_d_a = self.backward_d_a(real_a, fake_a) # calculate gradients for D_A\n loss_d_b = self.backward_d_b(real_b, fake_b) # calculate gradients for D_B\n self.optimizer_d.step() # update D_A and D_B's weights\n\n return CycleGANStats(\n real_a,\n real_b,\n fake_a,\n fake_b,\n rec_a,\n rec_b,\n idt_a,\n idt_b,\n loss_g_a_to_b.item(),\n loss_g_b_to_a.item(),\n loss_idt_a.item(),\n loss_idt_b.item(),\n loss_cycle_a.item(),\n loss_cycle_b.item(),\n loss_d_a,\n loss_d_b,\n )\n"
] | [
[
"torch.nn.functional.mse_loss",
"torch.tensor"
]
] |
amarflybot/intent_classifier | [
"1a03a0809adf402157df0cd1f906bcf4d38337a8"
] | [
"intent_model/metrics.py"
] | [
"# Copyright 2017 Neural Networks and Deep Learning lab, MIPT\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 numpy as np\n\nfrom keras import backend as K\nimport sklearn.metrics\n\n\ndef precision_K(y_true, y_pred):\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\n precision = true_positives / (predicted_positives + K.epsilon())\n return precision\n\ndef recall_K(y_true, y_pred):\n true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n possible_positives = K.sum(K.round(K.clip(y_true, 0, 1)))\n recall = true_positives / (possible_positives + K.epsilon())\n return recall\n\ndef fbeta_score_K(y_true, y_pred, beta=1):\n if beta < 0:\n raise ValueError('The lowest choosable beta is zero (only precision).')\n\n if K.sum(K.round(K.clip(y_true, 0, 1))) == 0:\n return 0\n\n p = precision_K(y_true, y_pred)\n r = recall_K(y_true, y_pred)\n bb = beta ** 2\n fbeta_score = (1 + bb) * (p * r) / (bb * p + r + K.epsilon())\n return fbeta_score\n\n\ndef precision_np(y_true, y_pred):\n y_true = np.array(y_true)\n y_pred = np.array(y_pred)\n true_positives = np.sum(np.round(np.clip(y_true * y_pred, 0, 1)))\n predicted_positives = np.sum(np.round(np.clip(y_pred, 0, 1)))\n precision = true_positives / (predicted_positives + 10e-8)\n return precision\n\n\ndef recall_np(y_true, y_pred):\n y_true = np.array(y_true)\n y_pred = np.array(y_pred)\n true_positives = np.sum(np.round(np.clip(y_true * y_pred, 0, 1)))\n possible_positives = np.sum(np.round(np.clip(y_true, 0, 1)))\n recall = true_positives / (possible_positives + 10e-8)\n return recall\n\n\ndef fbeta_score_np(y_true, y_pred, beta=1):\n y_true = np.array(y_true)\n y_pred = np.array(y_pred)\n if beta < 0:\n raise ValueError('The lowest choosable beta is zero (only precision).')\n\n # If there are no true positives, fix the F score at 0 like sklearn.\n if np.sum(np.round(np.clip(y_true, 0, 1))) == 0:\n return 0\n\n p = precision_np(y_true, y_pred)\n r = recall_np(y_true, y_pred)\n bb = beta ** 2\n fbeta_score = (1 + bb) * (p * r) / (bb * p + r + 10e-8)\n return fbeta_score\n\ndef fmeasure(y_true, y_pred):\n try:\n _ = K.is_keras_tensor(y_pred)\n return fbeta_score_K(y_true, y_pred, beta=1)\n except ValueError:\n return fbeta_score_np(y_true, y_pred, beta=1)\n\ndef roc_auc_score(y_true, y_pred):\n \"\"\"Compute Area Under the Curve (AUC) from prediction scores.\n\n Args:\n y_true: true binary labels\n y_pred: target scores, can either be probability estimates of the positive class\n\n Returns:\n Area Under the Curve (AUC) from prediction scores\n \"\"\"\n try:\n return sklearn.metrics.roc_auc_score(y_true.reshape(-1), y_pred.reshape(-1))\n except ValueError:\n return 0.\n"
] | [
[
"numpy.array",
"numpy.clip"
]
] |
LittleNightmare/ArknightsAutoHelper | [
"3135b54d69f2255f99c13d42dc936065701c3129"
] | [
"imgreco/end_operation.py"
] | [
"import sys\nimport pickle\n\nimport numpy as np\nfrom PIL import Image, ImageOps\n\nfrom richlog import get_logger\nfrom . import util\nfrom . import imgops\nfrom . import item\nfrom . import minireco\nfrom . import resources\nfrom .util import any_in\n\nLOGFILE = 'log/drop-recognition.html'\n\nclass RecognizeSession:\n def __init__(self):\n self.recognized_groups = []\n self.low_confidence = False\n self.vh = 0\n self.vw = 0\n\ndef tell_stars(starsimg):\n thstars = (np.asarray(starsimg.convert('L')) > 96)\n width, height = thstars.shape[::-1]\n starwidth = width // 3\n threshold = height * (width/12)\n stars = []\n star1 = thstars[:, 0:starwidth]\n stars.append(np.count_nonzero(star1) > threshold)\n\n star2 = thstars[:, starwidth:starwidth*2]\n stars.append(np.count_nonzero(star2) > threshold)\n\n star3 = thstars[:, starwidth*2:]\n stars.append(np.count_nonzero(star3) > threshold)\n return tuple(stars)\n\n\nrecozh = minireco.MiniRecognizer(resources.load_pickle('minireco/NotoSansCJKsc-Medium.dat'))\nreco_novecento_bold = minireco.MiniRecognizer(resources.load_pickle('minireco/Novecentosanswide_Bold.dat'))\n\ngrouptemplates = []\ndef _load_data():\n _, files = resources.get_entries('end_operation')\n for f in files:\n if f.endswith('.png'):\n grouptemplates.append((f[:-4], resources.load_image('end_operation/'+f, 'L')))\n\n\ndef tell_group(groupimg, session, bartop, barbottom, ):\n logger = get_logger(LOGFILE)\n logger.logimage(groupimg)\n grouptext = groupimg.crop((0, barbottom, groupimg.width, groupimg.height))\n\n thim = imgops.enhance_contrast(grouptext.convert('L'), 60)\n thim = imgops.crop_blackedge(thim)\n logger.logimage(thim)\n # groupname = recozh.recognize(thim)\n # logger.logtext(recozh.recognize(thim))\n\n # if len(recognized_groups) == 0 and any_in('首次', groupname):\n # groupname = '首次掉落'\n # elif any_in('声望', groupname) and '声望&龙门币奖励' not in recognized_groups:\n # groupname = '声望&龙门币奖励'\n # elif any_in('常规', groupname) and '常规掉落' not in recognized_groups:\n # groupname = '常规掉落'\n # elif any_in('特殊', groupname) and '特殊掉落' not in recognized_groups:\n # groupname = '特殊掉落'\n # elif any_in('幸运', groupname) and '幸运掉落' not in recognized_groups:\n # groupname = '幸运掉落'\n # elif any_in('额物资', groupname) and '额外物资' not in recognized_groups:\n # groupname = '额外物资'\n # elif any_in('报酬', groupname) and '报酬' not in recognized_groups:\n # groupname = '报酬'\n # elif any_in('理智返还', groupname) and '理智返还' not in recognized_groups:\n # groupname = '理智返还'\n\n comparsions = [(x[0], imgops.compare_ccoeff(*imgops.uniform_size(thim, x[1])))\n for x in grouptemplates\n if x[0] not in session.recognized_groups]\n comparsions.sort(key=lambda x: x[1], reverse=True)\n logger.logtext(repr(comparsions))\n groupname = comparsions[0][0]\n if comparsions[0][1] < 0.6:\n session.low_confidence = True\n if groupname == '幸运掉落':\n return (groupname, [('(家具)', 1)])\n\n vw, vh = session.vw, session.vh\n itemcount = roundint(groupimg.width / (20.370*vh))\n result = []\n for i in range(itemcount):\n itemimg = groupimg.crop((20.370*vh*i, 0.000*vh, 40.741*vh, 18.981*vh))\n # x1, _, x2, _ = (0.093*vh, 0.000*vh, 19.074*vh, 18.981*vh)\n itemimg = itemimg.crop((0.093*vh, 0, 19.074*vh, itemimg.height))\n result.append(item.tell_item(itemimg, session))\n return (groupname, result)\n\n\ndef find_jumping(ary, threshold):\n logger = get_logger(LOGFILE)\n ary = np.array(ary, dtype=np.int16)\n diffs = np.diff(ary)\n shit = [x for x in enumerate(diffs) if abs(x[1]) >= threshold]\n groups = [[shit[0]]]\n for x in shit[1:]:\n lastgroup = groups[-1]\n if np.sign(x[1]) == np.sign(lastgroup[-1][1]):\n lastgroup.append(x)\n else:\n groups.append([x])\n logger.logtext(repr(groups))\n pts = []\n for group in groups:\n pts.append(int(np.average(\n tuple(x[0] for x in group), weights=tuple(abs(x[1]) for x in group)))+1)\n return pts\n\n\ndef roundint(x): \n return int(round(x))\n\n# scale = 0\n\n\ndef check_level_up_popup(img):\n vw, vh = util.get_vwvh(img.size)\n\n ap_recovered_img = img.crop((50*vw+8.056*vh, 46.574*vh, 50*vw+24.907*vh, 51.296*vh)) # 理智已恢复\n ap_recovered_img = imgops.enhance_contrast(ap_recovered_img, 100, 225)\n ap_recovered_text = recozh.recognize(ap_recovered_img)\n return '理智' in ap_recovered_text\n\n\ndef check_end_operation(img):\n vw, vh = util.get_vwvh(img.size)\n\n operation_end_img = img.crop((4.722*vh, 80.278*vh, 56.389*vh, 93.889*vh))\n operation_end_img = imgops.image_threshold(operation_end_img, 225).convert('L')\n operation_end_img = imgops.scale_to_height(operation_end_img, 24)\n return '结束' in recozh.recognize(operation_end_img)\n\ndef get_dismiss_level_up_popup_rect(viewport):\n vw, vh = util.get_vwvh(viewport)\n return (100*vw-67.315*vh, 16.019*vh, 100*vw-5.185*vh, 71.343*vh)\n\nget_dismiss_end_operation_rect = get_dismiss_level_up_popup_rect\n\ndef recognize(im):\n import time\n t0 = time.monotonic()\n vw, vh = util.get_vwvh(im.size)\n logger = get_logger(LOGFILE)\n\n lower = im.crop((0, 61.111*vh, 100*vw, 100*vh))\n logger.logimage(lower)\n\n operation_id = lower.crop((0, 4.444*vh, 23.611*vh, 11.388*vh)).convert('L')\n logger.logimage(operation_id)\n operation_id = imgops.enhance_contrast(imgops.crop_blackedge(operation_id), 80, 220)\n logger.logimage(operation_id)\n operation_id_str = reco_novecento_bold.recognize(operation_id).upper()\n # FIXME: recognizer can't recognize [0o], [-i] well (the game uses sᴍᴀʟʟ ᴄᴀᴘs and the font has sᴍᴀʟʟ ᴄᴀᴘs in ASCII range)\n # FIXME: currently, we have no 'o' and 'i' in recognizer data as '0' and '-' are used more frequently\n\n # operation_name = lower.crop((0, 14.074*vh, 23.611*vh, 20*vh)).convert('L')\n # operation_name = imgops.enhance_contrast(imgops.crop_blackedge(operation_name))\n # logger.logimage(operation_name)\n\n stars = lower.crop((23.611*vh, 6.759*vh, 53.241*vh, 16.944*vh))\n logger.logimage(stars)\n stars_status = tell_stars(stars)\n\n level = lower.crop((63.148*vh, 4.444*vh, 73.333*vh, 8.611*vh))\n logger.logimage(level)\n exp = lower.crop((76.852*vh, 5.556*vh, 94.074*vh, 7.963*vh))\n logger.logimage(exp)\n\n items = lower.crop((68.241*vh, 10.926*vh, lower.width, 35.000*vh))\n logger.logimage(items)\n\n x, y = 6.667*vh, 18.519*vh\n linedet = items.crop((x, y, x+1, items.height)).convert('L')\n d = np.asarray(linedet)\n linetop, linebottom, *_ = find_jumping(d.reshape(linedet.height), 32)\n linetop += y\n linebottom += y\n\n grouping = items.crop((0, linetop, items.width, linebottom))\n grouping = grouping.resize((grouping.width, 1), Image.BILINEAR)\n grouping = grouping.convert('L')\n\n logger.logimage(grouping.resize((grouping.width, 16)))\n\n d = np.array(grouping, dtype=np.int16)[0]\n points = [0, *find_jumping(d, 32)]\n assert(len(points) % 2 == 0)\n finalgroups = list(zip(*[iter(points)]*2)) # each_slice(2)\n logger.logtext(repr(finalgroups))\n\n imggroups = [items.crop((x1, 0, x2, items.height))\n for x1, x2 in finalgroups]\n items = []\n\n session = RecognizeSession()\n session.vw = vw\n session.vh = vh\n\n for group in imggroups:\n result = tell_group(group, session, linetop, linebottom)\n session.recognized_groups.append(result[0])\n items.append(result)\n \n\n t1 = time.monotonic()\n if session.low_confidence:\n logger.logtext('LOW CONFIDENCE')\n logger.logtext('time elapsed: %f' % (t1-t0))\n return {\n 'operation': operation_id_str,\n 'stars': stars_status,\n 'items': items,\n 'low_confidence': session.low_confidence\n }\n\n\n_load_data()\n\n\nif __name__ == '__main__':\n print(globals()[sys.argv[-2]](Image.open(sys.argv[-1])))\n"
] | [
[
"numpy.sign",
"numpy.diff",
"numpy.asarray",
"numpy.count_nonzero",
"numpy.array"
]
] |
equinor/lcm | [
"338bf67e6eb412446e469b4c73f7000990445ebd"
] | [
"api/plots/bridge.py"
] | [
"import base64\nfrom io import BytesIO\n\nimport matplotlib.pyplot as plt\nfrom matplotlib.ticker import ScalarFormatter\n\nfrom calculators.bridge import calculate_blend_cumulative, SIZE_STEPS, theoretical_bridge\nfrom classes.product import Product\nfrom controllers.products import products_get\n\n\ndef bridge_plot(products: dict, mode, value) -> str:\n bridge = theoretical_bridge(mode, value)\n\n (\n fig,\n bridgeplot,\n ) = plt.subplots()\n bridgeplot.set_title(\"Bridge\")\n bridgeplot.set_xscale(\"log\")\n bridgeplot.set_xlabel(\"Particle Size μm\")\n bridgeplot.set_ylabel(\"Accumulated volume %\")\n bridgeplot.set_xticks([0.1, 1, 10, 100, 1000])\n bridgeplot.xaxis.set_major_formatter(ScalarFormatter())\n bridgeplot.plot(SIZE_STEPS, bridge, color=\"black\", label=\"Ideal\")\n bridgeplot.axes.set_ylim([0, 100])\n bridgeplot.axes.set_xlim([0.01, 10000])\n\n products_class = []\n all_products = products_get()\n for id, values in products.items():\n products_class.append(\n Product(product_id=id, share=(values[\"percentage\"] / 100), cumulative=all_products[id][\"cumulative\"])\n )\n bridgeplot.plot(SIZE_STEPS, calculate_blend_cumulative(products_class), color=\"red\", label=\"Blend\")\n\n bridgeplot.legend()\n\n tmpfile = BytesIO()\n fig.savefig(tmpfile, format=\"png\")\n encoded = base64.b64encode(tmpfile.getvalue()).decode(\"utf-8\")\n return encoded\n"
] | [
[
"matplotlib.ticker.ScalarFormatter",
"matplotlib.pyplot.subplots"
]
] |
ZheyuYe/gluon-nlp | [
"23d9d73f89ed83376def818434684eca17a3dea6"
] | [
"tests/test_sequence_sampler.py"
] | [
"import collections\nimport functools\nimport mxnet as mx\nimport numpy as np\nimport scipy\nimport pytest\nfrom mxnet.gluon import nn, HybridBlock\nfrom numpy.testing import assert_allclose\nfrom gluonnlp.sequence_sampler import BeamSearchScorer, BeamSearchSampler\nmx.npx.set_np()\n\n\[email protected]('length', [False, True])\[email protected]('alpha', [0.0, 1.0])\[email protected]('K', [1.0, 5.0])\[email protected]('batch_size', [1, 2])\[email protected]('vocab_size', [2, 5])\[email protected]('from_logits', [False, True])\[email protected]('hybridize', [False, True])\ndef test_beam_search_score(length, alpha, K, batch_size, vocab_size, from_logits, hybridize):\n scorer = BeamSearchScorer(alpha=alpha, K=K, from_logits=from_logits)\n if hybridize:\n scorer.hybridize()\n sum_log_probs = mx.np.zeros((batch_size,))\n scores = mx.np.zeros((batch_size,))\n for step in range(1, length + 1):\n if not from_logits:\n log_probs = np.random.normal(0, 1, (batch_size, vocab_size))\n log_probs = np.log((scipy.special.softmax(log_probs, axis=-1)))\n else:\n log_probs = np.random.uniform(-10, 0, (batch_size, vocab_size))\n log_probs = mx.np.array(log_probs, dtype=np.float32)\n sum_log_probs += log_probs[:, 0]\n scores = scorer(log_probs, scores, mx.np.array(step))[:, 0]\n lp = (K + length) ** alpha / (K + 1) ** alpha\n assert_allclose(scores.asnumpy(), sum_log_probs.asnumpy() / lp, 1E-5, 1E-5)\n\n\n# TODO(sxjscience) Test for the state_batch_axis\[email protected]('early_return', [False, True])\[email protected]('eos_id', [0, None])\ndef test_beam_search(early_return, eos_id):\n class SimpleStepDecoder(HybridBlock):\n def __init__(self, vocab_size=5, hidden_units=4):\n super().__init__()\n self.x2h_map = nn.Embedding(input_dim=vocab_size, output_dim=hidden_units)\n self.h2h_map = nn.Dense(units=hidden_units, flatten=False)\n self.vocab_map = nn.Dense(units=vocab_size, flatten=False)\n\n @property\n def state_batch_axis(self):\n return 0\n\n @property\n def data_batch_axis(self):\n return 0\n\n def hybrid_forward(self, F, data, state):\n \"\"\"\n\n Parameters\n ----------\n F\n data :\n (batch_size,)\n states :\n (batch_size, C)\n\n Returns\n -------\n out :\n (batch_size, vocab_size)\n new_state :\n (batch_size, C)\n \"\"\"\n new_state = self.h2h_map(state)\n out = self.vocab_map(self.x2h_map(data) + new_state)\n return out, new_state\n\n vocab_size = 3\n batch_size = 2\n hidden_units = 3\n beam_size = 4\n step_decoder = SimpleStepDecoder(vocab_size, hidden_units)\n step_decoder.initialize()\n sampler = BeamSearchSampler(beam_size=4, decoder=step_decoder, eos_id=eos_id, vocab_size=vocab_size,\n max_length_b=100, early_return=early_return)\n states = mx.np.random.normal(0, 1, (batch_size, hidden_units))\n inputs = mx.np.random.randint(0, vocab_size, (batch_size,))\n samples, scores, valid_length = sampler(inputs, states)\n samples = samples.asnumpy()\n valid_length = valid_length.asnumpy()\n for i in range(batch_size):\n for j in range(beam_size):\n vl = valid_length[i, j]\n if eos_id is not None:\n assert samples[i, j, vl - 1] == eos_id\n if vl < samples.shape[2]:\n assert (samples[i, j, vl:] == -1).all()\n assert (samples[i, :, 0] == inputs[i].asnumpy()).all()\n\n\n# TODO(sxjscience) Test for the state_batch_axis\[email protected]('early_return', [False, True])\[email protected]('eos_id', [0, None])\ndef test_beam_search_stochastic(early_return, eos_id):\n class SimpleStepDecoder(HybridBlock):\n def __init__(self, vocab_size=5, hidden_units=4):\n super().__init__()\n self.x2h_map = nn.Embedding(input_dim=vocab_size, output_dim=hidden_units)\n self.h2h_map = nn.Dense(units=hidden_units, flatten=False)\n self.vocab_map = nn.Dense(units=vocab_size, flatten=False)\n\n @property\n def state_batch_axis(self):\n return 0\n\n @property\n def data_batch_axis(self):\n return 0\n\n def hybrid_forward(self, F, data, state):\n \"\"\"\n\n Parameters\n ----------\n F\n data :\n (batch_size,)\n states :\n (batch_size, C)\n\n Returns\n -------\n out :\n (batch_size, vocab_size)\n new_state :\n (batch_size, C)\n \"\"\"\n new_state = self.h2h_map(state)\n out = self.vocab_map(self.x2h_map(data) + new_state)\n return out, new_state\n\n vocab_size = 3\n batch_size = 2\n hidden_units = 3\n beam_size = 4\n step_decoder = SimpleStepDecoder(vocab_size, hidden_units)\n step_decoder.initialize()\n sampler = BeamSearchSampler(beam_size=4, decoder=step_decoder, eos_id=eos_id, vocab_size=vocab_size,\n stochastic=True, max_length_b=100, early_return=early_return)\n states = mx.np.random.normal(0, 1, (batch_size, hidden_units))\n inputs = mx.np.random.randint(0, vocab_size, (batch_size,))\n samples, scores, valid_length = sampler(inputs, states)\n samples = samples.asnumpy()\n valid_length = valid_length.asnumpy()\n for i in range(batch_size):\n for j in range(beam_size):\n vl = valid_length[i, j]\n if eos_id is not None:\n assert samples[i, j, vl-1] == eos_id\n if vl < samples.shape[2]:\n assert (samples[i, j, vl:] == -1).all()\n assert (samples[i, :, 0] == inputs[i].asnumpy()).all()\n\n # test for repeativeness\n has_different_sample = False\n for _ in range(10):\n new_samples, scores, valid_length = sampler(inputs, states)\n if not np.array_equal(new_samples.asnumpy(), samples):\n has_different_sample = True\n break\n assert has_different_sample\n\[email protected]('early_return', [False, True])\[email protected]('sampling_paras', [(-1.0, -1), (0.05, -1), (-1.0, 1), (-1.0, 3)])\[email protected]('eos_id', [0, None])\ndef test_multinomial_sampling(early_return, sampling_paras, eos_id):\n class SimpleStepDecoder(HybridBlock):\n def __init__(self, vocab_size=5, hidden_units=4):\n super().__init__()\n self.x2h_map = nn.Embedding(input_dim=vocab_size, output_dim=hidden_units)\n self.h2h_map = nn.Dense(units=hidden_units, flatten=False)\n self.vocab_map = nn.Dense(units=vocab_size, flatten=False)\n\n @property\n def state_batch_axis(self):\n return 0\n\n @property\n def data_batch_axis(self):\n return 0\n\n def hybrid_forward(self, F, data, state):\n new_state = self.h2h_map(state)\n out = self.vocab_map(self.x2h_map(data) + new_state)\n return out, new_state\n\n vocab_size = 5\n batch_size = 2\n hidden_units = 3\n beam_size = 4\n step_decoder = SimpleStepDecoder(vocab_size, hidden_units)\n step_decoder.initialize()\n sampling_topp, sampling_topk = sampling_paras\n sampler = BeamSearchSampler(beam_size=4, decoder=step_decoder, eos_id=eos_id, vocab_size=vocab_size,\n stochastic=False,\n sampling=True, sampling_topp=sampling_topp, sampling_topk=sampling_topk,\n max_length_b=100, early_return=early_return)\n states = mx.np.random.normal(0, 1, (batch_size, hidden_units))\n inputs = mx.np.random.randint(0, vocab_size, (batch_size,))\n samples, scores, valid_length = sampler(inputs, states)\n samples = samples.asnumpy()\n valid_length = valid_length.asnumpy()\n for i in range(batch_size):\n for j in range(beam_size):\n vl = valid_length[i, j]\n if eos_id is not None:\n assert samples[i, j, vl - 1] == eos_id\n if vl < samples.shape[2]:\n assert (samples[i, j, vl:] == -1).all()\n assert (samples[i, :, 0] == inputs[i].asnumpy()).all()\n"
] | [
[
"numpy.random.normal",
"scipy.special.softmax",
"numpy.random.uniform"
]
] |
cogmaster-stats/python-cogstats | [
"e8a7082a27370b5ac27721190a05ed2b5a463a10"
] | [
"examples/solutions/plot_brain_size.py"
] | [
"\"\"\"\nRelating Gender and IQ\n=======================\n\nGoing back to the brain size + IQ data, test if the VIQ of male and\nfemale are different after removing the effect of brain size, height and\nweight.\n\"\"\"\nimport pandas\nfrom statsmodels.formula.api import ols\n\ndata = pandas.read_csv('../brain_size.csv', sep=';', na_values='.')\n\nmodel = ols('VIQ ~ Gender + MRI_Count + Height', data).fit()\nprint(model.summary())\n\n# Here, we don't need to define a contrast, as we are testing a single\n# coefficient of our model, and not a combination of coefficients.\n# However, defining a contrast, which would then be a 'unit contrast',\n# will give us the same results\nprint(model.f_test([0, 1, 0, 0]))\n\n###############################################################################\n# Here we plot a scatter matrix to get intuitions on our results.\n# This goes beyond what was asked in the exercise\n\n# This plotting is useful to get an intuitions on the relationships between\n# our different variables\n\nfrom pandas.tools import plotting\nimport matplotlib.pyplot as plt\n\n# Fill in the missing values for Height for plotting\ndata['Height'].fillna(method='pad', inplace=True)\n\n# The parameter 'c' is passed to plt.scatter and will control the color\n# The same holds for parameters 'marker', 'alpha' and 'cmap', that\n# control respectively the type of marker used, their transparency and\n# the colormap\nplotting.scatter_matrix(data[['VIQ', 'MRI_Count', 'Height']],\n c=(data['Gender'] == 'Female'), marker='o',\n alpha=1, cmap='winter')\n\nfig = plt.gcf()\nfig.suptitle(\"blue: male, green: female\", size=13)\n\nplt.show()\n"
] | [
[
"pandas.read_csv",
"matplotlib.pyplot.gcf",
"matplotlib.pyplot.show",
"pandas.tools.plotting.scatter_matrix"
]
] |
kushaltirumala/callibratable_style_consistency_flies | [
"d4e87d78bfa61068feff2169523bb963941163e2"
] | [
"lib/models/ctvae.py"
] | [
"import torch\nimport torch.nn as nn\nimport numpy as np\n\nfrom lib.models.core import BaseSequentialModel\nfrom lib.distributions import Normal\n\n\nclass CTVAE(BaseSequentialModel):\n\n name = 'ctvae' # conditional trajectory VAE policy\n model_args = ['state_dim', 'action_dim', 'z_dim', 'h_dim', 'rnn_dim', 'num_layers']\n requires_labels = True\n\n def __init__(self, model_config):\n super().__init__(model_config)\n\n def _construct_model(self):\n state_dim = self.config['state_dim']\n action_dim = self.config['action_dim']\n z_dim = self.config['z_dim']\n h_dim = self.config['h_dim']\n enc_rnn_dim = self.config['rnn_dim']\n dec_rnn_dim = self.config['rnn_dim'] if self.is_recurrent else 0\n num_layers = self.config['num_layers']\n # print(\"number of layers is\" + str(num_layers))\n # print(self.config)\n label_dim = self.config['label_dim']\n # print(\"number of label dim \" + str(label_dim))\n\n if \"conditional_single_fly_policy_2_to_2\" in self.config and self.config[\"conditional_single_fly_policy_2_to_2\"]:\n self.enc_birnn = nn.GRU(int(state_dim/2)+int(action_dim/2), enc_rnn_dim, num_layers=num_layers, bidirectional=True)\n else:\n self.enc_birnn = nn.GRU(state_dim+action_dim, enc_rnn_dim, num_layers=num_layers, bidirectional=True)\n\n # TODO hacky, change this\n if 'mode' in self.config and self.config['mode'] == 'mujoco':\n assert not self.is_recurrent\n\n self.enc_mean = nn.Linear(2*enc_rnn_dim+label_dim, z_dim)\n self.enc_logvar = nn.Linear(2*enc_rnn_dim+label_dim, z_dim)\n\n self.dec_action_fc = nn.Sequential(\n nn.Linear(state_dim+z_dim+label_dim+dec_rnn_dim, h_dim),\n nn.Tanh(),\n nn.Linear(h_dim, h_dim),\n nn.Tanh())\n self.dec_action_mean = nn.Sequential(\n nn.Linear(h_dim, action_dim),\n nn.Tanh())\n self.dec_action_logvar = nn.Parameter(torch.zeros(action_dim))\n else:\n self.enc_fc = nn.Sequential(\n nn.Linear(2*enc_rnn_dim+label_dim, h_dim),\n nn.ReLU(),\n nn.Linear(h_dim, h_dim),\n nn.ReLU())\n self.enc_mean = nn.Linear(h_dim, z_dim)\n self.enc_logvar = nn.Linear(h_dim, z_dim)\n\n if \"conditional_single_fly_policy_2_to_2\" in self.config and self.config[\"conditional_single_fly_policy_2_to_2\"]:\n self.dec_action_fc = nn.Sequential(\n nn.Linear(state_dim+int(action_dim/2)+z_dim+label_dim+dec_rnn_dim, h_dim),\n nn.ReLU(),\n nn.Linear(h_dim, h_dim),\n nn.ReLU())\n else:\n self.dec_action_fc = nn.Sequential(\n nn.Linear(state_dim+z_dim+label_dim+dec_rnn_dim, h_dim),\n nn.ReLU(),\n nn.Linear(h_dim, h_dim),\n nn.ReLU())\n if (\"conditional_single_fly_policy_4_to_2\" in self.config and self.config[\"conditional_single_fly_policy_4_to_2\"]) or (\"conditional_single_fly_policy_2_to_2\" in self.config and self.config[\"conditional_single_fly_policy_2_to_2\"]):\n self.dec_action_mean = nn.Linear(h_dim, int(action_dim / 2))\n self.dec_action_logvar = nn.Linear(h_dim, int(action_dim / 2))\n else:\n self.dec_action_mean = nn.Linear(h_dim, action_dim)\n self.dec_action_logvar = nn.Linear(h_dim, action_dim)\n\n if self.is_recurrent:\n self.dec_rnn = nn.GRU(state_dim+action_dim, dec_rnn_dim, num_layers=num_layers)\n\n def _define_losses(self):\n self.log.add_loss('kl_div')\n self.log.add_loss('nll')\n self.log.add_metric('kl_div_true')\n\n def forward(self, states, actions, labels_dict):\n self.log.reset()\n\n assert actions.size(1)+1 == states.size(1) # final state has no corresponding action\n states = states.transpose(0,1)\n actions = actions.transpose(0,1)\n labels = torch.cat(list(labels_dict.values()), dim=-1)\n\n # Encode\n if \"conditional_single_fly_policy_2_to_2\" in self.config and self.config[\"conditional_single_fly_policy_2_to_2\"]:\n if self.config[\"policy_for_fly_1_2_to_2\"]:\n posterior = self.encode(states[:-1, :, 0:2], actions=actions[:, :, 0:2], labels=labels)\n else:\n posterior = self.encode(states[:-1, :, 2:4], actions=actions[:, :, 2:4], labels=labels)\n else:\n posterior = self.encode(states[:-1], actions=actions, labels=labels)\n # print(posterior)\n\n kld = Normal.kl_divergence(posterior, free_bits=0.0).detach()\n self.log.metrics['kl_div_true'] = torch.sum(kld)\n\n kld = Normal.kl_divergence(posterior, free_bits=1/self.config['z_dim'])\n self.log.losses['kl_div'] = torch.sum(kld)\n\n # Decode\n self.reset_policy(labels=labels, z=posterior.sample())\n\n\n for t in range(actions.size(0)):\n if \"conditional_single_fly_policy_4_to_2\" in self.config and self.config[\"conditional_single_fly_policy_4_to_2\"]:\n if self.config[\"policy_for_fly_1_4_to_2\"]:\n action_likelihood = self.decode_action(states[t])\n self.log.losses['nll'] -= action_likelihood.log_prob(actions[t, :, 0:2])\n else:\n action_likelihood = self.decode_action(torch.cat((states[t + 1, :, 0:2], states[t, :, 2:4]), dim=1))\n self.log.losses['nll'] -= action_likelihood.log_prob(actions[t, :, 2:4])\n elif \"conditional_single_fly_policy_2_to_2\" in self.config and self.config[\"conditional_single_fly_policy_2_to_2\"]:\n if self.config[\"policy_for_fly_1_2_to_2\"]:\n if t == 0:\n action_likelihood = self.decode_action(states[t], actions=torch.Tensor(np.zeros((actions.size(1), 2))))\n else:\n action_likelihood = self.decode_action(states[t], actions=actions[t - 1, :, 2:4])\n self.log.losses['nll'] -= action_likelihood.log_prob(actions[t, :, 0:2])\n else:\n if t == 0:\n action_likelihood = self.decode_action(torch.cat((states[t + 1, :, 0:2], states[t, :, 2:4]), dim=1), actions=torch.Tensor(np.zeros((actions.size(1), 2))))\n else:\n action_likelihood = self.decode_action(torch.cat((states[t + 1, :, 0:2], states[t, :, 2:4]), dim=1),\n actions=actions[t, :, 0:2])\n self.log.losses['nll'] -= action_likelihood.log_prob(actions[t, :, 2:4])\n else:\n action_likelihood = self.decode_action(states[t])\n self.log.losses['nll'] -= action_likelihood.log_prob(actions[t])\n\n if self.is_recurrent:\n self.update_hidden(states[t], actions[t])\n\n return self.log\n"
] | [
[
"torch.sum",
"torch.nn.Linear",
"torch.nn.Tanh",
"torch.nn.GRU",
"torch.zeros",
"torch.nn.ReLU",
"torch.cat"
]
] |
GarrettJenkinson/condor_pytorch | [
"53406e11c0b6e27483b81f91f555013cd7d02a71"
] | [
"src/condor_pytorch/losses.py"
] | [
"import torch.nn.functional as F\nimport torch\n\n\ndef CondorOrdinalCrossEntropy(logits, levels, importance_weights=None, reduction='mean'):\n \"\"\"Computes the CONDOR loss described in\n\n CONDOR TBD.\n\n Parameters\n ----------\n logits : torch.tensor, shape(num_examples, num_classes-1)\n Outputs of the CONDOR layer.\n\n levels : torch.tensor, shape(num_examples, num_classes-1)\n True labels represented as extended binary vectors\n (via `condor_pytorch.dataset.levels_from_labelbatch`).\n\n importance_weights : torch.tensor, shape=(num_classes-1,) (default=None)\n Optional weights for the different labels in levels.\n A tensor of ones, i.e.,\n `torch.ones(num_classes-1, dtype=torch.float32)`\n will result in uniform weights that have the same effect as None.\n\n reduction : str or None (default='mean')\n If 'mean' or 'sum', returns the averaged or summed loss value across\n all data points (rows) in logits. If None, returns a vector of\n shape (num_examples,)\n\n Returns\n ----------\n loss : torch.tensor\n A torch.tensor containing a single loss value (if `reduction='mean'` or '`sum'`)\n or a loss value for each data record (if `reduction=None`).\n\n Examples\n ----------\n >>> import torch\n >>> levels = torch.tensor(\n ... [[1., 1., 0., 0.],\n ... [1., 0., 0., 0.],\n ... [1., 1., 1., 1.]])\n >>> logits = torch.tensor(\n ... [[2.1, 1.8, -2.1, -1.8],\n ... [1.9, -1., -1.5, -1.3],\n ... [1.9, 1.8, 1.7, 1.6]])\n >>> CondorOrdinalCrossEntropy(logits, levels)\n tensor(0.8259)\n \"\"\"\n\n if not logits.shape == levels.shape:\n raise ValueError(\"Please ensure that logits (%s) has the same shape as levels (%s). \"\n % (logits.shape, levels.shape))\n\n logprobs = torch.cumsum(F.logsigmoid(logits), dim = 1)\n term1 = (logprobs*levels\n + torch.log(1 - torch.exp(logprobs)+torch.finfo(torch.float32).eps)*(1-levels))\n\n if importance_weights is not None:\n term1 *= importance_weights\n\n val = (-torch.sum(term1, dim=1))\n\n if reduction == 'mean':\n loss = torch.mean(val)\n elif reduction == 'sum':\n loss = torch.sum(val)\n elif reduction is None:\n loss = val\n else:\n s = ('Invalid value for `reduction`. Should be \"mean\", '\n '\"sum\", or None. Got %s' % reduction)\n raise ValueError(s)\n\n return loss\n"
] | [
[
"torch.sum",
"torch.nn.functional.logsigmoid",
"torch.exp",
"torch.finfo",
"torch.mean"
]
] |
8W9aG/textacy | [
"7f3bd999a79d85e967bcba66aa57816ed1172089"
] | [
"src/textacy/vsm/vectorizers.py"
] | [
"\"\"\"\n:mod:`textacy.vsm.vectorizers`: Transform a collection of tokenized documents into\na document-term matrix of shape (# docs, # unique terms), with various ways to filter\nor limit included terms and flexible weighting schemes for their values.\n\nA second option aggregates terms in tokenized documents by provided group labels,\nresulting in a \"group-term-matrix\" of shape (# unique groups, # unique terms),\nwith filtering and weighting functionality as described above.\n\nSee the :class:`Vectorizer` and :class:`GroupVectorizer` docstrings for usage\nexamples and explanations of the various weighting schemes.\n\"\"\"\nimport collections\nimport operator\nfrom array import array\nfrom typing import Dict, List\n\nimport numpy as np\nimport scipy.sparse as sp\nfrom sklearn.preprocessing import normalize as normalize_mat\n\nfrom .. import errors\nfrom .matrix_utils import get_doc_lengths, get_inverse_doc_freqs, filter_terms_by_df\n\n\nBM25_K1 = 1.6 # value typically bounded in [1.2, 2.0]\nBM25_B = 0.75\n\n\nclass Vectorizer:\n \"\"\"\n Transform one or more tokenized documents into a sparse document-term matrix\n of shape (# docs, # unique terms), with flexibly weighted and normalized values.\n\n Stream a corpus with metadata from disk:\n\n .. code-block:: pycon\n\n >>> ds = textacy.datasets.CapitolWords()\n >>> records = ds.records(limit=1000)\n >>> corpus = textacy.Corpus(\"en\", data=records)\n >>> corpus\n Corpus(1000 docs; 538172 tokens)\n\n Tokenize and vectorize the first 600 documents of this corpus:\n\n .. code-block:: pycon\n\n >>> tokenized_docs = (\n ... doc._.to_terms_list(ngrams=1, entities=True, as_strings=True)\n ... for doc in corpus[:600])\n >>> vectorizer = Vectorizer(\n ... apply_idf=True, norm=\"l2\",\n ... min_df=3, max_df=0.95)\n >>> doc_term_matrix = vectorizer.fit_transform(tokenized_docs)\n >>> doc_term_matrix\n <600x4346 sparse matrix of type '<class 'numpy.float64'>'\n with 69673 stored elements in Compressed Sparse Row format>\n\n Tokenize and vectorize the remaining 400 documents of the corpus, using only\n the groups, terms, and weights learned in the previous step:\n\n .. code-block:: pycon\n\n >>> tokenized_docs = (\n ... doc._.to_terms_list(ngrams=1, entities=True, as_strings=True)\n ... for doc in corpus[600:])\n >>> doc_term_matrix = vectorizer.transform(tokenized_docs)\n >>> doc_term_matrix\n <400x4346 sparse matrix of type '<class 'numpy.float64'>'\n with 38756 stored elements in Compressed Sparse Row format>\n\n Inspect the terms associated with columns; they're sorted alphabetically:\n\n .. code-block:: pycon\n\n >>> vectorizer.terms_list[:5]\n ['', '$', '$ 1 million', '$ 1.2 billion', '$ 10 billion']\n\n (Btw: That empty string shouldn't be there. Somehow, spaCy is labeling it as\n a named entity...)\n\n If known in advance, limit the terms included in vectorized outputs\n to a particular set of values:\n\n .. code-block:: pycon\n\n >>> tokenized_docs = (\n ... doc._.to_terms_list(ngrams=1, entities=True, as_strings=True)\n ... for doc in corpus[:600])\n >>> vectorizer = Vectorizer(\n ... apply_idf=True, idf_type=\"smooth\", norm=\"l2\",\n ... min_df=3, max_df=0.95,\n ... vocabulary_terms=[\"president\", \"bill\", \"unanimous\", \"distinguished\", \"american\"])\n >>> doc_term_matrix = vectorizer.fit_transform(tokenized_docs)\n >>> doc_term_matrix\n <600x5 sparse matrix of type '<class 'numpy.float64'>'\n with 844 stored elements in Compressed Sparse Row format>\n >>> vectorizer.terms_list\n ['american', 'bill', 'distinguished', 'president', 'unanimous']\n\n Specify different weighting schemes to determine values in the matrix,\n adding or customizing individual components, as desired:\n\n .. code-block:: pycon\n\n >>> money_idx = vectorizer.vocabulary_terms[\"$\"]\n >>> doc_term_matrix = Vectorizer(\n ... tf_type=\"linear\", norm=None, min_df=3, max_df=0.95\n ... ).fit_transform(tokenized_docs)\n >>> print(doc_term_matrix[0:7, money_idx].toarray())\n [[0]\n [0]\n [1]\n [4]\n [0]\n [0]\n [2]]\n >>> doc_term_matrix = Vectorizer(\n ... tf_type=\"sqrt\", apply_dl=True, dl_type=\"sqrt\", norm=None, min_df=3, max_df=0.95\n ... ).fit_transform(tokenized_docs)\n >>> print(doc_term_matrix[0:7, money_idx].toarray())\n [[0. ]\n [0. ]\n [0.10101525]\n [0.26037782]\n [0. ]\n [0. ]\n [0.11396058]]\n >>> doc_term_matrix = Vectorizer(\n ... tf_type=\"bm25\", apply_idf=True, idf_type=\"smooth\", norm=None, min_df=3, max_df=0.95\n ... ).fit_transform(tokenized_docs)\n >>> print(doc_term_matrix[0:7, money_idx].toarray())\n [[0. ]\n [0. ]\n [3.28353965]\n [5.82763722]\n [0. ]\n [0. ]\n [4.83933924]]\n\n If you're not sure what's going on mathematically, :attr:`Vectorizer.weighting`\n gives the formula being used to calculate weights, based on the parameters\n set when initializing the vectorizer:\n\n .. code-block:: pycon\n\n >>> vectorizer.weighting\n '(tf * (k + 1)) / (k + tf) * log((n_docs + 1) / (df + 1)) + 1'\n\n In general, weights may consist of a local component (term frequency),\n a global component (inverse document frequency), and a normalization\n component (document length). Individual components may be modified:\n they may have different scaling (e.g. tf vs. sqrt(tf)) or different behaviors\n (e.g. \"standard\" idf vs bm25's version). There are *many* possible weightings,\n and some may be better for particular use cases than others. When in doubt,\n though, just go with something standard.\n\n - \"tf\": Weights are simply the absolute per-document term frequencies (tfs),\n i.e. value (i, j) in an output doc-term matrix corresponds to the number\n of occurrences of term j in doc i. Terms appearing many times in a given\n doc receive higher weights than less common terms.\n Params: ``tf_type=\"linear\", apply_idf=False, apply_dl=False``\n - \"tfidf\": Doc-specific, *local* tfs are multiplied by their corpus-wide,\n *global* inverse document frequencies (idfs). Terms appearing in many docs\n have higher document frequencies (dfs), correspondingly smaller idfs, and\n in turn, lower weights.\n Params: ``tf_type=\"linear\", apply_idf=True, idf_type=\"smooth\", apply_dl=False``\n - \"bm25\": This scheme includes a local tf component that increases asymptotically,\n so higher tfs have diminishing effects on the overall weight; a global idf\n component that can go *negative* for terms that appear in a sufficiently\n high proportion of docs; as well as a row-wise normalization that accounts for\n document length, such that terms in shorter docs hit the tf asymptote sooner\n than those in longer docs.\n Params: ``tf_type=\"bm25\", apply_idf=True, idf_type=\"bm25\", apply_dl=True``\n - \"binary\": This weighting scheme simply replaces all non-zero tfs with 1,\n indicating the presence or absence of a term in a particular doc. That's it.\n Params: ``tf_type=\"binary\", apply_idf=False, apply_dl=False``\n\n Slightly altered versions of these \"standard\" weighting schemes are common,\n and may have better behavior in general use cases:\n\n - \"lucene-style tfidf\": Adds a doc-length normalization to the usual local\n and global components.\n Params: ``tf_type=\"linear\", apply_idf=True, idf_type=\"smooth\", apply_dl=True, dl_type=\"sqrt\"``\n - \"lucene-style bm25\": Uses a smoothed idf instead of the classic bm25 variant\n to prevent weights on terms from going negative.\n Params: ``tf_type=\"bm25\", apply_idf=True, idf_type=\"smooth\", apply_dl=True, dl_type=\"linear\"``\n\n Args:\n tf_type ({\"linear\", \"sqrt\", \"log\", \"binary\"}): Type of term frequency (tf)\n to use for weights' local component:\n\n - \"linear\": tf (tfs are already linear, so left as-is)\n - \"sqrt\": tf => sqrt(tf)\n - \"log\": tf => log(tf) + 1\n - \"binary\": tf => 1\n\n apply_idf (bool): If True, apply global idfs to local term weights, i.e.\n divide per-doc term frequencies by the (log of the) total number\n of documents in which they appear; otherwise, don't.\n idf_type ({\"standard\", \"smooth\", \"bm25\"}): Type of inverse document\n frequency (idf) to use for weights' global component:\n\n - \"standard\": idf = log(n_docs / df) + 1.0\n - \"smooth\": idf = log(n_docs + 1 / df + 1) + 1.0, i.e. 1 is added\n to all document frequencies, as if a single document containing\n every unique term was added to the corpus. This prevents zero divisions!\n - \"bm25\": idf = log((n_docs - df + 0.5) / (df + 0.5)), which is\n a form commonly used in information retrieval that allows for\n very common terms to receive negative weights.\n\n apply_dl (bool): If True, normalize local(+global) weights by doc length,\n i.e. divide by the total number of in-vocabulary terms appearing\n in a given doc; otherwise, don't.\n dl_type ({\"linear\", \"sqrt\", \"log\"}): Type of document-length scaling\n to use for weights' normalization component:\n\n - \"linear\": dl (dls are already linear, so left as-is)\n - \"sqrt\": dl => sqrt(dl)\n - \"log\": dl => log(dl)\n\n norm ({\"l1\", \"l2\"} or None): If \"l1\" or \"l2\", normalize weights by the\n L1 or L2 norms, respectively, of row-wise vectors; otherwise, don't.\n vocabulary_terms (Dict[str, int] or Iterable[str]): Mapping of unique term\n string to unique term id, or an iterable of term strings that gets\n converted into a suitable mapping. Note that, if specified, vectorized\n outputs will include *only* these terms as columns.\n min_df (float or int): If float, value is the fractional proportion of\n the total number of documents, which must be in [0.0, 1.0]. If int,\n value is the absolute number. Filter terms whose document frequency\n is less than ``min_df``.\n max_df (float or int): If float, value is the fractional proportion of\n the total number of documents, which must be in [0.0, 1.0]. If int,\n value is the absolute number. Filter terms whose document frequency\n is greater than ``max_df``.\n max_n_terms (int): Only include terms whose document frequency is within\n the top ``max_n_terms``.\n\n Attributes:\n vocabulary_terms (Dict[str, int]): Mapping of unique term string to unique\n term id, either provided on instantiation or generated by calling\n :meth:`Vectorizer.fit()` on a collection of tokenized documents.\n \"\"\"\n\n def __init__(\n self,\n *,\n tf_type=\"linear\",\n apply_idf=False,\n idf_type=\"smooth\",\n apply_dl=False,\n dl_type=\"sqrt\",\n norm=None,\n min_df=1,\n max_df=1.0,\n max_n_terms=None,\n vocabulary_terms=None,\n ):\n # sanity check numeric arguments\n if min_df < 0 or max_df < 0:\n raise ValueError(\"`min_df` and `max_df` must be positive numbers or None\")\n if max_n_terms and max_n_terms < 0:\n raise ValueError(\"`max_n_terms` must be a positive integer or None\")\n self.tf_type = tf_type\n self.apply_idf = apply_idf\n self.idf_type = idf_type\n self.apply_dl = apply_dl\n self.dl_type = dl_type\n self.norm = norm\n self.min_df = min_df\n self.max_df = max_df\n self.max_n_terms = max_n_terms\n self.vocabulary_terms, self._fixed_terms = self._validate_vocabulary(\n vocabulary_terms\n )\n self.id_to_term_ = {}\n self._idf_diag = None\n self._avg_doc_length = None\n\n def _validate_vocabulary(self, vocabulary):\n \"\"\"\n Validate an input vocabulary. If it's a mapping, ensure that term ids\n are unique and compact (i.e. without any gaps between 0 and the number\n of terms in ``vocabulary``. If it's a sequence, sort terms then assign\n integer ids in ascending order.\n\n Args:\n vocabulary_terms (Dict[str, int] or Iterable[str])\n\n Returns:\n Dict[str, int]\n bool\n \"\"\"\n if vocabulary is not None:\n if not isinstance(vocabulary, collections.abc.Mapping):\n vocab = {}\n for i, term in enumerate(sorted(vocabulary)):\n if vocab.setdefault(term, i) != i:\n raise ValueError(\n f\"Terms in `vocabulary` must be unique, but '{term}' \"\n \"was found more than once.\"\n )\n vocabulary = vocab\n else:\n ids = set(vocabulary.values())\n if len(ids) != len(vocabulary):\n counts = collections.Counter(vocabulary.values())\n n_dupe_term_ids = sum(\n 1\n for term_id, term_id_count in counts.items()\n if term_id_count > 1\n )\n raise ValueError(\n \"Term ids in `vocabulary` must be unique, but \"\n f\"{n_dupe_term_ids} ids were assigned to more than one term.\"\n )\n for i in range(len(vocabulary)):\n if i not in ids:\n raise ValueError(\n \"Term ids in `vocabulary` must be compact, i.e. \"\n f\"not have any gaps, but term id {i} is missing from \"\n f\"a vocabulary of {len(vocabulary)} terms\"\n )\n if not vocabulary:\n raise ValueError(\"`vocabulary` must not be empty.\")\n is_fixed = True\n else:\n is_fixed = False\n return vocabulary, is_fixed\n\n def _check_vocabulary(self):\n \"\"\"\n Check that instance has a valid vocabulary mapping;\n if not, raise a ValueError.\n \"\"\"\n if not isinstance(self.vocabulary_terms, collections.abc.Mapping):\n raise ValueError(\"vocabulary hasn't been built; call `Vectorizer.fit()`\")\n if len(self.vocabulary_terms) == 0:\n raise ValueError(\"vocabulary is empty\")\n\n @property\n def id_to_term(self) -> Dict[int, str]:\n \"\"\"\n Mapping of unique term id (int) to unique term string (str), i.e.\n the inverse of :attr:`Vectorizer.vocabulary`. This attribute is only\n generated if needed, and it is automatically kept in sync with the\n corresponding vocabulary.\n \"\"\"\n if len(self.id_to_term_) != self.vocabulary_terms:\n self.id_to_term_ = {\n term_id: term_str for term_str, term_id in self.vocabulary_terms.items()\n }\n return self.id_to_term_\n\n # TODO: Do we *want* to allow setting to this property?\n # @id_to_term.setter\n # def id_to_term(self, new_id_to_term):\n # self.id_to_term_ = new_id_to_term\n # self.vocabulary_terms = {\n # term_str: term_id for term_id, term_str in new_id_to_term.items()}\n\n @property\n def terms_list(self) -> List[str]:\n \"\"\"\n List of term strings in column order of vectorized outputs. For example,\n ``terms_list[0]`` gives the term assigned to the first column in an\n output doc-term-matrix, ``doc_term_matrix[:, 0]``.\n \"\"\"\n self._check_vocabulary()\n return [\n term_str\n for term_str, _ in sorted(\n self.vocabulary_terms.items(), key=operator.itemgetter(1)\n )\n ]\n\n def fit(self, tokenized_docs):\n \"\"\"\n Count terms in ``tokenized_docs`` and, if not already provided, build up\n a vocabulary based those terms. Fit and store global weights (IDFs)\n and, if needed for term weighting, the average document length.\n\n Args:\n tokenized_docs (Iterable[Iterable[str]]): A sequence of tokenized\n documents, where each is a sequence of (str) terms. For example::\n\n >>> ([tok.lemma_ for tok in spacy_doc]\n ... for spacy_doc in spacy_docs)\n >>> ((ne.text for ne in extract.entities(doc))\n ... for doc in corpus)\n >>> (doc._.to_terms_list(as_strings=True)\n ... for doc in docs)\n\n Returns:\n :class:`Vectorizer`: The instance that has just been fit.\n \"\"\"\n _ = self._fit(tokenized_docs)\n return self\n\n def fit_transform(self, tokenized_docs):\n \"\"\"\n Count terms in ``tokenized_docs`` and, if not already provided, build up\n a vocabulary based those terms. Fit and store global weights (IDFs)\n and, if needed for term weighting, the average document length.\n Transform ``tokenized_docs`` into a document-term matrix with values\n weighted according to the parameters in :class:`Vectorizer` initialization.\n\n Args:\n tokenized_docs (Iterable[Iterable[str]]): A sequence of tokenized\n documents, where each is a sequence of (str) terms. For example::\n\n >>> ([tok.lemma_ for tok in spacy_doc]\n ... for spacy_doc in spacy_docs)\n >>> ((ne.text for ne in extract.entities(doc))\n ... for doc in corpus)\n >>> (doc._.to_terms_list(as_strings=True)\n ... for doc in docs)\n\n Returns:\n :class:`scipy.sparse.csr_matrix`: The transformed document-term matrix.\n Rows correspond to documents and columns correspond to terms.\n \"\"\"\n # count terms and fit global weights\n doc_term_matrix = self._fit(tokenized_docs)\n # re-weight values in doc-term matrix, as specified in init\n doc_term_matrix = self._reweight_values(doc_term_matrix)\n return doc_term_matrix\n\n def transform(self, tokenized_docs):\n \"\"\"\n Transform ``tokenized_docs`` into a document-term matrix with values\n weighted according to the parameters in :class:`Vectorizer` initialization\n and the global weights computed by calling :meth:`Vectorizer.fit()`.\n\n Args:\n tokenized_docs (Iterable[Iterable[str]]): A sequence of tokenized\n documents, where each is a sequence of (str) terms. For example::\n\n >>> ([tok.lemma_ for tok in spacy_doc]\n ... for spacy_doc in spacy_docs)\n >>> ((ne.text for ne in extract.entities(doc))\n ... for doc in corpus)\n >>> (doc._.to_terms_list(as_strings=True)\n ... for doc in docs)\n\n Returns:\n :class:`scipy.sparse.csr_matrix`: The transformed document-term matrix.\n Rows correspond to documents and columns correspond to terms.\n\n Note:\n For best results, the tokenization used to produce ``tokenized_docs``\n should be the same as was applied to the docs used in fitting this\n vectorizer or in generating a fixed input vocabulary.\n\n Consider an extreme case where the docs used in fitting consist of\n lowercased (non-numeric) terms, while the docs to be transformed are\n all uppercased: The output doc-term-matrix will be empty.\n \"\"\"\n self._check_vocabulary()\n doc_term_matrix, _ = self._count_terms(tokenized_docs, True)\n return self._reweight_values(doc_term_matrix)\n\n def _fit(self, tokenized_docs):\n \"\"\"\n Count terms and, if :attr:`Vectorizer.fixed_terms` is False, build up\n a vocabulary based on the terms found in ``tokenized_docs``. Transform\n ``tokenized_docs`` into a document-term matrix with absolute tf weights.\n Store global weights (IDFs) and, if :attr:`Vectorizer.doc_length_norm`\n is not None, the average doc length.\n\n Args:\n tokenized_docs (Iterable[Iterable[str]])\n\n Returns:\n :class:`scipy.sparse.csr_matrix`\n \"\"\"\n # count terms and, if not provided on init, build up a vocabulary\n doc_term_matrix, vocabulary_terms = self._count_terms(\n tokenized_docs, self._fixed_terms\n )\n\n if self._fixed_terms is False:\n # filter terms by doc freq or info content, as specified in init\n doc_term_matrix, vocabulary_terms = self._filter_terms(\n doc_term_matrix, vocabulary_terms\n )\n # sort features alphabetically (vocabulary_terms modified in-place)\n doc_term_matrix = self._sort_vocab_and_matrix(\n doc_term_matrix, vocabulary_terms, axis=\"columns\"\n )\n # *now* vocabulary_terms are known and fixed\n self.vocabulary_terms = vocabulary_terms\n self._fixed_terms = True\n\n n_docs, n_terms = doc_term_matrix.shape\n\n if self.apply_idf is True:\n # store the global weights as a diagonal sparse matrix of idfs\n idfs = get_inverse_doc_freqs(doc_term_matrix, type_=self.idf_type)\n self._idf_diag = sp.spdiags(\n idfs, diags=0, m=n_terms, n=n_terms, format=\"csr\"\n )\n\n if self.tf_type == \"bm25\" and self.apply_dl is True:\n # store the avg document length, used in bm25 weighting to normalize\n # term weights by the length of the containing documents\n self._avg_doc_length = get_doc_lengths(\n doc_term_matrix, type_=self.dl_type\n ).mean()\n\n return doc_term_matrix\n\n def _count_terms(self, tokenized_docs, fixed_vocab):\n \"\"\"\n Count terms found in ``tokenized_docs`` and, if ``fixed_vocab`` is False,\n build up a vocabulary based on those terms.\n\n Args:\n tokenized_docs (Iterable[Iterable[str]])\n fixed_vocab (bool)\n\n Returns:\n :class:`scipy.sparse.csr_matrix`\n Dict[str, int]\n \"\"\"\n if fixed_vocab is False:\n # add a new value when a new term is seen\n vocabulary = collections.defaultdict()\n vocabulary.default_factory = vocabulary.__len__\n else:\n vocabulary = self.vocabulary_terms\n\n indices = array(str(\"i\"))\n indptr = array(str(\"i\"), [0])\n for terms in tokenized_docs:\n for term in terms:\n try:\n indices.append(vocabulary[term])\n except KeyError:\n # ignore out-of-vocabulary terms when _fixed_terms=True\n continue\n indptr.append(len(indices))\n\n if fixed_vocab is False:\n # we no longer want defaultdict behaviour\n vocabulary = dict(vocabulary)\n\n indices = np.frombuffer(indices, dtype=np.intc)\n indptr = np.frombuffer(indptr, dtype=np.intc)\n data = np.ones(len(indices))\n\n # build the matrix, then consolidate duplicate entries\n # by adding them together, in-place\n doc_term_matrix = sp.csr_matrix(\n (data, indices, indptr),\n shape=(len(indptr) - 1, len(vocabulary)),\n dtype=np.int32,\n )\n doc_term_matrix.sum_duplicates()\n\n # pretty sure this is a good thing to do... o_O\n doc_term_matrix.sort_indices()\n\n return doc_term_matrix, vocabulary\n\n def _filter_terms(self, doc_term_matrix, vocabulary):\n \"\"\"\n Filter terms in ``vocabulary`` by their document frequency or information\n content, as specified in :class:`Vectorizer` initialization.\n\n Args:\n doc_term_matrix (:class:`sp.sparse.csr_matrix`)\n vocabulary (Dict[str, int])\n\n Returns:\n :class:`scipy.sparse.csr_matrix`\n Dict[str, int]\n \"\"\"\n if self.max_df != 1.0 or self.min_df != 1 or self.max_n_terms is not None:\n doc_term_matrix, vocabulary = filter_terms_by_df(\n doc_term_matrix,\n vocabulary,\n max_df=self.max_df,\n min_df=self.min_df,\n max_n_terms=self.max_n_terms,\n )\n return doc_term_matrix, vocabulary\n\n def _sort_vocab_and_matrix(self, matrix, vocabulary, axis):\n \"\"\"\n Sort terms in ``vocabulary`` alphabetically, modifying the vocabulary\n in-place, and returning a correspondingly reordered ``matrix`` along\n its rows or columns, depending on ``axis``.\n\n Args:\n matrix (:class:`sp.sparse.csr_matrix`)\n vocabulary (Dict[str, int])\n axis ({'rows', 'columns'} or {0, 1})\n\n Returns:\n :class:`scipy.sparse.csr_matrix`\n \"\"\"\n sorted_vocab = sorted(vocabulary.items())\n new_idx_array = np.empty(len(sorted_vocab), dtype=np.int32)\n for new_idx, (term, old_idx) in enumerate(sorted_vocab):\n new_idx_array[new_idx] = old_idx\n vocabulary[term] = new_idx\n # use fancy indexing to reorder rows or columns\n if axis == \"rows\" or axis == 0:\n return matrix[new_idx_array, :]\n elif axis == \"columns\" or axis == 1:\n return matrix[:, new_idx_array]\n else:\n raise ValueError(\n errors.value_invalid_msg(\"axis\", axis, {\"rows\", \"columns\", 0, 1})\n )\n\n def _reweight_values(self, doc_term_matrix):\n \"\"\"\n Re-weight values in a doc-term matrix according to parameters specified\n in :class:`Vectorizer` initialization: binary or tf-idf weighting,\n sublinear term-frequency, document-normalized weights.\n\n Args:\n doc_term_matrix (:class:`sp.sparse.csr_matrix`)\n\n Returns:\n :class:`scipy.sparse.csr_matrix`\n \"\"\"\n # re-weight the local components (term freqs)\n if self.tf_type == \"binary\":\n doc_term_matrix.data.fill(1)\n elif self.tf_type == \"bm25\":\n if self.apply_dl is False:\n doc_term_matrix.data = (\n doc_term_matrix.data\n * (BM25_K1 + 1.0)\n / (BM25_K1 + doc_term_matrix.data)\n )\n else:\n dls = get_doc_lengths(doc_term_matrix, type_=self.dl_type)\n length_norm = (1 - BM25_B) + (BM25_B * (dls / self._avg_doc_length))\n doc_term_matrix = doc_term_matrix.tocoo(copy=False)\n doc_term_matrix.data = (\n doc_term_matrix.data\n * (BM25_K1 + 1.0)\n / (\n doc_term_matrix.data\n + (BM25_K1 * length_norm[doc_term_matrix.row])\n )\n )\n doc_term_matrix = doc_term_matrix.tocsr(copy=False)\n elif self.tf_type == \"sqrt\":\n _ = np.sqrt(doc_term_matrix.data, doc_term_matrix.data, casting=\"unsafe\")\n elif self.tf_type == \"log\":\n _ = np.log(doc_term_matrix.data, doc_term_matrix.data, casting=\"unsafe\")\n doc_term_matrix.data += 1.0\n elif self.tf_type == \"linear\":\n pass # tfs are already linear\n else:\n # this should never raise, i'm just being a worrywart\n raise ValueError(\n errors.value_invalid_msg(\n \"tf_type\", self.tf_type, {\"binary\", \"bm25\", \"sqrt\", \"log\", \"linear\"}\n )\n )\n\n # apply the global component (idfs), column-wise\n if self.apply_idf is True:\n doc_term_matrix = doc_term_matrix * self._idf_diag\n\n # apply normalizations, row-wise\n # unless we've already handled it for bm25-style tf\n if self.apply_dl is True and self.tf_type != \"bm25\":\n n_docs, _ = doc_term_matrix.shape\n dls = get_doc_lengths(doc_term_matrix, type_=self.dl_type)\n dl_diag = sp.spdiags(1.0 / dls, diags=0, m=n_docs, n=n_docs, format=\"csr\")\n doc_term_matrix = dl_diag * doc_term_matrix\n if self.norm is not None:\n doc_term_matrix = normalize_mat(\n doc_term_matrix, norm=self.norm, axis=1, copy=False\n )\n\n return doc_term_matrix\n\n @property\n def weighting(self):\n \"\"\"\n str: A mathematical representation of the overall weighting scheme\n used to determine values in the vectorized matrix, depending on the\n params used to initialize the :class:`Vectorizer`.\n \"\"\"\n w = []\n tf_types = {\n \"binary\": \"1\",\n \"linear\": \"tf\",\n \"sqrt\": \"sqrt(tf)\",\n \"log\": \"log(tf)\",\n \"bm25\": {\n True: \"(tf * (k + 1)) / (tf + k * (1 - b + b * (length / avg(lengths)))\",\n False: \"(tf * (k + 1)) / (tf + k)\",\n },\n }\n idf_types = {\n \"standard\": \"log(n_docs / df) + 1\",\n \"smooth\": \"log((n_docs + 1) / (df + 1)) + 1\",\n \"bm25\": \"log((n_docs - df + 0.5) / (df + 0.5))\",\n }\n dl_types = {\n \"linear\": \"1/length\",\n \"sqrt\": \"1/sqrt(length)\",\n \"log\": \"1/log(length) + 1\",\n }\n if self.tf_type == \"bm25\":\n w.append(tf_types[self.tf_type][self.apply_dl])\n else:\n w.append(tf_types[self.tf_type])\n if self.apply_idf:\n w.append(idf_types[self.idf_type])\n if self.apply_dl and self.tf_type != \"bm25\":\n w.append(dl_types[self.dl_type])\n return \" * \".join(w)\n\n\nclass GroupVectorizer(Vectorizer):\n \"\"\"\n Transform one or more tokenized documents into a group-term matrix of\n shape (# groups, # unique terms), with tf-, tf-idf, or binary-weighted values.\n\n This is an extension of typical document-term matrix vectorization, where\n terms are grouped by the documents in which they co-occur. It allows for\n customized grouping, such as by a shared author or publication year, that\n may span multiple documents, without forcing users to merge those documents\n themselves.\n\n Stream a corpus with metadata from disk::\n\n >>> ds = textacy.datasets.CapitolWords()\n >>> records = ds.records(limit=1000)\n >>> corpus = textacy.Corpus(\"en\", data=records)\n >>> corpus\n Corpus(1000 docs; 538172 tokens)\n\n Tokenize and vectorize the first 600 documents of this corpus, where terms\n are grouped not by documents but by a categorical value in the docs' metadata::\n\n >>> tokenized_docs, groups = textacy.io.unzip(\n ... (doc._.to_terms_list(ngrams=1, entities=True, as_strings=True),\n ... doc._.meta[\"speaker_name\"])\n ... for doc in corpus[:600])\n >>> vectorizer = GroupVectorizer(\n ... apply_idf=True, idf_type=\"smooth\", norm=\"l2\",\n ... min_df=3, max_df=0.95)\n >>> grp_term_matrix = vectorizer.fit_transform(tokenized_docs, groups)\n >>> grp_term_matrix\n <5x1793 sparse matrix of type '<class 'numpy.float64'>'\n with 6075 stored elements in Compressed Sparse Row format>\n\n Tokenize and vectorize the remaining 400 documents of the corpus, using only\n the groups, terms, and weights learned in the previous step::\n\n >>> tokenized_docs, groups = textacy.io.unzip(\n ... (doc._.to_terms_list(ngrams=1, entities=True, as_strings=True),\n ... doc._.meta[\"speaker_name\"])\n ... for doc in corpus[600:])\n >>> grp_term_matrix = vectorizer.transform(tokenized_docs, groups)\n >>> grp_term_matrix\n <5x1793 sparse matrix of type '<class 'numpy.float64'>'\n with 4440 stored elements in Compressed Sparse Row format>\n\n Inspect the terms associated with columns and groups associated with rows;\n they're sorted alphabetically::\n\n >>> vectorizer.terms_list[:5]\n ['$ 1 million', '$ 160 million', '$ 7 billion', '0', '1 minute']\n >>> vectorizer.grps_list\n ['Bernie Sanders', 'John Kasich', 'Joseph Biden', 'Lindsey Graham', 'Rick Santorum']\n\n If known in advance, limit the terms and/or groups included in vectorized outputs\n to a particular set of values::\n\n >>> tokenized_docs, groups = textacy.io.unzip(\n ... (doc._.to_terms_list(ngrams=1, entities=True, as_strings=True),\n ... doc._.meta[\"speaker_name\"])\n ... for doc in corpus[:600])\n >>> vectorizer = GroupVectorizer(\n ... apply_idf=True, idf_type=\"smooth\", norm=\"l2\",\n ... min_df=3, max_df=0.95,\n ... vocabulary_terms=[\"legislation\", \"federal government\", \"house\", \"constitutional\"],\n ... vocabulary_grps=[\"Bernie Sanders\", \"Lindsey Graham\", \"Rick Santorum\"])\n >>> grp_term_matrix = vectorizer.fit_transform(tokenized_docs, groups)\n >>> grp_term_matrix\n <3x4 sparse matrix of type '<class 'numpy.float64'>'\n with 12 stored elements in Compressed Sparse Row format>\n >>> vectorizer.terms_list\n ['constitutional', 'federal government', 'house', 'legislation']\n >>> vectorizer.grps_list\n ['Bernie Sanders', 'Lindsey Graham', 'Rick Santorum']\n\n For a discussion of the various weighting schemes that can be applied, check\n out the :class:`Vectorizer` docstring.\n\n Args:\n tf_type ({\"linear\", \"sqrt\", \"log\", \"binary\"}): Type of term frequency (tf)\n to use for weights' local component:\n\n - \"linear\": tf (tfs are already linear, so left as-is)\n - \"sqrt\": tf => sqrt(tf)\n - \"log\": tf => log(tf) + 1\n - \"binary\": tf => 1\n\n apply_idf (bool): If True, apply global idfs to local term weights, i.e.\n divide per-doc term frequencies by the total number of documents\n in which they appear (well, the log of that number); otherwise, don't.\n idf_type ({\"standard\", \"smooth\", \"bm25\"}): Type of inverse document\n frequency (idf) to use for weights' global component:\n\n - \"standard\": idf = log(n_docs / df) + 1.0\n - \"smooth\": idf = log(n_docs + 1 / df + 1) + 1.0, i.e. 1 is added\n to all document frequencies, as if a single document containing\n every unique term was added to the corpus.\n - \"bm25\": idf = log((n_docs - df + 0.5) / (df + 0.5)), which is\n a form commonly used in information retrieval that allows for\n very common terms to receive negative weights.\n\n apply_dl (bool): If True, normalize local(+global) weights by doc length,\n i.e. divide by the total number of in-vocabulary terms appearing\n in a given doc; otherwise, don't.\n dl_type ({\"linear\", \"sqrt\", \"log\"}): Type of document-length scaling\n to use for weights' normalization component:\n\n - \"linear\": dl (dls are already linear, so left as-is)\n - \"sqrt\": dl => sqrt(dl)\n - \"log\": dl => log(dl)\n\n norm ({\"l1\", \"l2\"} or None): If \"l1\" or \"l2\", normalize weights by the\n L1 or L2 norms, respectively, of row-wise vectors; otherwise, don't.\n vocabulary_terms (Dict[str, int] or Iterable[str]): Mapping of unique term\n string to unique term id, or an iterable of term strings that gets\n converted into a suitable mapping. Note that, if specified, vectorized\n outputs will include *only* these terms as columns.\n vocabulary_grps (Dict[str, int] or Iterable[str]): Mapping of unique group\n string to unique group id, or an iterable of group strings that gets\n converted into a suitable mapping. Note that, if specified, vectorized\n outputs will include *only* these groups as rows.\n min_df (float or int): If float, value is the fractional proportion of\n the total number of documents, which must be in [0.0, 1.0]. If int,\n value is the absolute number. Filter terms whose document frequency\n is less than ``min_df``.\n max_df (float or int): If float, value is the fractional proportion of\n the total number of documents, which must be in [0.0, 1.0]. If int,\n value is the absolute number. Filter terms whose document frequency\n is greater than ``max_df``.\n max_n_terms (int): Only include terms whose document frequency is within\n the top ``max_n_terms``.\n\n Attributes:\n vocabulary_terms (Dict[str, int]): Mapping of unique term string to unique\n term id, either provided on instantiation or generated by calling\n :meth:`GroupVectorizer.fit()` on a collection of tokenized documents.\n vocabulary_grps (Dict[str, int]): Mapping of unique group string to unique\n group id, either provided on instantiation or generated by calling\n :meth:`GroupVectorizer.fit()` on a collection of tokenized documents.\n id_to_term (Dict[int, str]): Mapping of unique term id to unique term\n string, i.e. the inverse of :attr:`GroupVectorizer.vocabulary_terms`.\n This mapping is only generated as needed.\n terms_list (List[str]): List of term strings in column order of\n vectorized outputs.\n\n See Also:\n :class:`Vectorizer`\n \"\"\"\n\n def __init__(\n self,\n *,\n tf_type=\"linear\",\n apply_idf=False,\n idf_type=\"smooth\",\n apply_dl=False,\n dl_type=\"linear\",\n norm=None,\n min_df=1,\n max_df=1.0,\n max_n_terms=None,\n vocabulary_terms=None,\n vocabulary_grps=None,\n ):\n super().__init__(\n tf_type=tf_type,\n apply_idf=apply_idf,\n idf_type=idf_type,\n apply_dl=apply_dl,\n dl_type=dl_type,\n norm=norm,\n min_df=min_df,\n max_df=max_df,\n max_n_terms=max_n_terms,\n vocabulary_terms=vocabulary_terms,\n )\n # now do the same thing for grps as was done for terms\n self.vocabulary_grps, self._fixed_grps = self._validate_vocabulary(\n vocabulary_grps\n )\n self.id_to_grp_ = {}\n\n @property\n def id_to_grp(self) -> Dict[int, str]:\n \"\"\"\n Mapping of unique group id (int) to unique group string (str), i.e.\n the inverse of :attr:`GroupVectorizer.vocabulary_grps`. This attribute\n is only generated if needed, and it is automatically kept in sync\n with the corresponding vocabulary.\n \"\"\"\n if len(self.id_to_grp_) != self.vocabulary_grps:\n self.id_to_grp_ = {\n grp_id: grp_str for grp_str, grp_id in self.vocabulary_grps.items()\n }\n return self.id_to_grp_\n\n # @id_to_grp.setter\n # def id_to_grp(self, new_id_to_grp):\n # self.id_to_grp_ = new_id_to_grp\n # self.vocabulary_grps = {\n # grp_str: grp_id for grp_id, grp_str in new_id_to_grp.items()}\n\n @property\n def grps_list(self) -> List[str]:\n \"\"\"\n List of group strings in row order of vectorized outputs. For example,\n ``grps_list[0]`` gives the group assigned to the first row in an\n output group-term-matrix, ``grp_term_matrix[0, :]``.\n \"\"\"\n self._check_vocabulary()\n return [\n grp_str\n for grp_str, _ in sorted(\n self.vocabulary_grps.items(), key=operator.itemgetter(1)\n )\n ]\n\n def fit(self, tokenized_docs, grps):\n \"\"\"\n Count terms in ``tokenized_docs`` and, if not already provided, build up\n a vocabulary based those terms; do the same for the groups in ``grps``.\n Fit and store global weights (IDFs) and, if needed for term weighting,\n the average document length.\n\n Args:\n tokenized_docs (Iterable[Iterable[str]]): A sequence of tokenized\n documents, where each is a sequence of (str) terms. For example::\n\n >>> ([tok.lemma_ for tok in spacy_doc]\n ... for spacy_doc in spacy_docs)\n >>> ((ne.text for ne in extract.entities(doc))\n ... for doc in corpus)\n >>> (doc._.to_terms_list(as_strings=True)\n ... for doc in docs)\n\n grps (Iterable[str]): Sequence of group names by which the terms in\n ``tokenized_docs`` are aggregated, where the first item in ``grps``\n corresponds to the first item in ``tokenized_docs``, and so on.\n\n Returns:\n :class:`GroupVectorizer`: The instance that has just been fit.\n \"\"\"\n _ = self._fit(tokenized_docs, grps)\n return self\n\n def fit_transform(self, tokenized_docs, grps):\n \"\"\"\n Count terms in ``tokenized_docs`` and, if not already provided, build up\n a vocabulary based those terms; do the same for the groups in ``grps``.\n Fit and store global weights (IDFs) and, if needed for term weighting,\n the average document length. Transform ``tokenized_docs`` into a\n group-term matrix with values weighted according to the parameters in\n :class:`GroupVectorizer` initialization.\n\n Args:\n tokenized_docs (Iterable[Iterable[str]]): A sequence of tokenized\n documents, where each is a sequence of (str) terms. For example::\n\n >>> ([tok.lemma_ for tok in spacy_doc]\n ... for spacy_doc in spacy_docs)\n >>> ((ne.text for ne in extract.entities(doc))\n ... for doc in corpus)\n >>> (doc._.to_terms_list(as_strings=True)\n ... for doc in docs)\n\n grps (Iterable[str]): Sequence of group names by which the terms in\n ``tokenized_docs`` are aggregated, where the first item in ``grps``\n corresponds to the first item in ``tokenized_docs``, and so on.\n\n Returns:\n :class:`scipy.sparse.csr_matrix`: The transformed group-term matrix.\n Rows correspond to groups and columns correspond to terms.\n \"\"\"\n # count terms and fit global weights\n grp_term_matrix = self._fit(tokenized_docs, grps)\n # re-weight values in group-term matrix, as specified in init\n grp_term_matrix = self._reweight_values(grp_term_matrix)\n return grp_term_matrix\n\n def transform(self, tokenized_docs, grps):\n \"\"\"\n Transform ``tokenized_docs`` and ``grps`` into a group-term matrix with\n values weighted according to the parameters in :class:`GroupVectorizer`\n initialization and the global weights computed by calling\n :meth:`GroupVectorizer.fit()`.\n\n Args:\n tokenized_docs (Iterable[Iterable[str]]): A sequence of tokenized\n documents, where each is a sequence of (str) terms. For example::\n\n >>> ([tok.lemma_ for tok in spacy_doc]\n ... for spacy_doc in spacy_docs)\n >>> ((ne.text for ne in extract.entities(doc))\n ... for doc in corpus)\n >>> (doc._.to_terms_list(as_strings=True)\n ... for doc in docs)\n\n grps (Iterable[str]): Sequence of group names by which the terms in\n ``tokenized_docs`` are aggregated, where the first item in ``grps``\n corresponds to the first item in ``tokenized_docs``, and so on.\n\n Returns:\n :class:`scipy.sparse.csr_matrix`: The transformed group-term matrix.\n Rows correspond to groups and columns correspond to terms.\n\n Note:\n For best results, the tokenization used to produce ``tokenized_docs``\n should be the same as was applied to the docs used in fitting this\n vectorizer or in generating a fixed input vocabulary.\n\n Consider an extreme case where the docs used in fitting consist of\n lowercased (non-numeric) terms, while the docs to be transformed are\n all uppercased: The output group-term-matrix will be empty.\n \"\"\"\n self._check_vocabulary()\n grp_term_matrix, _, _ = self._count_terms(tokenized_docs, grps, True, True)\n return self._reweight_values(grp_term_matrix)\n\n def _fit(self, tokenized_docs, grps):\n \"\"\"\n Count terms and, if :attr:`Vectorizer.fixed_terms` is False, build up\n a vocabulary based on the terms found in ``tokenized_docs``. Transform\n ``tokenized_docs`` into a document-term matrix with absolute tf weights.\n Store global weights (IDFs) and, if :attr:`Vectorizer.doc_length_norm`\n is not None, the average doc length.\n\n Args:\n tokenized_docs (Iterable[Iterable[str]])\n grps (Iterable[str])\n\n Returns:\n :class:`scipy.sparse.csr_matrix`\n \"\"\"\n # count terms and, if not provided on init, build up a vocabulary\n grp_term_matrix, vocabulary_terms, vocabulary_grps = self._count_terms(\n tokenized_docs, grps, self._fixed_terms, self._fixed_grps\n )\n\n if self._fixed_terms is False:\n # filter terms by doc freq or info content, as specified in init\n grp_term_matrix, vocabulary_terms = self._filter_terms(\n grp_term_matrix, vocabulary_terms\n )\n # sort features alphabetically (vocabulary_terms modified in-place)\n grp_term_matrix = self._sort_vocab_and_matrix(\n grp_term_matrix, vocabulary_terms, axis=\"columns\"\n )\n # *now* vocabulary_terms are known and fixed\n self.vocabulary_terms = vocabulary_terms\n self._fixed_terms = True\n if self._fixed_grps is False:\n # sort groups alphabetically (vocabulary_grps modified in-place)\n grp_term_matrix = self._sort_vocab_and_matrix(\n grp_term_matrix, vocabulary_grps, axis=\"rows\"\n )\n # *now* vocabulary_grps are known and fixed\n self.vocabulary_grps = vocabulary_grps\n self._fixed_grps = True\n\n n_grps, n_terms = grp_term_matrix.shape\n\n if self.apply_idf is True:\n # store the global weights as a diagonal sparse matrix of idfs\n idfs = get_inverse_doc_freqs(grp_term_matrix, type_=self.idf_type)\n self._idf_diag = sp.spdiags(\n idfs, diags=0, m=n_terms, n=n_terms, format=\"csr\"\n )\n\n if self.tf_type == \"bm25\" and self.apply_dl is True:\n # store the avg document length, used in bm25 weighting to normalize\n # term weights by the length of the containing documents\n self._avg_doc_length = get_doc_lengths(\n grp_term_matrix, type_=self.dl_type\n ).mean()\n\n return grp_term_matrix\n\n def _count_terms(self, tokenized_docs, grps, fixed_vocab_terms, fixed_vocab_grps):\n \"\"\"\n Count terms and build up a vocabulary based on the terms found in the\n ``tokenized_docs`` and the groups found in ``grps``.\n\n Args:\n tokenized_docs (Iterable[Iterable[str]])\n grps (Iterable[str])\n fixed_vocab_terms (bool)\n fixed_vocab_grps (bool)\n\n Returns:\n :class:`scipy.sparse.csr_matrix`\n Dict[str, int]\n Dict[str, int]\n \"\"\"\n # TODO: can we adapt the optimization from `Vectorizer._count_terms()` here?\n if fixed_vocab_terms is False:\n # add a new value when a new term is seen\n vocabulary_terms = collections.defaultdict()\n vocabulary_terms.default_factory = vocabulary_terms.__len__\n else:\n vocabulary_terms = self.vocabulary_terms\n\n if fixed_vocab_grps is False:\n # add a new value when a new group is seen\n vocabulary_grps = collections.defaultdict()\n vocabulary_grps.default_factory = vocabulary_grps.__len__\n else:\n vocabulary_grps = self.vocabulary_grps\n\n data = array(str(\"i\"))\n cols = array(str(\"i\"))\n rows = array(str(\"i\"))\n for grp, terms in zip(grps, tokenized_docs):\n\n try:\n grp_idx = vocabulary_grps[grp]\n except KeyError:\n # ignore out-of-vocabulary groups when fixed_grps=True\n continue\n\n term_counter = collections.defaultdict(int)\n for term in terms:\n try:\n term_idx = vocabulary_terms[term]\n term_counter[term_idx] += 1\n except KeyError:\n # ignore out-of-vocabulary terms when fixed_terms=True\n continue\n\n data.extend(term_counter.values())\n cols.extend(term_counter.keys())\n rows.extend(grp_idx for _ in range(len(term_counter)))\n\n # do we still want defaultdict behaviour?\n if fixed_vocab_terms is False:\n vocabulary_terms = dict(vocabulary_terms)\n if fixed_vocab_grps is False:\n vocabulary_grps = dict(vocabulary_grps)\n\n data = np.frombuffer(data, dtype=np.intc)\n rows = np.frombuffer(rows, dtype=np.intc)\n cols = np.frombuffer(cols, dtype=np.intc)\n\n grp_term_matrix = sp.csr_matrix(\n (data, (rows, cols)),\n shape=(len(vocabulary_grps), len(vocabulary_terms)),\n dtype=np.int32,\n )\n grp_term_matrix.sort_indices()\n\n return grp_term_matrix, vocabulary_terms, vocabulary_grps\n"
] | [
[
"scipy.sparse.spdiags",
"numpy.log",
"sklearn.preprocessing.normalize",
"numpy.sqrt",
"numpy.frombuffer"
]
] |
lucarebuffi/wofry | [
"07d1d00c828599b225a96e44713911830b3f0d6b"
] | [
"wofry/propagator/wavefront1D/generic_wavefront.py"
] | [
"import numpy, copy\nimport scipy.constants as codata\n\nfrom srxraylib.util.data_structures import ScaledArray, ScaledMatrix\n\nfrom wofry.propagator.wavefront import Wavefront, WavefrontDimension\n\nfrom wofry.propagator.util.gaussian_schell_model import GaussianSchellModel1D\n\n# needed for h5 i/o\nimport os\nimport sys\nimport time\nfrom wofry.propagator.polarization import Polarization\ntry:\n import h5py\nexcept:\n raise ImportError(\"h5py not available: input/output to files not working\")\n# --------------------------------------------------\n# Wavefront 1D\n# --------------------------------------------------\n\nclass GenericWavefront1D(Wavefront):\n\n def __init__(self, wavelength=1e-10, electric_field_array=None, electric_field_array_pi=None):\n self._wavelength = wavelength\n self._electric_field_array = electric_field_array\n self._electric_field_array_pi = electric_field_array_pi\n\n def get_dimension(self):\n return WavefrontDimension.ONE\n\n def is_polarized(self):\n if self._electric_field_array_pi is None:\n return False\n else:\n return True\n\n def duplicate(self):\n if self.is_polarized():\n return GenericWavefront1D(wavelength=self._wavelength,\n electric_field_array=ScaledArray(np_array=copy.copy(self._electric_field_array.np_array),\n scale=copy.copy(self._electric_field_array.scale)),\n electric_field_array_pi=ScaledArray(np_array=copy.copy(self._electric_field_array_pi.np_array),\n scale=copy.copy(self._electric_field_array_pi.scale)) )\n else:\n return GenericWavefront1D(wavelength=self._wavelength,\n electric_field_array=ScaledArray(np_array=copy.copy(self._electric_field_array.np_array),\n scale=copy.copy(self._electric_field_array.scale)))\n\n @classmethod\n def initialize_wavefront(cls, wavelength=1e-10, number_of_points=1000, polarization=Polarization.SIGMA):\n\n sA = ScaledArray.initialize(np_array=numpy.full(number_of_points, (1.0 + 0.0j), dtype=complex))\n\n if ((polarization == Polarization.PI) or (polarization == Polarization.TOTAL)):\n sA_pi = ScaledArray.initialize(np_array=numpy.full(number_of_points, (0.0 + 0.0j), dtype=complex))\n else:\n sA_pi = None\n\n return GenericWavefront1D(wavelength, sA, sA_pi)\n\n @classmethod\n def initialize_wavefront_from_steps(cls, x_start=-1.0, x_step=0.002, number_of_points=1000, wavelength=1e-10, polarization=Polarization.SIGMA):\n\n sA = ScaledArray.initialize_from_steps(np_array=numpy.full(number_of_points, (1.0 + 0.0j), dtype=complex),\n initial_scale_value=x_start,\n scale_step=x_step)\n if ((polarization == Polarization.PI) or (polarization == Polarization.TOTAL)):\n sA_pi = ScaledArray.initialize_from_steps(np_array=numpy.full(number_of_points, (0.0 + 0.0j), dtype=complex),\n initial_scale_value=x_start,\n scale_step=x_step)\n else:\n sA_pi = None\n\n return GenericWavefront1D(wavelength, sA, sA_pi)\n\n @classmethod\n def initialize_wavefront_from_range(cls, x_min=0.0, x_max=0.0, number_of_points=1000, wavelength=1e-10, polarization=Polarization.SIGMA ):\n\n sA = ScaledArray.initialize_from_range(np_array=numpy.full(number_of_points, (1.0 + 0.0j), dtype=complex),\n min_scale_value=x_min,\n max_scale_value=x_max)\n\n if ((polarization == Polarization.PI) or (polarization == Polarization.TOTAL)):\n sA_pi = ScaledArray.initialize_from_range(np_array=numpy.full(number_of_points, (0.0 + 0.0j), dtype=complex),\n min_scale_value=x_min,\n max_scale_value=x_max)\n else:\n sA_pi = None\n return GenericWavefront1D(wavelength, sA, sA_pi )\n\n @classmethod\n def initialize_wavefront_from_arrays(cls, x_array, y_array, y_array_pi=None, wavelength=1e-10):\n if x_array.size != y_array.size:\n raise Exception(\"Unmatched shapes for x and y\")\n\n sA = ScaledArray.initialize_from_steps(np_array=y_array,\n initial_scale_value=x_array[0],\n scale_step=(x_array[1]-x_array[0]))\n\n if y_array_pi is not None:\n sA_pi = ScaledArray.initialize_from_steps(np_array=y_array_pi,\n initial_scale_value=x_array[0],\n scale_step=(x_array[1]-x_array[0]))\n else:\n sA_pi = None\n\n return GenericWavefront1D(wavelength, sA, sA_pi)\n\n\n # main parameters\n\n # grid\n\n def size(self):\n return self._electric_field_array.size()\n\n def delta(self):\n return self._electric_field_array.delta()\n\n def offset(self):\n return self._electric_field_array.offset()\n\n def get_abscissas(self):\n return self._electric_field_array.scale\n\n def get_mesh_x(self):\n return self.get_abscissas()\n\n # photon energy\n\n def get_wavelength(self):\n return self._wavelength\n\n def get_wavenumber(self):\n return 2*numpy.pi/self._wavelength\n\n def get_photon_energy(self):\n m2ev = codata.c * codata.h / codata.e # lambda(m) = m2eV / energy(eV)\n return m2ev / self._wavelength\n\n\n # wavefront\n\n def get_complex_amplitude(self, polarization=Polarization.SIGMA):\n\n if polarization == Polarization.SIGMA:\n return self._electric_field_array.np_array\n elif polarization == Polarization.PI:\n if self.is_polarized():\n return self._electric_field_array_pi.np_array\n else:\n raise Exception(\"Wavefront is not polarized.\")\n else:\n raise Exception(\"Only 0=SIGMA and 1=PI are valid polarization values.\")\n\n def get_amplitude(self, polarization=Polarization.SIGMA):\n return numpy.absolute(self.get_complex_amplitude(polarization=polarization))\n\n def get_phase(self,from_minimum_intensity=0.0,unwrap=0, polarization=Polarization.SIGMA):\n phase = numpy.angle(self.get_complex_amplitude(polarization=polarization))\n if (from_minimum_intensity > 0.0):\n intensity = self.get_intensity()\n intensity /= intensity.max()\n bad_indices = numpy.where(intensity < from_minimum_intensity )\n phase[bad_indices] = 0.0\n if unwrap:\n phase = numpy.unwrap(phase)\n return phase\n\n def get_intensity(self, polarization=Polarization.SIGMA):\n if polarization == Polarization.TOTAL:\n if self.is_polarized():\n return self.get_amplitude(polarization=Polarization.SIGMA)**2 + \\\n self.get_amplitude(polarization=Polarization.PI)**2\n else:\n return self.get_amplitude(polarization=Polarization.SIGMA)**2\n else:\n return self.get_amplitude(polarization=polarization)**2\n\n def get_integrated_intensity(self, polarization=Polarization.SIGMA):\n return self.get_intensity(polarization=polarization).sum() * (self.get_abscissas()[1] - self.get_abscissas()[0])\n\n # interpolated values\n\n def get_interpolated_complex_amplitude(self, abscissa_value, polarization=Polarization.SIGMA): # singular\n\n if polarization == Polarization.SIGMA:\n return self._electric_field_array.interpolate_value(abscissa_value)\n elif polarization == Polarization.PI:\n if self.is_polarized():\n return self._electric_field_array_pi.interpolate_value(abscissa_value)\n else:\n raise Exception(\"Wavefront is not polarized.\")\n else:\n raise Exception(\"Only 0=SIGMA and 1=PI are valid polarization values.\")\n\n\n def get_interpolated_complex_amplitudes(self, abscissa_values, polarization=Polarization.SIGMA): # plural\n\n if polarization == Polarization.SIGMA:\n return self._electric_field_array.interpolate_values(abscissa_values)\n elif polarization == Polarization.PI:\n if self.is_polarized():\n return self._electric_field_array_pi.interpolate_values(abscissa_values)\n else:\n raise Exception(\"Wavefront is not polarized.\")\n else:\n raise Exception(\"Only 0=SIGMA and 1=PI are valid polarization values.\")\n\n\n\n def get_interpolated_amplitude(self, abscissa_value, polarization=Polarization.SIGMA): # singular!\n return numpy.absolute(self.get_interpolated_complex_amplitude(abscissa_value,polarization=polarization))\n\n def get_interpolated_amplitudes(self, abscissa_values, polarization=Polarization.SIGMA): # plural!\n return numpy.absolute(self.get_interpolated_complex_amplitudes(abscissa_values,polarization=polarization))\n\n def get_interpolated_phase(self, abscissa_value, polarization=Polarization.SIGMA): # singular!\n complex_amplitude = self.get_interpolated_complex_amplitude(abscissa_value, polarization=polarization)\n return numpy.arctan2(numpy.imag(complex_amplitude), numpy.real(complex_amplitude))\n\n def get_interpolated_phases(self, abscissa_values, polarization=Polarization.SIGMA): # plural!\n complex_amplitudes = self.get_interpolated_complex_amplitudes(abscissa_values, polarization=polarization)\n return numpy.arctan2(numpy.imag(complex_amplitudes), numpy.real(complex_amplitudes))\n\n def get_interpolated_intensity(self, abscissa_value, polarization=Polarization.SIGMA):\n if polarization == Polarization.TOTAL:\n interpolated_complex_amplitude = self.get_interpolated_amplitude(abscissa_value,polarization=Polarization.SIGMA)\n if self.is_polarized():\n interpolated_complex_amplitude_pi = self.get_interpolated_amplitude(abscissa_value,polarization=Polarization.PI)\n return numpy.abs(interpolated_complex_amplitude)**2 + numpy.abs(interpolated_complex_amplitude_pi)**2\n else:\n return numpy.abs(interpolated_complex_amplitude)**2\n elif polarization == Polarization.SIGMA:\n interpolated_complex_amplitude = self.get_interpolated_amplitude(abscissa_value,polarization=Polarization.SIGMA)\n return numpy.abs(interpolated_complex_amplitude)**2\n elif polarization == Polarization.PI:\n interpolated_complex_amplitude_pi = self.get_interpolated_amplitude(abscissa_value,polarization=Polarization.PI)\n return numpy.abs(interpolated_complex_amplitude_pi)**2\n else:\n raise Exception(\"Wrong polarization value.\")\n\n\n def get_interpolated_intensities(self, abscissa_values, polarization=Polarization.SIGMA):\n # return self.get_interpolated_amplitudes(abscissa_values,polarization=Polarization.SIGMA)**2\n\n if polarization == Polarization.TOTAL:\n interpolated_complex_amplitude = self.get_interpolated_complex_amplitude(abscissa_values,polarization=Polarization.SIGMA)\n if self.is_polarized():\n interpolated_complex_amplitude_pi = self.get_interpolated_complex_amplitude(abscissa_values,polarization=Polarization.PI)\n return numpy.abs(interpolated_complex_amplitude)**2 + numpy.abs(interpolated_complex_amplitude_pi)**2\n else:\n return numpy.abs(interpolated_complex_amplitude)**2\n elif polarization == Polarization.SIGMA:\n interpolated_complex_amplitude = self.get_interpolated_complex_amplitude(abscissa_values,polarization=Polarization.SIGMA)\n return numpy.abs(interpolated_complex_amplitude)**2\n elif polarization == Polarization.PI:\n interpolated_complex_amplitude_pi = self.get_interpolated_complex_amplitude(abscissa_values,polarization=Polarization.PI)\n return numpy.abs(interpolated_complex_amplitude_pi)**2\n else:\n raise Exception(\"Wrong polarization value.\")\n\n\n # modifiers\n\n def set_wavelength(self, wavelength):\n self._wavelength = wavelength\n\n def set_wavenumber(self, wavenumber):\n self._wavelength = 2 * numpy.pi / wavenumber\n\n def set_photon_energy(self, photon_energy):\n m2ev = codata.c * codata.h / codata.e # lambda(m) = m2eV / energy(eV)\n self._wavelength = m2ev / photon_energy\n\n def set_complex_amplitude(self, complex_amplitude, complex_amplitude_pi=None):\n if complex_amplitude.size != self._electric_field_array.size():\n raise Exception(\"Complex amplitude array has different dimension\")\n\n self._electric_field_array.np_array = complex_amplitude\n\n if complex_amplitude_pi is not None:\n if self.is_polarized():\n if complex_amplitude_pi.size != self._electric_field_array_pi.size():\n raise Exception(\"Complex amplitude array has different dimension\")\n\n self._electric_field_array_pi.np_array = complex_amplitude_pi\n else:\n raise Exception('Cannot set PI-polarized complex amplitude to a non-polarized wavefront.')\n\n def set_pi_complex_amplitude_to_zero(self):\n if self.is_polarized():\n self._electric_field_array_pi.np_array *= 0.0\n\n def set_plane_wave_from_complex_amplitude(self, complex_amplitude=(1.0 + 0.0j), inclination=0.0):\n self._electric_field_array.np_array = numpy.full(self._electric_field_array.size(), complex_amplitude, dtype=complex)\n if inclination != 0.0:\n self.add_phase_shifts( self.get_wavenumber() * self._electric_field_array.scale * numpy.tan(inclination) )\n # if polarized, set arbitrary PI component to zero\n self.set_pi_complex_amplitude_to_zero()\n\n def set_plane_wave_from_amplitude_and_phase(self, amplitude=1.0, phase=0.0, inclination=0.0):\n self.set_plane_wave_from_complex_amplitude(amplitude*numpy.cos(phase) + 1.0j*amplitude*numpy.sin(phase))\n if inclination != 0.0:\n self.add_phase_shifts( self.get_wavenumber() * self._electric_field_array.scale * numpy.tan(inclination) )\n # if polarized, set arbitrary PI component to zero\n self.set_pi_complex_amplitude_to_zero()\n\n def set_spherical_wave(self, radius=1.0, center=0.0, complex_amplitude=1.0):\n if radius == 0: raise Exception(\"Radius cannot be zero\")\n\n self._electric_field_array.np_array = complex_amplitude * numpy.exp(-1.0j * self.get_wavenumber() *\n ( (self._electric_field_array.scale - center)** 2) / (-2 * radius))\n # if polarized, set arbitrary PI component to zero\n self.set_pi_complex_amplitude_to_zero()\n\n def set_gaussian_hermite_mode(self, sigma_x, mode_x, amplitude=1.0, shift=0.0, beta=100.0):\n a1D = GaussianSchellModel1D(amplitude, sigma_x, beta*sigma_x)\n\n real_amplitude = a1D.phi(mode_x, self.get_abscissas() - shift)\n eigenvalue = a1D.beta(mode_x)\n\n self.set_complex_amplitude(numpy.sqrt(eigenvalue)*real_amplitude+0.0j)\n # if polarized, set arbitrary PI component to zero\n self.set_pi_complex_amplitude_to_zero()\n\n # note that amplitude is for \"amplitude\" not for intensity!\n def set_gaussian(self, sigma_x, amplitude=1.0, shift=0.0):\n self.set_gaussian_hermite_mode(sigma_x, 0, amplitude=amplitude, shift=shift)\n # if polarized, set arbitrary PI component to zero\n self.set_pi_complex_amplitude_to_zero()\n\n def add_phase_shift(self, phase_shift, polarization=Polarization.SIGMA):\n if polarization == Polarization.SIGMA:\n self._electric_field_array.np_array *= numpy.exp(1.0j * phase_shift)\n elif polarization == Polarization.PI:\n if self.is_polarized():\n self._electric_field_array_pi.np_array *= numpy.exp(1.0j * phase_shift)\n else:\n raise Exception(\"Wavefront is not polarized\")\n else:\n raise Exception(\"Invalid polarization value (only 0=SIGMA or 1=PI are valid)\")\n\n def add_phase_shifts(self, phase_shifts, polarization=Polarization.SIGMA):\n\n if polarization == Polarization.SIGMA:\n if phase_shifts.size != self._electric_field_array.size():\n raise Exception(\"Phase Shifts array has different dimension\")\n self._electric_field_array.np_array = numpy.multiply(self._electric_field_array.np_array, numpy.exp(1.0j * phase_shifts))\n elif polarization == Polarization.PI:\n if self.is_polarized():\n if phase_shifts.size != self._electric_field_array_pi.size():\n raise Exception(\"Phase Shifts array has different dimension\")\n self._electric_field_array_pi.np_array = numpy.multiply(self._electric_field_array_pi.np_array, numpy.exp(1.0j * phase_shifts))\n else:\n raise Exception(\"Wavefront is not polarized\")\n else:\n raise Exception(\"Invalid polarization value (only 0=SIGMA or 1=PI are valid)\")\n\n\n def rescale_amplitude(self, factor, polarization=Polarization.SIGMA):\n\n if polarization == Polarization.SIGMA:\n self._electric_field_array.np_array *= factor\n elif polarization == Polarization.PI:\n if self.is_polarized():\n self._electric_field_array_pi.np_array *= factor\n else:\n raise Exception(\"Wavefront is not polarized\")\n elif polarization == Polarization.TOTAL:\n self.rescale_amplitude(factor, polarization=Polarization.SIGMA)\n self.rescale_amplitude(factor, polarization=Polarization.PI)\n else:\n raise Exception(\"Invalid polarization value (only 0=SIGMA, 1=PI or 3=TOTAL are valid)\")\n\n\n def rescale_amplitudes(self, factors, polarization=Polarization.SIGMA):\n\n\n if polarization == Polarization.SIGMA:\n if factors.size != self._electric_field_array.size(): raise Exception(\"Factors array has different dimension\")\n self._electric_field_array.np_array = numpy.multiply(self._electric_field_array.np_array, factors)\n elif polarization == Polarization.PI:\n if self.is_polarized():\n if factors.size != self._electric_field_array_pi.size(): raise Exception(\"Factors array has different dimension\")\n self._electric_field_array_pi.np_array = numpy.multiply(self._electric_field_array_pi.np_array, factors)\n else:\n raise Exception(\"Wavefront is not polarized\")\n elif polarization == Polarization.TOTAL:\n self.rescale_amplitudes(factors, polarization=Polarization.SIGMA)\n self.rescale_amplitudes(factors, polarization=Polarization.PI)\n else:\n raise Exception(\"Invalid polarization value (only 0=SIGMA, 1=PI or 3=TOTAL are valid)\")\n\n\n def clip(self, x_min, x_max, negative=False):\n window = numpy.ones(self._electric_field_array.size())\n\n if not negative:\n lower_window = numpy.where(self.get_abscissas() < x_min)\n upper_window = numpy.where(self.get_abscissas() > x_max)\n\n if len(lower_window) > 0: window[lower_window] = 0\n if len(upper_window) > 0: window[upper_window] = 0\n else:\n window_indices = numpy.where((self.get_abscissas() >= x_min) & (self.get_abscissas() <= x_max))\n\n if len(window_indices) > 0:\n window[window_indices] = 0.0\n\n if self.is_polarized():\n self.rescale_amplitudes(window,polarization=Polarization.TOTAL)\n else:\n self.rescale_amplitudes(window,polarization=Polarization.SIGMA)\n\n def is_identical(self,wfr,decimal=7):\n from numpy.testing import assert_array_almost_equal\n try:\n assert_array_almost_equal(self.get_complex_amplitude(),wfr.get_complex_amplitude(),decimal)\n assert(self.is_polarized() == wfr.is_polarized())\n if self.is_polarized():\n assert_array_almost_equal(self.get_complex_amplitude(polarization=Polarization.PI),\n wfr.get_complex_amplitude(polarization=Polarization.PI),decimal)\n\n assert_array_almost_equal(self.get_abscissas(),wfr.get_abscissas(),decimal)\n assert_array_almost_equal(self.get_photon_energy(),wfr.get_photon_energy(),decimal)\n except:\n return False\n\n return True\n\n\n #\n # auxiliary methods get main wavefront phase curvature (radius)\n #\n def _figure_of_merit(self,radius,weight_with_intensity=True):\n \"\"\"\n Computes a \"figure of merit\" for finding the wavefront curvature.\n A low value of the figure of metit means that the entered radius (checked)\n corresponds to the radius of the wavefront.\n\n If wavefront is polarized, the pi component is ignored.\n\n :param radius:\n :param weight_with_intensity:\n :return: a positive scalar with the figure of merit\n \"\"\"\n x = self.get_abscissas()\n new_phase = 1.0 * self.get_wavenumber() * (x**2) / (-2 * radius)\n\n wavefront2 = self.duplicate()\n wavefront2.add_phase_shifts(new_phase)\n\n if weight_with_intensity:\n out = numpy.abs(wavefront2.get_phase()*wavefront2.get_intensity()).sum()\n else:\n out = numpy.abs(wavefront2.get_phase()).sum()\n\n return out\n\n def scan_wavefront_curvature(self,rmin=-10000.0,rmax=10000.0,rpoints=100):\n\n radii = numpy.linspace(rmax,rmin,rpoints)\n fig_of_mer = numpy.zeros_like(radii)\n\n for i,radius in enumerate(radii):\n fig_of_mer[i] =self._figure_of_merit(radius)\n\n return radii,fig_of_mer\n\n\n def guess_wavefront_curvature(self,rmin=-10000.0,rmax=10000.0,rpoints=100):\n from scipy.optimize import minimize\n\n radii,fig_of_mer = self.scan_wavefront_curvature(rmin=rmin,rmax=rmax,rpoints=rpoints)\n\n res = minimize(self._figure_of_merit, radii[numpy.argmin(fig_of_mer)], args=self, method='powell',options={'xtol': 1e-8, 'disp': True})\n\n return res.x\n\n #\n # auxiliary function to dump h5 files\n #\n def _dump_arr_2_hdf5(self,_arr,_calculation, _filename, _subgroupname):\n \"\"\"\n Auxiliary routine to save_h5_file\n :param _arr: (usually 2D) array to be saved on the hdf5 file inside the _subgroupname\n :param _calculation\n :param _filename: path to file for saving the wavefront\n :param _subgroupname: container mechanism by which HDF5 files are organised\n \"\"\"\n sys.stdout.flush()\n f = h5py.File(_filename, 'a')\n try:\n f1 = f.create_group(_subgroupname)\n except:\n f1 = f[_subgroupname]\n fdata = f1.create_dataset(_calculation, data=_arr)\n f.close()\n\n def save_h5_file(self,filename,subgroupname=\"wfr\",intensity=True,phase=False,overwrite=True,verbose=False):\n \"\"\"\n Auxiliary function to write wavefront data into a hdf5 generic file.\n When using the append mode to write h5 files, overwriting does not work and makes the code crash. To avoid this\n issue, try/except is used. If by any chance a file should be overwritten, it is firstly deleted and re-written.\n :param self: input / output resulting Wavefront structure (instance of GenericWavefront2D);\n :param filename: path to file for saving the wavefront\n :param subgroupname: container mechanism by which HDF5 files are organised\n :param intensity: writes intensity for sigma and pi polarisation (default=True)\n :param amplitude:\n :param phase:\n :param overwrite: flag that should always be set to True to avoid infinity loop on the recursive part of the function.\n :param verbose: if True, print some file i/o messages\n \"\"\"\n if overwrite:\n try:\n os.remove(filename)\n except:\n pass\n\n\n try:\n if not os.path.isfile(filename): # if file doesn't exist, create it.\n sys.stdout.flush()\n f = h5py.File(filename, 'w')\n # point to the default data to be plotted\n f.attrs['default'] = 'entry'\n # give the HDF5 root some more attributes\n f.attrs['file_name'] = filename\n f.attrs['file_time'] = time.time()\n f.attrs['creator'] = 'oasys-wofry'\n f.attrs['HDF5_Version'] = h5py.version.hdf5_version\n f.attrs['h5py_version'] = h5py.version.version\n f.close()\n\n # always writes complex amplitude\n x_polarization = self.get_complex_amplitude() # sigma\n self._dump_arr_2_hdf5(x_polarization, \"wfr_complex_amplitude_s\", filename, subgroupname)\n\n if self.is_polarized():\n y_polarization = self.get_complex_amplitude(polarization=Polarization.PI) # pi\n self._dump_arr_2_hdf5(y_polarization, \"wfr_complex_amplitude_p\", filename, subgroupname)\n\n if intensity:\n if self.is_polarized():\n self._dump_arr_2_hdf5(self.get_intensity(polarization=Polarization.TOTAL),\"intensity/wfr_intensity\", filename, subgroupname)\n self._dump_arr_2_hdf5(self.get_intensity(polarization=Polarization.SIGMA),\"intensity/wfr_intensity_s\", filename, subgroupname)\n self._dump_arr_2_hdf5(self.get_intensity(polarization=Polarization.PI),\"intensity/wfr_intensity_p\", filename, subgroupname)\n else:\n self._dump_arr_2_hdf5(self.get_intensity(),\"intensity/wfr_intensity\", filename, subgroupname)\n\n if phase:\n if self.is_polarized():\n self._dump_arr_2_hdf5(self.get_phase(polarization=Polarization.SIGMA)-self.get_phase(polarization=Polarization.PI),\n \"phase/wfr_phase\", filename, subgroupname)\n self._dump_arr_2_hdf5(self.get_phase(polarization=Polarization.SIGMA),\"phase/wfr_phase_s\", filename, subgroupname)\n self._dump_arr_2_hdf5(self.get_phase(polarization=Polarization.PI),\"phase/wfr_phase_p\", filename, subgroupname)\n else:\n self._dump_arr_2_hdf5(self.get_phase(polarization=Polarization.SIGMA),\"phase/wfr_phase\", filename, subgroupname)\n\n\n # add mesh and SRW information\n f = h5py.File(filename, 'a')\n f1 = f[subgroupname]\n\n # point to the default data to be plotted\n f1.attrs['NX_class'] = 'NXentry'\n f1.attrs['default'] = 'intensity'\n\n # TODO: add self interpreting decoder\n # f1[\"wfr_method\"] = \"WOFRY\"\n f1[\"wfr_dimension\"] = 1\n f1[\"wfr_photon_energy\"] = self.get_photon_energy()\n x = self.get_abscissas()\n\n\n f1[\"wfr_mesh\"] = numpy.array([x[0],x[-1],x.size])\n\n\n # Add NX plot attribites for automatic plot with silx view\n myflags = [intensity,phase]\n mylabels = ['intensity','phase']\n for i,label in enumerate(mylabels):\n if myflags[i]:\n f2 = f1[mylabels[i]]\n f2.attrs['NX_class'] = 'NXdata'\n f2.attrs['signal'] = 'wfr_%s'%(mylabels[i])\n f2.attrs['axes'] = b'axis_x'\n\n f3 = f2[\"wfr_%s\"%(mylabels[i])]\n\n # axis data\n ds = f2.create_dataset('axis_x', data=1e6*x)\n ds.attrs['units'] = 'microns'\n ds.attrs['long_name'] = 'Pixel Size (microns)' # suggested Y axis plot label\n f.close()\n\n except:\n # TODO: check exit??\n if overwrite is not True:\n raise Exception(\"Bad input argument\")\n os.remove(filename)\n if verbose: print(\"save_h5_file: file deleted %s\"%filename)\n self.save_h5_file(filename,subgroupname, intensity=intensity, phase=phase, overwrite=False)\n\n if verbose: print(\"save_h5_file: written/updated %s data in file: %s\"%(subgroupname,filename))\n\n @classmethod\n def load_h5_file(cls,filename,filepath=\"wfr\"):\n\n try:\n f = h5py.File(filename, 'r')\n mesh = f[filepath+\"/wfr_mesh\"][()]\n complex_amplitude_s = f[filepath+\"/wfr_complex_amplitude_s\"][()]\n energy = f[filepath + \"/wfr_photon_energy\"][()]\n try:\n complex_amplitude_p = f[filepath + \"/wfr_complex_amplitude_p\"][()]\n except:\n complex_amplitude_p = None\n f.close()\n except:\n raise Exception(\"Failed to load 2D wavefront from h5 file: \"+filename)\n\n wfr = cls.initialize_wavefront_from_arrays(\n numpy.linspace(mesh[0],mesh[1],int(mesh[2])),\n complex_amplitude_s,complex_amplitude_p)\n wfr.set_photon_energy(energy)\n return wfr\n\n\nif __name__ == \"__main__\":\n # w = GenericWavefront1D.initialize_wavefront_from_steps(polarization=Polarization.TOTAL)\n # w.save_h5_file(\"/tmp/wf.h5\",subgroupname=\"wfr\",intensity=True,phase=False,overwrite=True,verbose=True)\n # w2 = GenericWavefront1D.load_h5_file(\"/tmp/wf.h5\",filepath=\"wfr\")\n # assert(w2.is_identical(w))\n x = numpy.linspace(100e-6, -100e-6, 100)\n y = numpy.exp( -(x-50e-6)**2 / 2 / (10e-6)**2 )\n wfr = GenericWavefront1D.initialize_wavefront_from_arrays(x, numpy.sqrt(y) + 0j)\n from srxraylib.plot.gol import plot\n plot(1e6 * x,y,\n 1e6 * wfr.get_abscissas(), wfr.get_intensity(),\n legend=[\"original\", \"wfr\"])"
] | [
[
"numpy.sqrt",
"numpy.zeros_like",
"numpy.unwrap",
"numpy.multiply",
"numpy.argmin",
"numpy.abs",
"numpy.cos",
"numpy.exp",
"numpy.tan",
"numpy.array",
"numpy.sin",
"numpy.where",
"numpy.full",
"numpy.linspace",
"numpy.real",
"numpy.imag"
]
] |
AntayaScienceAndTechnology/McFee | [
"96a9a6d552253c622147fe9c9c1c253ba7bc66a2"
] | [
"McFee_Functions.py"
] | [
"__author__ = 'Chris Jones'\n\nimport numpy as np\nfrom scipy.integrate import quad\n\nimport heat_xfer as hx\n\n\n# Values for default parameters\ndefault_rrr = 150\ndefault_I = 200.\ndefault_res_increase = 0.\ndefault_rho_273 = 1.71e-6\nlinspace_num = 500\n\ndef get_kr_ave1(u_l, u_h):\n \"\"\"\n Returns the average k*r value from u_l to u_h using integration\n :param u_l:\n :param u_h:\n :return:\n \"\"\"\n if u_l == u_h:\n return 0.\n\n kr_func = lambda u: hx.therm_cond_cu(u, rrr=default_rrr) * hx.resistivity_BG(u)\n return (1 / (u_h - u_l)) * quad(kr_func, u_l, u_h)[0]\n\n\ndef get_qn1(u_l, u_h, I): # The heat flow at the cold end\n \"\"\"\n Returns the nth heat flow value in watts using integration\n :param u_l:\n :param u_h:\n :param I:\n :return:\n \"\"\"\n return I * np.sqrt(2 * get_kr_ave1(u_l, u_h) * (u_h - u_l))\n\n\ndef get_qps1(u, u_l, I=default_I):\n qps = np.zeros(len(u))\n\n for i in range(len(u)):\n qps[i] = get_qn1(u_l, u[i], I)\n\n return qps\n\n\ndef get_kr_ave2(u_l, u_h, du, r_increase=default_res_increase):\n \"\"\"\n Returns the average k*r value from u_l to u_h using summation\n :param u_l:\n :param u_h:\n :param du:\n :return:\n \"\"\"\n if u_l == u_h:\n return 0.\n\n # x = np.arange(u_h, u_l - du, -du)\n x = np.linspace(u_h, u_l, linspace_num)\n return np.sum(get_kp(x)*get_rp(x, r_increase=r_increase)) / float(len(x))\n\n\ndef get_qn2(u_l, u_h, I, du, r_increase=default_res_increase):\n \"\"\"\n Returns the nth heat flow value in watts using summation\n :param u_l: cold end temperature in Kelvin\n :type u_l: float\n :param u_h: warm end temperature in Kelvin\n :type u_h: float\n :param I: conductor current\n :type I: float\n :param du: temperature step size\n :type du: float\n :returns: heat load seen at cold end of conductor\n :rtype: float\n \"\"\"\n return I * np.sqrt(2. * get_kr_ave2(u_l, u_h, du, r_increase=r_increase) * (u_h - u_l))\n\n\ndef get_qps2(u, du, I=default_I):\n qps = np.zeros(len(u))\n u_max = max(u)\n\n for i in range(len(u)):\n qps[i] = get_qn2(u_max, u[i], I, du)\n\n return qps\n\n\ndef get_kr_cumsum(cell_temps, r_increase=default_res_increase):\n \"\"\"\n For a given cell temperature range, return the sum of the k*r products.\n Used by 'get_la_ratio()'\n :param cell_temps:\n :type cell_temps: numpy.ndarray\n :return: cumulative sum of k*r values\n :rtype: numpy.ndarray\n \"\"\"\n return np.cumsum(get_kp(cell_temps)*get_rp(cell_temps, r_increase=r_increase))\n\n\ndef get_qn3(kr_sum, du, I):\n \"\"\"\n Returns the value of Q from a range. Meant to be used by 'get_la_ratio()'\n :param kr_sum:\n :param du:\n :param I:\n :return:\n :rtype:\n \"\"\"\n return I * np.sqrt(2. * kr_sum * du)\n\n\ndef get_la_ratio(u, du, I, r_increase=default_res_increase):\n \"\"\"\n Given a temperature range and current, returns the optimized length to area ratio of the conductor.\n :param r_increase:\n :param u:\n :param du:\n :param I:\n :return:\n \"\"\"\n ct = get_cell_temps(u)\n kr = get_kr_cumsum(ct, r_increase=r_increase)\n sp = get_sp(ct, r_increase=r_increase)\n\n qs = get_qn3(kr, du, I)\n\n ratio = 0.\n\n for i in range(len(ct) - 1):\n ratio += (sp[i] - sp[i+1]) * qs[i]\n\n ratio += (sp[-1] * qs[-1])\n\n return ratio / I ** 2.\n\n\ndef get_kp(u, rrr=default_rrr):\n \"\"\"\n Given a temperature, or array of temperatures, returns the thermal conductivity.\n :param u:\n :param rrr:\n :return:\n \"\"\"\n return hx.therm_cond_cu(u, rrr)\n\n\ndef get_sp(u, rrr=default_rrr, rho273=default_rho_273, r_increase=default_res_increase):\n \"\"\"\n Given a temperature, or an array of temperatures, returns the electrical conductivity.\n :param r_increase:\n :param u:\n :param rrr:\n :param rho273:\n :return:\n \"\"\"\n return 1. / (hx.resistivity_BG(u, rrr, rho273) + r_increase)\n\n\ndef get_rp(u, rrr=default_rrr, rho273=default_rho_273, r_increase=default_res_increase):\n \"\"\"\n Given a temperature, or an array of temperatures, returns the electrical resistivity.\n :param u:\n :param rrr:\n :param rho273:\n :return:\n \"\"\"\n return hx.resistivity_BG(u, rrr, rho273) + r_increase\n\n\ndef get_cell_temps(u):\n \"\"\"\n For a temperature array of length n >= 2, where the values represent temperatures at cell boundaries,\n this function returns the average temperature for the cell in an n-1 length array.\n :param u:\n :return:\n \"\"\"\n temps = np.zeros(len(u)-1)\n\n for i in range(len(temps)):\n temps[i] = 0.5 * (u[i] + u[i + 1])\n\n return temps"
] | [
[
"numpy.sqrt",
"scipy.integrate.quad",
"numpy.linspace"
]
] |
bestend/chatspace | [
"04819eaaf4e9e2d43f8aa8ed5b39f3100b33f921"
] | [
"chatspace/dataset.py"
] | [
"import tensorflow as tf\n\n\ndef make_chatspace_training_dataset(\n lookup_table: tf.lookup.StaticHashTable,\n space_skip_prob: float,\n):\n \"\"\"\n Chatspace 모델에 넣을 Input을 만드는 함수를 반환합니다.\n 정상 문장을 입력으로 받아 랜덤하게 띄어쓰기를 지웁니다.\n\n :param lookup_table: Vocab 정보로 초기화된 ``tf.lookup.StaticHashTable``\n :param space_skip_prob: 띄어쓰기를 지울 확률\n \"\"\"\n\n @tf.function\n def _mapping_function(\n sentence: tf.Tensor,\n ):\n sentence = tf.strings.unicode_split(sentence, \"UTF-8\")\n sentence = tf.strings.regex_replace(sentence, \" +\", \" \")\n sentence_length = tf.shape(sentence)[0]\n\n def cond(index, inputs, labels):\n return index < sentence_length\n\n def body(index, inputs, labels):\n inputs = tf.concat([inputs, [sentence[index]]], axis=0)\n\n index, labels = tf.cond(\n index != sentence_length - 1 and sentence[index + 1] == \" \",\n lambda: tf.cond(\n tf.random.uniform([], minval=0, maxval=1) <= space_skip_prob,\n lambda: (index + 1, tf.concat([labels, [1]], axis=0)),\n lambda: (index, tf.concat([labels, [0]], axis=0)),\n ),\n lambda: (index, tf.concat([labels, [0]], axis=0)),\n )\n\n index += 1\n return index, inputs, labels\n\n _, inputs, labels = tf.while_loop(\n cond,\n body,\n (\n tf.constant(0),\n tf.constant([], dtype=tf.string),\n tf.constant([], dtype=tf.int32),\n ),\n shape_invariants=(\n tf.TensorShape([]),\n tf.TensorShape([None]),\n tf.TensorShape([None]),\n ),\n )\n\n # 문장의 앞뒤에 BOS, EOS 토큰을 붙입니다.\n inputs = tf.concat([[\"<s>\"], inputs, [\"</s>\"]], axis=0)\n labels = tf.concat([[0], labels, [0]], axis=0)\n inputs = lookup_table.lookup(inputs)\n\n return inputs, labels\n\n return _mapping_function\n"
] | [
[
"tensorflow.shape",
"tensorflow.strings.unicode_split",
"tensorflow.TensorShape",
"tensorflow.concat",
"tensorflow.random.uniform",
"tensorflow.strings.regex_replace",
"tensorflow.constant"
]
] |
yehonadav/yonadav_tutorials | [
"e797fdaeaea4c5d85392f724442645afb9391f15"
] | [
"learn_anaconda/learn_ml/ep5.py"
] | [
"from sklearn import datasets\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.metrics import accuracy_score\nfrom scipy.spatial import distance\nimport random\n\n\ndef euc(a, b):\n return distance.euclidean(a, b)\n\n\n# random classifier\nclass ScrappyRandom:\n def fit(self, x_train, y_train):\n self.x_train = x_train\n self.y_train = y_train\n\n def predict(self, x_test):\n predictions = []\n for _ in x_test:\n label = random.choice(self.y_train)\n predictions.append(label)\n return predictions\n\n\nclass ScrappyKNN:\n def fit(self, x_train, y_train):\n self.x_train = x_train\n self.y_train = y_train\n\n def predict(self, x_Test):\n predictions = []\n for row in x_test:\n label = self.closest(row)\n predictions.append(label)\n return predictions\n\n def closest(self, row):\n best_dist = euc(row, self.x_train[0])\n best_index = 0\n for i in range(1, len(self.x_train)):\n dist = euc(row, self.x_train[i])\n if dist < best_dist:\n best_dist = dist\n best_index = i\n return self.y_train[best_index]\n\niris = datasets.load_iris()\n\nx = iris.data\ny = iris.target\n\nx_train, x_test, y_train, y_test = train_test_split(x, y, test_size=.5)\n\n\nmy_classifier = ScrappyRandom()\nmy_classifier.fit(x_train, y_train)\n\npredictions = my_classifier.predict(x_test)\nprint(accuracy_score(y_test, predictions))\n\n\nmy_classifier = ScrappyKNN()\nmy_classifier.fit(x_train, y_train)\n\npredictions = my_classifier.predict(x_test)\nprint(accuracy_score(y_test, predictions))"
] | [
[
"sklearn.metrics.accuracy_score",
"scipy.spatial.distance.euclidean",
"sklearn.model_selection.train_test_split",
"sklearn.datasets.load_iris"
]
] |
umamibeef/pyscf | [
"09834c8f5a4f5320cdde29d285b6ccd89b3263e0"
] | [
"pyscf/mcscf/test/test_addons.py"
] | [
"#!/usr/bin/env python\n# Copyright 2014-2018 The PySCF Developers. 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 copy\nimport unittest\nfrom functools import reduce\nimport numpy, scipy\nfrom pyscf import lib\nfrom pyscf import gto\nfrom pyscf import scf\nfrom pyscf import mcscf\nfrom pyscf import fci\n\nb = 1.4\nmol = gto.Mole()\nmol.build(\nverbose = 7,\noutput = '/dev/null',\natom = [\n ['N',( 0.000000, 0.000000, -b/2)],\n ['N',( 0.000000, 0.000000, b/2)], ],\nbasis = {'N': 'ccpvdz', },\nsymmetry = 1\n)\nmfr = scf.RHF(mol)\nmfr.scf()\nmcr = mcscf.CASSCF(mfr, 4, 4)\nmcr.conv_tol_grad = 1e-6\nmcr.mc1step()[0]\n\nmfu = scf.UHF(mol)\nmfu.scf()\nmcu = mcscf.UCASSCF(mfu, 4, 4)\nmcu.conv_tol_grad = 1e-6\nmcu.mc1step()[0]\n\nmol_prg = gto.M(\nverbose = 0,\natom = [\n ['N',( 0.000000, 0.000000, -(b+0.1)/2)],\n ['N',( 0.000000, 0.000000, (b+0.1)/2)], ],\nbasis = 'ccpvdz',\nsymmetry=1)\nmfr_prg = scf.RHF(mol_prg).set (max_cycle=1).run()\nmcr_prg = mcscf.CASSCF(mfr_prg, 4, 4).set (max_cycle_macro=1).run()\nmfu_prg = scf.UHF(mol_prg).set (max_cycle=1).run()\nmcu_prg = mcscf.UCASSCF(mfu_prg, 4, 4).set (max_cycle_macro=1).run()\n\nmol_prb = mol.copy ()\nmol_prb.basis = {'N': 'aug-cc-pvdz' }\nmol_prb.build ()\nmfr_prb = scf.RHF(mol_prb).set (max_cycle=1).run()\nmcr_prb = mcscf.CASSCF(mfr_prb, 4, 4).set (max_cycle_macro=1).run()\n\n\ndef tearDownModule():\n global mol, mfr, mcr, mfu, mcu\n mol.stdout.close()\n del mol, mfr, mcr, mfu, mcu\n\n\nclass KnownValues(unittest.TestCase):\n def test_spin_square(self):\n ss = mcscf.addons.spin_square(mcr)[0]\n self.assertAlmostEqual(ss, 0, 7)\n\n def test_ucasscf_spin_square(self):\n ss = mcscf.addons.spin_square(mcu)[0]\n self.assertAlmostEqual(ss, 0, 7)\n\n def test_rcas_natorb(self):\n mo1, ci1, mocc1 = mcscf.addons.cas_natorb(mcr)\n self.assertAlmostEqual(numpy.linalg.norm(mo1) , 9.9260608594977491, 6)\n self.assertAlmostEqual(numpy.linalg.norm(mocc1), 5.1687145190800079, 6)\n\n#TODO: def test_ucas_natorb(self):\n#TODO: mo2, ci2, mocc2 = mcscf.addons.cas_natorb(mcu)\n#TODO: self.assertAlmostEqual(numpy.linalg.norm(mo2) , 11.4470460817871*numpy.sqrt(2), 7)\n#TODO: self.assertAlmostEqual(numpy.linalg.norm(mocc2), 2.59144951056707/numpy.sqrt(2), 7)\n\n def test_get_fock(self):\n f1 = mcscf.addons.get_fock(mcr)\n self.assertTrue(numpy.allclose(f1, f1.T))\n self.assertAlmostEqual(numpy.linalg.norm(f1), 25.482177562349467, 6)\n#TODO: f1 = mcscf.addons.get_fock(mcu)\n#TODO: self.assertTrue(numpy.allclose(f1[0], f1[0].T))\n#TODO: self.assertTrue(numpy.allclose(f1[1], f1[1].T))\n#TODO: self.assertAlmostEqual(numpy.linalg.norm(f1), 23.597476504476919*numpy.sqrt(2), 6)\n\n def test_canonicalize1(self):\n numpy.random.seed(1)\n f1 = numpy.random.random(mcr.mo_coeff.shape)\n u1 = numpy.linalg.svd(f1)[0]\n mo1 = numpy.dot(mcr.mo_coeff, u1)\n mo1 = lib.tag_array(mo1, orbsym=mcr.mo_coeff.orbsym)\n mo, ci, mo_e = mcr.canonicalize(mo1)\n e1 = numpy.einsum('ji,jk,ki', mo, f1, mo)\n self.assertAlmostEqual(e1, 44.2658681077, 7)\n self.assertAlmostEqual(lib.fp(mo_e), 5.1364166175063097, 7)\n\n mo, ci, mo_e = mcr.canonicalize(mo1, eris=mcr.ao2mo(mcr.mo_coeff))\n e1 = numpy.einsum('ji,jk,ki', mo, f1, mo)\n self.assertAlmostEqual(e1, 44.2658681077, 7)\n self.assertAlmostEqual(lib.fp(mo_e), 4.1206025804989173, 7)\n\n mcr1 = copy.copy(mcr)\n mcr1.frozen = 2\n mo, ci, mo_e = mcr1.canonicalize(mo1)\n self.assertAlmostEqual(lib.fp(mo_e), 6.6030999409178577, 7)\n\n mcr1.frozen = [0,1]\n mo, ci, mo_e = mcr1.canonicalize(mo1)\n self.assertAlmostEqual(lib.fp(mo_e), 6.6030999409178577, 7)\n\n mcr1.frozen = [1,12]\n mo, ci, mo_e = mcr1.canonicalize(mo1)\n self.assertAlmostEqual(lib.fp(mo_e), 5.2182584355788162, 7)\n\n def test_canonicalize(self):\n mo, ci, mo_e = mcr.canonicalize()\n self.assertAlmostEqual(numpy.linalg.norm(mo), 9.9260608594977242, 7)\n mo, ci, mo_e = mcr.canonicalize(eris=mcr.ao2mo(mcr.mo_coeff))\n self.assertAlmostEqual(numpy.linalg.norm(mo), 9.9260608594977242, 7)\n\n def test_make_rdm12(self):\n dmr = mcscf.addons.make_rdm1(mcr)\n dm1, dm2 = mcscf.addons.make_rdm12(mcr)\n self.assertTrue(numpy.allclose(dmr, dm1))\n self.assertAlmostEqual(numpy.linalg.norm(dm1), 3.8205551262007567, 6)\n self.assertAlmostEqual(numpy.linalg.norm(dm2), 14.987267883423314, 5)\n\n def test_make_rdm1s(self):\n dm1 = mcscf.addons.make_rdm1s(mcr)\n self.assertAlmostEqual(numpy.linalg.norm(dm1), 2.7015404376335805, 5)\n dm1 = mcscf.addons.make_rdm1s(mcu)\n self.assertAlmostEqual(numpy.linalg.norm(dm1), 2.7015404376335805, 5)\n\n def test_sort_mo(self):\n mo1 = numpy.arange(mfr.mo_energy.size).reshape(1,-1)\n ref = [[0, 1, 2, 3, 7, 4, 5, 6, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,\n 18, 19, 20, 21, 22, 23, 24, 25, 26, 27]]\n mo2 = mcscf.addons.sort_mo(mcr, mo1, [5,6,7,9])\n self.assertTrue(numpy.allclose(mo2, ref))\n mo2 = mcscf.addons.sort_mo(mcu, (mo1,mo1), [5,6,7,9])\n self.assertTrue(numpy.allclose(mo2, (ref,ref)))\n mo2 = mcscf.addons.sort_mo(mcu, (mo1,mo1), [[5,6,7,9],[5,6,8,9]])\n ref1 = [[0, 1, 2, 3, 6, 4, 5, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,\n 18, 19, 20, 21, 22, 23, 24, 25, 26, 27]]\n self.assertTrue(numpy.allclose(mo2, (ref,ref1)))\n\n def test_sort_mo_by_irrep(self):\n mc1 = mcscf.CASSCF(mfr, 8, 4)\n mo0 = mcscf.sort_mo_by_irrep(mc1, mfr.mo_coeff, {'E1ux':2, 'E1uy':2, 'E1gx':2, 'E1gy':2})\n mo1 = mcscf.sort_mo_by_irrep(mc1, mfr.mo_coeff, {2:2, 3:2, 6:2, 7:2}, {2:0, 3:0, 6:0, 7:0})\n mo2 = mcscf.sort_mo_by_irrep(mc1, mfr.mo_coeff, (0,0,2,2,0,0,2,2))\n mo3 = mcscf.sort_mo_by_irrep(mc1, mfr.mo_coeff, {'E1ux':2, 'E1uy':2, 2:2, 3:2})\n self.assertTrue(numpy.allclose(mo0, mo1))\n self.assertTrue(numpy.allclose(mo0, mo2))\n self.assertTrue(numpy.allclose(mo0, mo3))\n\n def test_sort_mo_by_irrep1(self):\n mol = gto.M(atom='N 0 0 -.45; N 0 0 .45', basis='ccpvdz',\n symmetry=True, verbose=0)\n mf = scf.RHF(mol).run()\n mc1 = mcscf.CASSCF(mf, 6, 6)\n caslst = mcscf.addons.caslst_by_irrep(mc1, mf.mo_coeff,\n {'A1g': 1, 'A1u': 1, 'E1uy': 1, 'E1ux': 1, 'E1gy': 1, 'E1gx': 1},\n {'A1g': 2, 'A1u': 2})\n self.assertEqual(list(caslst), [4,5,7,8,9,10])\n caslst = mcscf.addons.caslst_by_irrep(mc1, mf.mo_coeff,\n {'E1uy': 1, 'E1ux': 1, 'E1gy': 1, 'E1gx': 1},\n {'A1g': 2, 'A1u': 2})\n self.assertEqual(list(caslst), [4,5,7,8,9,10])\n caslst = mcscf.addons.caslst_by_irrep(mc1, mf.mo_coeff,\n {'E1uy': 1, 'E1ux': 1, 'E1gy': 1, 'E1gx': 1},\n {'A1u': 2})\n self.assertEqual(list(caslst), [4,5,7,8,9,10])\n caslst = mcscf.addons.caslst_by_irrep(mc1, mf.mo_coeff,\n {'A1g': 1, 'A1u': 1}, {'E1uy': 1, 'E1ux': 1})\n self.assertEqual(list(caslst), [3,6,8,9,12,13])\n\n self.assertRaises(ValueError, mcscf.addons.caslst_by_irrep, mc1, mf.mo_coeff,\n {'A1g': 1, 'A1u': 1}, {'E1uy': 3, 'E1ux': 3})\n self.assertRaises(ValueError, mcscf.addons.caslst_by_irrep, mc1, mf.mo_coeff,\n {'A1g': 3, 'A1u': 4}, {'E1uy': 1, 'E1ux': 1})\n self.assertRaises(ValueError, mcscf.addons.caslst_by_irrep, mc1, mf.mo_coeff,\n {'E2ux': 2, 'E2uy': 2}, {'E1uy': 1, 'E1ux': 1})\n\n def test_make_natural_orbitals_from_restricted(self):\n from pyscf import mp, ci, cc\n npt = numpy.testing\n\n mol = gto.M(atom = 'C 0 0 0; O 0 0 1.2', basis = '3-21g', spin = 0)\n myhf = scf.RHF(mol).run()\n ncas, nelecas = (8, 10)\n mymc = mcscf.CASCI(myhf, ncas, nelecas)\n\n # Test MP2\n # Trusted results from ORCA v4.2.1\n rmp2_noons = [1.99992732,1.99989230,1.99204357,1.98051334,1.96825487,1.94377615,1.94376239,0.05792320,0.05791037,0.02833335,0.00847013,0.00531989,0.00420320,0.00420280,0.00257965,0.00101638,0.00101606,0.00085503]\n mymp = mp.MP2(myhf).run()\n noons, natorbs = mcscf.addons.make_natural_orbitals(mymp)\n npt.assert_array_almost_equal(rmp2_noons, noons, decimal=5)\n mymc.kernel(natorbs)\n\n # The tests below are only to ensure that `make_natural_orbitals` can \n # run at all since we've confirmed above that the NOONs are correct.\n # Test CISD\n mycisd = ci.CISD(myhf).run()\n noons, natorbs = mcscf.addons.make_natural_orbitals(mycisd)\n mymc.kernel(natorbs)\n\n # Test CCSD\n myccsd = cc.CCSD(myhf).run()\n noons, natorbs = mcscf.addons.make_natural_orbitals(myccsd)\n mymc.kernel(natorbs)\n\n def test_make_natural_orbitals_from_unrestricted(self):\n from pyscf import mp, ci, cc\n npt = numpy.testing\n\n mol = gto.M(atom = 'O 0 0 0; O 0 0 1.2', basis = '3-21g', spin = 2)\n myhf = scf.UHF(mol).run()\n ncas, nelecas = (8, 12)\n mymc = mcscf.CASCI(myhf, ncas, nelecas)\n\n # Test UHF\n # The tests below are only to ensure that `make_natural_orbitals` can \n # run at all since we've confirmed above that the NOONs are correct for MP2\n mcscf.addons.make_natural_orbitals(myhf)\n\n # Test MP2\n # Trusted results from ORCA v4.2.1\n rmp2_noons = [1.99992786,1.99992701,1.99414062,1.98906552,1.96095173,1.96095165,1.95280755,1.02078458,1.02078457,0.04719006,0.01274288,0.01274278,0.00728679,0.00582683,0.00543964,0.00543962,0.00290772,0.00108258]\n mymp = mp.UMP2(myhf).run()\n noons, natorbs = mcscf.addons.make_natural_orbitals(mymp)\n npt.assert_array_almost_equal(rmp2_noons, noons)\n mymc.kernel(natorbs)\n\n # The tests below are only to ensure that `make_natural_orbitals` can \n # run at all since we've confirmed above that the NOONs are correct.\n # Test CISD\n mycisd = ci.CISD(myhf).run()\n noons, natorbs = mcscf.addons.make_natural_orbitals(mycisd)\n mymc.kernel(natorbs)\n\n # Test CCSD\n myccsd = cc.CCSD(myhf).run()\n noons, natorbs = mcscf.addons.make_natural_orbitals(myccsd)\n mymc.kernel(natorbs)\n\n def test_state_average(self):\n mc = mcscf.CASSCF(mfr, 4, 4)\n mc.fcisolver = fci.solver(mol, singlet=False)\n mc.state_average_((.64,.36))\n e = mc.kernel()\n e = mc.e_states\n self.assertAlmostEqual(mc.e_tot, -108.83342083775061, 7)\n self.assertAlmostEqual(mc.e_average, -108.83342083775061, 7)\n self.assertAlmostEqual(e[0]*.64+e[1]*.36, -108.83342083775061, 7)\n dm1 = mc.analyze()\n self.assertAlmostEqual(lib.fp(dm1[0]), 0.52396929381500434, 4)\n\n self.assertRaises(TypeError, mc.state_average_, (.64,.36))\n\n def test_state_average_fci_dmrg(self):\n fcisolver1 = fci.direct_spin1_symm.FCISolver(mol)\n class FCI_as_DMRG(fci.direct_spin1_symm.FCISolver):\n def __getattribute__(self, attr):\n \"\"\"Prevent 'private' attribute access\"\"\"\n if attr in ('make_rdm1s', 'spin_square', 'contract_2e',\n 'absorb_h1e'):\n raise AttributeError\n else:\n return object.__getattribute__(self, attr)\n def kernel(self, *args, **kwargs):\n return fcisolver1.kernel(*args, **kwargs)\n def approx_kernel(self, *args, **kwargs):\n return fcisolver1.kernel(*args, **kwargs)\n @property\n def orbsym(self):\n return fcisolver1.orbsym\n @orbsym.setter\n def orbsym(self, x):\n fcisolver1.orbsym = x\n spin_square = None\n large_ci = None\n transform_ci_for_orbital_rotation = None\n\n mc = mcscf.CASSCF(mfr, 4, 4)\n mc.fcisolver = FCI_as_DMRG(mol)\n mc.fcisolver.nroots = fcisolver1.nroots = 2\n mc.state_average_((.64,.36))\n mc.kernel()\n e = mc.e_states\n self.assertAlmostEqual(e[0]*.64+e[1]*.36, -108.83342083775061, 7)\n dm1 = mc.analyze()\n self.assertAlmostEqual(lib.fp(dm1[0]), 0.52396929381500434*2, 4)\n\n def test_state_average_mix(self):\n solver1 = fci.FCI(mol)\n solver1.spin = 0\n solver1.nroots = 2\n solver2 = fci.FCI(mol, singlet=False)\n solver2.spin = 2\n mc = mcscf.CASSCF(mfr, 4, 4)\n mc = mcscf.addons.state_average_mix_(mc, [solver1, solver2],\n (0.25,0.25,0.5))\n mc.kernel()\n e = mc.e_states\n self.assertAlmostEqual(mc.e_tot, -108.80340952016508, 7)\n self.assertAlmostEqual(mc.e_average, -108.80340952016508, 7)\n self.assertAlmostEqual(numpy.dot(e,[.25,.25,.5]), -108.80340952016508, 7)\n dm1 = mc.analyze()\n self.assertAlmostEqual(lib.fp(dm1[0]), 0.52172669549357464, 4)\n self.assertAlmostEqual(lib.fp(dm1[1]), 0.53366776017869022, 4)\n self.assertAlmostEqual(lib.fp(dm1[0]+dm1[1]), 1.0553944556722636, 4)\n\n mc.cas_natorb()\n\n def test_state_average_mix_fci_dmrg(self):\n fcisolver1 = fci.direct_spin0_symm.FCISolver(mol)\n class FCI_as_DMRG(fci.direct_spin0_symm.FCISolver):\n def __getattribute__(self, attr):\n \"\"\"Prevent 'private' attribute access\"\"\"\n if attr in ('make_rdm1s', 'spin_square', 'contract_2e',\n 'absorb_h1e'):\n raise AttributeError\n else:\n return object.__getattribute__(self, attr)\n def kernel(self, *args, **kwargs):\n return fcisolver1.kernel(*args, **kwargs)\n def approx_kernel(self, *args, **kwargs):\n return fcisolver1.kernel(*args, **kwargs)\n @property\n def orbsym(self):\n return fcisolver1.orbsym\n @orbsym.setter\n def orbsym(self, x):\n fcisolver1.orbsym = x\n spin_square = None\n large_ci = None\n transform_ci_for_orbital_rotation = None\n\n solver1 = FCI_as_DMRG(mol)\n solver1.spin = fcisolver1.spin = 0\n solver1.nroots = fcisolver1.nroots = 2\n solver2 = fci.FCI(mol, singlet=False)\n solver2.spin = 2\n mc = mcscf.CASSCF(mfr, 4, 4)\n mc = mcscf.addons.state_average_mix_(mc, [solver1, solver2],\n (0.25,0.25,0.5))\n mc.kernel()\n e = mc.e_states\n self.assertAlmostEqual(numpy.dot(e, [.25,.25,.5]), -108.80340952016508, 7)\n dm1 = mc.analyze()\n self.assertAlmostEqual(lib.fp(dm1[0]), 1.0553944556722636, 4)\n self.assertEqual(dm1[1], None)\n\n mc.cas_natorb()\n\n def test_state_specific(self):\n mc = mcscf.CASSCF(mfr, 4, 4)\n mc.fcisolver = fci.solver(mol, singlet=False)\n mc.state_specific_(state=1)\n e = mc.kernel()[0]\n self.assertAlmostEqual(e, -108.70065770892457, 7)\n dm1 = mc.analyze()\n self.assertAlmostEqual(lib.fp(dm1[0]), 0.54605283139098515, 4)\n\n mc = mcscf.CASSCF(mfr, 4, 4)\n mc.state_specific_(state=0)\n e = mc.kernel()[0]\n self.assertAlmostEqual(mc.e_tot, mcr.e_tot, 7)\n dm1 = mc.analyze()\n dmref = mcr.analyze()\n self.assertAlmostEqual(float(abs(dm1[0]-dmref[0]).max()), 0, 4)\n\n def test_project_init_guess_geom (self):\n mfr_mo_norm = numpy.einsum ('ip,ip->p', mfr.mo_coeff.conj (),\n mfr_prg.get_ovlp ().dot (mfr.mo_coeff))\n mfr_mo_norm = mfr.mo_coeff / numpy.sqrt (mfr_mo_norm)[None,:]\n mo1 = mcscf.addons.project_init_guess (mcr_prg, mfr.mo_coeff)\n s1 = reduce(numpy.dot, (mo1.T, mfr_prg.get_ovlp(), mo1))\n self.assertEqual(numpy.count_nonzero(numpy.linalg.eigh(s1)[0]>1e-10),\n s1.shape[0])\n self.assertAlmostEqual(numpy.linalg.norm(s1), 5.2915026221291841, 9)\n\n def test_project_init_guess_basis (self):\n mo1 = mcscf.addons.project_init_guess (mcr_prb, mfr.mo_coeff, prev_mol=mfr.mol)\n s1 = reduce(numpy.dot, (mo1.T, mfr_prb.get_ovlp(), mo1))\n self.assertEqual(numpy.count_nonzero(numpy.linalg.eigh(s1)[0]>1e-10),\n s1.shape[0])\n self.assertAlmostEqual(numpy.linalg.norm(s1), 6.782329983125268, 9)\n \n def test_project_init_guess_uhf (self): \n mo1_u = mcscf.addons.project_init_guess (mcu_prg, mfu.mo_coeff)\n for mo1 in mo1_u:\n s1 = reduce(numpy.dot, (mo1.T, mfu_prg.get_ovlp(), mo1))\n self.assertEqual(numpy.count_nonzero(numpy.linalg.eigh(s1)[0]>1e-10),\n s1.shape[0])\n self.assertAlmostEqual(numpy.linalg.norm(s1), 5.2915026221291841, 9)\n\n def test_project_init_guess_activefirst (self):\n with lib.temporary_env (mcr_prg, ncas=6, ncore=3):\n mo1 = mcscf.addons.project_init_guess (mcr_prg, mfr.mo_coeff, priority='active')\n s1 = reduce(numpy.dot, (mo1.T, mfr_prg.get_ovlp(), mo1))\n self.assertEqual(numpy.count_nonzero(numpy.linalg.eigh(s1)[0]>1e-10),\n s1.shape[0])\n self.assertAlmostEqual(numpy.linalg.norm(s1), 5.2915026221291841, 9)\n mfr_mo_norm = numpy.einsum ('ip,ip->p', mfr.mo_coeff.conj (),\n mfr_prg.get_ovlp ().dot (mfr.mo_coeff))\n mfr_mo_norm = mfr.mo_coeff / numpy.sqrt (mfr_mo_norm)[None,:]\n s2 = [reduce (numpy.dot, (mfr_prg.get_ovlp (), mo1[:,i], mfr_mo_norm[:,i]))\n for i in (1,3)] # core, active (same irrep)\n self.assertAlmostEqual (s2[1], 1.0, 9)\n self.assertFalse (s2[0] > s2[1])\n\n def test_project_init_guess_corefirst (self):\n with lib.temporary_env (mcr_prg, ncas=6, ncore=3):\n mo1 = mcscf.addons.project_init_guess (mcr_prg, mfr.mo_coeff, priority='core')\n s1 = reduce(numpy.dot, (mo1.T, mfr_prg.get_ovlp(), mo1))\n self.assertEqual(numpy.count_nonzero(numpy.linalg.eigh(s1)[0]>1e-10),\n s1.shape[0])\n self.assertAlmostEqual(numpy.linalg.norm(s1), 5.2915026221291841, 9)\n mfr_mo_norm = numpy.einsum ('ip,ip->p', mfr.mo_coeff.conj (),\n mfr_prg.get_ovlp ().dot (mfr.mo_coeff))\n mfr_mo_norm = mfr.mo_coeff / numpy.sqrt (mfr_mo_norm)[None,:]\n s1 = [reduce (numpy.dot, (mfr_prg.get_ovlp (), mo1[:,i], mfr_mo_norm[:,i]))\n for i in (1,3)] # core, active (same irrep)\n self.assertAlmostEqual (s1[0], 1.0, 9)\n self.assertTrue (s1[0] > s1[1])\n\n def test_project_init_guess_gramschmidt (self):\n gram_schmidt_idx = numpy.arange (27, dtype=numpy.integer)[:,None].tolist ()\n mo1 = mcscf.addons.project_init_guess (mcr_prg, mfr.mo_coeff, priority=gram_schmidt_idx)\n s1 = reduce(numpy.dot, (mo1.T, mfr_prg.get_ovlp(), mo1))\n self.assertEqual(numpy.count_nonzero(numpy.linalg.eigh(s1)[0]>1e-10),\n s1.shape[0])\n self.assertAlmostEqual(numpy.linalg.norm(s1), 5.2915026221291841, 9)\n mf2moi = reduce (numpy.dot, (mfr_prg.mo_coeff.conj ().T, mfr_prg.get_ovlp (), mfr.mo_coeff))\n Q, R = scipy.linalg.qr (mf2moi) # Arbitrary sign, so abs below\n mo2 = numpy.dot (mfr_prg.mo_coeff, Q)\n s2 = numpy.abs (reduce (numpy.dot, (mo1.conj ().T, mfr_prg.get_ovlp (), mo2)))\n self.assertAlmostEqual(numpy.linalg.norm(s2), 5.2915026221291841, 9)\n\n def test_project_init_guess_prioritylists (self):\n pr = [[[27],[5,3],[6,12]],[[5],[17],[13,10,8,6]]]\n mo1_u = mcscf.addons.project_init_guess (mcu_prg, mfu.mo_coeff, priority=pr)\n s0 = mfu_prg.get_ovlp ()\n for ix, mo1 in enumerate (mo1_u):\n s1 = reduce(numpy.dot, (mo1.T, s0, mo1))\n self.assertEqual(numpy.count_nonzero(numpy.linalg.eigh(s1)[0]>1e-10),\n s1.shape[0])\n self.assertAlmostEqual(numpy.linalg.norm(s1), 5.2915026221291841, 9)\n mfu_mo = mfu.mo_coeff[ix]\n mfu_mo_norm = numpy.einsum ('ip,ip->p', mfu_mo.conj (), s0.dot (mfu_mo))\n mfu_mo_norm = mfu.mo_coeff[ix] / numpy.sqrt (mfu_mo_norm)[None,:]\n p = pr[ix][0][0]\n s2 = reduce (numpy.dot, (mfu_prg.get_ovlp (), mo1[:,p], mfu_mo_norm[:,p]))\n self.assertAlmostEqual (s2, 1.0, 9)\n\n def test_project_init_guess_usehfcore (self):\n mo1 = mcscf.addons.project_init_guess (mcr_prg, mfr.mo_coeff, use_hf_core=True)\n s1 = reduce(numpy.dot, (mo1.T, mfr_prg.get_ovlp(), mo1))\n self.assertEqual(numpy.count_nonzero(numpy.linalg.eigh(s1)[0]>1e-10),\n s1.shape[0])\n self.assertAlmostEqual(numpy.linalg.norm(s1), 5.2915026221291841, 9)\n s2 = reduce (numpy.dot, (mo1[:,:5].T, mfr_prg.get_ovlp (), mfr_prg.mo_coeff[:,:5]))\n self.assertEqual(numpy.count_nonzero(numpy.linalg.eigh(s2)[0]>1e-10),\n s2.shape[0])\n self.assertAlmostEqual (numpy.linalg.norm (s2), 2.23606797749979, 9)\n\n\n def test_state_average_bad_init_guess(self):\n mc = mcscf.CASCI(mfr, 4, 4)\n mc.run()\n mc.state_average_([.8, .2])\n mscan = mc.as_scanner()\n e = mscan(mol)\n self.assertAlmostEqual(e, -108.84390277715984, 9)\n\n\nif __name__ == \"__main__\":\n print(\"Full Tests for mcscf.addons\")\n unittest.main()\n\n"
] | [
[
"numpy.sqrt",
"numpy.allclose",
"numpy.linalg.eigh",
"numpy.random.seed",
"numpy.linalg.svd",
"numpy.random.random",
"scipy.linalg.qr",
"numpy.arange",
"numpy.einsum",
"numpy.dot",
"numpy.linalg.norm"
]
] |
C3Imaging/SyntheticHeadPose | [
"b139aeda41ace2a07138705a4997d2ea65cb11a6"
] | [
"HPEDA/FSANet_Train.py"
] | [
"import time\nimport sys\nimport argparse\nimport datetime\nimport pathlib\nimport numpy as np\n\nimport torch\nimport torch.nn as nn\nfrom torch.autograd import Variable\n\n# Set seed\ntorch.manual_seed(0)\n\n# Where to add a new import\nfrom torch.optim.lr_scheduler import StepLR\n\n# from torch.utils.tensorboard import SummaryWriter\n# from torchsummary import summary\n# from torchsummaryX import summary\n\nimport datasets\nfrom HPEDA.FSANetDA import FSANet\nfrom utils import AverageMeter\n\n\ndef parse_args():\n \"\"\"Parse input arguments.\"\"\"\n parser = argparse.ArgumentParser(description='Monocular Head Pose Estimation from Synthetic Data')\n parser.add_argument('--gpu', dest='gpu_id', help='GPU device id to use [0]',\n default=0, type=int)\n parser.add_argument('--epochs', dest='epochs', help='Maximum number of training epochs.',\n default=40, type=int)\n parser.add_argument('--bs', dest='batch_size', help='Batch size.',\n default=8, type=int)\n parser.add_argument('--lr', dest='lr', help='Base learning rate.',\n default=0.0001, type=float)\n parser.add_argument(\"--validation_split\", type=float, default=0.01,\n help=\"validation split ratio\")\n parser.add_argument('--data_dir', dest='data_dir', help='Directory path for data.',\n default='/mnt/fastssd/Shubhajit_Stuff/HPECode/Data/BIWI/',\n type=str)\n parser.add_argument('--filename_list', dest='filename_list',\n help='Path to text file containing relative paths for every example.',\n default='/mnt/fastssd/Shubhajit_Stuff/HPECode/Data/Mixed/RawNPY.txt',\n type=str)\n parser.add_argument('--output_string', dest='output_string', help='String appended to output snapshots.',\n default='BIWIRaw', type=str)\n\n # Pose_Synth_Raw | PoseSynthNPY\n parser.add_argument('--dataset', dest='dataset', help='Dataset type.', default='Pose_BIWI_NPY', type=str)\n\n args = parser.parse_args()\n return args\n\n\ndef main():\n\n # Parse Arguments\n args = parse_args()\n\n # get device GPU or CPU\n device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n\n # Load Dataset\n if args.dataset == 'PoseSynthNPY':\n pose_dataset = datasets.Pose_Synth_NPY(args.data_dir, args.filename_list)\n elif args.dataset == 'Pose_Synth_Raw':\n pose_dataset = datasets.Pose_Synth_Raw(args.data_dir, args.filename_list)\n elif args.dataset == 'PoseSynRealRaw':\n pose_dataset = datasets.Pose_Synth_Raw_RB(args.data_dir, args.filename_list)\n elif args.dataset == 'Pose_BIWI_NPY':\n pose_dataset = datasets.Pose_BIWI_NPY(args.data_dir, args.filename_list)\n elif args.dataset == 'Pose_Synth_NPYDA':\n pose_dataset = datasets.Pose_Synth_NPYDA(args.data_dir, args.filename_list)\n else:\n print('Error: not a valid dataset name')\n sys.exit()\n\n # hyper parameters & Model Params\n num_capsule = 3\n dim_capsule = 16\n routings = 5\n\n num_primcaps = 7 * 3\n m_dim = 5\n s_set = [num_capsule, dim_capsule, routings, num_primcaps, m_dim]\n\n model = FSANet(s_set).cuda()\n print('Model created.')\n\n # print(summary(model, torch.rand((1, 3, 64, 64)).cuda()))\n\n # get multiple GPU\n if torch.cuda.device_count() > 1:\n print(\"Let's use\", torch.cuda.device_count(), \"GPUs!\")\n model = nn.DataParallel(model)\n\n # load model to GPU\n model.to(device)\n\n # transfer learning\n # modelPath = r'models/MySynthNPY_11-22-2020_21-41-04-n8857-e100-bs8-lr0.0001/weights.epoch89_model.pth'\n # model.load_state_dict(torch.load(modelPath))\n\n # Training parameters\n optimizer = torch.optim.Adam(model.parameters(), args.lr)\n batch_size = args.batch_size\n\n # Load train loader\n train_loader = torch.utils.data.DataLoader(dataset=pose_dataset,\n batch_size=batch_size,\n drop_last=True,\n shuffle=True,\n num_workers=2)\n\n # Loss\n l1_criterion = nn.L1Loss()\n nll_criterion = nn.NLLLoss() # domain adaptation\n\n now = datetime.datetime.now() # current date and time\n runID = args.output_string + now.strftime(\"_%m-%d-%Y_%H-%M-%S\") \\\n + '-n' + str(len(train_loader)) \\\n + '-e' + str(args.epochs) \\\n + '-bs' + str(batch_size) \\\n + '-lr' + str(args.lr)\n outputPath = './models/'\n runPath = outputPath + runID\n pathlib.Path(runPath).mkdir(parents=True, exist_ok=True)\n\n # gamma = decaying factor (lr decayed on each step_size epoch with a rate of gamma\n # scheduler = StepLR(optimizer, step_size=2, gamma=0.1)\n\n # Start training...\n for epoch in range(args.epochs):\n batch_time = AverageMeter()\n losses = AverageMeter()\n N = len(train_loader)\n\n # print('###################################### Epoch :', str(epoch))\n\n # Switch to train mode\n model.train()\n end = time.time()\n\n # Decay Learning Rate\n # scheduler.step()\n\n for i, (images, cont_labels) in enumerate(train_loader):\n\n optimizer.zero_grad()\n\n images = Variable(images).cuda()\n label_angles = Variable(cont_labels[:, :3]).cuda(non_blocking=True)\n\n # Predict\n angles, _ = model(images, alpha=0.1)\n\n # Compute the loss\n l1_pose = l1_criterion(angles, label_angles)\n\n loss = l1_pose\n\n # Update step\n losses.update(loss.data.item(), images.size(0))\n loss.backward()\n optimizer.step()\n\n # Measure elapsed time\n batch_time.update(time.time() - end)\n end = time.time()\n eta = str(datetime.timedelta(seconds=int(batch_time.val * (N - i))))\n\n # Log progress\n if i % 5 == 0:\n # Print to console\n print('Epoch: [{0}][{1}/{2}]\\t'\n 'Time {batch_time.val:.3f} ({batch_time.sum:.3f})\\t'\n 'ETA {eta}\\t'\n 'Loss {loss.val:.4f} ({loss.avg:.4f})\\t'\n 'L1_Loss: {l1_loss:.4f}'\n .format(epoch, i, N,\n batch_time=batch_time,\n loss=losses,\n eta=eta,\n l1_loss=l1_pose\n ))\n\n # save Model intermediate\n path = runPath + '/weights.epoch{0}_model.pth'.format(epoch)\n torch.save(model.cpu().state_dict(), path) # saving model\n model.cuda()\n\n # Start DA Training\n # for epoch in range(args.epochs):\n # batch_time = AverageMeter()\n # losses = AverageMeter()\n # N = len(train_loader)\n #\n # # print('###################################### Epoch :', str(epoch))\n #\n # # Switch to train mode\n # model.train()\n #\n # end = time.time()\n #\n #\n #\n # for i, (images, cont_labels, biwiImages) in enumerate(train_loader):\n #\n # p = float(i + epoch * N) / args.epochs / N\n # alpha = 2. / (1. + np.exp(-10 * p)) - 1\n #\n # optimizer.zero_grad()\n #\n # source_images = Variable(images).cuda()\n # label_angles = Variable(cont_labels[:, :3]).cuda(non_blocking=True)\n # source_domain_label = torch.zeros(batch_size)\n # source_domain_label = source_domain_label.long().cuda()\n #\n # target_images = Variable(biwiImages).cuda()\n # target_domain_label = torch.ones(batch_size)\n # target_domain_label = target_domain_label.long().cuda()\n #\n # # Predict source domain\n # angles, source_domain_output = model(source_images, alpha=alpha)\n #\n # # Compute the loss in source domain\n # l1_pose = l1_criterion(angles, label_angles)\n # nll_source = nll_criterion(source_domain_output, source_domain_label)\n #\n # # Predict target domain\n # _, target_domain_output = model(target_images, alpha=alpha)\n #\n # # Compute the loss in target domain\n # nll_target = nll_criterion(target_domain_output, target_domain_label)\n #\n # loss = 0.2*l1_pose + 1.5*nll_source + 1.5*nll_target\n #\n #\n #\n # # Update step\n # losses.update(loss.data.item(), images.size(0))\n # loss.backward()\n # optimizer.step()\n #\n # # Measure elapsed time\n # batch_time.update(time.time() - end)\n # end = time.time()\n # eta = str(datetime.timedelta(seconds=int(batch_time.val * (N - i))))\n #\n # # Log progress\n # if i % 5 == 0:\n # # Print to console\n # print('Epoch: [{0}][{1}/{2}]\\t'\n # 'Time {batch_time.val:.3f} ({batch_time.sum:.3f})\\t'\n # 'ETA {eta}\\t'\n # 'Loss {loss.val:.4f} ({loss.avg:.4f})\\t'\n # 'L1_Loss: {l1_loss:.4f}'\n # .format(epoch, i, N,\n # batch_time=batch_time,\n # loss=losses,\n # eta=eta,\n # l1_loss=l1_pose\n # ))\n #\n # # save Model intermediate\n # path = runPath + '/weights.epoch{0}_model.pth'.format(epoch)\n # torch.save(model.cpu().state_dict(), path) # saving model\n # model.cuda()\n\n\nif __name__ == '__main__':\n main()\n\n"
] | [
[
"torch.utils.data.DataLoader",
"torch.nn.NLLLoss",
"torch.manual_seed",
"torch.nn.L1Loss",
"torch.autograd.Variable",
"torch.cuda.device_count",
"torch.cuda.is_available",
"torch.nn.DataParallel"
]
] |
bpmunson/ctg | [
"1407f652fe7aa7df0566d8f619437515aab2e380"
] | [
"tests/compare_with_ctg/fit_ac_fc/compare_fit_ac_fc.py"
] | [
"import numpy as np\nimport pandas as pd\n\nimport os\nimport sys\nsys.path.insert(0, \"../../../ctg/core\")\n\n#from fit_ac_fc import *\nfrom fit_ac_fc2 import Counts\nfrom config import config\n\nabundance_file = os.path.join(config.A549_test, \"A549_abundance_thresholds.txt\")\ncounts_file = os.path.join(config.A549_test, \"A549_timepoint_counts.txt\")\n#times = np.array([[3,14, 21, 28], [3,14,21,28]])\ntimes = np.array([3,14,21,28])\n\n#ac, fc, allbad, sdfc, df, p_t, lfdr, names, lmbda, xfit, mask = fit_ac_fc(abundance_file, counts_file, times)\n#ac, fc, allbad, sdfc, df, p_t, lfdr = fit_ac_fc(abundance_file, counts_file, times)\n#ac, fc, allbad, sdfc, p_t, names = fit_ac_fc(abundance_file, counts_file, times)\n\nfilesList = ['a1_ctg.csv',\n 'a2_ctg.csv',\n 'allbad_ctg.csv',\n 'df_ctg.csv',\n 'fc_ctg.csv',\n 'lfdr_fc_ctg.csv',\n 'p_t_ctg.csv',\n 'sdfc_ctg.csv',\n 'lambda1_ctg.csv',\n 'lambda2_ctg.csv',\n 'xfit1_ctg.csv',\n 'xfit2_ctg.csv',\n 'good1_ctg.csv',\n 'good2_ctg.csv']\n\n# for fn in filesList:\n# pd.read_csv(fn)\n\ndef compare_a():\n a1_df = pd.read_csv(filesList[0])\n a2_df = pd.read_csv(filesList[1])\n\n assert (a1_df.iloc[:,0] != a2_df.iloc[:,0]).sum() == 0\n\n ac_ctg = pd.DataFrame([a1_df.iloc[:,1], a2_df.iloc[:,1]],).T\n ac_ctg.index = a1_df.iloc[:,0]\n\n assert np.allclose(ac_ctg.as_matrix(), ac.T)\n\ndef comapre_fc():\n fc_ctg = pd.read_csv(filesList[4], index_col=0)\n\n assert np.allclose(fc_ctg.as_matrix().ravel(), fc)\n\ndef compare_allbad():\n allbad_ctg = pd.read_csv(filesList[2], index_col=0)\n\n assert (allbad_ctg.as_matrix().ravel() == np.array(allbad)).all()\n\ndef compare_sdfc():\n sdfc_ctg = pd.read_csv(filesList[7], index_col=0)\n\n # print(sdfc)\n # print(sdfc_ctg.as_matrix().ravel())\n\n assert np.allclose(sdfc, sdfc_ctg.as_matrix().ravel())\n\ndef compare_df():\n df_ctg = pd.read_csv(filesList[3], index_col=0)\n\n assert np.allclose(df_ctg.as_matrix().ravel(), df)\n\ndef compare_p_t():\n p_t_ctg = pd.read_csv(filesList[6], index_col=0)\n\n assert np.allclose(p_t_ctg.as_matrix().ravel(), p_t)\n\ndef compare_lfdr():\n lfdr_ctg = pd.read_csv(filesList[5], index_col=0)\n\n print(lfdr_ctg.as_matrix().ravel())\n print(lfdr)\n\n print(np.allclose(lfdr_ctg.as_matrix().ravel(), lfdr))\n\ndef _compare_lambda():\n #Note: lambda is usually not returned. Use for debugging\n lmbda1_df = pd.read_csv(filesList[8], index_col=0)\n lmbda2_df = pd.read_csv(filesList[9], index_col=0)\n\n lmbda_ctg = pd.DataFrame([lmbda1_df.iloc[:,0], lmbda2_df.iloc[:,0]],).T\n\n assert np.allclose(lmbda_ctg.as_matrix(), lmbda.T)\n\ndef _compare_xfit():\n xfit1_df = pd.read_csv(filesList[10], index_col=0)\n xfit2_df = pd.read_csv(filesList[11], index_col=0)\n\n assert np.allclose(xfit1_df.as_matrix(), xfit[0])\n assert np.allclose(xfit2_df.as_matrix(), xfit[1])\n\ndef _compare_mask():\n good1_df = pd.read_csv(filesList[12], index_col=0)\n good2_df = pd.read_csv(filesList[13], index_col=0)\n\n assert np.allclose(good1_df.as_matrix(), mask[0])\n assert np.allclose(good2_df.as_matrix(), mask[1])\n\nif __name__ == \"__main__\":\n def test_suite(): \n compare_a()\n comapre_fc()\n compare_allbad()\n compare_sdfc()\n #compare_df()\n #compare_p_t()\n #compare_lfdr()\n\n # _compare_lambda()\n # _compare_xfit()\n # _compare_mask()\n\n def fit_ac_fc(abundance_file, counts_file, times): \n if isinstance(counts_file, str): \n c = Counts.from_file(counts_file)\n c.fit_ac_fc(pd.read_csv(abundance_file, sep='\\t', index_col=0))\n\n else: \n c = Counts(counts_file)\n c.fit_ac_fc(pd.read_csv(abundance_file, sep='\\t', index_col=0))\n\n return c.ac, c.fitness, c.mask.allbad, c.sdfc, c.p_t, c.names\n\n global ac, fc, allbad, sdfc, p_t, names\n\n #Testing files input\n ac, fc, allbad, sdfc, p_t, names = fit_ac_fc(abundance_file, counts_file, times)\n test_suite()\n\n print('Passed file inputs (implicit)')\n\n # #Testing files input\n # ac, fc, allbad, sdfc, p_t, names = fit_ac_fc(abundance_file, counts_file, times, method='explicit', \n # n_reps=2, \n # columns_map=[[0,1],[2,3],[4,5],[6,7]])\n # test_suite() \n # print('Paseed file inputs (explicit)')\n\n #Testing dataframe input\n counts_df = pd.read_csv(counts_file, sep='\\s+')\n ac, fc, allbad, sdfc, p_t, names = fit_ac_fc(abundance_file, counts_df, times)\n test_suite()\n\n print('Passed dataframe input (implicit)')\n\n #Testing explicit method\n # ac, fc, allbad, sdfc, p_t, names = fit_ac_fc(abundance_file, counts_df, times, method='explicit', \n # n_reps=2, \n # columns_map=[[0,1],[2,3],[4,5],[6,7]])\n # test_suite()\n # print('Passed dataframe input (explicit')\n\n #TODO: Test changing the column order\n"
] | [
[
"numpy.array",
"pandas.DataFrame",
"pandas.read_csv"
]
] |
mavabene/ROAR | [
"51955293ad87128ec2c549142abf91d45314f380"
] | [
"ROAR/planning_module/mission_planner/waypoint_following_mission_planner.py"
] | [
"from ROAR.planning_module.mission_planner.mission_planner import (\n MissionPlanner,\n)\nfrom pathlib import Path\nimport logging\nfrom typing import List, Optional\nfrom ROAR.utilities_module.data_structures_models import Transform, Location, Rotation\nfrom collections import deque\nfrom ROAR.agent_module.agent import Agent\nimport numpy as np\n\n\nclass WaypointFollowingMissionPlanner(MissionPlanner):\n \"\"\"\n A mission planner that takes in a file that contains x,y,z coordinates, formulate into carla.Transform\n \"\"\"\n\n def run_in_series(self) -> deque:\n \"\"\"\n Regenerate waypoints from file\n Find the waypoint that is closest to the current vehicle location.\n return a mission plan starting from that waypoint\n\n Args:\n vehicle: current state of the vehicle\n\n Returns:\n mission plan that start from the current vehicle location\n \"\"\"\n super(WaypointFollowingMissionPlanner, self).run_in_series()\n return self.produce_mission_plan()\n\n def __init__(self, agent: Agent):\n super().__init__(agent=agent)\n self.logger = logging.getLogger(__name__)\n self.file_path: Path = Path(self.agent.agent_settings.waypoint_file_path)\n self.mission_plan = self.produce_mission_plan()\n self.logger.debug(\"Path Following Mission Planner Initiated.\")\n\n def produce_mission_plan(self) -> deque:\n \"\"\"\n Generates a list of waypoints based on the input file path\n :return a list of waypoint\n \"\"\"\n raw_path: List[List[float]] = self._read_data_file()\n length = self.agent.agent_settings.num_laps * len(raw_path)\n #mission_plan = deque(maxlen=length)\n mission_plan = deque(maxlen=11*length)\n\n for coord in np.tile(raw_path, (self.agent.agent_settings.num_laps, 1)):\n if len(coord) == 3 or len(coord) == 6:\n mission_plan.append(self._raw_coord_to_transform(coord))\n self.logger.debug(f\"Computed Mission path of length [{len(mission_plan)}]\")\n return mission_plan\n\n def produce_single_lap_mission_plan(self):\n raw_path: List[List[float]] = self._read_data_file()\n mission_plan = deque(maxlen=len(raw_path))\n for coord in raw_path:\n if len(coord) == 3 or len(coord) == 6:\n mission_plan.append(self._raw_coord_to_transform(coord))\n self.logger.debug(f\"Computed Mission path of length [{len(mission_plan)}]\")\n return mission_plan\n\n def _read_data_file(self) -> List[List[float]]:\n \"\"\"\n Read data file and generate a list of (x, y, z) where each of x, y, z is of type float\n Returns:\n List of waypoints in format of [x, y, z]\n \"\"\"\n result = []\n with open(self.file_path.as_posix(), \"r\") as f:\n for line in f:\n result.append(self._read_line(line=line))\n return result\n\n def _raw_coord_to_transform(self, raw: List[float]) -> Optional[Transform]:\n \"\"\"\n transform coordinate to Transform instance\n\n Args:\n raw: coordinate in form of [x, y, z, pitch, yaw, roll]\n\n Returns:\n Transform instance\n \"\"\"\n if len(raw) == 3:\n return Transform(\n location=Location(x=raw[0], y=raw[1], z=raw[2]),\n rotation=Rotation(pitch=0, yaw=0, roll=0),\n )\n elif len(raw) == 6:\n return Transform(\n location=Location(x=raw[0], y=raw[1], z=raw[2]),\n rotation=Rotation(roll=raw[3], pitch=raw[4], yaw=raw[5]),\n )\n else:\n self.logger.error(f\"Point {raw} is invalid, skipping\")\n return None\n\n def _read_line(self, line: str) -> List[float]:\n \"\"\"\n parse a line of string of \"x,y,z\" into [x,y,z]\n Args:\n line: comma delimetered line\n\n Returns:\n [x, y, z]\n \"\"\"\n try:\n x, y, z = line.split(\",\")\n x, y, z = float(x), float(y), float(z)\n return [x, y, z]\n except:\n x, y, z, roll, pitch, yaw = line.split(\",\")\n return [float(x), float(y), float(z), float(roll), float(pitch), float(yaw)]\n"
] | [
[
"numpy.tile"
]
] |
ChouaibBELILITA/Final_year_Project | [
"688cdeaeabb46fc3f924bb29c2e92865be421d26"
] | [
"detect_video.py"
] | [
"import time\nfrom absl import app, flags, logging\nfrom absl.flags import FLAGS\nimport cv2\nimport tensorflow as tf\nfrom yolov3_tf2.models import (\n YoloV3, YoloV3Tiny\n)\nfrom yolov3_tf2.dataset import transform_images\nfrom yolov3_tf2.utils import draw_outputs\n\n\nflags.DEFINE_string('classes', './data/face.names', 'path to classes file')\nflags.DEFINE_string('weights', './checkpoints/yolov3_train_10.tf',\n 'path to weights file')\nflags.DEFINE_boolean('tiny', False, 'yolov3 or yolov3-tiny')\nflags.DEFINE_integer('size', 416, 'resize images to')\nflags.DEFINE_string('video', './DonaldTrump.mp4',\n 'path to video file or number for webcam)')\nflags.DEFINE_string('output', None, 'path to output video')\nflags.DEFINE_string('output_format', 'XVID', 'codec used in VideoWriter when saving video to file')\nflags.DEFINE_integer('num_classes', 80, 'number of classes in the model')\n\n\ndef main(_argv):\n physical_devices = tf.config.experimental.list_physical_devices('GPU')\n if len(physical_devices) > 0:\n tf.config.experimental.set_memory_growth(physical_devices[0], True)\n\n if FLAGS.tiny:\n yolo = YoloV3Tiny(classes=FLAGS.num_classes)\n else:\n yolo = YoloV3(classes=FLAGS.num_classes)\n\n yolo.load_weights(FLAGS.weights)\n logging.info('weights loaded')\n\n class_names = [c.strip() for c in open(FLAGS.classes).readlines()]\n logging.info('classes loaded')\n\n times = []\n\n try:\n vid = cv2.VideoCapture(int(FLAGS.video))\n except:\n vid = cv2.VideoCapture(FLAGS.video)\n\n out = None\n\n if FLAGS.output:\n width = int(vid.get(cv2.CAP_PROP_FRAME_WIDTH))\n height = int(vid.get(cv2.CAP_PROP_FRAME_HEIGHT))\n fps = int(vid.get(cv2.CAP_PROP_FPS))\n codec = cv2.VideoWriter_fourcc(*FLAGS.output_format)\n out = cv2.VideoWriter(FLAGS.output, codec, fps, (width, height))\n\n while True:\n _, img = vid.read()\n\n if img is None:\n logging.warning(\"Empty Frame\")\n time.sleep(0.1)\n continue\n\n img_in = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) \n img_in = tf.expand_dims(img_in, 0)\n img_in = transform_images(img_in, FLAGS.size)\n\n t1 = time.time()\n boxes, scores, classes, nums = yolo.predict(img_in)\n t2 = time.time()\n times.append(t2-t1)\n times = times[-20:]\n\n img = draw_outputs(img, (boxes, scores, classes, nums), class_names)\n img = cv2.putText(img, \"Time: {:.2f}ms\".format(sum(times)/len(times)*1000), (0, 30),\n cv2.FONT_HERSHEY_COMPLEX_SMALL, 1, (0, 0, 255), 2)\n if FLAGS.output:\n out.write(img)\n cv2.imshow('output', img)\n if cv2.waitKey(1) == ord('q'):\n break\n\n cv2.destroyAllWindows()\n\n\nif __name__ == '__main__':\n try:\n app.run(main)\n except SystemExit:\n pass\n"
] | [
[
"tensorflow.config.experimental.list_physical_devices",
"tensorflow.expand_dims",
"tensorflow.config.experimental.set_memory_growth"
]
] |
fangqyi/garage | [
"ddafba385ef005f46f913ab352f9638760e5b412",
"ddafba385ef005f46f913ab352f9638760e5b412",
"ddafba385ef005f46f913ab352f9638760e5b412"
] | [
"src/garage/tf/regressors/bernoulli_mlp_regressor.py",
"src/garage/tf/optimizers/first_order_optimizer.py",
"src/garage/replay_buffer/her_replay_buffer.py"
] | [
"\"\"\"Bernoulli MLP Regressor based on MLP with Normalized Inputs.\"\"\"\r\nfrom dowel import tabular\r\nimport numpy as np\r\nimport tensorflow as tf\r\n\r\nfrom garage.tf.distributions import Bernoulli\r\nfrom garage.tf.misc import tensor_utils\r\nfrom garage.tf.models import NormalizedInputMLPModel\r\nfrom garage.tf.optimizers import ConjugateGradientOptimizer, LbfgsOptimizer\r\nfrom garage.tf.regressors.regressor import StochasticRegressor\r\n\r\n\r\nclass BernoulliMLPRegressor(StochasticRegressor):\r\n \"\"\"Fits data to a Bernoulli distribution, parameterized by an MLP.\r\n\r\n Args:\r\n input_shape (tuple[int]): Input shape of the training data. Since an\r\n MLP model is used, implementation assumes flattened inputs. The\r\n input shape of each data point should thus be of shape (x, ).\r\n output_dim (int): Output dimension of the model.\r\n name (str): Model name, also the variable scope.\r\n hidden_sizes (list[int]): Output dimension of dense layer(s) for\r\n the MLP for the network. For example, (32, 32) means the MLP\r\n consists of two hidden layers, each with 32 hidden units.\r\n hidden_nonlinearity (Callable): Activation function for intermediate\r\n dense layer(s). It should return a tf.Tensor. Set it to\r\n None to maintain a linear activation.\r\n hidden_w_init (Callable): Initializer function for the weight\r\n of intermediate dense layer(s). The function should return a\r\n tf.Tensor. Default is Glorot uniform initializer.\r\n hidden_b_init (Callable): Initializer function for the bias\r\n of intermediate dense layer(s). The function should return a\r\n tf.Tensor. Default is zero initializer.\r\n output_nonlinearity (Callable): Activation function for output dense\r\n layer. It should return a tf.Tensor. Set it to None to\r\n maintain a linear activation.\r\n output_w_init (Callable): Initializer function for the weight\r\n of output dense layer(s). The function should return a\r\n tf.Tensor. Default is Glorot uniform initializer.\r\n output_b_init (Callable): Initializer function for the bias\r\n of output dense layer(s). The function should return a\r\n tf.Tensor. Default is zero initializer.\r\n optimizer (garage.tf.Optimizer): Optimizer for minimizing the negative\r\n log-likelihood. Defaults to LbsgsOptimizer\r\n optimizer_args (dict): Arguments for the optimizer. Default is None,\r\n which means no arguments.\r\n tr_optimizer (garage.tf.Optimizer): Optimizer for trust region\r\n approximation. Defaults to ConjugateGradientOptimizer.\r\n tr_optimizer_args (dict): Arguments for the trust region optimizer.\r\n Default is None, which means no arguments.\r\n use_trust_region (bool): Whether to use trust region constraint.\r\n max_kl_step (float): KL divergence constraint for each iteration.\r\n normalize_inputs (bool): Bool for normalizing inputs or not.\r\n layer_normalization (bool): Bool for using layer normalization or not.\r\n\r\n \"\"\"\r\n\r\n def __init__(self,\r\n input_shape,\r\n output_dim,\r\n name='BernoulliMLPRegressor',\r\n hidden_sizes=(32, 32),\r\n hidden_nonlinearity=tf.nn.relu,\r\n hidden_w_init=tf.initializers.glorot_uniform(),\r\n hidden_b_init=tf.zeros_initializer(),\r\n output_nonlinearity=tf.nn.sigmoid,\r\n output_w_init=tf.initializers.glorot_uniform(),\r\n output_b_init=tf.zeros_initializer(),\r\n optimizer=None,\r\n optimizer_args=None,\r\n tr_optimizer=None,\r\n tr_optimizer_args=None,\r\n use_trust_region=True,\r\n max_kl_step=0.01,\r\n normalize_inputs=True,\r\n layer_normalization=False):\r\n\r\n super().__init__(input_shape, output_dim, name)\r\n self._use_trust_region = use_trust_region\r\n self._max_kl_step = max_kl_step\r\n self._normalize_inputs = normalize_inputs\r\n\r\n with tf.compat.v1.variable_scope(self._name, reuse=False) as vs:\r\n self._variable_scope = vs\r\n if optimizer_args is None:\r\n optimizer_args = dict()\r\n if tr_optimizer_args is None:\r\n tr_optimizer_args = dict()\r\n\r\n if optimizer is None:\r\n optimizer = LbfgsOptimizer(**optimizer_args)\r\n else:\r\n optimizer = optimizer(**optimizer_args)\r\n\r\n if tr_optimizer is None:\r\n tr_optimizer = ConjugateGradientOptimizer(**tr_optimizer_args)\r\n else:\r\n tr_optimizer = tr_optimizer(**tr_optimizer_args)\r\n\r\n self._optimizer = optimizer\r\n self._tr_optimizer = tr_optimizer\r\n self._first_optimized = False\r\n\r\n self.model = NormalizedInputMLPModel(\r\n input_shape,\r\n output_dim,\r\n hidden_sizes=hidden_sizes,\r\n hidden_nonlinearity=hidden_nonlinearity,\r\n hidden_w_init=hidden_w_init,\r\n hidden_b_init=hidden_b_init,\r\n output_nonlinearity=output_nonlinearity,\r\n output_w_init=output_w_init,\r\n output_b_init=output_b_init,\r\n layer_normalization=layer_normalization)\r\n\r\n self._dist = Bernoulli(output_dim)\r\n\r\n self._initialize()\r\n\r\n def _initialize(self):\r\n input_var = tf.compat.v1.placeholder(tf.float32,\r\n shape=(None, ) +\r\n self._input_shape)\r\n\r\n with tf.compat.v1.variable_scope(self._variable_scope):\r\n self.model.build(input_var)\r\n\r\n ys_var = tf.compat.v1.placeholder(dtype=tf.float32,\r\n name='ys',\r\n shape=(None, self._output_dim))\r\n\r\n old_prob_var = tf.compat.v1.placeholder(dtype=tf.float32,\r\n name='old_prob',\r\n shape=(None,\r\n self._output_dim))\r\n\r\n y_hat = self.model.networks['default'].y_hat\r\n\r\n old_info_vars = dict(p=old_prob_var)\r\n info_vars = dict(p=y_hat)\r\n\r\n mean_kl = tf.reduce_mean(\r\n self._dist.kl_sym(old_info_vars, info_vars))\r\n\r\n loss = -tf.reduce_mean(\r\n self._dist.log_likelihood_sym(ys_var, info_vars))\r\n\r\n predicted = y_hat >= 0.5\r\n\r\n self._f_predict = tensor_utils.compile_function([input_var],\r\n predicted)\r\n self._f_prob = tensor_utils.compile_function([input_var], y_hat)\r\n\r\n self._optimizer.update_opt(loss=loss,\r\n target=self,\r\n inputs=[input_var, ys_var])\r\n self._tr_optimizer.update_opt(\r\n loss=loss,\r\n target=self,\r\n inputs=[input_var, ys_var, old_prob_var],\r\n leq_constraint=(mean_kl, self._max_kl_step))\r\n\r\n def fit(self, xs, ys):\r\n \"\"\"Fit with input data xs and label ys.\r\n\r\n Args:\r\n xs (numpy.ndarray): Input data.\r\n ys (numpy.ndarray): Label of input data.\r\n\r\n \"\"\"\r\n if self._normalize_inputs:\r\n # recompute normalizing constants for inputs\r\n self.model.networks['default'].x_mean.load(\r\n np.mean(xs, axis=0, keepdims=True))\r\n self.model.networks['default'].x_std.load(\r\n np.std(xs, axis=0, keepdims=True) + 1e-8)\r\n\r\n if self._use_trust_region and self._first_optimized:\r\n # To use trust region constraint and optimizer\r\n old_prob = self._f_prob(xs)\r\n inputs = [xs, ys, old_prob]\r\n optimizer = self._tr_optimizer\r\n else:\r\n inputs = [xs, ys]\r\n optimizer = self._optimizer\r\n loss_before = optimizer.loss(inputs)\r\n tabular.record('{}/LossBefore'.format(self._name), loss_before)\r\n optimizer.optimize(inputs)\r\n loss_after = optimizer.loss(inputs)\r\n tabular.record('{}/LossAfter'.format(self._name), loss_after)\r\n tabular.record('{}/dLoss'.format(self._name), loss_before - loss_after)\r\n self._first_optimized = True\r\n\r\n def predict(self, xs):\r\n \"\"\"Predict ys based on input xs.\r\n\r\n Args:\r\n xs (numpy.ndarray): Input data of shape (samples, input_dim)\r\n\r\n Return:\r\n numpy.ndarray: The deterministic predicted ys (one hot vectors)\r\n of shape (samples, output_dim)\r\n\r\n \"\"\"\r\n return self._f_predict(xs)\r\n\r\n def sample_predict(self, xs):\r\n \"\"\"Do a Bernoulli sampling given input xs.\r\n\r\n Args:\r\n xs (numpy.ndarray): Input data of shape (samples, input_dim)\r\n\r\n Returns:\r\n numpy.ndarray: The stochastic sampled ys\r\n of shape (samples, output_dim)\r\n\r\n \"\"\"\r\n p = self._f_prob(xs)\r\n return self._dist.sample(dict(p=p))\r\n\r\n def predict_log_likelihood(self, xs, ys):\r\n \"\"\"Log likelihood of ys given input xs.\r\n\r\n Args:\r\n xs (numpy.ndarray): Input data of shape (samples, input_dim)\r\n ys (numpy.ndarray): Output data of shape (samples, output_dim)\r\n\r\n Returns:\r\n numpy.ndarray: The log likelihood of shape (samples, )\r\n\r\n \"\"\"\r\n p = self._f_prob(xs)\r\n return self._dist.log_likelihood(ys, dict(p=p))\r\n\r\n def log_likelihood_sym(self, x_var, y_var, name=None):\r\n \"\"\"Build a symbolic graph of the log-likelihood.\r\n\r\n Args:\r\n x_var (tf.Tensor): Input tf.Tensor for the input data.\r\n y_var (tf.Tensor): Input tf.Tensor for the one hot label of data.\r\n name (str): Name of the new graph.\r\n\r\n Return:\r\n tf.Tensor: Output of the symbolic log-likelihood graph.\r\n\r\n \"\"\"\r\n with tf.compat.v1.variable_scope(self._variable_scope):\r\n prob, _, _ = self.model.build(x_var, name=name)\r\n\r\n return self._dist.log_likelihood_sym(y_var, dict(p=prob))\r\n\r\n def dist_info_sym(self, input_var, state_info_vars=None, name=None):\r\n \"\"\"Build a symbolic graph of the distribution parameters.\r\n\r\n Args:\r\n input_var (tf.Tensor): Input tf.Tensor for the input data.\r\n state_info_vars (dict): a dictionary whose values should contain\r\n information about the state of the regressor at the time it\r\n received the input.\r\n name (str): Name of the new graph.\r\n\r\n Return:\r\n dict[tf.Tensor]: Output of the symbolic graph of the distribution\r\n parameters.\r\n\r\n \"\"\"\r\n with tf.compat.v1.variable_scope(self._variable_scope):\r\n prob, _, _ = self.model.build(input_var, name=name)\r\n\r\n return dict(prob=prob)\r\n\r\n @property\r\n def recurrent(self):\r\n \"\"\"bool: If this module has a hidden state.\"\"\"\r\n return False\r\n\r\n @property\r\n def vectorized(self):\r\n \"\"\"bool: If this module supports vectorization input.\"\"\"\r\n return True\r\n\r\n @property\r\n def distribution(self):\r\n \"\"\"garage.tf.distributions.DiagonalGaussian: Distribution.\"\"\"\r\n return self.model.networks['default'].dist\r\n\r\n def __getstate__(self):\r\n \"\"\"Object.__getstate__.\r\n\r\n Returns:\r\n dict: The state to be pickled for the instance.\r\n\r\n \"\"\"\r\n new_dict = super().__getstate__()\r\n del new_dict['_f_predict']\r\n del new_dict['_f_prob']\r\n return new_dict\r\n\r\n def __setstate__(self, state):\r\n \"\"\"Object.__setstate__.\r\n\r\n Args:\r\n state (dict): Unpickled state.\r\n\r\n \"\"\"\r\n super().__setstate__(state)\r\n self._initialize()\r\n",
"\"\"\"First order optimizer.\"\"\"\r\nimport time\r\n\r\nfrom dowel import logger\r\nimport pyprind\r\nimport tensorflow as tf\r\n\r\nfrom garage.np.optimizers import BatchDataset\r\nfrom garage.tf.misc import tensor_utils\r\nfrom garage.tf.optimizers.utils import LazyDict\r\n\r\n\r\nclass FirstOrderOptimizer:\r\n \"\"\"First order optimier.\r\n\r\n Performs (stochastic) gradient descent, possibly using fancier methods like\r\n ADAM etc.\r\n\r\n Args:\r\n tf_optimizer_cls (tf.Optimizer): Optimizer to be used.\r\n tf_optimizer_args (dict): Optimizer arguments.\r\n max_epochs (int): Maximum number of epochs for update.\r\n tolerance (float): Tolerance for difference in loss during update.\r\n batch_size (int): Batch size for optimization.\r\n callback (callable): Function to call during each epoch. Default is\r\n None.\r\n verbose (bool): If true, intermediate log message will be printed.\r\n name (str): Name scope of the optimizer.\r\n\r\n \"\"\"\r\n\r\n def __init__(self,\r\n tf_optimizer_cls=None,\r\n tf_optimizer_args=None,\r\n max_epochs=1000,\r\n tolerance=1e-6,\r\n batch_size=32,\r\n callback=None,\r\n verbose=False,\r\n name='FirstOrderOptimizer'):\r\n self._opt_fun = None\r\n self._target = None\r\n self._callback = callback\r\n if tf_optimizer_cls is None:\r\n tf_optimizer_cls = tf.compat.v1.train.AdamOptimizer\r\n if tf_optimizer_args is None:\r\n tf_optimizer_args = dict(learning_rate=1e-3)\r\n self._tf_optimizer = tf_optimizer_cls(**tf_optimizer_args)\r\n self._max_epochs = max_epochs\r\n self._tolerance = tolerance\r\n self._batch_size = batch_size\r\n self._verbose = verbose\r\n self._input_vars = None\r\n self._train_op = None\r\n self._name = name\r\n\r\n def update_opt(self, loss, target, inputs, extra_inputs=None, **kwargs):\r\n \"\"\"Construct operation graph for the optimizer.\r\n\r\n Args:\r\n loss (tf.Tensor): Loss objective to minimize.\r\n target (object): Target object to optimize. The object should\r\n implemenet `get_params()` and `get_param_values`.\r\n inputs (list[tf.Tensor]): List of input placeholders.\r\n extra_inputs (list[tf.Tensor]): List of extra input placeholders.\r\n kwargs (dict): Extra unused keyword arguments. Some optimizers\r\n have extra input, e.g. KL constraint.\r\n\r\n \"\"\"\r\n del kwargs\r\n with tf.name_scope(self._name):\r\n self._target = target\r\n\r\n self._train_op = self._tf_optimizer.minimize(\r\n loss, var_list=target.get_params())\r\n\r\n if extra_inputs is None:\r\n extra_inputs = list()\r\n self._input_vars = inputs + extra_inputs\r\n self._opt_fun = LazyDict(\r\n f_loss=lambda: tensor_utils.compile_function(\r\n inputs + extra_inputs, loss), )\r\n\r\n def loss(self, inputs, extra_inputs=None):\r\n \"\"\"The loss.\r\n\r\n Args:\r\n inputs (list[numpy.ndarray]): List of input values.\r\n extra_inputs (list[numpy.ndarray]): List of extra input values.\r\n\r\n Returns:\r\n float: Loss.\r\n\r\n Raises:\r\n Exception: If loss function is None, i.e. not defined.\r\n\r\n \"\"\"\r\n if self._opt_fun is None:\r\n raise Exception(\r\n 'Use update_opt() to setup the loss function first.')\r\n if extra_inputs is None:\r\n extra_inputs = tuple()\r\n return self._opt_fun['f_loss'](*(tuple(inputs) + extra_inputs))\r\n\r\n # pylint: disable=too-many-branches\r\n def optimize(self, inputs, extra_inputs=None, callback=None):\r\n \"\"\"Perform optimization.\r\n\r\n Args:\r\n inputs (list[numpy.ndarray]): List of input values.\r\n extra_inputs (list[numpy.ndarray]): List of extra input values.\r\n callback (callable): Function to call during each epoch. Default\r\n is None.\r\n\r\n Raises:\r\n NotImplementedError: If inputs are invalid.\r\n Exception: If loss function is None, i.e. not defined.\r\n\r\n \"\"\"\r\n if not inputs:\r\n # Assumes that we should always sample mini-batches\r\n raise NotImplementedError('No inputs are fed to optimizer.')\r\n if self._opt_fun is None:\r\n raise Exception(\r\n 'Use update_opt() to setup the loss function first.')\r\n\r\n f_loss = self._opt_fun['f_loss']\r\n\r\n if extra_inputs is None:\r\n extra_inputs = tuple()\r\n\r\n last_loss = f_loss(*(tuple(inputs) + extra_inputs))\r\n\r\n start_time = time.time()\r\n\r\n dataset = BatchDataset(inputs,\r\n self._batch_size,\r\n extra_inputs=extra_inputs)\r\n\r\n sess = tf.compat.v1.get_default_session()\r\n\r\n for epoch in range(self._max_epochs):\r\n if self._verbose:\r\n logger.log('Epoch {}'.format(epoch))\r\n progbar = pyprind.ProgBar(len(inputs[0]))\r\n\r\n for batch in dataset.iterate(update=True):\r\n sess.run(self._train_op,\r\n dict(list(zip(self._input_vars, batch))))\r\n if self._verbose:\r\n progbar.update(len(batch[0]))\r\n\r\n if self._verbose:\r\n if progbar.active:\r\n progbar.stop()\r\n\r\n new_loss = f_loss(*(tuple(inputs) + extra_inputs))\r\n\r\n if self._verbose:\r\n logger.log('Epoch: {} | Loss: {}'.format(epoch, new_loss))\r\n if self._callback or callback:\r\n elapsed = time.time() - start_time\r\n callback_args = dict(\r\n loss=new_loss,\r\n params=self._target.get_param_values()\r\n if self._target else None,\r\n itr=epoch,\r\n elapsed=elapsed,\r\n )\r\n if self._callback:\r\n self._callback(callback_args)\r\n if callback:\r\n callback(**callback_args)\r\n\r\n if abs(last_loss - new_loss) < self._tolerance:\r\n break\r\n last_loss = new_loss\r\n\r\n def __getstate__(self):\r\n \"\"\"Object.__getstate__.\r\n\r\n Returns:\r\n dict: The state to be pickled for the instance.\r\n\r\n \"\"\"\r\n new_dict = self.__dict__.copy()\r\n del new_dict['_opt_fun']\r\n del new_dict['_tf_optimizer']\r\n del new_dict['_train_op']\r\n del new_dict['_input_vars']\r\n return new_dict\r\n\r\n def __setstate__(self, state):\r\n \"\"\"Object.__setstate__.\r\n\r\n Args:\r\n state (dict): Unpickled state.\r\n\r\n \"\"\"\r\n obj = type(self)()\r\n self.__dict__.update(obj.__dict__)\r\n self.__dict__.update(state)\r\n",
"\"\"\"This module implements a Hindsight Experience Replay (HER).\r\n\r\nSee: https://arxiv.org/abs/1707.01495.\r\n\"\"\"\r\nimport inspect\r\n\r\nimport numpy as np\r\n\r\nfrom garage.replay_buffer.replay_buffer import ReplayBuffer\r\n\r\n\r\ndef make_her_sample(replay_k, reward_fun):\r\n \"\"\"Generate a transition sampler for HER ReplayBuffer.\r\n\r\n Args:\r\n replay_k (float): Ratio between HER replays and regular replays\r\n reward_fun (callable): Function to re-compute the reward with\r\n substituted goals\r\n\r\n Returns:\r\n callable: A function that returns sample transitions for HER.\r\n\r\n \"\"\"\r\n future_p = 1 - (1. / (1 + replay_k))\r\n\r\n def _her_sample_transitions(episode_batch, sample_batch_size):\r\n \"\"\"Generate a dictionary of transitions.\r\n\r\n Args:\r\n episode_batch (dict): Original transitions which\r\n transitions[key] has shape :math:`(N, T, S^*)`.\r\n sample_batch_size (int): Batch size per sample.\r\n\r\n Returns:\r\n dict[numpy.ndarray]: Transitions.\r\n\r\n \"\"\"\r\n # Select which episodes to use\r\n time_horizon = episode_batch['action'].shape[1]\r\n rollout_batch_size = episode_batch['action'].shape[0]\r\n episode_idxs = np.random.randint(rollout_batch_size,\r\n size=sample_batch_size)\r\n # Select time steps to use\r\n t_samples = np.random.randint(time_horizon, size=sample_batch_size)\r\n transitions = {\r\n key: episode_batch[key][episode_idxs, t_samples]\r\n for key in episode_batch.keys()\r\n }\r\n\r\n her_idxs = np.where(\r\n np.random.uniform(size=sample_batch_size) < future_p)\r\n future_offset = np.random.uniform(\r\n size=sample_batch_size) * (time_horizon - t_samples)\r\n future_offset = future_offset.astype(int)\r\n future_t = (t_samples + future_offset)[her_idxs]\r\n\r\n future_ag = episode_batch['achieved_goal'][episode_idxs[her_idxs],\r\n future_t]\r\n transitions['goal'][her_idxs] = future_ag\r\n\r\n achieved_goals = episode_batch['achieved_goal'][episode_idxs[her_idxs],\r\n t_samples[her_idxs]]\r\n transitions['achieved_goal'][her_idxs] = achieved_goals\r\n\r\n # Re-compute reward since we may have substituted the goal.\r\n reward_params_keys = inspect.signature(reward_fun).parameters.keys()\r\n reward_params = {\r\n rk: transitions[k]\r\n for k, rk in zip(['next_achieved_goal', 'goal'],\r\n list(reward_params_keys)[:-1])\r\n }\r\n reward_params['info'] = {}\r\n transitions['reward'] = reward_fun(**reward_params)\r\n\r\n transitions = {\r\n k: transitions[k].reshape(sample_batch_size,\r\n *transitions[k].shape[1:])\r\n for k in transitions.keys()\r\n }\r\n\r\n goals = transitions['goal']\r\n next_inputs = np.concatenate((transitions['next_observation'], goals,\r\n transitions['achieved_goal']),\r\n axis=-1)\r\n inputs = np.concatenate(\r\n (transitions['observation'], goals, transitions['achieved_goal']),\r\n axis=-1)\r\n transitions['observation'] = inputs\r\n transitions['next_observation'] = next_inputs\r\n\r\n assert transitions['action'].shape[0] == sample_batch_size\r\n return transitions\r\n\r\n return _her_sample_transitions\r\n\r\n\r\nclass HerReplayBuffer(ReplayBuffer):\r\n \"\"\"Replay buffer for HER (Hindsight Experience Replay).\r\n\r\n It constructs hindsight examples using future strategy.\r\n\r\n Args:\r\n replay_k (float): Ratio between HER replays and regular replays\r\n reward_fun (callable): Function to re-compute the reward with\r\n substituted goals\r\n env_spec (garage.envs.EnvSpec): Environment specification.\r\n size_in_transitions (int): total size of transitions in the buffer\r\n time_horizon (int): time horizon of rollout.\r\n\r\n \"\"\"\r\n\r\n def __init__(self, replay_k, reward_fun, env_spec, size_in_transitions,\r\n time_horizon):\r\n self._env_spec = env_spec\r\n self._sample_transitions = make_her_sample(replay_k, reward_fun)\r\n self._replay_k = replay_k\r\n self._reward_fun = reward_fun\r\n super().__init__(env_spec, size_in_transitions, time_horizon)\r\n\r\n def sample(self, batch_size):\r\n \"\"\"Sample a transition of batch_size.\r\n\r\n Args:\r\n batch_size (int): Batch size to sample.\r\n\r\n Return:\r\n dict[numpy.ndarray]: Transitions which transitions[key] has the\r\n shape of :math:`(N, S^*)`. Keys include [`observation`,\r\n `action`, `goal`, `achieved_goal`, `terminal`,\r\n `next_observation`, `next_achieved_goal` and `reward`].\r\n\r\n \"\"\"\r\n buffer = {}\r\n for key in self._buffer:\r\n buffer[key] = self._buffer[key][:self._current_size]\r\n\r\n transitions = self._sample_transitions(buffer, batch_size)\r\n\r\n for key in (['reward', 'next_observation', 'next_achieved_goal'] +\r\n list(self._buffer.keys())):\r\n assert key in transitions, 'key %s missing from transitions' % key\r\n\r\n return transitions\r\n\r\n def __getstate__(self):\r\n \"\"\"Object.__getstate__.\r\n\r\n Returns:\r\n dict: The state to be pickled for the instance.\r\n\r\n \"\"\"\r\n new_dict = self.__dict__.copy()\r\n del new_dict['_sample_transitions']\r\n return new_dict\r\n\r\n def __setstate__(self, state):\r\n \"\"\"Object.__setstate__.\r\n\r\n Args:\r\n state (dict): Unpickled state.\r\n\r\n \"\"\"\r\n self.__dict__ = state\r\n replay_k = state['_replay_k']\r\n reward_fun = state['_reward_fun']\r\n self._sample_transitions = make_her_sample(replay_k, reward_fun)\r\n\r\n def add_transitions(self, **kwargs):\r\n \"\"\"Add multiple transitions into the replay buffer.\r\n\r\n A transition contains one or multiple entries, e.g.\r\n observation, action, reward, terminal and next_observation.\r\n The same entry of all the transitions are stacked, e.g.\r\n {'observation': [obs1, obs2, obs3]} where obs1 is one\r\n numpy.ndarray observation from the environment.\r\n\r\n Args:\r\n kwargs (dict(str, [numpy.ndarray])): Dictionary that holds\r\n the transitions.\r\n\r\n \"\"\"\r\n obses = kwargs['observation']\r\n obs = [obs['observation'] for obs in obses]\r\n d_g = [obs['desired_goal'] for obs in obses]\r\n a_g = [obs['achieved_goal'] for obs in obses]\r\n next_obses = kwargs['next_observation']\r\n super().add_transitions(\r\n observation=obs,\r\n action=kwargs['action'],\r\n goal=d_g,\r\n achieved_goal=a_g,\r\n terminal=kwargs['terminal'],\r\n next_observation=[\r\n next_obs['observation'] for next_obs in next_obses\r\n ],\r\n next_achieved_goal=[\r\n next_obs['achieved_goal'] for next_obs in next_obses\r\n ],\r\n )\r\n"
] | [
[
"tensorflow.compat.v1.placeholder",
"tensorflow.zeros_initializer",
"tensorflow.compat.v1.variable_scope",
"numpy.std",
"tensorflow.initializers.glorot_uniform",
"numpy.mean"
],
[
"tensorflow.name_scope",
"tensorflow.compat.v1.get_default_session"
],
[
"numpy.random.uniform",
"numpy.concatenate",
"numpy.random.randint"
]
] |
eth-ait/motion-infilling | [
"be814cfe971ec58d0e66c7644db3cdc89f71d092"
] | [
"data-preprocessing/view.py"
] | [
"import os\nimport numpy as np\nimport matplotlib.animation as animation\nimport matplotlib.colors as colors\nimport matplotlib.patheffects as pe\nimport matplotlib.pyplot as plt\n\nfrom matplotlib.animation import ArtistAnimation\nfrom mpl_toolkits.mplot3d import Axes3D\nfrom Quaternions import Quaternions\n\n\ndef animation_plot(animations, interval=33.33):\n footsteps = []\n\n for ai in range(len(animations)):\n anim = animations[ai][0].copy()[:, 3:]\n\n joints, root_x, root_z, root_r = anim[:, :-7], anim[:, -7], anim[:, -6], anim[:, -5]\n joints = joints.reshape((len(joints), -1, 3))\n\n rotation = Quaternions.id(1)\n offsets = []\n translation = np.array([[0, 0, 0]])\n\n for i in range(len(joints)):\n joints[i, :, :] = rotation * joints[i]\n joints[i, :, 0] = joints[i, :, 0] + translation[0, 0]\n joints[i, :, 2] = joints[i, :, 2] + translation[0, 2]\n rotation = Quaternions.from_angle_axis(-root_r[i], np.array([0, 1, 0])) * rotation\n offsets.append(rotation * np.array([0, 0, 1]))\n translation = translation + rotation * np.array([root_x[i], 0, root_z[i]])\n\n animations[ai] = joints\n footsteps.append(anim[:, -4:])\n\n footsteps = np.array(footsteps)\n print(footsteps.shape)\n\n scale = 1.25 * ((len(animations)) / 2)\n\n fig = plt.figure(figsize=(12, 8))\n ax = fig.add_subplot(111, projection='3d')\n ax.set_xlim3d(-scale * 30, scale * 30)\n ax.set_zlim3d(0, scale * 60)\n ax.set_ylim3d(-scale * 30, scale * 30)\n ax.set_xticks([], [])\n ax.set_yticks([], [])\n ax.set_zticks([], [])\n ax.set_aspect('equal')\n\n acolors = list(sorted(colors.cnames.keys()))[::-1]\n lines = []\n\n parents = np.array([-1, 0, 1, 2, 3, 0, 5, 6, 7, 0, 9, 10, 11, 11, 13, 14, 15, 11, 17, 18, 19])\n\n for ai, anim in enumerate(animations):\n lines.append([plt.plot([0, 0], [0, 0], [0, 0], color=acolors[ai],\n lw=2, path_effects=[pe.Stroke(linewidth=3, foreground='black'), pe.Normal()])[0] for _ in\n range(anim.shape[1])])\n\n def animate(i):\n changed = []\n for ai in range(len(animations)):\n offset = 25 * (ai - ((len(animations)) / 2))\n for j in range(len(parents)):\n if parents[j] != -1:\n lines[ai][j].set_data(\n [animations[ai][i, j, 0] + offset, animations[ai][i, parents[j], 0] + offset],\n [-animations[ai][i, j, 2], -animations[ai][i, parents[j], 2]])\n lines[ai][j].set_3d_properties(\n [animations[ai][i, j, 1], animations[ai][i, parents[j], 1]])\n changed += lines\n\n return changed\n\n plt.tight_layout()\n\n ani = animation.FuncAnimation(fig,\n animate, np.arange(len(animations[0])), interval=interval)\n\n plt.show()\n\n\nif __name__ == '__main__':\n\n data_path = '../data_preprocessed/valid/'\n db = 'data_hdm05.npz'\n database = np.load(os.path.join(data_path, db))['clips']\n\n for i in range(10):\n index0 = np.random.randint(0, len(database))\n index1 = np.random.randint(0, len(database))\n index2 = np.random.randint(0, len(database))\n\n animation_plot([\n database[index0:index0 + 1],\n database[index1:index1 + 1],\n database[index2:index2 + 1],\n ])\n"
] | [
[
"matplotlib.pyplot.figure",
"matplotlib.pyplot.tight_layout",
"matplotlib.colors.cnames.keys",
"matplotlib.patheffects.Stroke",
"matplotlib.pyplot.show",
"matplotlib.patheffects.Normal",
"numpy.array"
]
] |
sqoshi/masked-face-recognizer | [
"40f66d776b203a1875200647b62d623f696d88a4"
] | [
"src/predictions/trainers/trainer.py"
] | [
"import logging\nimport pickle\nfrom abc import ABC, abstractmethod\nfrom typing import Any, Dict, List, Optional, Union\n\nfrom numpy.typing import NDArray\nfrom sklearn.preprocessing import LabelEncoder\n\nfrom predictions.face_recognizer import ModelType\nfrom settings import output\n\nlogger = logging.getLogger(__name__)\n\n\ndef read_pickle(path: str) -> Dict[str, NDArray[Any]]:\n \"\"\"Loading pickled object from path.\"\"\"\n with open(path, \"rb\") as fr:\n return pickle.load(fr)\n\n\nEmbsDictOrPath = Union[str, Dict[str, List[NDArray[Any]]]]\n\n\nclass Trainer(ABC):\n \"\"\"Model trainer class template.\"\"\"\n\n def __init__(self, model: ModelType, embeddings: EmbsDictOrPath) -> None:\n self._model = model\n self._embeddings: Optional[List[Any]] = None\n self._labels: Optional[List[Any]] = None\n self.label_encoder = LabelEncoder()\n self.load_embeddings(embeddings)\n\n def load_embeddings(self, embeddings: EmbsDictOrPath) -> None:\n if isinstance(embeddings, str):\n logger.info(\"Loading embeddings from path %s.\", embeddings)\n data = read_pickle(embeddings)\n self._embeddings = data[\"vectors\"]\n self._labels = data[\"classes\"]\n elif isinstance(embeddings, dict):\n logger.info(\"Loading embeddings from dictionary.\")\n self._embeddings = embeddings[\"vectors\"]\n self._labels = embeddings[\"classes\"]\n else:\n raise TypeError(\"Input must be a dictionary or path to a pickled dict!\")\n\n @abstractmethod\n def train(self) -> None:\n pass\n\n def store_model(self, fn: str = \"model.pickle\") -> None:\n \"\"\"Saves model in directory as pickle.\"\"\"\n with open(output / fn, \"wb\") as fw:\n pickle.dump(self._model, fw, protocol=pickle.HIGHEST_PROTOCOL)\n"
] | [
[
"sklearn.preprocessing.LabelEncoder"
]
] |
awesome-archive/tsfresh | [
"9419aa15bb26a3725291f39636354e67c9b04caa"
] | [
"tests/transformers/test_feature_selector.py"
] | [
"# -*- coding: utf-8 -*-\n# This file as well as the whole tsfresh package are licenced under the MIT licence (see the LICENCE.txt)\n# Maximilian Christ (maximilianchrist.com), Blue Yonder Gmbh, 2016\n\nfrom unittest import TestCase\nimport pandas as pd\n\nimport numpy as np\n\nfrom tsfresh.transformers.feature_selector import FeatureSelector\n\nclass FeatureSelectorTestCase(TestCase):\n def setUp(self):\n np.random.seed(0)\n\n\n def test_not_fitted(self):\n selector = FeatureSelector()\n\n X = pd.DataFrame()\n\n self.assertRaises(RuntimeError, selector.transform, X)\n\n def test_extract_relevant_features(self):\n selector = FeatureSelector()\n\n y = pd.Series(np.random.binomial(1, 0.5, 1000))\n X = pd.DataFrame(index=range(1000))\n\n z = y - np.random.binomial(1, 0.1, 1000) + np.random.binomial(1, 0.1, 1000)\n z[z == -1] = 0\n z[z == 2] = 1\n\n X[\"rel1\"] = z\n X[\"rel2\"] = y * np.random.normal(0, 1, 1000) + np.random.normal(0, 1, 1000)\n X[\"rel3\"] = y + np.random.normal(0, 1, 1000)\n X[\"rel4\"] = y ** 2 + np.random.normal(0, 1, 1000)\n X[\"rel5\"] = np.sqrt(y) + np.random.binomial(2, 0.1, 1000)\n\n X[\"irr_constant\"] = 1.113344\n\n X[\"irr1\"] = np.random.normal(0, 1, 1000)\n X[\"irr2\"] = np.random.poisson(1, 1000)\n X[\"irr3\"] = np.random.binomial(1, 0.3, 1000)\n X[\"irr4\"] = np.random.normal(0, 1, 1000)\n X[\"irr5\"] = np.random.poisson(1, 1000)\n X[\"irr6\"] = np.random.binomial(1, 0.3, 1000)\n X[\"irr7\"] = np.random.normal(0, 1, 1000)\n X[\"irr8\"] = np.random.poisson(1, 1000)\n X[\"irr9\"] = np.random.binomial(1, 0.3, 1000)\n\n returned_seelctor = selector.fit(X, y)\n self.assertIs(returned_seelctor, selector)\n\n self.assertEqual(sorted(list(selector.relevant_features.index)), [\"rel1\", \"rel3\", \"rel4\", \"rel5\"])\n\n new_X = X.copy()\n\n selected_X = selector.transform(new_X)\n\n self.assertEqual(sorted(list(selector.relevant_features.index)), sorted(list(selected_X.columns)))\n\n def test_nothing_relevant(self):\n selector = FeatureSelector()\n\n y = pd.Series(np.random.binomial(1, 0.5, 1000))\n X = pd.DataFrame(index=range(1000))\n\n X[\"irr1\"] = np.random.normal(0, 1, 1000)\n X[\"irr2\"] = np.random.normal(2, 1, 1000)\n\n selector.fit(X, y)\n\n transformed_X = selector.transform(X.copy())\n\n self.assertEqual(list(transformed_X.columns), [])\n self.assertEqual(list(transformed_X.index), list(X.index))\n\n def test_with_numpy_array(self):\n selector = FeatureSelector()\n\n y = pd.Series(np.random.binomial(1, 0.5, 1000))\n X = pd.DataFrame(index=range(1000))\n\n X[\"irr1\"] = np.random.normal(0, 1, 1000)\n X[\"rel1\"] = y\n\n y_numpy = y.values\n X_numpy = X.as_matrix()\n\n selector.fit(X, y)\n selected_X = selector.transform(X)\n\n selector.fit(X_numpy, y_numpy)\n selected_X_numpy = selector.transform(X_numpy)\n\n self.assertTrue((selected_X_numpy == selected_X.values).all())\n\n self.assertTrue(selected_X_numpy.shape, (1, 1000))\n\n\n\n"
] | [
[
"numpy.random.binomial",
"numpy.sqrt",
"pandas.DataFrame",
"numpy.random.seed",
"numpy.random.poisson",
"numpy.random.normal"
]
] |
Xinghanzzy/transformer-simple | [
"e34592c41829e2c35955fa38e802765116dc1c35"
] | [
"modules.py"
] | [
"# -*- coding: utf-8 -*-\n#/usr/bin/python2\n'''\nJune 2017 by kyubyong park. \[email protected].\nhttps://www.github.com/kyubyong/transformer\n'''\n\nfrom __future__ import print_function\nimport tensorflow as tf\nimport numpy as np\n\ndef normalize(inputs, \n epsilon = 1e-8,\n scope=\"ln\",\n reuse=None):\n '''Applies layer normalization.\n \n Args:\n inputs: A tensor with 2 or more dimensions, where the first dimension has\n `batch_size`.\n epsilon: A floating number. A very small number for preventing ZeroDivision Error.\n scope: Optional scope for `variable_scope`.\n reuse: Boolean, whether to reuse the weights of a previous layer\n by the same name.\n \n Returns:\n A tensor with the same shape and data dtype as `inputs`.\n '''\n with tf.variable_scope(scope, reuse=reuse):\n inputs_shape = inputs.get_shape()\n params_shape = inputs_shape[-1:]\n # Tensor(\"encoder/num_blocks_0/multihead_attention/ln/moments/mean:0\", shape=(32, 10, 1), dtype=float32)\n mean, variance = tf.nn.moments(inputs, [-1], keep_dims=True)\n beta= tf.Variable(tf.zeros(params_shape))\n gamma = tf.Variable(tf.ones(params_shape))\n normalized = (inputs - mean) / ( (variance + epsilon) ** (.5) )\n outputs = gamma * normalized + beta\n \n return outputs\n\ndef embedding(inputs, \n vocab_size, \n num_units, \n zero_pad=True, \n scale=True,\n scope=\"embedding\", \n reuse=None):\n '''Embeds a given tensor.\n\n data_load 之后产生的x,y的大小\n x，y的shape为[N,T]，N即batch_size的大小，T为最大句子长度maxlen，默认为10。\n 这个之后应该是再加一个hidden_size (num_units)\n\n Args:\n inputs: A `Tensor` with type `int32` or `int64` containing the ids\n to be looked up in `lookup table`.\n vocab_size: An int. Vocabulary size.\n num_units: An int. Number of embedding hidden units.\n zero_pad: A boolean. If True, all the values of the fist row (id 0)\n should be constant zeros.\n scale: A boolean. If True. the outputs is multiplied by sqrt num_units.\n scope: Optional scope for `variable_scope`.\n reuse: Boolean, whether to reuse the weights of a previous layer\n by the same name.\n\n Returns:\n A `Tensor` with one more rank than inputs's. The last dimensionality\n should be `num_units`.\n \n For example,\n \n ```\n import tensorflow as tf\n \n inputs = tf.to_int32(tf.reshape(tf.range(2*3), (2, 3)))\n outputs = embedding(inputs, 6, 2, zero_pad=True)\n with tf.Session() as sess:\n sess.run(tf.global_variables_initializer())\n print sess.run(outputs)\n >>\n [[[ 0. 0. ]\n [ 0.09754146 0.67385566]\n [ 0.37864095 -0.35689294]]\n\n [[-1.01329422 -1.09939694]\n [ 0.7521342 0.38203377]\n [-0.04973143 -0.06210355]]]\n ```\n \n ```\n import tensorflow as tf\n \n inputs = tf.to_int32(tf.reshape(tf.range(2*3), (2, 3)))\n outputs = embedding(inputs, 6, 2, zero_pad=False)\n with tf.Session() as sess:\n sess.run(tf.global_variables_initializer())\n print sess.run(outputs)\n >>\n [[[-0.19172323 -0.39159766]\n [-0.43212751 -0.66207761]\n [ 1.03452027 -0.26704335]]\n\n [[-0.11634696 -0.35983452]\n [ 0.50208133 0.53509563]\n [ 1.22204471 -0.96587461]]] \n ``` \n '''\n with tf.variable_scope(scope, reuse=reuse):\n lookup_table = tf.get_variable('lookup_table',\n dtype=tf.float32,\n shape=[vocab_size, num_units],\n initializer=tf.contrib.layers.xavier_initializer())\n if zero_pad:\n lookup_table = tf.concat((tf.zeros(shape=[1, num_units]),\n lookup_table[1:, :]), 0)\n # todo: embedding_lookup\n outputs = tf.nn.embedding_lookup(lookup_table, inputs)\n \n if scale:\n outputs = outputs * (num_units ** 0.5) \n \n return outputs\n \n\ndef positional_encoding(inputs,\n num_units,\n zero_pad=True,\n scale=True,\n scope=\"positional_encoding\",\n reuse=None):\n '''Sinusoidal Positional_Encoding.\n Equivalent to adding a constant matrix each time\n Args:\n inputs: A 2d Tensor with shape of (N, T).\n num_units: Output dimensionality\n zero_pad: Boolean. If True, all the values of the first row (id = 0) should be constant zero\n scale: Boolean. If True, the output will be multiplied by sqrt num_units(check details from paper)\n scope: Optional scope for `variable_scope`.\n reuse: Boolean, whether to reuse the weights of a previous layer\n by the same name.\n\n Returns:\n A 'Tensor' with one more rank than inputs's, with the dimensionality should be 'num_units'\n '''\n\n N, T = inputs.get_shape().as_list()\n with tf.variable_scope(scope, reuse=reuse):\n # [1,T] [[0, 1, 2, ..., T]] -> [N, T]\n position_ind = tf.tile(tf.expand_dims(tf.range(T), 0), [N, 1])\n\n # First part of the PE function: sin and cos argument\n # [T, num_units] sin(pos/10000^(2i/dmodel) )\n position_enc = np.array([\n [pos / np.power(10000, 2.*i/num_units) for i in range(num_units)]\n for pos in range(T)])\n\n # Second part, apply the cosine to even columns and sin to odds. 奇数偶数\n position_enc[:, 0::2] = np.sin(position_enc[:, 0::2]) # dim 2i\n position_enc[:, 1::2] = np.cos(position_enc[:, 1::2]) # dim 2i+1\n\n # Convert to a tensor\n lookup_table = tf.convert_to_tensor(position_enc)\n\n if zero_pad:\n lookup_table = tf.concat((tf.zeros(shape=[1, num_units]),\n lookup_table[1:, :]), 0)\n outputs = tf.nn.embedding_lookup(lookup_table, position_ind)\n\n if scale:\n outputs = outputs * num_units**0.5\n\n return outputs\n\n\n\ndef multihead_attention(queries, \n keys, \n num_units=None, \n num_heads=8, \n dropout_rate=0,\n is_training=True,\n causality=False,\n scope=\"multihead_attention\", \n reuse=None):\n '''Applies multihead attention.\n\n data_load 输出\n x，y的shape为[N,T]，N即batch_size的大小，T为最大句子长度maxlen，默认为10。\n Form libei\n Input Embedding: Batch * Length * Hidden\n Posional Encoding : Length * Hidden\n Encoder Input = Input Embedding + Posional Encoding\n Query,Key,Value = Conv(Encoder Input,Hidden,3*Hidden)\n\n Query = SplitHeads(Query)\n Key = SplitHeads(Key)\n Value = SplitHeads(Value)\n\n Shape (Batch,Length,Heads,Channels)\n\n\n Args:\n queries: A 3d tensor with shape of [N, T_q, C_q].\n keys: A 3d tensor with shape of [N, T_k, C_k].\n num_units: A scalar. Attention size.\n dropout_rate: A floating point number.\n is_training: Boolean. Controller of mechanism for dropout.\n causality: Boolean. If true, units that reference the future are masked. \n num_heads: An int. Number of heads.\n scope: Optional scope for `variable_scope`.\n reuse: Boolean, whether to reuse the weights of a previous layer\n by the same name.\n \n Returns\n A 3d tensor with shape of (N, T_q, C) \n '''\n with tf.variable_scope(scope, reuse=reuse):\n # Set the fall back option for num_units\n if num_units is None:\n num_units = queries.get_shape().as_list[-1]\n \n # Linear projections Q、K、V 使用不同的矩阵进行映射学习\n # 新版代码使用一个大矩阵然后split为三份\n # self attention 在 encoder-decoder attention时候Q来自encoder K、V来自decoder; encoder或decoder时候 Q、K、V一样\n Q = tf.layers.dense(queries, num_units, activation=tf.nn.relu) # (N, T_q, C)\n K = tf.layers.dense(keys, num_units, activation=tf.nn.relu) # (N, T_k, C)\n V = tf.layers.dense(keys, num_units, activation=tf.nn.relu) # (N, T_k, C)\n \n # Split and concat\n # 分为8头\n Q_ = tf.concat(tf.split(Q, num_heads, axis=2), axis=0) # (h*N, T_q, C/h)\n K_ = tf.concat(tf.split(K, num_heads, axis=2), axis=0) # (h*N, T_k, C/h) \n V_ = tf.concat(tf.split(V, num_heads, axis=2), axis=0) # (h*N, T_k, C/h) \n\n # Multiplication (h*batch,length_q,length_k)\n outputs = tf.matmul(Q_, tf.transpose(K_, [0, 2, 1])) # (h*N, T_q, T_k)\n\n # Scale\n outputs = outputs / (K_.get_shape().as_list()[-1] ** 0.5)\n\n # Key Masking\n # N, T padding 0\n key_masks = tf.sign(tf.abs(tf.reduce_sum(keys, axis=-1))) # (N, T_k)\n key_masks = tf.tile(key_masks, [num_heads, 1]) # (h*N, T_k)\n key_masks = tf.tile(tf.expand_dims(key_masks, 1), [1, tf.shape(queries)[1], 1]) # (h*N, T_q, T_k)\n # tf.expand_dims(input, dim, name=None) add 1 at dim\n paddings = tf.ones_like(outputs)*(-2**32+1)\n outputs = tf.where(tf.equal(key_masks, 0), paddings, outputs) # (h*N, T_q, T_k)\n\n # Causality = Future blinding\n if causality:\n diag_vals = tf.ones_like(outputs[0, :, :]) # (T_q, T_k)\n tril = tf.contrib.linalg.LinearOperatorTriL(diag_vals).to_dense() # (T_q, T_k) triangular matrix\n masks = tf.tile(tf.expand_dims(tril, 0), [tf.shape(outputs)[0], 1, 1]) # (h*N, T_q, T_k)\n \n paddings = tf.ones_like(masks)*(-2**32+1)\n outputs = tf.where(tf.equal(masks, 0), paddings, outputs) # (h*N, T_q, T_k)\n \n # Activation\n outputs = tf.nn.softmax(outputs) # (h*N, T_q, T_k)\n \n # Query Masking\n query_masks = tf.sign(tf.abs(tf.reduce_sum(queries, axis=-1))) # (N, T_q)\n query_masks = tf.tile(query_masks, [num_heads, 1]) # (h*N, T_q)\n query_masks = tf.tile(tf.expand_dims(query_masks, -1), [1, 1, tf.shape(keys)[1]]) # (h*N, T_q, T_k)\n outputs *= query_masks # broadcasting. (N, T_q, C) should be (h*N, T_q, T_k)。\n \n # Dropouts\n outputs = tf.layers.dropout(outputs, rate=dropout_rate, training=tf.convert_to_tensor(is_training))\n \n # Weighted sum\n outputs = tf.matmul(outputs, V_) # ( h*N, T_q, C/h)\n # 少了个线性变换\n # Restore shape\n outputs = tf.concat(tf.split(outputs, num_heads, axis=0), axis=2 ) # (N, T_q, C)\n \n # Residual connection\n outputs += queries\n \n # Normalize\n outputs = normalize(outputs) # (N, T_q, C)\n \n return outputs\n\ndef feedforward(inputs, \n num_units=[2048, 512],\n scope=\"multihead_attention\", \n reuse=None):\n '''Point-wise feed forward net.\n \n Args:\n inputs: A 3d tensor with shape of [N, T, C].\n num_units: A list of two integers.\n scope: Optional scope for `variable_scope`.\n reuse: Boolean, whether to reuse the weights of a previous layer\n by the same name.\n \n Returns:\n A 3d tensor with the same shape and dtype as inputs\n '''\n with tf.variable_scope(scope, reuse=reuse):\n # Inner layer\n params = {\"inputs\": inputs, \"filters\": num_units[0], \"kernel_size\": 1,\n \"activation\": tf.nn.relu, \"use_bias\": True}\n outputs = tf.layers.conv1d(**params)\n \n # Readout layer\n params = {\"inputs\": outputs, \"filters\": num_units[1], \"kernel_size\": 1,\n \"activation\": None, \"use_bias\": True}\n outputs = tf.layers.conv1d(**params)\n \n # Residual connection\n outputs += inputs\n \n # Normalize\n outputs = normalize(outputs)\n \n return outputs\n\ndef label_smoothing(inputs, epsilon=0.1):\n '''Applies label smoothing. See https://arxiv.org/abs/1512.00567.\n \n Args:\n inputs: A 3d tensor with shape of [N, T, V], where V is the number of vocabulary.\n epsilon: Smoothing rate.\n \n For example,\n \n ```\n import tensorflow as tf\n inputs = tf.convert_to_tensor([[[0, 0, 1], \n [0, 1, 0],\n [1, 0, 0]],\n\n [[1, 0, 0],\n [1, 0, 0],\n [0, 1, 0]]], tf.float32)\n \n outputs = label_smoothing(inputs)\n \n with tf.Session() as sess:\n print(sess.run([outputs]))\n \n >>\n [array([[[ 0.03333334, 0.03333334, 0.93333334],\n [ 0.03333334, 0.93333334, 0.03333334],\n [ 0.93333334, 0.03333334, 0.03333334]],\n\n [[ 0.93333334, 0.03333334, 0.03333334],\n [ 0.93333334, 0.03333334, 0.03333334],\n [ 0.03333334, 0.93333334, 0.03333334]]], dtype=float32)] \n ``` \n '''\n K = inputs.get_shape().as_list()[-1] # number of channels\n return ((1-epsilon) * inputs) + (epsilon / K)\n \n \n\n \n"
] | [
[
"tensorflow.ones",
"tensorflow.variable_scope",
"tensorflow.matmul",
"tensorflow.convert_to_tensor",
"tensorflow.nn.softmax",
"tensorflow.split",
"tensorflow.reduce_sum",
"numpy.cos",
"tensorflow.transpose",
"tensorflow.layers.conv1d",
"tensorflow.shape",
"tensorflow.ones_like",
"tensorflow.expand_dims",
"numpy.power",
"tensorflow.contrib.layers.xavier_initializer",
"tensorflow.tile",
"tensorflow.layers.dense",
"tensorflow.nn.embedding_lookup",
"tensorflow.nn.moments",
"tensorflow.zeros",
"tensorflow.equal",
"tensorflow.contrib.linalg.LinearOperatorTriL",
"tensorflow.range",
"numpy.sin"
]
] |
diazandr3s/MONAI | [
"209db9e08129855df878634639d4c2700d9acd83"
] | [
"tests/test_integration_workflows.py"
] | [
"# Copyright (c) MONAI Consortium\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n# http://www.apache.org/licenses/LICENSE-2.0\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport os\nimport shutil\nimport tempfile\nimport unittest\nimport warnings\nfrom glob import glob\n\nimport nibabel as nib\nimport numpy as np\nimport torch\nfrom ignite.metrics import Accuracy\nfrom torch.utils.tensorboard import SummaryWriter\n\nimport monai\nfrom monai.data import create_test_image_3d\nfrom monai.engines import IterationEvents, SupervisedEvaluator, SupervisedTrainer\nfrom monai.handlers import (\n CheckpointLoader,\n CheckpointSaver,\n LrScheduleHandler,\n MeanDice,\n SegmentationSaver,\n StatsHandler,\n TensorBoardImageHandler,\n TensorBoardStatsHandler,\n ValidationHandler,\n from_engine,\n)\nfrom monai.inferers import SimpleInferer, SlidingWindowInferer\nfrom monai.transforms import (\n Activationsd,\n AsChannelFirstd,\n AsDiscreted,\n Compose,\n KeepLargestConnectedComponentd,\n LoadImaged,\n RandCropByPosNegLabeld,\n RandRotate90d,\n SaveImaged,\n ScaleIntensityd,\n ToTensord,\n)\nfrom monai.utils import set_determinism\nfrom monai.utils.enums import PostFix\nfrom tests.testing_data.integration_answers import test_integration_value\nfrom tests.utils import DistTestCase, TimedCall, pytorch_after, skip_if_quick\n\nTASK = \"integration_workflows\"\n\n\ndef run_training_test(root_dir, device=\"cuda:0\", amp=False, num_workers=4):\n images = sorted(glob(os.path.join(root_dir, \"img*.nii.gz\")))\n segs = sorted(glob(os.path.join(root_dir, \"seg*.nii.gz\")))\n train_files = [{\"image\": img, \"label\": seg} for img, seg in zip(images[:20], segs[:20])]\n val_files = [{\"image\": img, \"label\": seg} for img, seg in zip(images[-20:], segs[-20:])]\n\n # define transforms for image and segmentation\n train_transforms = Compose(\n [\n LoadImaged(keys=[\"image\", \"label\"]),\n AsChannelFirstd(keys=[\"image\", \"label\"], channel_dim=-1),\n ScaleIntensityd(keys=[\"image\", \"label\"]),\n RandCropByPosNegLabeld(\n keys=[\"image\", \"label\"], label_key=\"label\", spatial_size=[96, 96, 96], pos=1, neg=1, num_samples=4\n ),\n RandRotate90d(keys=[\"image\", \"label\"], prob=0.5, spatial_axes=[0, 2]),\n ToTensord(keys=[\"image\", \"label\"]),\n ]\n )\n val_transforms = Compose(\n [\n LoadImaged(keys=[\"image\", \"label\"]),\n AsChannelFirstd(keys=[\"image\", \"label\"], channel_dim=-1),\n ScaleIntensityd(keys=[\"image\", \"label\"]),\n ToTensord(keys=[\"image\", \"label\"]),\n ]\n )\n\n # create a training data loader\n train_ds = monai.data.CacheDataset(data=train_files, transform=train_transforms, cache_rate=0.5)\n # use batch_size=2 to load images and use RandCropByPosNegLabeld to generate 2 x 4 images for network training\n train_loader = monai.data.DataLoader(train_ds, batch_size=2, shuffle=True, num_workers=num_workers)\n # create a validation data loader\n val_ds = monai.data.CacheDataset(data=val_files, transform=val_transforms, cache_rate=1.0)\n val_loader = monai.data.DataLoader(val_ds, batch_size=1, num_workers=num_workers)\n\n # create UNet, DiceLoss and Adam optimizer\n net = monai.networks.nets.UNet(\n spatial_dims=3,\n in_channels=1,\n out_channels=1,\n channels=(16, 32, 64, 128, 256),\n strides=(2, 2, 2, 2),\n num_res_units=2,\n ).to(device)\n loss = monai.losses.DiceLoss(sigmoid=True)\n opt = torch.optim.Adam(net.parameters(), 1e-3)\n lr_scheduler = torch.optim.lr_scheduler.StepLR(opt, step_size=2, gamma=0.1)\n summary_writer = SummaryWriter(log_dir=root_dir)\n\n val_postprocessing = Compose(\n [\n ToTensord(keys=[\"pred\", \"label\"]),\n Activationsd(keys=\"pred\", sigmoid=True),\n AsDiscreted(keys=\"pred\", threshold=0.5),\n KeepLargestConnectedComponentd(keys=\"pred\", applied_labels=[1]),\n ]\n )\n\n class _TestEvalIterEvents:\n def attach(self, engine):\n engine.add_event_handler(IterationEvents.FORWARD_COMPLETED, self._forward_completed)\n\n def _forward_completed(self, engine):\n pass\n\n val_handlers = [\n StatsHandler(iteration_log=False),\n TensorBoardStatsHandler(summary_writer=summary_writer, iteration_log=False),\n TensorBoardImageHandler(\n log_dir=root_dir, batch_transform=from_engine([\"image\", \"label\"]), output_transform=from_engine(\"pred\")\n ),\n CheckpointSaver(save_dir=root_dir, save_dict={\"net\": net}, save_key_metric=True),\n _TestEvalIterEvents(),\n ]\n\n evaluator = SupervisedEvaluator(\n device=device,\n val_data_loader=val_loader,\n network=net,\n inferer=SlidingWindowInferer(roi_size=(96, 96, 96), sw_batch_size=4, overlap=0.5),\n postprocessing=val_postprocessing,\n key_val_metric={\n \"val_mean_dice\": MeanDice(include_background=True, output_transform=from_engine([\"pred\", \"label\"]))\n },\n additional_metrics={\"val_acc\": Accuracy(output_transform=from_engine([\"pred\", \"label\"]))},\n metric_cmp_fn=lambda cur, prev: cur >= prev, # if greater or equal, treat as new best metric\n val_handlers=val_handlers,\n amp=bool(amp),\n to_kwargs={\"memory_format\": torch.preserve_format},\n amp_kwargs={\"dtype\": torch.float16 if bool(amp) else torch.float32} if pytorch_after(1, 10, 0) else {},\n )\n\n train_postprocessing = Compose(\n [\n ToTensord(keys=[\"pred\", \"label\"]),\n Activationsd(keys=\"pred\", sigmoid=True),\n AsDiscreted(keys=\"pred\", threshold=0.5),\n KeepLargestConnectedComponentd(keys=\"pred\", applied_labels=[1]),\n ]\n )\n\n class _TestTrainIterEvents:\n def attach(self, engine):\n engine.add_event_handler(IterationEvents.FORWARD_COMPLETED, self._forward_completed)\n engine.add_event_handler(IterationEvents.LOSS_COMPLETED, self._loss_completed)\n engine.add_event_handler(IterationEvents.BACKWARD_COMPLETED, self._backward_completed)\n engine.add_event_handler(IterationEvents.MODEL_COMPLETED, self._model_completed)\n\n def _forward_completed(self, engine):\n pass\n\n def _loss_completed(self, engine):\n pass\n\n def _backward_completed(self, engine):\n pass\n\n def _model_completed(self, engine):\n pass\n\n train_handlers = [\n LrScheduleHandler(lr_scheduler=lr_scheduler, print_lr=True),\n ValidationHandler(validator=evaluator, interval=2, epoch_level=True),\n StatsHandler(tag_name=\"train_loss\", output_transform=from_engine(\"loss\", first=True)),\n TensorBoardStatsHandler(\n summary_writer=summary_writer, tag_name=\"train_loss\", output_transform=from_engine(\"loss\", first=True)\n ),\n CheckpointSaver(save_dir=root_dir, save_dict={\"net\": net, \"opt\": opt}, save_interval=2, epoch_level=True),\n _TestTrainIterEvents(),\n ]\n\n trainer = SupervisedTrainer(\n device=device,\n max_epochs=5,\n train_data_loader=train_loader,\n network=net,\n optimizer=opt,\n loss_function=loss,\n inferer=SimpleInferer(),\n postprocessing=train_postprocessing,\n key_train_metric={\"train_acc\": Accuracy(output_transform=from_engine([\"pred\", \"label\"]))},\n train_handlers=train_handlers,\n amp=bool(amp),\n optim_set_to_none=True,\n to_kwargs={\"memory_format\": torch.preserve_format},\n amp_kwargs={\"dtype\": torch.float16 if bool(amp) else torch.float32} if pytorch_after(1, 10, 0) else {},\n )\n trainer.run()\n\n return evaluator.state.best_metric\n\n\ndef run_inference_test(root_dir, model_file, device=\"cuda:0\", amp=False, num_workers=4):\n images = sorted(glob(os.path.join(root_dir, \"im*.nii.gz\")))\n segs = sorted(glob(os.path.join(root_dir, \"seg*.nii.gz\")))\n val_files = [{\"image\": img, \"label\": seg} for img, seg in zip(images, segs)]\n\n # define transforms for image and segmentation\n val_transforms = Compose(\n [\n LoadImaged(keys=[\"image\", \"label\"]),\n AsChannelFirstd(keys=[\"image\", \"label\"], channel_dim=-1),\n ScaleIntensityd(keys=[\"image\", \"label\"]),\n ToTensord(keys=[\"image\", \"label\"]),\n ]\n )\n\n # create a validation data loader\n val_ds = monai.data.Dataset(data=val_files, transform=val_transforms)\n val_loader = monai.data.DataLoader(val_ds, batch_size=1, num_workers=num_workers)\n\n # create UNet, DiceLoss and Adam optimizer\n net = monai.networks.nets.UNet(\n spatial_dims=3,\n in_channels=1,\n out_channels=1,\n channels=(16, 32, 64, 128, 256),\n strides=(2, 2, 2, 2),\n num_res_units=2,\n ).to(device)\n\n val_postprocessing = Compose(\n [\n ToTensord(keys=[\"pred\", \"label\"]),\n Activationsd(keys=\"pred\", sigmoid=True),\n AsDiscreted(keys=\"pred\", threshold=0.5),\n KeepLargestConnectedComponentd(keys=\"pred\", applied_labels=[1]),\n # test the case that `pred` in `engine.state.output`, while `image_meta_dict` in `engine.state.batch`\n SaveImaged(\n keys=\"pred\", meta_keys=PostFix.meta(\"image\"), output_dir=root_dir, output_postfix=\"seg_transform\"\n ),\n ]\n )\n val_handlers = [\n StatsHandler(iteration_log=False),\n CheckpointLoader(load_path=f\"{model_file}\", load_dict={\"net\": net}),\n SegmentationSaver(\n output_dir=root_dir,\n output_postfix=\"seg_handler\",\n batch_transform=from_engine(PostFix.meta(\"image\")),\n output_transform=from_engine(\"pred\"),\n ),\n ]\n\n evaluator = SupervisedEvaluator(\n device=device,\n val_data_loader=val_loader,\n network=net,\n inferer=SlidingWindowInferer(roi_size=(96, 96, 96), sw_batch_size=4, overlap=0.5),\n postprocessing=val_postprocessing,\n key_val_metric={\n \"val_mean_dice\": MeanDice(include_background=True, output_transform=from_engine([\"pred\", \"label\"]))\n },\n additional_metrics={\"val_acc\": Accuracy(output_transform=from_engine([\"pred\", \"label\"]))},\n val_handlers=val_handlers,\n amp=bool(amp),\n )\n evaluator.run()\n\n return evaluator.state.best_metric\n\n\n@skip_if_quick\nclass IntegrationWorkflows(DistTestCase):\n def setUp(self):\n set_determinism(seed=0)\n\n self.data_dir = tempfile.mkdtemp()\n for i in range(40):\n im, seg = create_test_image_3d(128, 128, 128, num_seg_classes=1, channel_dim=-1)\n n = nib.Nifti1Image(im, np.eye(4))\n nib.save(n, os.path.join(self.data_dir, f\"img{i:d}.nii.gz\"))\n n = nib.Nifti1Image(seg, np.eye(4))\n nib.save(n, os.path.join(self.data_dir, f\"seg{i:d}.nii.gz\"))\n\n self.device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu:0\")\n monai.config.print_config()\n\n def tearDown(self):\n set_determinism(seed=None)\n shutil.rmtree(self.data_dir)\n\n def train_and_infer(self, idx=0):\n results = []\n set_determinism(seed=0)\n best_metric = run_training_test(self.data_dir, device=self.device, amp=(idx == 2))\n model_file = sorted(glob(os.path.join(self.data_dir, \"net_key_metric*.pt\")))[-1]\n infer_metric = run_inference_test(self.data_dir, model_file, device=self.device, amp=(idx == 2))\n\n print(\"best metric\", best_metric)\n print(\"infer metric\", infer_metric)\n if idx == 2:\n self.assertTrue(test_integration_value(TASK, key=\"best_metric_2\", data=best_metric, rtol=1e-2))\n else:\n self.assertTrue(test_integration_value(TASK, key=\"best_metric\", data=best_metric, rtol=1e-2))\n # check inference properties\n if idx == 2:\n self.assertTrue(test_integration_value(TASK, key=\"infer_metric_2\", data=infer_metric, rtol=1e-2))\n else:\n self.assertTrue(test_integration_value(TASK, key=\"infer_metric\", data=infer_metric, rtol=1e-2))\n results.append(best_metric)\n results.append(infer_metric)\n\n def _test_saved_files(postfix):\n output_files = sorted(glob(os.path.join(self.data_dir, \"img*\", f\"*{postfix}.nii.gz\")))\n values = []\n for output in output_files:\n ave = np.mean(nib.load(output).get_fdata())\n values.append(ave)\n if idx == 2:\n self.assertTrue(test_integration_value(TASK, key=\"output_sums_2\", data=values, rtol=1e-2))\n else:\n self.assertTrue(test_integration_value(TASK, key=\"output_sums\", data=values, rtol=1e-2))\n\n _test_saved_files(postfix=\"seg_handler\")\n _test_saved_files(postfix=\"seg_transform\")\n try:\n os.remove(model_file)\n except Exception as e:\n warnings.warn(f\"Fail to remove {model_file}: {e}.\")\n if torch.cuda.is_available():\n try:\n torch.cuda.empty_cache()\n except Exception:\n pass\n\n return results\n\n def test_training(self):\n repeated = []\n test_rounds = 3\n for i in range(test_rounds):\n results = self.train_and_infer(idx=i)\n repeated.append(results)\n np.testing.assert_allclose(repeated[0], repeated[1])\n\n @TimedCall(seconds=300, skip_timing=not torch.cuda.is_available(), daemon=False)\n def test_timing(self):\n self.train_and_infer(idx=2)\n\n\nif __name__ == \"__main__\":\n unittest.main()\n"
] | [
[
"torch.cuda.empty_cache",
"numpy.eye",
"torch.cuda.is_available",
"torch.utils.tensorboard.SummaryWriter",
"numpy.testing.assert_allclose",
"torch.optim.lr_scheduler.StepLR"
]
] |
sirmarcel/cmlkit-examples | [
"fe9d15b16095af2730875dc9a98d2918eede6f5e"
] | [
"dataset/kaggle.py"
] | [
"import qmmlpack as qmml\nimport numpy as np\nimport ase.io as asio\nimport csv\nfrom cmlkit.dataset import Dataset, Subset\nimport cmlkit.indices as cmli\n\n# The following assumes that you have downloaded the Kaggle dataset from\n# https://www.kaggle.com/c/nomad2018-predict-transparent-conductors/data,\n# in particular train.csv.zip and train.zip, and have unzipped them\n# into this directory\n\n# You also need to have installed ASE, like so\n# conda install -c conda-forge ase\n\n# Use ASE to read the input files, which are in\n# aims format, despite having the xyz extension\n\nz = []\nr = []\nb = []\n\nfor i in range(2400):\n f = 'train/{}/geometry.xyz'.format(i + 1)\n structure = asio.read(f, format='aims')\n z.append(structure.numbers)\n r.append(structure.positions)\n b.append(structure.cell)\n\n# Convert to numpy arrays\nz = np.array(z)\nr = np.array(r)\nb = np.array(b)\n\n# Parse the CSV file for properties\n\nsg = []\nfe = []\nbg = []\n\nwith open('train.csv') as f:\n reader = csv.DictReader(f)\n for row in reader:\n sg.append(int(row['spacegroup']))\n fe.append(float(row['formation_energy_ev_natom']))\n bg.append(float(row['bandgap_energy_ev']))\n\n# Once again convert to numpy array\nfe = np.array(fe)\nsg = np.array(sg)\nbg = np.array(bg)\n\n# The following computes some associated quantities\n\nn_atoms = np.array([len(zz) for zz in z]) # count atoms in unit cell\nn_sub = np.array([len(zz[zz != 8]) for zz in z]) # count atoms that are not O (the number of substitution sites)\n\nfepa = fe * n_sub / n_atoms # formation energy per atom\nfecreal = fepa * n_atoms # formation energy per unit cell (NOT per site)\n\n# And now we actually create the Dataset\n\ndesc = \"Dataset (training portion) from the NOMAD2018 Kaggle challenge: \\\nRelaxed geometries and their properties. Note that fe is not the formation energy per atom but per substitution site!\"\n\ndata = Dataset('kaggle',\n z, r, b,\n {'fe': fe, 'fepa': fepa, 'fecreal': fecreal, 'n_atoms': n_atoms, 'n_sub': n_sub, 'sg': sg},\n desc=desc, family='tco')\n\n# And save. Bam!\ndata.save()\n\n# Let's now create a model building and validation split\n\nnp.random.seed(2312)\nrest, build = cmli.twoway_split(data.n, 2000)\n\nsub1 = Subset(data, build, name='build', desc='Randomly picked subset of 2000 structures')\nsub2 = Subset(data, rest, name='rest', desc='Randomly picked subset of 400 remaining structures (complement to build)')\nsub1.save()\nsub2.save()\n"
] | [
[
"numpy.array",
"numpy.random.seed"
]
] |
joepatmckenna/normal_forms | [
"e506304295a2592cfc050a2a688add89715aa5ff"
] | [
"normal_forms/examples/normal_form/for_plotting.py"
] | [
"import matplotlib.pyplot as plt\nimport numpy as np\n\ndef before_and_after(f, h, x_min=-1, x_max=1, y_min=-1, y_max=1):\n fig, ax = plt.subplots(1, 2, figsize=(8, 3))\n\n x = np.linspace(x_min, x_max, 500)\n y = np.linspace(y_min, y_max, 500)\n X, Y = np.meshgrid(x, y)\n\n Z = np.array([[f(xi, yi) for xi in x] for yi in y])\n ax[0].contour(X, Y, Z[..., 0], [0])\n ax[0].contour(X, Y, Z[..., 1], [0])\n ax[0].streamplot(X, Y, Z[..., 0], Z[..., 1])\n\n Z = np.array([[h(xi, yi) for xi in x] for yi in y])\n ax[1].contour(X, Y, Z[..., 0], [0])\n ax[1].contour(X, Y, Z[..., 1], [0])\n ax[1].streamplot(X, Y, Z[..., 0], Z[..., 1])\n\n plt.show()\n"
] | [
[
"matplotlib.pyplot.show",
"numpy.meshgrid",
"numpy.linspace",
"matplotlib.pyplot.subplots"
]
] |
zygmuntz/project-rhubarb | [
"d12fbdcdff817710c072f2e3128aae3a641c10ff"
] | [
"code/linear_dates_only.py"
] | [
"#!/usr/bin/env python\n\n\"the benchmark with date features only\"\n\"0.30421 on public leaderboard\"\n\nimport numpy as np\nimport pandas as pd\n\nfrom sklearn.linear_model import LinearRegression\n\n#\n\ntrain_file = '../data/train.csv'\ntest_file = '../data/test.csv'\n\noutput_file = 'linear_regression_with_date_features_only.csv'\n\nlog_transform = True\n\n#\n\ntrain = pd.read_csv( train_file, parse_dates = [ 'date' ])\ntest = pd.read_csv( test_file, parse_dates = [ 'date' ])\n\ntrain = train.dropna( axis = 0, how = 'any' )\n\n# day of week & month features\n\ntrain['day_of_week'] = train.date.dt.dayofweek\ntrain['month'] = train.date.dt.month\n\ntest['day_of_week'] = test.date.dt.dayofweek\ntest['month'] = test.date.dt.month\n\ntrain = pd.get_dummies( train, columns = [ 'day_of_week', 'month' ])\ntest = pd.get_dummies( test, columns = [ 'day_of_week', 'month' ])\n\n#\n\nday_of_week_cols = [ c for c in train.columns if c.startswith( 'day_of_week_' )]\nmonth_cols = [ c for c in train.columns if c.startswith( 'month_' )]\n\nuse_cols = day_of_week_cols + month_cols\n\nx_train = train[ use_cols ]\ny_train = train.mortality_rate.values\n\nx_test = test[ use_cols ]\n\n#\n\nlr = LinearRegression()\nlr.fit( x_train, y_train )\n\np = lr.predict( x_test )\n\npredictions = test[[ 'Id' ]].copy()\npredictions[ 'mortality_rate' ] = p\n\npredictions.to_csv( output_file, index = False )\n"
] | [
[
"pandas.read_csv",
"sklearn.linear_model.LinearRegression",
"pandas.get_dummies"
]
] |
arnodelorme/picard | [
"f8fb90c2bd2e21087e565da186664c4e54626e41"
] | [
"picard/_tools.py"
] | [
"# Authors: Pierre Ablin <[email protected]>\n# Alexandre Gramfort <[email protected]>\n# Jean-Francois Cardoso <[email protected]>\n#\n# License: BSD (3-clause)\nimport numbers\n\nimport numpy as np\n\nfrom scipy.linalg import expm\n\n\ndef gradient(Y, psiY):\n '''\n Compute the gradient for the current signals\n '''\n _, T = Y.shape\n return np.inner(psiY, Y) / float(T)\n\n\ndef proj_hessian_approx(Y, psidY_mean, G):\n '''\n Computes the projected Hessian approximation.\n '''\n N, _ = Y.shape\n diag = psidY_mean[:, None] * np.ones(N)[None, :]\n off_diag = np.diag(G)\n return 0.5 * (diag + diag.T - off_diag[:, None] - off_diag[None, :])\n\n\ndef regularize_hessian(h, l):\n '''\n Clips the eigenvalues of h to l\n '''\n h[h < l] = l\n return h\n\n\ndef solve_hessian(G, h):\n '''\n Returns the inverse Hessian times G\n '''\n return G / h\n\n\ndef loss(Y, signs, density):\n '''\n Returns the loss function\n '''\n output = 0.\n _, T = Y.shape\n for y, s in zip(Y, signs):\n output += s * np.mean(density.log_lik(y))\n return output\n\n\ndef l_bfgs_direction(G, h, s_list, y_list, r_list):\n q = G.copy()\n a_list = []\n for s, y, r in zip(reversed(s_list), reversed(y_list), reversed(r_list)):\n alpha = r * np.sum(s * q)\n a_list.append(alpha)\n q -= alpha * y\n z = solve_hessian(q, h)\n for s, y, r, alpha in zip(s_list, y_list, r_list, reversed(a_list)):\n beta = r * np.sum(y * z)\n z += (alpha - beta) * s\n return -z\n\n\ndef line_search(Y, signs, density, direction, current_loss, ls_tries):\n '''\n Performs a backtracking line search, starting from Y and W, in the\n direction direction.\n '''\n alpha = 1.\n if current_loss is None:\n current_loss = loss(Y, signs, density)\n for _ in range(ls_tries):\n Y_new = np.dot(expm(alpha * direction), Y)\n new_loss = loss(Y_new, signs, density)\n if new_loss < current_loss:\n return True, Y_new, new_loss, alpha\n alpha /= 2.\n else:\n return False, Y_new, new_loss, alpha\n\n\ndef permute(A):\n '''Get a permutation to diagonalize and scale a matrix\n\n Parameters\n ----------\n A : ndarray, shape (n_features, n_features)\n A matrix close from a permutation and scale matrix.\n\n Returns\n -------\n A : ndarray, shape (n_features, n_features)\n A permuted matrix.\n '''\n A = A.copy()\n n = A.shape[0]\n idx = np.arange(n)\n done = False\n while not done:\n done = True\n for i in range(n):\n for j in range(i):\n if A[i, i] ** 2 + A[j, j] ** 2 < A[i, j] ** 2 + A[j, i] ** 2:\n A[(i, j), :] = A[(j, i), :]\n idx[i], idx[j] = idx[j], idx[i]\n done = False\n A /= np.diag(A)\n order_sort = np.argsort(np.sum(np.abs(A), axis=0))\n A = A[order_sort, :]\n A = A[:, order_sort]\n return A\n\n\ndef check_random_state(seed):\n \"\"\"Turn seed into a np.random.RandomState instance\n Parameters\n ----------\n seed : None | int | instance of RandomState\n If seed is None, return the RandomState singleton used by np.random.\n If seed is an int, return a new RandomState instance seeded with seed.\n If seed is already a RandomState instance, return it.\n Otherwise raise ValueError.\n \"\"\"\n if seed is None or seed is np.random:\n return np.random.mtrand._rand\n if isinstance(seed, (numbers.Integral, np.integer)):\n return np.random.RandomState(seed)\n if isinstance(seed, np.random.RandomState):\n return seed\n raise ValueError('%r cannot be used to seed a numpy.random.RandomState'\n ' instance' % seed)\n\n\ndef _sym_decorrelation(W):\n \"\"\" Symmetric decorrelation\n i.e. W <- (W * W.T) ^{-1/2} * W\n \"\"\"\n s, u = np.linalg.eigh(np.dot(W, W.T))\n return np.dot(np.dot(u * (1. / np.sqrt(s)), u.T), W)\n\n\ndef _ica_par(X, fun, max_iter, w_init, verbose):\n \"\"\"Parallel FastICA.\n Used internally by FastICA --main loop\n \"\"\"\n if verbose:\n print('Running %d iterations of FastICA...' % max_iter)\n W = _sym_decorrelation(w_init)\n del w_init\n p_ = float(X.shape[1])\n for ii in range(max_iter):\n gwtx, g_wtx = fun.score_and_der(np.dot(W, X))\n g_wtx = g_wtx.mean(axis=1)\n W = _sym_decorrelation(np.dot(gwtx, X.T) / p_ -\n g_wtx[:, np.newaxis] * W)\n del gwtx, g_wtx\n if verbose:\n print('Running Picard...')\n return W\n"
] | [
[
"numpy.ones",
"numpy.sum",
"numpy.dot",
"numpy.diag",
"scipy.linalg.expm",
"numpy.abs",
"numpy.arange",
"numpy.random.RandomState",
"numpy.sqrt",
"numpy.inner"
]
] |
alexwong/tvm | [
"0b0bc3ed92b5578c481662287a39556f9b1a2535"
] | [
"python/tvm/relay/frontend/tensorflow.py"
] | [
"\n# Licensed to the Apache Software Foundation (ASF) under one\n# or more contributor license agreements. See the NOTICE file\n# distributed with this work for additional information\n# regarding copyright ownership. The ASF licenses this file\n# to you under the Apache License, Version 2.0 (the\n# \"License\"); you may not use this file except in compliance\n# with the License. You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing,\n# software distributed under the License is distributed on an\n# \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n# KIND, either express or implied. See the License for the\n# specific language governing permissions and limitations\n# under the License.\n# pylint: disable=import-self, invalid-name, unused-argument, too-many-lines, len-as-condition, broad-except\n\"\"\"TF: Tensorflow frontend.\"\"\"\nfrom __future__ import absolute_import as _abs\nfrom __future__ import print_function\n\nimport warnings\nfrom collections import defaultdict\n\n# Numpy support\nimport numpy as np\n\nimport tvm\n\nfrom tvm.relay.prelude import Prelude\n\nfrom .. import analysis\nfrom .. import expr as _expr\nfrom .. import op as _op\nfrom ..expr_functor import ExprMutator\nfrom .. import module as _module\nfrom .common import AttrCvt, get_relay_op\nfrom .common import infer_type as _infer_type\nfrom .common import infer_shape as _infer_shape\nfrom .common import infer_channels as _infer_channels\nfrom .common import infer_value as _infer_value\nfrom .common import infer_value_simulated as _infer_value_simulated\n\n__all__ = ['from_tensorflow']\n\n\ndef _get_pad_pair(input1d, kernel1d, stride1d):\n if input1d % stride1d == 0:\n pad = max(kernel1d - stride1d, 0)\n else:\n pad = max(kernel1d - (input1d % stride1d), 0)\n\n pad_before = pad // 2\n pad_after = pad - pad_before\n\n return [pad_before, pad_after]\n\ndef _math_name_picker(surfix):\n def _impl(attr):\n return 'broadcast_' + surfix\n return _impl\n\ndef _dimension_picker(prefix, surfix=''):\n def _impl(attr):\n kernel = attr['kernel_shape']\n if len(kernel) == 2:\n return prefix + '2d' + surfix\n raise tvm.error.OpAttributeInvalid(\n 'Only 2D kernels are supported for operator {}'.format(prefix + '2d'))\n return _impl\n\ndef _dimension_constraint():\n def _dim_check(attrs):\n if len(attrs['kernel_shape']) == 2:\n return True\n return False\n return _dim_check, \"Only 2d kernel supported.\"\n\ndef _get_param(params, input_node):\n if isinstance(input_node, _expr.Constant):\n return np.atleast_1d(input_node.data.asnumpy())\n return params.pop(input_node.name_hint).asnumpy()\n\ndef _get_num_param(params, input_node):\n return _get_param(params, input_node).item()\n\ndef _get_list_param(params, input_node):\n return _get_param(params, input_node).tolist()\n\ndef _get_tuple_param(params, input_node):\n return tuple(_get_param(params, input_node))\n\ndef _need_module_for_shape_inference(op):\n return op in ['StridedSlice']\n\ndef _need_prelude_for_shape_inference(op):\n return \"TensorArray\" in op\n\ndef _rsqrt():\n def _impl(inputs, attr, params):\n inputs.append(tvm.relay.const(-0.5, attr['T'].name))\n return AttrCvt(op_name=\"power\")(inputs, attr)\n return _impl\n\ndef _argx(func, func_name):\n \"\"\" A common wrapper for argmin and argmax operations \"\"\"\n def _impl(inputs, attr, params):\n try:\n # In Tensorflow, `axis` argument is a Tensor, not attribute. We\n # support the case where it inputs from a scalar constant.\n axis_input_value = [_get_num_param(params, inputs[1])]\n except (IndexError, KeyError):\n raise TypeError( \\\n \"Unsupported argument for `{}` : `axis` should be a constant\".format(func_name))\n return func(inputs[0], axis=axis_input_value, keepdims=False)\n return _impl\n\ndef _elemwise(name):\n def _impl(inputs, attr, params):\n assert len(inputs) == 2, \"{} take 2 inputs, {} given\".format(name, len(inputs))\n return get_relay_op(name)(*inputs)\n return _impl\n\ndef _pool3d(name):\n def _impl(inputs, attr, params):\n attr['data_format'] = attr['data_format'].decode(\"utf-8\")\n flip_layout = False\n\n input_shape = attr['_input_shapes'][inputs[0]]\n\n if attr['data_format'] == 'NDHWC':\n attr['kernel_shape'] = (attr['ksize'][1], attr['ksize'][2], attr['ksize'][3])\n attr['strides'] = (attr['strides'][1], attr['strides'][2], attr['strides'][3])\n elif attr['data_format'] == 'NCDHW':\n attr['kernel_shape'] = (attr['ksize'][2], attr['ksize'][3], attr['ksize'][4])\n attr['strides'] = (attr['strides'][2], attr['strides'][3], attr['strides'][4])\n else:\n msg = 'Value {} of attribute \"data_format\" of operator Pooling ' \\\n 'is not valid.'\n raise tvm.error.OpAttributeInvalid(msg.format(attr['data_format']))\n if attr['data_format'] == \"NDHWC\":\n input_shape = [attr['_input_shapes'][inputs[0]][i] for i in (0, 4, 1, 2, 3)]\n inputs[0] = _op.transpose(inputs[0], axes=(0, 4, 1, 2, 3))\n attr['data_format'] = \"NCDHW\"\n attr['_input_shapes'][inputs[0]] = input_shape\n flip_layout = True\n\n attr['padding'] = attr['padding'].decode(\"utf-8\")\n\n if attr['padding'] == 'VALID':\n attr['padding'] = [0, 0, 0, 0, 0, 0]\n elif attr['padding'] == 'SAME':\n stride_d, stride_h, stride_w = attr['strides']\n kernel_d, kernel_h, kernel_w = attr['kernel_shape']\n if attr['data_format'] == 'NDHWC':\n in_d = input_shape[1]\n in_h = input_shape[2]\n in_w = input_shape[3]\n else:\n in_d = input_shape[2]\n in_h = input_shape[3]\n in_w = input_shape[4]\n pad_d = _get_pad_pair(in_d, kernel_d, stride_d)\n pad_v = _get_pad_pair(in_h, kernel_h, stride_h)\n pad_h = _get_pad_pair(in_w, kernel_w, stride_w)\n\n attr['padding'] = [pad_d[0], pad_v[0], pad_h[0], pad_d[1], pad_v[1], pad_h[1]]\n else:\n msg = 'Value {} in attribute \"padding\" of operator Pooling is ' \\\n 'not valid.'\n raise tvm.error.OpAttributeInvalid(msg.format(attr['padding']))\n\n if name == \"avg_pool\":\n attr['count_include_pad'] = False\n attr['ceil_mode'] = False\n out = AttrCvt(\n op_name=name,\n transforms={\n 'kernel_shape': 'pool_size',\n 'data_format': 'layout'},\n ignores=['ksize'])(inputs, attr)\n if flip_layout:\n out = _op.transpose(out, axes=(0, 2, 3, 4, 1))\n return out\n\n return _impl\n\ndef _pooling(name):\n def _impl(inputs, attr, params):\n\n attr['data_format'] = attr['data_format'].decode(\"utf-8\")\n flip_layout = False\n\n input_shape = attr['_input_shapes'][inputs[0]]\n\n if attr['data_format'] == 'NHWC':\n attr['kernel_shape'] = (attr['ksize'][1], attr['ksize'][2])\n attr['strides'] = (attr['strides'][1], attr['strides'][2])\n elif attr['data_format'] == 'NCHW':\n attr['kernel_shape'] = (attr['ksize'][2], attr['ksize'][3])\n attr['strides'] = (attr['strides'][2], attr['strides'][3])\n else:\n msg = 'Value {} of attribute \"data_format\" of operator Pooling ' \\\n 'is not valid.'\n raise tvm.error.OpAttributeInvalid(msg.format(attr['data_format']))\n\n if attr['_target_layout'] == \"NCHW\" and attr['data_format'] == \"NHWC\":\n tmp_shape = attr['_input_shapes'][inputs[0]]\n input_shape = [tmp_shape[ii] for ii in (0, 3, 1, 2)]\n inputs[0] = _op.transpose(inputs[0], axes=(0, 3, 1, 2))\n attr['data_format'] = \"NCHW\"\n flip_layout = True\n\n # Fix padding\n attr['padding'] = attr['padding'].decode(\"utf-8\")\n\n if attr['padding'] == 'VALID':\n attr['padding'] = [0, 0]\n elif attr['padding'] == 'SAME':\n stride_h, stride_w = attr['strides']\n kernel_h, kernel_w = attr['kernel_shape']\n if attr['data_format'] == 'NHWC':\n in_h = input_shape[1]\n in_w = input_shape[2]\n else:\n in_h = input_shape[2]\n in_w = input_shape[3]\n\n pad_v = _get_pad_pair(in_h, kernel_h, stride_h)\n pad_h = _get_pad_pair(in_w, kernel_w, stride_w)\n\n attr['padding'] = [pad_v[0], pad_h[0], pad_v[1], pad_h[1]]\n else:\n msg = 'Value {} in attribute \"padding\" of operator Pooling is ' \\\n 'not valid.'\n raise tvm.error.OpAttributeInvalid(msg.format(attr['padding']))\n\n if name == \"avg_pool\":\n attr['count_include_pad'] = False\n\n out = AttrCvt(\n op_name=_dimension_picker(name),\n transforms={\n 'kernel_shape':'pool_size',\n 'data_format':'layout'},\n ignores=['ksize'],\n extras={'ceil_mode': False},\n custom_check=_dimension_constraint())(inputs, attr)\n\n if flip_layout:\n out = _op.transpose(out, axes=(0, 2, 3, 1))\n\n return out\n return _impl\n\ndef _conv(opname):\n def _impl(inputs, attr, params):\n attr['data_format'] = attr['data_format'].decode(\"utf-8\")\n flip_layout = False\n\n if opname == 'conv_transpose' and attr['data_format'] == 'NHWC':\n # transform to NCHW for TVM backend compatible and set 'flip_layout'\n # to have output flip back to NHWC\n tmp_shape = attr['_input_shapes'][inputs[2]]\n tmp_shape = [tmp_shape[ii] for ii in (0, 3, 1, 2)]\n inputs[2] = _op.transpose(inputs[2], axes=(0, 3, 1, 2))\n attr['_input_shapes'][inputs[2]] = tmp_shape\n attr['strides'][1], attr['strides'][2], attr['strides'][3] = \\\n attr['strides'][3], attr['strides'][1], attr['strides'][2]\n attr['data_format'] = 'NCHW'\n\n if opname == 'conv_transpose' and len(attr['_output_shapes']) > 0:\n tmp_shape = attr['_output_shapes'][0]\n tmp_shape = [tmp_shape[ii] for ii in (0, 3, 1, 2)]\n attr['_output_shapes'][0] = tmp_shape\n\n flip_layout = True\n\n inputs_data = inputs[0] if opname != 'conv_transpose' else inputs[2]\n\n # NCHW Layout require weights transpose\n if attr['data_format'] == 'NCHW':\n tmp_shape = attr['_input_shapes'][inputs[1]]\n if opname in ['conv', 'conv_transpose']:\n tmp_shape = [tmp_shape[ii] for ii in (3, 2, 0, 1)]\n inputs[1] = _op.transpose(inputs[1], axes=(3, 2, 0, 1))\n else:\n tmp_shape = [tmp_shape[ii] for ii in (2, 3, 0, 1)]\n inputs[1] = _op.transpose(inputs[1], axes=(2, 3, 0, 1))\n attr['_input_shapes'][inputs[1]] = tmp_shape\n\n input_shape = attr['_input_shapes'][inputs_data]\n weights_shape = attr['_input_shapes'][inputs[1]]\n\n if attr['_target_layout'] == \"NCHW\" and attr['data_format'] == \"NHWC\":\n input_shape = [input_shape[ii] for ii in (0, 3, 1, 2)]\n inputs_data = _op.transpose(inputs_data, axes=(0, 3, 1, 2))\n if opname in ['conv', 'conv_transpose']:\n weights_shape = [weights_shape[ii] for ii in (3, 2, 0, 1)]\n inputs[1] = _op.transpose(inputs[1], axes=(3, 2, 0, 1))\n else:\n weights_shape = [weights_shape[ii] for ii in (2, 3, 0, 1)]\n inputs[1] = _op.transpose(inputs[1], axes=(2, 3, 0, 1))\n\n attr['data_format'] = \"NCHW\"\n attr['strides'] = [attr['strides'][ii] for ii in (0, 3, 1, 2)]\n flip_layout = True\n\n if attr['data_format'] == 'NHWC':\n kernel_h, kernel_w, _, depth_mult = weights_shape\n attr['kernel_shape'] = (weights_shape[0], weights_shape[1])\n if opname == 'conv':\n attr['channels'] = weights_shape[3]\n elif opname == 'conv_transpose':\n attr['channels'] = weights_shape[2]\n else:\n attr['channels'] = input_shape[3] * depth_mult\n\n if 'dilations' in attr:\n attr['dilations'] = (attr['dilations'][1], attr['dilations'][2])\n attr['strides'] = (attr['strides'][1], attr['strides'][2])\n elif attr['data_format'] == 'NCHW':\n _, depth_mult, kernel_h, kernel_w = weights_shape\n attr['kernel_shape'] = (weights_shape[2], weights_shape[3])\n if opname == 'conv':\n attr['channels'] = weights_shape[0]\n elif opname == 'conv_transpose':\n attr['channels'] = weights_shape[1]\n else:\n attr['channels'] = input_shape[1] * depth_mult\n if attr['channels'] < 0:\n attr['channels'] *= -1\n\n if 'dilations' in attr:\n attr['dilations'] = (attr['dilations'][2], attr['dilations'][3])\n attr['strides'] = (attr['strides'][2], attr['strides'][3])\n else:\n msg = 'Value {} in attribute \"data_format\" of operator Conv is ' \\\n 'not valid.'\n raise tvm.error.OpAttributeInvalid(msg.format(attr['data_format']))\n\n if opname == 'depthwise':\n attr['groups'] = attr['channels']\n\n # Fix padding\n attr['padding'] = attr['padding'].decode(\"utf-8\")\n\n if attr['padding'] == 'VALID':\n attr['padding'] = [0, 0]\n elif attr['padding'] == 'SAME':\n stride_h, stride_w = attr['strides']\n kernel_h, kernel_w = attr['kernel_shape']\n\n pdata_shape = input_shape\n if opname == 'conv_transpose' and len(attr['_output_shapes']) > 0:\n pdata_shape = attr['_output_shapes'][0]\n\n if attr['data_format'] == 'NHWC':\n in_h = pdata_shape[1]\n in_w = pdata_shape[2]\n else:\n in_h = pdata_shape[2]\n in_w = pdata_shape[3]\n\n dilation_h = attr['dilations'][0]\n dilation_w = attr['dilations'][1]\n dilated_kernel_h = (kernel_h - 1) * dilation_h + 1\n dilated_kernel_w = (kernel_w - 1) * dilation_w + 1\n pad_v = _get_pad_pair(in_h, dilated_kernel_h, stride_h)\n pad_h = _get_pad_pair(in_w, dilated_kernel_w, stride_w)\n\n if opname != 'conv_transpose':\n if attr['data_format'] == 'NHWC':\n inputs_data = _op.nn.pad(data=inputs_data,\n pad_width=((0, 0),\n (pad_v[0], pad_v[1]),\n (pad_h[0], pad_h[1]),\n (0, 0)))\n else:\n inputs_data = _op.nn.pad(data=inputs_data,\n pad_width=((0, 0),\n (0, 0),\n (pad_v[0], pad_v[1]),\n (pad_h[0], pad_h[1])))\n\n attr['padding'] = [0, 0]\n else:\n attr['padding'] = [pad_v[0], pad_h[0], pad_v[1], pad_h[1]]\n\n else:\n msg = 'Value {} in attribute \"padding\" of operator Conv is not ' \\\n 'valid.'\n raise tvm.error.OpAttributeInvalid(msg.format(attr['padding']))\n\n if 'kernel_layout' not in attr:\n if opname in ['conv', 'conv_transpose']:\n attr['kernel_layout'] = 'HWIO' if attr['data_format'] == 'NHWC' else 'OIHW'\n else:\n attr['kernel_layout'] = 'HWOI' if attr['data_format'] == 'NHWC' else 'OIHW'\n\n use_bias = len(inputs) == (3 if opname != 'conv_transpose' else 4)\n channel_axis = 1 if attr['data_format'] == \"NCHW\" else 3\n\n # Ignore the new attributes from TF2.0, for now.\n out = AttrCvt(\n op_name=_dimension_picker('conv', \\\n surfix=\"_transpose\" if opname == 'conv_transpose' else \"\"),\n ignores=['explicit_paddings'],\n transforms={\n 'kernel_shape': 'kernel_size',\n 'data_format': 'data_layout',\n 'dilations': ('dilation', (0, 0)),\n 'group': ('groups', 1)},\n custom_check=_dimension_constraint())([inputs_data, inputs[1]], attr)\n\n if use_bias:\n out = _op.nn.bias_add(out,\n inputs[2] if opname != 'conv_transpose' else inputs[3],\n axis=channel_axis)\n\n if flip_layout:\n out = _op.transpose(out, axes=(0, 2, 3, 1))\n\n return out\n return _impl\n\ndef _decode_image():\n def _impl(inputs, attr, params):\n # Image decode wrapper: Expecting user to feed decoded input to next layer drop this layer.\n warnings.warn(\"DecodeJpeg: It's a pass through, please handle preprocessing before input\")\n return inputs[0]\n return _impl\n\ndef _crop_and_resize():\n def _impl(inputs, attr, params):\n # input image is a 4-D tensor of shape [batch, image_height, image_width, depth]\n # boxes is a 2-D tensor of shape [num_boxes, 4], 4 is for [y1, x1, y2, x2]\n try:\n boxes = _get_list_param(params, inputs[1])\n box_ind = _get_list_param(params, inputs[2])\n crop_size = _get_list_param(params, inputs[3])\n except (IndexError, KeyError):\n boxes = _infer_value(inputs[1], params).asnumpy().tolist()\n box_ind = _infer_value(inputs[2], params).asnumpy().tolist()\n crop_size = _infer_value(inputs[3], params).asnumpy().tolist()\n\n data_shape = attr['_input_shapes'][inputs[0]]\n data_dim = len(data_shape)\n method = attr['method'].decode()\n\n attrs = {}\n attrs['size'] = crop_size\n attrs['layout'] = 'NHWC'\n if method.lower() == 'nearest':\n raise tvm.error.OpAttributeUnImplemented(\n 'Attribute method=nearest is not supported')\n else:\n attrs['align_corners'] = True\n attrs['method'] = 'bilinear'\n\n out = None\n begin = [0] * data_dim\n size = data_shape[:]\n for idx in box_ind:\n # 1) Crop\n # y is mapped to the image coordinate at y * (image_height - 1)\n # x is mapped to the image coordinate at x * (image_width - 1)\n begin[0] = idx\n begin[1] = int(round(boxes[idx][0] * (data_shape[1] - 1)))\n begin[2] = int(round(boxes[idx][1] * (data_shape[2] - 1)))\n size[0] = idx + 1\n size[1] = int(round((data_shape[1] - 1) * boxes[idx][2])) + 1\n size[2] = int(round((data_shape[2] - 1) * boxes[idx][3])) + 1\n res_crop = _op.strided_slice(inputs[0], begin=begin, end=size)\n\n # 2) Resize\n res_resize = get_relay_op('resize')(res_crop, **attrs)\n out = _op.concatenate([out, res_resize], axis=0) if out else res_resize\n return out\n return _impl\n\ndef _cast():\n def _impl(inputs, attr, params):\n return inputs[0].astype(attr['DstT'].name)\n return _impl\n\ndef _expand_dims():\n def _impl(inputs, attr, params):\n dim_input = inputs.pop(1)\n axis = _get_num_param(params, dim_input)\n return AttrCvt(op_name=\"expand_dims\", ignores=['Tdim', 'N'],\n extras={'axis': int(axis), 'num_newaxis': 1})(inputs, attr)\n return _impl\n\ndef _resize(method):\n def _impl(inputs, attr, params):\n output_shape0 = attr['_output_shapes'][0]\n # Dynamic size models might have _output_shapes attr equal to [None] here\n size = output_shape0[1:3] if output_shape0 is not None else [-1, -1]\n # Important that the size is defined. If an axis is not, we need to infer what\n # the shape should be.\n if -1 in size:\n size = _infer_value(inputs[1], params).asnumpy().reshape([-1]).tolist()\n attr['size'] = size\n inputs.pop(1)\n # NHWC\n attr['layout'] = 'NHWC'\n\n # Ignore the new attributes from TF2.0, for now.\n return AttrCvt(op_name='resize',\n ignores=['Tdim', 'half_pixel_centers'],\n extras={'method': method})(inputs, attr)\n return _impl\n\ndef _check_numerics():\n def _impl(inputs, attr, params):\n # Making a copy node assuming no need to verify\n return AttrCvt(op_name=\"copy\", ignores=['message'])(inputs, attr)\n return _impl\n\ndef _assert():\n # ToDo: In general people want asserts to be gone from TensorFlow graphs\n # when they are optimizing them, so converting it to a no-op is\n # reasonable. However, it would be nice to have the option to keep them\n # once Relay gets a Halt or Assert op.\n return _no_op()\n\ndef _no_op():\n def _impl(inputs, attr, params):\n # ToDo: This should really be an op that returns nothing, which could\n # be represented as an empty tuple. It turns out that TVM\n # infrastructure doesn't like running functions that return None and\n # also don't like running functions that return an empty tuple. So it\n # doesn't work, but it should be made to work and then this could be\n # improved. In the mean time, it is hard to imagine a case where it\n # matters in any real way that a no-op is converted to a constant 0.\n return tvm.relay.const(0)\n return _impl\n\ndef _matmul():\n def _impl(inputs, attr, params):\n channels = _infer_channels(inputs[1], not attr['transpose_b'])\n if attr['transpose_a']:\n inputs[0] = _op.transpose(inputs[0], axes=(1, 0))\n if not attr['transpose_b']:\n inputs[1] = _op.transpose(inputs[1], axes=(1, 0))\n return AttrCvt(op_name=\"dense\",\n extras={'units': channels},\n ignores=['transpose_a', 'transpose_b', 'T'])(inputs, attr)\n\n return _impl\n\ndef _batch_matmul():\n def _impl(inputs, attr, params):\n input_x = inputs[0]\n input_y = inputs[1]\n orig_shape_x = attr['_input_shapes'][input_x]\n orig_shape_y = attr['_input_shapes'][input_y]\n\n # reshape n-dimensional batch matmul into 3d\n if len(orig_shape_x) > 3:\n outer_dims = [orig_shape_x[i] for i in range(0, len(orig_shape_x) - 2)]\n num_outer_elts = np.prod(outer_dims)\n new_shape_x = (num_outer_elts, orig_shape_x[-2], orig_shape_x[-1])\n new_shape_y = (num_outer_elts, orig_shape_y[-2], orig_shape_y[-1])\n input_x = _op.reshape(input_x, newshape=new_shape_x)\n input_y = _op.reshape(input_y, newshape=new_shape_y)\n\n adj_x = attr['adj_x']\n adj_y = attr['adj_y']\n input_x = _op.transpose(input_x, axes=[0, 2, 1]) if adj_x else input_x\n input_y = _op.transpose(input_y, axes=[0, 2, 1]) if not adj_y else input_y\n ret = get_relay_op('batch_matmul')(input_x, input_y)\n\n # reshape result back to n-dimensional\n if len(orig_shape_x) > 3:\n final_shape = list(orig_shape_x)\n final_shape[-2] = orig_shape_x[-1] if adj_x else orig_shape_x[-2]\n final_shape[-1] = orig_shape_y[-2] if adj_y else orig_shape_y[-1]\n ret = _op.reshape(ret, newshape=final_shape)\n\n return ret\n return _impl\n\ndef _identity():\n def _impl(inputs, attr, params):\n return inputs[0]\n return _impl\n\ndef _concatV2():\n def _impl(inputs, attr, params):\n pop_node = inputs.pop(len(inputs)-1)\n axis = int(_get_num_param(params, pop_node))\n return AttrCvt(\n op_name=\"concatenate\", ignores=['T', 'N', 'Tidx'],\n extras={'axis': axis})([inputs], attr)\n return _impl\n\ndef _concat():\n def _impl(inputs, attr, params):\n pop_node = inputs.pop(0)\n axis = int(_get_num_param(params, pop_node))\n return AttrCvt(\n op_name=\"concatenate\", ignores=['N'],\n extras={'axis': axis})([inputs], attr)\n return _impl\n\ndef _pack():\n def _impl(inputs, attr, params):\n axis = int(attr[\"axis\"])\n inputs_reshaped = [_op.expand_dims(i, axis=axis, num_newaxis=1) for i in inputs]\n return _op.concatenate(inputs_reshaped, axis)\n return _impl\n\ndef _tensor_array():\n def _impl(inputs, attr, params, prelude):\n dtype_str = attr.get('dtype').name\n tensor_array_constructor = prelude.get_var('tensor_array', dtype_str)\n return tensor_array_constructor(_op.take(inputs[0], tvm.relay.const(0)))\n return _impl\n\ndef _tensor_array_scatter():\n def _impl(inputs, attr, params, prelude):\n dtype_str = attr.get('T').name\n values_rank = len(inputs[2].type_annotation.shape)\n unstack_name = \"tensor_array_unstack_tensor{}\".format(values_rank)\n unstack_function = prelude.get_var(unstack_name, dtype_str)\n values = unstack_function(inputs[2])\n tensor_array_scatter_func = prelude.get_var('tensor_array_scatter', dtype_str)\n return tensor_array_scatter_func(inputs[0], inputs[1], values)\n return _impl\n\ndef _tensor_array_gather():\n def _impl(inputs, attr, params, prelude):\n return prelude.tensor_array_gather(inputs[2], inputs[1])\n return _impl\n\ndef _tensor_array_size():\n def _impl(inputs, attr, params, prelude):\n return prelude.length(inputs[0])\n return _impl\n\ndef _tensor_array_write():\n def _impl(inputs, attr, params, prelude):\n input_rank = len(inputs[2].type_annotation.shape)\n dtype = attr.get('T').name\n\n tensor_name = 'tensor{}'.format(input_rank)\n tensor_func = prelude.get_var(tensor_name, dtype)\n v = tensor_func(inputs[2])\n write_func = prelude.get_var('tensor_array_write', dtype)\n\n return write_func(inputs[3], _op.take(inputs[1], tvm.relay.const(0)), v)\n return _impl\n\ndef _tensor_array_read():\n def _impl(inputs, attr, params, prelude):\n read_func = prelude.get_var('tensor_array_read', attr.get('dtype').name)\n return read_func(inputs[2], _op.take(inputs[1], tvm.relay.const(0)))\n return _impl\n\ndef _tensor_array_split():\n def _impl(inputs, attr, params, prelude):\n input_rank = len(inputs[1].type_annotation.shape)\n dtype_str = attr.get('T').name\n v = prelude.get_var(\"tensor{}\".format(input_rank), dtype_str)(inputs[1])\n lengths = _op.cast(inputs[2], 'int32')\n split_var = prelude.get_var('tensor_array_split', dtype_str)\n return split_var(inputs[0], v, lengths)\n return _impl\n\ndef _tensor_array_concat():\n def _impl(inputs, attr, params, prelude):\n concat_func = prelude.get_var('tensor_array_concat', attr['dtype'].name)\n return concat_func(inputs[1])\n return _impl\n\ndef _tile():\n def _impl(inputs, attr, params):\n reps = _get_list_param(params, inputs.pop())\n new_input = []\n new_input.append(inputs.pop(0))\n\n return AttrCvt(\n op_name='tile',\n extras={'reps': tuple(reps)},\n ignores=['Tmultiples'])(new_input, attr)\n return _impl\n\ndef _slice():\n def _impl(inputs, attr, params):\n try:\n begin = _get_list_param(params, inputs[1])\n except (IndexError, KeyError, AttributeError):\n begin = _infer_value(inputs[1], params).asnumpy().tolist()[0]\n try:\n size = _get_list_param(params, inputs[2])\n except (IndexError, KeyError, AttributeError):\n size = _infer_value(inputs[2], params).asnumpy().tolist()[0]\n data_shape = attr['_input_shapes'][inputs[0]]\n data_dim = len(data_shape)\n end = size\n for i in range(data_dim):\n if size[i] == -1:\n end[i] = data_shape[i] - begin[i]\n else:\n end[i] += begin[i]\n return _op.strided_slice(inputs[0], begin=begin, end=end)\n return _impl\n\n\ndef _reshape():\n def _impl(inputs, attr, params):\n pop_node = inputs.pop(1)\n\n try:\n shape_arg = _get_tuple_param(params, pop_node)\n except AttributeError:\n # Shape operator is already pruned, hence\n # try to infer shape by precompute prune if possible.\n try:\n params_new = _infer_value(pop_node, params)\n shape_arg = tuple(params_new.asnumpy().astype('int64').flatten())\n except Exception:\n # Deal with symbolic shape case.\n # Currently only shape_of can be the direct ancestor.\n if not isinstance(pop_node, tvm.relay.expr.Call) or \\\n \"shape_of\" not in str(pop_node.op):\n raise RuntimeError(\"If shape operator is used in reshape to \"\n \"express reshape_like, shape_of must be \"\n \"the direct ancestor of reshape when input \"\n \"shape is symbolic.\")\n return _op.reshape_like(inputs[0], pop_node.args[0])\n return AttrCvt(\n op_name=\"reshape\",\n extras={'newshape': shape_arg},\n ignores=['Tshape'])(inputs, attr)\n return _impl\n\n\ndef _depth_to_space():\n def _impl(inputs, attr, params):\n block_size = int(attr['block_size'])\n layout = attr['data_format'].decode(\"utf-8\")\n return _op.nn.depth_to_space(inputs[0], block_size, layout)\n\n return _impl\n\n\ndef _space_to_depth():\n def _impl(inputs, attr, params):\n block_size = int(attr['block_size'])\n layout = attr['data_format'].decode(\"utf-8\")\n return _op.nn.space_to_depth(inputs[0], block_size, layout)\n\n return _impl\n\n\ndef _bias_add():\n def _impl(inputs, attr, params):\n # Must expand for proper broadcasting in NCHW.\n if attr['data_format'].decode(\"utf-8\") == 'NCHW':\n bias = _op.reshape(inputs[1], newshape=(1, -1, 1, 1))\n else:\n bias = inputs[1]\n return _op.add(inputs[0], bias)\n return _impl\n\ndef _broadcast_to():\n def _impl(inputs, attr, params):\n if isinstance(inputs[1], _expr.Var):\n shape = params[inputs[1].name_hint]\n else:\n shape = _infer_value(inputs[1], params)\n shape = list(shape.asnumpy().reshape([-1]))\n return _op.broadcast_to(inputs[0], shape)\n return _impl\n\ndef _squeeze():\n def _impl(inputs, attr, params):\n if len(attr['squeeze_dims']) == 0:\n attr['squeeze_dims'] = None\n return AttrCvt(\n op_name=\"squeeze\",\n transforms={'squeeze_dims':'axis'},\n ignores=['T'])(inputs, attr)\n return _impl\n\ndef _fused_batch_norm():\n def _impl(inputs, attr, params):\n # Tensorflow: (data, gamma, beta, moving_mean, moving_variance)\n # Relay: (data, gamma, beta, moving_mean, moving_varience)\n axis = 3\n need_cast = False\n\n if 'data_format' in attr:\n attr['data_format'] = attr['data_format'].decode(\"utf-8\")\n if attr['data_format'] == 'NCHW':\n axis = 1\n if 'U' in attr:\n need_cast = True\n inputs[0] = _op.cast(inputs[0], dtype=attr['U'].name)\n\n out = AttrCvt(op_name='batch_norm',\n transforms={'scale_after_normalization':'scale',\n 'variance_epsilon':'epsilon'},\n extras={'axis': axis},\n ignores=['data_format', 'U'],\n disables=['momentum'])(inputs, attr)\n\n if need_cast:\n out = _op.cast(out, dtype=attr['T'].name)\n return out\n return _impl\n\ndef _batch_norm():\n def _impl(inputs, attr, params):\n # Rearrange inputs from\n # (data, moving_mean, moving_variance, beta, gamma)\n # to\n # (data, gamma, beta, moving_mean, moving_var)\n new_inputs = [inputs[0], inputs[4], inputs[3], inputs[1], inputs[2]]\n\n axis = 3\n if 'data_format' in attr:\n attr['data_format'] = attr['data_format'].decode(\"utf-8\")\n if attr['data_format'] == 'NCHW':\n axis = 1\n\n return AttrCvt(\n op_name='batch_norm',\n transforms={'scale_after_normalization':'scale', 'variance_epsilon':'epsilon'},\n extras={'axis': axis},\n ignores=['data_format'],\n disables=['momentum'])(new_inputs, attr)\n return _impl\n\ndef _relu6():\n def _impl(inputs, attr, params):\n return _op.clip(inputs[0], a_min=0, a_max=6)\n return _impl\n\ndef _shape():\n def _impl(inputs, attr, params):\n is_symbolic_shape = False\n for axis in attr['_input_shapes'][inputs[0]]:\n if not isinstance(axis, (int, tvm.expr.IntImm, tvm.expr.UIntImm)):\n is_symbolic_shape = True\n break\n\n if is_symbolic_shape:\n ret = _op.shape_of(inputs[0], dtype='int32')\n else:\n ret = np.array(attr['_input_shapes'][inputs[0]], dtype='int32')\n return ret\n\n return _impl\n\ndef _fill():\n def _impl(inputs, attr, params):\n output_shape = attr['_output_shapes'][0]\n # Output shape must be defined to avoid errors. If any axis is not, we must\n # try to compute its shape.\n if output_shape is None or -1 in output_shape:\n output_shape = _infer_value(inputs[0], params).asnumpy().reshape([-1]).tolist()\n\n fill_arg = _get_num_param(params, inputs.pop(1))\n dtype = attr['T'].name\n return _op.full(tvm.relay.const(fill_arg, dtype),\n output_shape, dtype)\n return _impl\n\ndef _lrn():\n def _impl(inputs, attr, params):\n attr_new = {}\n depth_radius = attr.get('depth_radius', 5)\n size = (depth_radius * 2) + 1\n attr_new['axis'] = 3 # Fix axis, NHWC format\n attr_new['size'] = size\n attr_new['bias'] = attr.get('bias', 1)\n attr_new['alpha'] = attr.get('alpha', 1) * size\n attr_new['beta'] = attr.get('beta', 0.5)\n return AttrCvt(op_name='lrn')(inputs, attr_new)\n return _impl\n\ndef _sum():\n def _impl(inputs, attr, params):\n axis = _get_tuple_param(params, inputs[1])\n return AttrCvt(\n op_name='sum',\n extras={'axis': axis},\n transforms={'keep_dims':'keepdims'},\n ignores=['name', 'Tidx'])([inputs[0]], attr)\n return _impl\n\ndef _reduce(op):\n def _impl(inputs, attr, params):\n axis = _get_list_param(params, inputs[1])\n axis = tuple(axis)\n return AttrCvt(\n op_name=op,\n extras={'axis': axis},\n transforms={'keep_dims':'keepdims'},\n ignores=['name', 'Tidx'])([inputs[0]], attr)\n return _impl\n\ndef _square():\n def _impl(inputs, attr, params):\n return _op.multiply(inputs[0], inputs[0])\n return _impl\n\ndef _gather():\n \"GatherV2, Gather\"\n def _impl(inputs, attr, params):\n if len(inputs) > 2:\n axis = _get_num_param(params, inputs.pop(2))\n else:\n axis = 0\n if int(attr.get('batch_dims', 0)) != 0:\n raise tvm.error.OpAttributeUnImplemented(\n 'Attribute batch_dims is not supported')\n new_input = inputs[0:2]\n return AttrCvt(op_name=\"take\",\n extras={'axis': tvm.const(axis, 'int32')},\n ignores=['Tindices', 'Tparams', 'validate_indices',\n 'Taxis', '_class', 'batch_dims'])(new_input, attr)\n return _impl\n\ndef _gather_nd():\n \"\"\"GatherNd\"\"\"\n def _impl(inputs, attr, params):\n return AttrCvt(op_name=\"gather_nd\",\n ignores=['Tindices', 'Tparams',\\\n 'Taxis', '_class'])(inputs, attr)\n return _impl\n\ndef _stridedSlice():\n def _impl(inputs, attr, params, mod):\n \"\"\"Strided Slice.\n Operator description: https://www.tensorflow.org/api_docs/python/tf/strided_slice\n Tensorflow mask validation: https://github.com/tensorflow/tensorflow/blob/master/\n tensorflow/core/util/strided_slice_op.cc#L147-L368\n \"\"\"\n begin = _get_list_param(params, inputs[1])\n end = _get_list_param(params, inputs[2])\n stride = _get_list_param(params, inputs[3])\n begin_mask = int(attr.get('begin_mask', 0))\n end_mask = int(attr.get('end_mask', 0))\n ellipsis_mask = int(attr.get('ellipsis_mask', 0))\n new_axis_mask = int(attr.get('new_axis_mask', 0))\n shrink_axis_mask = int(attr.get('shrink_axis_mask', 0))\n data_shape = attr['_input_shapes'][inputs[0]]\n data_dim = len(data_shape)\n stride_dim = len(stride)\n\n def _transform_mask(stride_dim, ellipsis_mask):\n \"\"\"Handle mask inputs to create new begin, end, stride and output shape\"\"\"\n m_begin = [0] * data_dim\n m_end = [0] * data_dim\n m_stride = [0] * data_dim\n fshape_indices = []\n #Count new axis after ellipsis_mask, consider while applying ellipsis_mask.\n ellipsis_seen = False\n new_axes_after_ellipsis = 0\n for i in range(stride_dim):\n mask = 1 << i\n if ellipsis_seen and (mask & new_axis_mask) != 0:\n new_axes_after_ellipsis += 1\n if (mask & ellipsis_mask) != 0:\n ellipsis_seen = True\n if not ellipsis_seen:\n #Used later for extending the stride attributes in the below loop.\n ellipsis_mask |= (1 << stride_dim)\n stride_dim += 1\n final_index = 0\n for index in range(stride_dim):\n mask = 1 << index\n if mask & ellipsis_mask:\n #Identify the end index for applying ellipsis_mask\n to_index = min(((data_dim - (stride_dim-index)) + 1 \\\n + new_axes_after_ellipsis), data_dim)\n for i in range(final_index, to_index):\n m_begin[final_index] = 0\n m_end[final_index] = data_shape[final_index]\n m_stride[final_index] = 1\n fshape_indices.append(final_index)\n final_index += 1\n elif mask &new_axis_mask:\n fshape_indices.append(-1)\n elif not mask & new_axis_mask:\n if final_index == len(m_begin):\n break\n if mask & begin_mask:\n m_begin[final_index] = data_shape[final_index] \\\n if stride[index] < 0 else 0\n elif begin[index]:\n m_begin[final_index] = begin[index]\n if mask & end_mask:\n m_end[final_index] = 0 if stride[index] < 0 \\\n else data_shape[final_index]\n elif end[index]:\n m_end[final_index] = end[index]\n m_stride[final_index] = stride[index]\n if mask & shrink_axis_mask:\n #Tensorflow make axis with shrink_axis_mask as dimension 1\n m_begin[final_index] = data_shape[final_index] + begin[index] \\\n if begin[index] < 0 else begin[index]\n m_end[final_index] = begin[index] + 1\n m_stride[final_index] = 1\n fshape_indices.append(-2)\n else:\n fshape_indices.append(final_index)\n\n final_index += 1\n return m_begin, m_end, m_stride, fshape_indices\n\n fshape_indices = None\n if begin_mask or end_mask or ellipsis_mask or new_axis_mask or shrink_axis_mask:\n begin, end, stride, fshape_indices = _transform_mask(stride_dim, ellipsis_mask)\n out = _op.strided_slice(inputs[0], begin=begin, end=end, strides=stride)\n out_shape = _infer_shape(out, mod=mod)\n if not fshape_indices:\n fshape_indices = range(len(out_shape))\n\n #Create final output shape.\n final_output = []\n for gather_index in fshape_indices:\n if gather_index == -1:\n final_output.append(1)\n elif gather_index == -2:\n pass\n else:\n final_output.append(out_shape[gather_index])\n\n if not final_output:\n return out\n return _op.reshape(out, newshape=tuple(final_output))\n return _impl\n\ndef _pad(name):\n def _impl(inputs, attr, params):\n padlist = _get_param(params, inputs[1])\n paddings = tuple(tuple(l) for l in padlist)\n attr['pad_width'] = paddings\n attr['pad_value'] = 0\n new_inputs = [inputs[0]]\n if name == 'PadV2':\n constant_values = _get_num_param(params, inputs[2])\n attr['pad_value'] = constant_values\n return AttrCvt(\n op_name='pad',\n ignores=['Tpaddings'],)(new_inputs, attr)\n return _impl\n\ndef _mirror_pad():\n def _impl(inputs, attr, params):\n padlist = _get_param(params, inputs[1])\n paddings = tuple(tuple(l) for l in padlist)\n attr['pad_width'] = paddings\n mode = attr['mode'].decode('utf-8')\n attr['mode'] = mode\n new_inputs = [inputs[0]]\n return AttrCvt(\n op_name='mirror_pad',\n ignores=['Tpaddings'],)(new_inputs, attr)\n return _impl\n\ndef _transpose():\n def _impl(inputs, attr, params):\n # If perm is not specified, axes is left empty,\n # otherwise its value is get from params\n try:\n axes = _get_list_param(params, inputs[1])\n except (IndexError, KeyError, AttributeError):\n axes = _infer_value_simulated(inputs[1], params).asnumpy()\n return _op.transpose(inputs[0], axes=axes)\n return _impl\n\ndef _where():\n def _impl(inputs, attr, params):\n if len(inputs) == 1:\n return AttrCvt(op_name=\"argwhere\")(inputs, attr)\n return AttrCvt(op_name=\"where\")(inputs, attr)\n return _impl\n\ndef _clip_by_value():\n def _impl(inputs, attr, params):\n a_min = _get_num_param(params, inputs[1])\n a_max = _get_num_param(params, inputs[2])\n return _op.clip(inputs[0], a_min=a_min, a_max=a_max)\n return _impl\n\ndef _reverse_v2():\n def _impl(inputs, attr, params):\n axis = _get_num_param(params, inputs[1])\n return AttrCvt(\n op_name=\"reverse\",\n ignores=['Tidx'],\n extras={'axis': int(axis)})([inputs[0]], attr)\n return _impl\n\ndef _rank():\n def _impl(inputs, attr, params):\n input_shape = attr['_input_shapes'][inputs[0]]\n\n name = attr[\"_node_name\"]\n params[name] = tvm.nd.array([len(input_shape)])\n return [_expr.var(name,\n shape=params[name].shape,\n dtype='int32')]\n\n return _impl\n\n\ndef _range():\n def _impl(inputs, attr, params):\n start = _get_param(params, inputs[0])[0]\n if hasattr(inputs[1], \"name_hint\") or isinstance(inputs[1], _expr.Constant):\n limit = _get_param(params, inputs[1])[0]\n else:\n if any(['Rank' in param for param in params]):\n limit = params.pop('Rank').asnumpy()[0]\n else:\n limit = _infer_value_simulated(inputs[1], params).asnumpy()[0]\n delta = _get_param(params, inputs[2])[0]\n dtype = attr['Tidx'].name if 'Tidx' in attr else str(start.dtype)\n return AttrCvt(\n op_name=\"arange\",\n ignores=['Tidx'],\n extras={'start': _expr.const(start),\n \"stop\": _expr.const(limit),\n 'step': _expr.const(delta),\n 'dtype': dtype})([], attr)\n return _impl\n\n\ndef _elu():\n def _impl(inputs, attr, params):\n dtype = attr['T'].name\n alpha = tvm.relay.const(-1.0, dtype)\n return alpha * _op.nn.relu(tvm.relay.const(1, dtype) \\\n - _op.exp(inputs[0])) + _op.nn.relu(inputs[0])\n return _impl\n\ndef _selu():\n def _impl(inputs, attr, params):\n dtype = attr['T'].name\n alpha = tvm.relay.const(-1.6732632423543772848170429916717, dtype)\n gamma = tvm.relay.const(1.0507009873554804934193349852946, dtype)\n return gamma * (alpha * _op.nn.relu(tvm.relay.const(1, dtype) \\\n - _op.exp(inputs[0])) + _op.nn.relu(inputs[0]))\n return _impl\n\ndef _mean():\n def _impl(inputs, attr, params):\n axis = _get_tuple_param(params, inputs[1])\n return AttrCvt(op_name=\"mean\", ignores=['Tdim', 'Tidx'],\n transforms={'keep_dims': 'keepdims'},\n extras={'axis': axis})([inputs[0]], attr)\n return _impl\n\ndef _broadcast(name):\n def _impl(inputs, attr, params):\n return AttrCvt(\n op_name=name,\n ignores=['name', 'Tidx']\n )(inputs, attr)\n return _impl\n\ndef _split(has_size_vector):\n # TF documentation https://www.tensorflow.org/api_docs/python/tf/split\n def _impl(inputs, attr, params):\n try:\n # order and number of inputs are different:\n # if has_size_vector:\n # https://www.tensorflow.org/api_docs/cc/class/tensorflow/ops/split-v\n # else:\n # https://www.tensorflow.org/api_docs/cc/class/tensorflow/ops/split\n\n # in addition, `axis` and `num_or_size_splits` can be tensors in TensorFlow,\n # we can only support constants\n if has_size_vector:\n input_node_index = 0\n input_axis_index = 2\n size_splits = _get_param(params, inputs[1])\n section_beginnings = np.cumsum(size_splits)[:-1]\n indices_or_sections = tuple(section_beginnings)\n else:\n input_node_index = 1\n input_axis_index = 0\n indices_or_sections = attr['num_split']\n input_node = inputs[input_node_index]\n axis_input_value = _get_num_param(params, inputs[input_axis_index])\n except (IndexError, KeyError):\n raise TypeError( \\\n \"Unsupported argument for split: `axis` and `num_or_size_splits` \" \\\n \"should be constants\")\n return _op.split(input_node,\n indices_or_sections=indices_or_sections,\n axis=int(axis_input_value))\n return _impl\n\ndef _unpack():\n def _impl(inputs, attr, params):\n input_node = inputs[0]\n axis = attr['axis']\n input_shape = attr['_input_shapes'][input_node]\n axis_length = input_shape[axis]\n if axis_length < 0:\n raise TypeError(\"Unstack with unknown axis length\")\n splitted = _op.split(input_node,\n indices_or_sections=axis_length,\n axis=axis)\n #name=attr.get('_node_name', 'unstack'))\n if axis == 0:\n axis = None\n else:\n axis = [axis]\n return _expr.TupleWrapper(\n _expr.Tuple([_op.squeeze(split_item, axis=axis) \\\n for split_item in splitted]), len(splitted))\n return _impl\n\ndef _softmax():\n def _impl(inputs, attr, params):\n return AttrCvt(op_name='softmax',\n transforms={'axis': ('axis', 1)})([inputs[0]], attr)\n return _impl\n\ndef _softplus():\n # op description: https://www.tensorflow.org/api_docs/python/tf/math/softplus\n def _impl(inputs, attr, params):\n exp_out = AttrCvt('exp')(inputs, attr)\n inputs.append(tvm.relay.const(1, attr['T'].name))\n rh = tvm.relay.const(1, attr['T'].name)\n add_out = get_relay_op('add')(exp_out, rh)\n return get_relay_op('log')(add_out)\n return _impl\n\ndef _topk():\n def _impl(inputs, attr, params):\n k = int(_get_num_param(params, inputs.pop(1)))\n if k < 1:\n raise tvm.error.OpAttributeInvalid(\n 'Attribute k must be positive in operator TopKV2')\n if attr['sorted'] is False:\n raise tvm.error.OpAttributeUnImplemented(\n 'Attribute sorted=False is not supported in operator TopKV2')\n return AttrCvt(op_name='topk',\n ignores=['sorted'],\n extras={'k': k, 'is_ascend': False, 'dtype': 'int32'})(inputs, attr)\n return _impl\n\ndef _floordiv():\n def _impl(inputs, attr, params):\n assert len(inputs) == 2\n return AttrCvt('floor_divide')(inputs, attr)\n return _impl\n\ndef _floormod():\n def _impl(inputs, attr, params):\n assert len(inputs) == 2\n return AttrCvt('floor_mod')(inputs, attr)\n return _impl\n\ndef _logical(name):\n def _impl(inputs, attr, params):\n return AttrCvt(op_name=name)(inputs, attr)\n return _impl\n\ndef _space_to_batch_nd():\n def _impl(inputs, attr, params):\n input_node = inputs[0]\n input_shape = attr['_input_shapes'][input_node]\n block_shape = _get_list_param(params, inputs[1])\n paddings = _get_list_param(params, inputs[2])\n N = len(input_shape)\n M = len(block_shape)\n batch = input_shape[0]\n remaining_shape_length = N - M - 1\n paddings = [(0, 0)] + paddings + [(0, 0)] * remaining_shape_length\n # From https://www.tensorflow.org/api_docs/cc/class/tensorflow/ops/space-to-batch-n-d:\n # Zero-pad the start and end of dimensions [1, ..., M] of the input according to paddings\n # to produce padded of shape padded_shape.\n padded = tvm.relay.nn.pad(input_node, pad_width=paddings)\n # Reshape padded to reshaped_padded of shape:\n # [batch] + [padded_shape[1] / block_shape[0], block_shape[0], ...,\n # padded_shape[M] / block_shape[M-1], block_shape[M-1]] + remaining_shape\n shape1 = [batch] + [item for i in range(M) for item in [-4, -1, block_shape[i]]] + [-2]\n reshaped_padded = tvm.relay.reshape(padded, newshape=shape1)\n # Permute dimensions of reshaped_padded to produce permuted_reshaped_padded of shape:\n # block_shape + [batch] + [padded_shape[1] / block_shape[0], ...,\n # padded_shape[M] / block_shape[M-1]] + remaining_shape\n axes = [2 * i + 2 for i in range(M)] + [0] + [2 * i + 1 for i in range(M)] + \\\n list(range(1 + 2 * M, 1 + 2 * M + remaining_shape_length))\n permuted_reshaped_padded = tvm.relay.transpose(reshaped_padded, axes=axes)\n permuted_reshaped_padded_shape = _infer_shape(permuted_reshaped_padded)\n # Reshape permuted_reshaped_padded to flatten block_shape into the batch dimension,\n # producing an output tensor of shape:\n # [batch * prod(block_shape)] + [padded_shape[1] / block_shape[0], ...,\n # padded_shape[M] / block_shape[M-1]] + remaining_shape\n shape2 = [batch * np.prod(block_shape)] + list(permuted_reshaped_padded_shape)[M + 1:]\n reshaped_permuted_reshaped_padded = tvm.relay.reshape(permuted_reshaped_padded,\n newshape=shape2)\n return reshaped_permuted_reshaped_padded\n\n return _impl\n\n\ndef _batch_to_space_nd():\n def _impl(inputs, attr, params):\n input_node = inputs[0]\n input_shape = attr['_input_shapes'][input_node]\n block_shape = _get_list_param(params, inputs[1])\n crops = _get_list_param(params, inputs[2])\n M = len(block_shape)\n batch = input_shape[0]\n # From https://www.tensorflow.org/api_docs/cc/class/tensorflow/ops/batch-to-space-n-d:\n # Reshape input to reshaped of shape:\n # [block_shape[0], ..., block_shape[M-1], batch / prod(block_shape),\n # input_shape[1], ..., input_shape[N-1]]\n shape1 = block_shape + [batch // np.prod(block_shape)] + input_shape[1:]\n reshaped = tvm.relay.reshape(input_node, newshape=shape1)\n # Permute dimensions of reshaped to produce permuted of shape\n # [batch / prod(block_shape), input_shape[1], block_shape[0], ...,\n # input_shape[M], block_shape[M-1], input_shape[M+1], ..., input_shape[N-1]]\n axes = [M] + [axis for i in range(M) for axis in [M + i + 1, i]] + \\\n list(range(2 * M + 1, len(shape1)))\n permuted = tvm.relay.transpose(reshaped, axes=axes)\n # Reshape permuted to produce reshaped_permuted of shape\n # [batch / prod(block_shape), input_shape[1] * block_shape[0], ...,\n # input_shape[M] * block_shape[M-1], input_shape[M+1], ..., input_shape[N-1]]\n shape2 = [0] + [-3] * M + [-2]\n reshaped_permuted = tvm.relay.reshape(permuted, newshape=shape2)\n # Crop the start and end of dimensions [1, ..., M] of reshaped_permuted according to crops\n # to produce the output of shape:\n # [batch / prod(block_shape), input_shape[1] * block_shape[0] - crops[0,0] - crops[0,1],\n # ..., input_shape[M] * block_shape[M-1] - crops[M-1,0] - crops[M-1,1],\n # input_shape[M+1], ..., input_shape[N-1]]\n reshaped_permuted_shape = _infer_shape(reshaped_permuted)\n cropped = reshaped_permuted\n for axis in range(1, M+1):\n crop = crops[axis - 1]\n if crop != [0, 0]:\n indices = tvm.relay.arange(\n _expr.const(crop[0]),\n _expr.const(reshaped_permuted_shape[axis] - crop[1]),\n dtype='int32'\n )\n cropped = tvm.relay.take(cropped, indices=indices, axis=axis)\n\n return cropped\n\n return _impl\n\n\ndef _prod():\n def _impl(inputs, attr, params):\n axis = _get_num_param(params, inputs[1])\n keepdims = attr['keep_dims']\n return _op.prod(inputs[0], int(axis), keepdims=keepdims)\n return _impl\n\ndef _log1p():\n # op description: https://www.tensorflow.org/api_docs/python/tf/math/log1p\n def _impl(inputs, attr, params):\n one = tvm.relay.const(1, attr['T'].name)\n add_out = get_relay_op('add')(inputs[0], one)\n return get_relay_op('log')(add_out)\n return _impl\n\ndef _one_hot():\n def _impl(inputs, attr, params):\n depth = int(_get_num_param(params, inputs[1]))\n dtype = attr['T'].name\n\n on_value = _get_num_param(params, inputs[2])\n off_value = _get_num_param(params, inputs[3])\n new_inputs = [inputs[0], \\\n tvm.relay.const(on_value, dtype), \\\n tvm.relay.const(off_value, dtype)]\n return AttrCvt('one_hot',\n ignores=['TI'],\n extras={'depth' : depth, 'dtype' : dtype})(new_inputs, attr)\n return _impl\n\ndef _squared_difference():\n def _impl(inputs, attr, params):\n difference = _op.subtract(inputs[0], inputs[1])\n return _op.multiply(difference, difference)\n return _impl\n\ndef _size():\n def _impl(inputs, attr, params):\n new_attr = attr\n new_attr['out_type'] = attr['out_type'].name\n return AttrCvt('ndarray_size', transforms={'out_type' : 'dtype'})(inputs, new_attr)\n return _impl\n\ndef _add_n():\n def _impl(inputs, attr, params):\n if not isinstance(inputs, tuple):\n inputs = list(inputs)\n assert len(inputs) > 0, \"add_n take >=1 inputs, but 0 given.\"\n _res = inputs[0]\n for each in inputs[1:]:\n _res = _op.add(_res, each)\n return _res\n return _impl\n\n\n# compatible operators that do NOT require any conversion.\n_identity_list = []\n\n# _convert_map defines maps of name to converter functor(callable)\n# for 1 to 1 mapping, use Renamer if nothing but name is different\n# use AttrCvt if attributes need to be converted\n# for 1 to N mapping(composed), use custom callable functions\n# for N to 1 mapping, currently not supported(?)\n_convert_map = {\n 'Abs' : AttrCvt('abs'),\n 'Add' : _elemwise('add'),\n 'AddN' : _add_n(),\n 'All' : _reduce('all'),\n 'Any' : _reduce('any'),\n 'ArgMax' : _argx(_op.argmax, 'argmax'),\n 'ArgMin' : _argx(_op.argmin, 'argmin'),\n 'Assert' : _assert(),\n 'AvgPool' : _pooling('avg_pool'),\n 'AvgPool3D' : _pool3d('avg_pool3d'),\n 'BatchMatMul' : _batch_matmul(),\n 'BatchMatMulV2' : _batch_matmul(),\n 'BatchNormWithGlobalNormalization' : _batch_norm(),\n 'BatchToSpaceND' : _batch_to_space_nd(),\n 'BiasAdd' : _bias_add(),\n 'BroadcastTo' : _broadcast_to(),\n 'Cast' : _cast(),\n 'Ceil' : AttrCvt('ceil'),\n 'CheckNumerics' : _check_numerics(),\n 'ClipByValue' : _clip_by_value(),\n 'Concat' : _concat(),\n 'ConcatV2' : _concatV2(),\n 'Conv2D' : _conv('conv'),\n 'Conv2DBackpropInput' : _conv('conv_transpose'),\n 'CropAndResize' : _crop_and_resize(),\n 'DecodeJpeg' : _decode_image(),\n 'DepthwiseConv2dNative' : _conv('depthwise'),\n 'DepthToSpace' : _depth_to_space(),\n 'Equal' : _broadcast('equal'),\n 'Elu' : _elu(),\n 'Erf' : AttrCvt('erf'),\n 'Exp' : AttrCvt('exp'),\n 'ExpandDims' : _expand_dims(),\n 'Fill' : _fill(),\n 'Floor' : AttrCvt('floor'),\n 'FloorDiv' : _floordiv(),\n 'FloorMod' : _floormod(),\n 'FusedBatchNorm' : _fused_batch_norm(),\n 'FusedBatchNormV2' : _fused_batch_norm(),\n 'Gather' : _gather(),\n 'GatherNd' : _gather_nd(),\n 'GatherV2' : _gather(),\n 'Greater' : _broadcast('greater'),\n 'GreaterEqual' : _broadcast('greater_equal'),\n 'Identity' : _identity(),\n 'LeakyRelu' : AttrCvt('leaky_relu'),\n 'LeftShift' : AttrCvt('left_shift'),\n 'Less' : _broadcast('less'),\n 'LessEqual' : _broadcast('less_equal'),\n 'Log' : AttrCvt('log'),\n 'Log1p' : _log1p(),\n 'Cos' : AttrCvt('cos'),\n 'Sin' : AttrCvt('sin'),\n 'LogicalAnd' : _logical('logical_and'),\n 'LogicalOr' : _logical('logical_or'),\n 'LogicalNot' : _logical('logical_not'),\n 'LogSoftmax' : AttrCvt('log_softmax'),\n 'LRN' : _lrn(),\n 'MatMul' : _matmul(),\n 'Max' : _reduce('max'),\n 'MaxPool' : _pooling('max_pool'),\n 'MaxPool3D' : _pool3d('max_pool3d'),\n 'Maximum' : _elemwise('maximum'),\n 'Mean' : _mean(),\n 'Min' : _reduce('min'),\n 'Minimum' : _elemwise('minimum'),\n 'MirrorPad' : _mirror_pad(),\n 'Mod' : _elemwise('mod'),\n 'Mul' : _elemwise('multiply'),\n 'Neg' : AttrCvt('negative'),\n 'NoOp' : _no_op(),\n 'NotEqual' : _broadcast('not_equal'),\n 'OneHot' : _one_hot(),\n 'Pack' : _pack(),\n 'TensorArrayV3' : _tensor_array(),\n 'TensorArrayScatterV3' : _tensor_array_scatter(),\n 'TensorArrayGatherV3' : _tensor_array_gather(),\n 'TensorArraySizeV3' : _tensor_array_size(),\n 'TensorArrayWriteV3' : _tensor_array_write(),\n 'TensorArrayReadV3' : _tensor_array_read(),\n 'TensorArraySplitV3' : _tensor_array_split(),\n 'TensorArrayConcatV3' : _tensor_array_concat(),\n 'Pad' : _pad('Pad'),\n 'PadV2' : _pad('PadV2'),\n 'Pow' : _elemwise('power'),\n 'Prod' : _prod(),\n 'Range' : _range(),\n 'Rank' : _rank(),\n 'RealDiv' : _elemwise('divide'),\n 'Relu' : AttrCvt('relu'),\n 'Relu6' : _relu6(),\n 'Reshape' : _reshape(),\n 'ResizeBilinear' : _resize('bilinear'),\n 'ResizeBicubic' : _resize('bilinear'),\n 'ResizeNearestNeighbor' : _resize('nearest_neighbor'),\n 'ReverseV2' : _reverse_v2(),\n 'RightShift' : AttrCvt('right_shift'),\n 'Round' : AttrCvt('round'),\n 'Rsqrt' : _rsqrt(),\n 'Select' : _where(),\n 'Selu' : _selu(),\n 'Shape' : _shape(),\n 'Sigmoid' : AttrCvt('sigmoid'),\n 'Sign' : AttrCvt('sign'),\n 'Size' : _size(),\n 'Slice' : _slice(),\n 'Softmax' : _softmax(),\n 'Softplus' : _softplus(),\n 'SpaceToBatchND' : _space_to_batch_nd(),\n 'SpaceToDepth' : _space_to_depth(),\n 'Split' : _split(False),\n 'SplitV' : _split(True),\n 'Sqrt' : AttrCvt('sqrt'),\n 'Square' : _square(),\n 'SquaredDifference' : _squared_difference(),\n 'Squeeze' : _squeeze(),\n 'StopGradient' : _identity(),\n 'StridedSlice' : _stridedSlice(),\n 'Sub' : _elemwise('subtract'),\n 'Sum' : _sum(),\n 'Tanh' : AttrCvt('tanh'),\n 'Tile' : _tile(),\n 'TopKV2' : _topk(),\n 'Transpose' : _transpose(),\n 'TruncateMod' : _elemwise('mod'),\n 'Unpack' : _unpack(),\n 'Where' : _where(),\n 'ZerosLike' : AttrCvt('zeros_like'),\n\n}\n\ndef _LSTMBlockCell():\n def _impl(inputs, in_state_c, in_state_h, attr, params):\n \"\"\"LSTM Block cell.\n Calculations are described in: https://github.com/tensorflow/tensorflow/blob/\n r1.8/tensorflow/contrib/rnn/python/ops/lstm_ops.py#L41-L114\n\n Parameters\n ----------\n inputs : relay.Expr\n Input data\n in_state_c: list of relay.Expr\n Cell state input values for all the layers\n in_state_h: list of relay.Expr\n Hidden state input values for all the layers\n attrs : dict\n Dict of operator attributes\n params : dict\n List of pretrained weights and bias\n\n Returns\n -------\n sym : relay.Expr\n Converted relay.Expr\n output: relay.Expr\n Output state value.\n \"\"\"\n in_data = inputs[0]\n in_weight = inputs[3]\n in_bias = inputs[7]\n forget_bias = attr.pop('forget_bias')\n input_shape = attr['_input_shapes'][inputs[0]]\n weight_shape = attr['_input_shapes'][inputs[3]]\n batch_size, input_size = input_shape[0], input_shape[1]\n num_hidden_layers = weight_shape[1]\n num_hidden = num_hidden_layers // 4\n\n in_data = _op.reshape(in_data,\n newshape=(batch_size, input_size))\n ixh = _op.concatenate([in_data, in_state_h], axis=1)\n in_weight = _op.transpose(in_weight, axes=None)\n gates = _op.nn.dense(ixh, in_weight,\n units=num_hidden_layers)\n gates_bias = _op.add(gates, in_bias)\n gate_list = _op.split(gates_bias, indices_or_sections=4, axis=1)\n in_gate = _op.sigmoid(gate_list[0])\n in_transform = _op.tanh(gate_list[1])\n forget_gate = _op.add(gate_list[2], tvm.relay.const(forget_bias, attr['T'].name))\n forget_gate = _op.sigmoid(forget_gate)\n out_gate = _op.sigmoid(gate_list[3])\n next_c = _op.add(_op.multiply(forget_gate, in_state_c),\n _op.multiply(in_gate, in_transform))\n next_h = out_gate * _op.tanh(next_c)\n out_state = _op.concatenate([next_c, next_h], axis=1)\n out_state = _op.reshape(out_state,\n newshape=(2, batch_size, num_hidden))\n return next_h, out_state\n return _impl\n\n# _convert_map_rnn defines maps of rnn operator name to\n# converter functor(callable) for 1 to 1 mapping.\n_convert_map_rnn = {\n 'LSTMBlockCell' : _LSTMBlockCell(),\n}\n\nclass RecurrentNetworks(object):\n \"\"\"Recurrent network layer handlers.\n\n Handle Layer operations.\n ToDo: Operators like RNN/GRU layer concepts also can be handled here\n\n Parameters\n ----------\n nodes : list\n list of graph nodes used for tensorflow parsing.\n\n out_rnn : list\n List of RecurrentNetwork outputs. This output will be appended to the\n 'head' nodes of the graph.\n\n graph : tensorflow graph definition object\n The loaded tensorflow GraphDef\n\n convert_map : dict\n Dict of name : callable, where name is the op's name that\n require conversion to relay, callable are functions which\n take attrs and return (new_op_name, new_attrs)\n \"\"\"\n def __init__(self, nodes, out_rnn, graph, convert_map):\n self._graph = graph\n self._convert_map = convert_map\n self._nodes = nodes\n self._out_rnn = out_rnn\n self._cur_lstm_layer = 0\n self._layer_name_list = []\n self._recurrent_ops_layer_map = {\n 'LSTMBlockCell' : self._LSTMBlockCellLayer(),\n }\n\n def _LSTMBlockCellLayer(self):\n \"\"\"LSTMBlockCell layer handler.\n\n Parameters\n ----------\n op_name : str\n Operator name, eg:LSTMBlockCell\n\n layer_name : str list\n Layer name is used for creating the state input placeholder.\n\n inputs : relay.Expr\n Input data\n\n attrs : dict\n Dict of operator attributes\n\n params : dict\n List of pretrained weights and bias\n\n num_layers : int\n Total number of LSTM layer presented in the graph\n\n Returns\n -------\n sym : relay.Expr\n The returned relay Expr\n \"\"\"\n def _impl(op_name, layer_name, inputs, attrs, params, num_layers):\n in_state_c_name = layer_name+'_c'\n in_state_h_name = layer_name+'_h'\n\n def _init_state(num_layers, batch_size, num_hidden):\n \"\"\"Create the initial states for the first layer in the graph.\"\"\"\n in_state_c = [_expr.var(in_state_c_name,\n shape=(num_layers, batch_size, num_hidden),\n dtype='float32')]\n\n in_state_h = [_expr.var(in_state_h_name,\n shape=(num_layers, batch_size, num_hidden),\n dtype='float32')]\n return in_state_c, in_state_h\n\n def _get_cur_input_state(in_state_c, in_state_h, num_layers,\n layer, batch_size, num_hidden):\n \"\"\"Select the appropriate states for the current layer\"\"\"\n in_state_c_tup = _op.split(in_state_c[0],\n indices_or_sections=num_layers, axis=0)\n in_state_h_tup = _op.split(in_state_h[0],\n indices_or_sections=num_layers, axis=0)\n cur_in_state_c = _op.reshape(in_state_c_tup[layer],\n newshape=(batch_size, num_hidden))\n cur_in_state_h = _op.reshape(in_state_h_tup[layer],\n newshape=(batch_size, num_hidden))\n return cur_in_state_c, cur_in_state_h\n\n def _LSTMBlockCellWrapper(inputs, attr, params,\n num_layers, layer):\n \"\"\"LSTM cell warapper to prepare the inputs\"\"\"\n input_shape = attr['_input_shapes'][inputs[0]]\n weight_shape = attr['_input_shapes'][inputs[3]]\n\n batch_size = input_shape[0]\n num_hidden = weight_shape[1] // 4\n\n if layer == 0:\n #Create initial states placeholder in case of first layer\n in_state_c, in_state_h = _init_state(num_layers,\n batch_size, num_hidden)\n else:\n in_state_c = self._nodes[in_state_c_name]\n in_state_h = self._nodes[in_state_h_name]\n\n cur_in_state_c, cur_in_state_h = _get_cur_input_state( \\\n in_state_c, in_state_h,\n num_layers, layer,\n batch_size, num_hidden)\n output, out_state = self._convert_map[op_name](inputs, cur_in_state_c,\n cur_in_state_h,\n attr, params)\n return output, out_state, in_state_c, in_state_h\n\n sym, cur_out_state, in_state_c, in_state_h = \\\n _LSTMBlockCellWrapper(inputs, attrs, params,\n num_layers, self._cur_lstm_layer)\n self._nodes[in_state_c_name] = in_state_c\n self._nodes[in_state_h_name] = in_state_h\n cur_out_state = _op.expand_dims(cur_out_state, axis=0, num_newaxis=1)\n self._out_rnn.append(cur_out_state)\n self._cur_lstm_layer += 1\n return sym\n return _impl\n\n def process_op(self, op_name, inputs, attrs, params):\n \"\"\"Process recurrent layer operators.\n\n List '_recurrent_ops_layer_map' map each Layer based operators with its\n layer handlers. Total number of layers are calculated to form the input\n data shapes.\n\n Parameters\n ----------\n op_name : str\n Operator name, such as LSTMBlockCell\n\n inputs : relay.Expr\n Input data\n\n attrs : dict\n Dict of operator attributes\n\n params : dict\n List of pretrained weights and bias\n\n Returns\n -------\n sym : relay.Expr\n Returns relay.Expr\n \"\"\"\n def _get_abs_layer_name(node):\n \"\"\"Identify the layer name is already handled. Return the absolute name\n \"\"\"\n if not self._layer_name_list:\n self._layer_name_list.append(node.name)\n return node.name\n\n for _name in self._layer_name_list:\n if _name in node.name:\n abs_name = _name\n else:\n self._layer_name_list.append(node.name)\n abs_name = node.name\n return abs_name\n\n #Find number of layers of this same operator node in the graph\n #and also read the inputs name for the current op.\n num_layers = 0\n for _, node in enumerate(self._graph.node):\n if node.op == op_name:\n layer_name = _get_abs_layer_name(node)\n num_layers += 1\n\n sym = self._recurrent_ops_layer_map[op_name](op_name, layer_name, inputs, attrs,\n params, num_layers)\n return sym\n\n# An internal list to contain all the control flow primitives used in Tensorflow\n# 1.x.\n_control_flow_nodes = ['Merge', 'Switch', 'NextIteration', 'Exit', 'Enter', 'LoopCond']\n\nclass RewriteSubgraph(ExprMutator):\n \"\"\"\n A helper class to rewrite expr in while loop function to variable\n\n Parameters\n ----------\n rewrite_map : Dict[expr, expr]\n A dictionay contains a set of expr to var mapping.\n \"\"\"\n def __init__(self, rewrite_map):\n ExprMutator.__init__(self)\n self.rewrite_map = rewrite_map\n\n def visit(self, expr):\n if expr in self.rewrite_map:\n return self.rewrite_map[expr]\n return super().visit(expr)\n\ndef rewrite_subgraph(expr, rewrites):\n return RewriteSubgraph(rewrites).visit(expr)\n\ndef _in_while_loop(control_flow_node_map, op_name):\n \"\"\"\n Check if a given control flow operator is part of a while loop execution\n frame. This is based on the fact that there is only one occurrence of\n `LoopCond` for a loop execution frame and it is only presented in the loop\n construct.\n\n Parameters\n ----------\n control_flow_node_map : Dict[str, Set[str]]\n A dictionay contains the unique control flow execution frame name to\n a set of primitive operators mapping.\n\n op_name : str\n The name of a control flow primitive.\n\n Returns\n -------\n ret : bool\n Return true if the operator is in a while loop execution frame,\n otherwise, return false.\n \"\"\"\n return op_name in control_flow_node_map and \\\n \"LoopCond\" in control_flow_node_map[op_name]\n\n\nclass Branch:\n \"\"\"A class contains the components that are used to build up a Relay if\n node.\n\n Parameters\n ----------\n cond : tvm.relay.Expr\n The condition of a if node.\n\n true_branch : tvm.relay.Expr\n The body of the true branch of a if expression.\n\n false_branch: tvm.relay.Expr\n The body of the false branch of a if expression.\n\n _if : tvm.relay.Expr\n An internal variable indicates where an if expression is already created\n for a matched TF condition construct.\n\n Examples\n --------\n The following is a cond statement written in TensorFlow:\n\n .. code-block:: python\n\n def vanilla_cond():\n i = tf.constant(1)\n j = tf.constant(4)\n\n def f1():\n return tf.multiply(1, 17)\n\n def f2():\n return tf.add(4, 23)\n r = tf.cond(tf.less(i, j), f1, f2)\n\n This condition statement should be converted into Relay in the following\n form:\n\n .. code-block:: python\n\n fn (%Const: Tensor[(1,), int32],\n %Const_1: Tensor[(1,), int32],\n %cond/Mul/x: Tensor[(1,), int32],\n %cond/Mul/y: Tensor[(1,), int32],\n %cond/Add/x: Tensor[(1,), int32],\n %cond/Add/y: Tensor[(1,), int32]) {\n %0 = less(%Const, %Const_1) # ty=Tensor[(1,), bool]\n %1 = min(%0)\n if (%1) {\n %2 = multiply(%cond/Mul/x, %cond/Mul/y)\n %2\n } else {\n %3 = add(%cond/Add/x, %cond/Add/y)\n %3\n }\n }\n \"\"\"\n def __init__(self):\n self._if = None\n self.cond = None\n self.true_branch = None\n self.false_branch = None\n\n def _if_node(self):\n \"\"\"An internal API to create a relay if node from the matched TF\n condition construct.\n \"\"\"\n # `cond` returns a tensor that contains boolean values. We add a `min`\n # operator to checks if there is any false value. If so, this condition\n # doesn't not hold.\n cond = tvm.relay.op.min(self.cond)\n return tvm.relay.If(cond, self.true_branch, self.false_branch)\n\n def if_node(self):\n \"\"\"Create an tvm.relay.If node if it hasn't been created yet.\"\"\"\n if self._if is None:\n self._if = self._if_node()\n return self._if\n\n\nclass Loop:\n \"\"\"\n A class contains the components that are used to build up a Relay\n recursive call.\n\n Parameters\n ----------\n loop_vars : List[tvm.relay.Expr]\n The loop variables that used in a while loop.\n\n cond : tvm.relay.Expr\n The condition of a while loop.\n\n body : tvm.relay.Expr\n The body of a matched while loop.\n\n _loop : tvm.relay.Expr\n An internal variable indicates where a recursive call is already created\n for a matched TF while loop construct.\n\n Examples\n --------\n The following is a vanilla loop from TensorFlow:\n\n .. code-block:: python\n\n i = tf.constant(0)\n c = lambda i: tf.less(i, 10)\n b = lambda i: tf.add(i, 1)\n r = tf.while_loop(c, b, [i])\n\n It will be converted to the following recursive call in Relay:\n\n .. code-block:: python\n\n fn (%while/Less/y: Tensor[(1,), int32],\n %while/Add/y: Tensor[(1,), int32],\n %Const: Tensor[(1,), int32]) {\n %0 = fn(%loop_var0: Tensor[(1,), int32]) {\n %1 = less(%loop_var0, %while/Less/y)\n %2 = min(%1)\n if (%2) {\n %3 = add(%loop_var0, %while/Add/y)\n free_var %while_loop\n %4 = %while_loop(%3)\n %4\n } else {\n %5 = (%loop_var0,)\n %5\n }\n }\n let %while_loop1 = %0\n %6 = %while_loop1(%Const)\n %6\n }\n \"\"\"\n def __init__(self):\n self.loop_vars = []\n self.cond = None\n self.body = []\n self._loop = None\n\n def _while_loop(self):\n \"\"\"An internal API to create a Relay recursive call for a matched TF\n `while_loop` construct.\n \"\"\"\n wl = tvm.relay.var('while_loop')\n\n sb = tvm.relay.scope_builder.ScopeBuilder()\n\n loop_vars = []\n bind_map = {}\n for i, var in enumerate(self.loop_vars):\n if not isinstance(var, _expr.Var):\n var_chk = _infer_type(var)\n var_type = var_chk.checked_type\n else:\n var_type = var.type_annotation\n\n v = tvm.relay.var(\"loop_var\" + str(i), type_annotation=var_type)\n loop_vars.append(v)\n bind_map[var] = v\n\n self.cond = rewrite_subgraph(self.cond, bind_map)\n self.body = [rewrite_subgraph(b, bind_map) for b in self.body]\n\n cond = tvm.relay.op.min(self.cond)\n\n with sb.if_scope(cond):\n sb.ret(wl(*self.body))\n with sb.else_scope():\n sb.ret(tvm.relay.Tuple(loop_vars))\n\n loop_fn = tvm.relay.Function(loop_vars, sb.get())\n sb = tvm.relay.scope_builder.ScopeBuilder()\n sb.let(wl, loop_fn)\n sb.ret(wl(*self.loop_vars))\n return sb.get()\n\n def while_loop(self):\n \"\"\"Instantiate a while loop if it has not been created yet.\"\"\"\n if self._loop is None:\n self._loop = self._while_loop()\n return self._loop\n return self._loop\n\n\nclass GraphProto(object):\n \"\"\" A helper class for handling relay graph copying from Tensorflow GraphDef.\n Definition:\n https://github.com/tensorflow/tensorflow/blob/master/tensorflow/core/framework/graph.proto\n \"\"\"\n def __init__(self):\n self._nodes = {}\n self._params = {}\n self._input_shapes = {}\n self._output_shapes = {}\n self._num_param = 0\n self._num_rnn_layer = False\n self._input_shapes = {}\n self._loops = {}\n self._branches = {}\n self._mod = _module.Module({})\n self._prelude = Prelude(self._mod)\n\n def from_tensorflow(self, graph, layout=\"NHWC\", shape=None, outputs=None):\n \"\"\"Construct relay nodes from tensorflow graph definition - GraphDef.\n\n Follow the tensorflow graph definition to parse and convert it to Relay.\n Some of the assumptions listed below.\n\n -> All Placeholders are considered as graph input.\n -> All Const nodes are params.\n -> Last node is assumed as graph output.\n -> _output_shapes : Graph should be frozen with add_shapes=True.\n Or user can pass input shape dictionary optionally.\n -> DecodeJpeg, ResizeBilinear: These are dummy operators.\n Hence user should handle preprocessing outside.\n -> CheckNumerics: No implementation as of now for this.\n Just copies input to output.\n\n Parameters\n ----------\n graph : tensorflow graph definition object\n The loaded tensorflow GraphDef\n\n layout : target layout to be used (Optional)\n NCHW only supported now to enable NHWC models on GPU.\n\n shape : Dictionary of input dimensions (Optional)\n Graph level input shape dictionary.\n\n outputs : List of output tensor names (Optional)\n if not specified then the last node is assumed as graph output.\n\n Returns\n -------\n mod : tvm.relay.Module\n The module that optimizations will be performed on.\n\n params : dict\n A dict of name: tvm.nd.array pairs, used as pretrained weights\n \"\"\"\n\n try:\n from tensorflow.python.framework import tensor_util\n except ImportError as e:\n raise ImportError(\n \"Unable to import tensorflow which is required {}\".format(e))\n\n missing_operators = self._parse_import_prerequisites(graph)\n\n if missing_operators:\n raise NotImplementedError( \\\n \"The following operators are not implemented: {}\".format(missing_operators))\n\n control_flow_node_map = defaultdict(set)\n for node in graph.node:\n node_name_prefix = node.name.rsplit('/', 1)[0]\n control_flow_node_map[node_name_prefix].add(node.op)\n if node.op == 'Placeholder' or node.op == 'PlaceholderWithDefault':\n # Give priority to user argument.\n if shape and node.name in shape:\n self._input_shapes[node.name] = list(shape[node.name])\n else:\n self._input_shapes[node.name] = \\\n tensor_util.TensorShapeProtoToList(node.attr['shape'].shape)\n for idx, dim in enumerate(self._input_shapes[node.name]):\n if dim < 0:\n self._input_shapes[node.name][idx] = 1\n warnings.warn(\"Use 1 instead of -1 in shape of operator %s.\"\n % node.name)\n\n self._output_shapes[node.name] = [self._input_shapes[node.name]]\n attr = self._parse_attr(node.attr)\n self._nodes[node.name] = [_expr.var(node.name,\n shape=self._input_shapes[node.name],\n dtype=attr['dtype'].name)]\n\n # Ignore user's input shape for Non placeholder\n elif node.op == 'Const':\n tensor_value = node.attr['value'].tensor\n self._input_shapes[node.name] = \\\n tensor_util.TensorShapeProtoToList(tensor_value.tensor_shape)\n if shape and node.name in shape:\n warnings.warn(\"Ignore the passed shape. Shape in graphdef \"\n \"will be used for operator %s.\" % node.name)\n\n # Parse the nodes to re-create TF graph using Relay operators.\n for node in graph.node:\n # Tensorflow doesn't have separate list for params extraction.\n # Operator name 'Const' is treated as a parameter to build params dict.\n\n input_shapes = {}\n attr = self._parse_attr(node.attr)\n\n # Variable converted to Const will not have only value attr\n if 'value' in attr and node.op == 'Const':\n self._output_shapes[node.name] = [self._input_shapes[node.name]]\n elif '_output_shapes' in attr:\n self._output_shapes[node.name] = \\\n [tensor_util.TensorShapeProtoToList(tshape) \\\n for tshape in attr['_output_shapes']]\n else:\n # Keep the list indexable to avoid key error.\n # Actual value will be filled after node creation.\n # Will infer shapes if the graph is not frozen with add_shapes=True\n self._output_shapes[node.name] = [None]\n\n if node.op == \"Const\":\n # All Const nodes are Param nodes, lets parse\n self._num_param += 1\n for key, value in node.attr.items():\n self._parse_param(key, value, node.name, shape)\n if node.name not in self._nodes:\n raise NotImplementedError( \\\n \"Const {} couldn't be converted to Param.\".format(node.name))\n\n attr = self._parse_attr(node.attr)\n\n elif node.op != \"Placeholder\" and node.op != 'PlaceholderWithDefault':\n # Pass the parsed shapes instead\n attr[\"_output_shapes\"] = output_shapes = self._output_shapes[node.name]\n\n # Pass the node name too in attr\n attr[\"_node_name\"] = node.name\n\n # Pass the target layout\n attr[\"_target_layout\"] = layout\n\n # Fill shapes for all inputs in a list\n inputs = []\n for i in node.input:\n # Some TensorFlow operators internally maintain execution layers\n # and their output name includes the layer number along with\n # graph node name. E.g. the node name is 'Model/RNN/cell_0/RnnCell', but the\n # output tensor name is 'Model/RNN/cell_0/RnnCell:0'. In this case,\n # the number has to be ignored for single-output nodes.\n # On the other hand, for multi-output nodes the number is the output index,\n # and the lack of the number implies 0.\n tensor_name = i.split(':')\n node_name = tensor_name[0]\n if node_name in self._nodes:\n in_sym = self._nodes[node_name]\n if isinstance(in_sym, _expr.TupleWrapper):\n tensor_slot = int(tensor_name[1]) if len(tensor_name) > 1 else 0\n in_sym = [in_sym[tensor_slot]]\n input_shape = self._output_shapes[node_name][tensor_slot]\n else:\n tensor_slot = 0\n input_shape = self._output_shapes[node_name][0]\n inputs.append(in_sym[0])\n input_shapes[in_sym[0]] = input_shape\n\n attr['_input_shapes'] = input_shapes\n\n if node.op in _control_flow_nodes:\n op = self._convert_control_flow_operator(node, inputs,\n attr,\n control_flow_node_map)\n else:\n op = self._convert_operator(node.op, inputs, attr, graph)\n\n # Check if op is converted to param\n if isinstance(op, np.ndarray):\n self._params[node.name] = tvm.nd.array(op)\n op = [_expr.var(node.name,\n shape=self._params[node.name].shape,\n dtype=self._params[node.name].dtype)]\n\n elif isinstance(op, (_expr.TupleWrapper, tuple, list)):\n pass\n elif isinstance(op, _expr.Expr):\n op = [op]\n else:\n raise RuntimeError(\"unexpected type %s\" % type(op))\n\n self._nodes[node.name] = op\n\n # Infer shapes even without specifying \"add_shapes=True\"\n if output_shapes == [None]:\n out_shapes = [_infer_shape(node_item, self._mod)\n for node_item in self._nodes[node.name]]\n self._output_shapes[node.name] = out_shapes\n\n if self._output_shapes[node.name] and shape and node.name in shape:\n assert self._output_shapes[node.name] == list(shape[node.name])\n\n # Infer shapes if passed explicitly\n node_output = self._nodes[node.name]\n if shape and (not self._output_shapes[node.name][0]\n or -1 in self._output_shapes[node.name][0]):\n out_shapes = [_infer_shape(node_item, self._mod) for node_item in node_output]\n self._output_shapes[node.name] = out_shapes\n\n out = []\n if outputs is None:\n if node.op == \"Exit\":\n out = [op[0].tuple_value]\n else:\n out = op\n else:\n for out_name in outputs:\n if \":\" in out_name:\n out_name, out_num = out_name.split(\":\")\n out_num = int(out_num)\n out.append(self._nodes[out_name][out_num])\n else:\n out.append(self._nodes[out_name][0])\n\n #Add the RNN outputs also with 'head' nodes of the relay graph\n if self._num_rnn_layer:\n if len(self._out_rnn) == 1:\n out.append(self._out_rnn[0])\n else:\n out_rnn = _op.concatenate(self._out_rnn, axis=0)\n out.append(out_rnn)\n\n out = out[0] if len(out) == 1 else _expr.Tuple(out)\n func = _expr.Function(analysis.free_vars(out), out)\n self._mod[\"main\"] = func\n return self._mod, self._params\n\n def _parse_import_prerequisites(self, graph):\n \"\"\" Calculate the named preconditions from TensorFlow `graph`.\n Return prerequisites for parsing:\n a. Set of operator names which don't have their mapping in TVM, i.e.\n which are not supported\n \"\"\"\n missing_operators = set()\n for node in graph.node:\n if node.op == \"Placeholder\" or node.op == 'PlaceholderWithDefault':\n pass\n elif node.op == \"Const\":\n pass\n else:\n if any([node.op in t for t in [_identity_list, _convert_map,\n _convert_map_rnn,\n _control_flow_nodes]]):\n pass\n else:\n missing_operators.add(node.op)\n\n return missing_operators\n\n def _parse_param(self, key, value, name, shape):\n try:\n from tensorflow.python.framework import tensor_util\n except ImportError as e:\n raise ImportError(\n \"Unable to import tensorflow which is required {}\".format(e))\n\n if key == 'value':\n np_array = tensor_util.MakeNdarray(value.tensor)\n\n if np_array.dtype == np.dtype(object):\n # Object types are generally tensorflow DT_STRING (DecodeJpeg op).\n # Just leave it as placeholder.\n if shape:\n var_shape = shape[name]\n else:\n var_shape = tensor_util.TensorShapeProtoToList(value.tensor.tensor_shape)\n self._nodes[name] = [_expr.var(name, shape=var_shape, dtype='uint8')]\n return\n\n array_ndim = len(np_array.shape)\n if array_ndim == 0:\n new_array = np.empty([1], dtype=np_array.dtype)\n new_array[0] = np_array\n self._nodes[name] = [tvm.relay.const(new_array)]\n else:\n self._params[name] = tvm.nd.array(np_array)\n self._nodes[name] = [_expr.var(name,\n shape=self._params[name].shape,\n dtype=self._params[name].dtype)]\n else:\n if key not in ('dtype', '_output_shapes', '_class'):\n raise NotImplementedError \\\n (\"Other attributes for a Const(param) Node {} ? .\".format(key))\n\n def _get_attr(self, buf):\n \"\"\"Returns the value of the attr of this buf with the given `name`.\n\n Args:\n buf: attrvalue protobuf.\n\n Returns:\n The value of the attr, as a Python object.\n\n Raises:\n ValueError: If this op does not have an attr with the given `name`.\n \"\"\"\n fields = [\"s\", \"i\", \"f\", \"b\", \"type\", \"shape\", \"tensor\", \"func\"]\n\n x = buf\n\n ret = []\n\n try:\n from tensorflow.python.framework import dtypes\n except ImportError as e:\n raise ImportError(\n \"Unable to import tensorflow which is required {}\".format(e))\n\n # Treat an empty oneof value as an empty list.\n if not x.WhichOneof(\"value\"):\n return ret\n if x.HasField(\"list\"):\n for f in fields:\n if getattr(x.list, f):\n if f == \"type\":\n ret += [dtypes.as_dtype(x) for x in list(getattr(x.list, f))]\n else:\n ret += list(getattr(x.list, f))\n else:\n for f in fields:\n if x.HasField(f):\n if f == \"type\":\n ret = dtypes.as_dtype(getattr(x, f))\n else:\n ret = getattr(x, f)\n return ret\n\n def _parse_attr(self, attr_proto):\n \"\"\"Convert a list of AttributeProto to a dict, with names as keys.\"\"\"\n attrs = {}\n for key, value in attr_proto.items():\n attrs[key] = self._get_attr(value)\n\n return attrs\n\n def _convert_rnn_operator(self, op_name, inputs,\n attrs, params, graph, convert_map):\n \"\"\"Convert RNN and its variant operators to Relay operators.\n This converter read the input states of each layers and\n also maintain the output states of each layer in a list.\n\n Parameters\n ----------\n op_name : str\n Operator name, such as LSTMBlockCell\n inputs : list of relay.Expr\n List of input symbols.\n attrs : dict\n Dict of operator attributes\n params : dict\n List of pretrained weights and bias\n graph : Tensorflow graph object\n Graph is to find the number of upcoming same operator to\n calculate the number of layers.\n convert_map : dict\n Dict of name : callable, where name is the op's name that\n require conversion to relay, callable are functions which\n take attrs and return (new_op_name, new_attrs)\n\n Returns\n -------\n sym : relay.Expr\n Converted relay.Expr\n \"\"\"\n if not self._num_rnn_layer:\n self._out_rnn = []\n self.rnn = RecurrentNetworks(self._nodes, self._out_rnn, graph, convert_map)\n self._num_rnn_layer = True\n sym = self.rnn.process_op(op_name, inputs, attrs, params)\n return sym\n\n def _convert_control_flow_operator(self, node, inputs, attrs, control_flow_node_map):\n \"\"\"\n Convert the Relay control flow primitive into corresponding component\n of a Relay control flow construct, i.e. `tf.cond` and `tf.while_loop`\n are converted in Relay `If` and recusrive call, respectively.\n\n Parameters\n ----------\n node: TensorFlow graph node object.\n A TensorFlow graph node object.\n\n inputs : List[tvm.relay.Expr]\n List of input symbols.\n\n attrs : Dict[tvm.Attrs]\n Dict of operator attributes.\n\n control_flow_node_map : Dict[str, Set[str]]\n A dictionary contains the execution frame name to primitives\n mapping.\n\n Returns\n -------\n op : tvm.relay.Expr\n Converted relay expression.\n \"\"\"\n node_name_prefix = node.name.rsplit('/', 1)[0]\n if node.op == \"Merge\":\n if _in_while_loop(control_flow_node_map, node_name_prefix):\n op = self._nodes[node.input[0]]\n self._loops[node_name_prefix] = Loop()\n else:\n if len(self._branches) == 0:\n raise RuntimeError(\"Cannot find a created \"\n \"conditional for merge node\")\n branch = self._branches[node_name_prefix]\n false_br = self._nodes[node.input[0]]\n true_br = self._nodes[node.input[1]]\n assert len(true_br) == 1\n assert len(false_br) == 1\n branch.true_branch = true_br[0]\n branch.false_branch = false_br[0]\n op = [branch.if_node()]\n elif node.op == \"Exit\":\n loop = self._loops[node_name_prefix]\n exit_name = node.name.split('/')[-1]\n assert str.startswith(exit_name, 'Exit')\n\n # TensorFlow has differen naming convention on different\n # versions.\n if '_' in exit_name:\n exit_number = int(\"0\" + exit_name[5:])\n else:\n exit_number = int(\"0\" + exit_name[4:])\n\n expr = loop.while_loop()\n op = _expr.TupleGetItem(expr, exit_number)\n elif node.op == \"Enter\":\n op = self._nodes[node.input[0]]\n elif node.op == \"LoopCond\":\n op = self._nodes[node.input[0]]\n assert len(op) == 1\n self._loops[node_name_prefix].cond = op[0]\n elif node.op == \"Switch\":\n op = self._nodes[node.input[0]]\n assert len(op) == 1\n if _in_while_loop(control_flow_node_map, node_name_prefix):\n self._loops[node_name_prefix].loop_vars.append(op[0])\n else:\n if node_name_prefix not in self._branches:\n self._branches[node_name_prefix] = Branch()\n chk_op = _infer_type(op[0])\n self._branches[node_name_prefix].cond = chk_op\n elif node.op == \"NextIteration\":\n op = self._nodes[node.input[0]]\n assert len(op) == 1\n self._loops[node_name_prefix].body.append(op[0])\n else:\n raise Exception(\"Cannot identify control flow operator: \" +\n \"{}\".format(node.op))\n\n return op\n\n\n def _convert_operator(self, op_name, inputs, attrs,\n graph, identity_list=None, convert_map=None):\n \"\"\"Convert from Tensorflow operator to relay operator.\n The converter must specify conversions explicitly for incompatible name, and\n apply handlers to operator attributes.\n\n Parameters\n ----------\n op_name : str\n Operator name, such as Conv2D, AvgPool\n inputs : list of relay.op\n List of input symbols.\n attrs : dict\n Dict of operator attributes\n identity_list : list\n List of operators that don't require conversion\n convert_map : dict\n Dict of name : callable, where name is the op's name that\n require conversion to relay, callable are functions which\n take attrs and return (new_op_name, new_attrs)\n\n Returns\n -------\n sym : relay.op\n Converted relay operator\n \"\"\"\n identity_list = identity_list if identity_list else _identity_list\n convert_map = convert_map if convert_map else _convert_map\n convert_map_rnn = _convert_map_rnn\n if op_name in identity_list:\n sym = get_relay_op(op_name)(*inputs, **attrs)\n elif op_name in convert_map:\n if _need_prelude_for_shape_inference(op_name):\n sym = convert_map[op_name](inputs, attrs, self._params, self._prelude)\n elif _need_module_for_shape_inference(op_name):\n sym = convert_map[op_name](inputs, attrs, self._params, self._mod)\n else:\n sym = convert_map[op_name](inputs, attrs, self._params)\n\n elif op_name in convert_map_rnn:\n sym = self._convert_rnn_operator(op_name, inputs, attrs,\n self._params, graph,\n convert_map_rnn)\n else:\n raise NotImplementedError(\"Operator {} not implemented.\".format(op_name))\n return sym\n\n\ndef from_tensorflow(graph, layout=\"NHWC\", shape=None, outputs=None):\n \"\"\"Load tensorflow graph which is a python tensorflow graph object into relay.\n The companion parameters will be handled automatically.\n\n Parameters\n ----------\n graph : GraphDef object\n Tensorflow GraphDef\n\n layout : target layout to be used (Optional)\n NCHW only supported now to enable NHWC models on GPU.\n\n shape : Dictionary of input dimensions (Optional)\n Graph level input shape dictionary.\n\n outputs : List of output tensor names (Optional)\n if not specified then the last node is assumed as graph output.\n\n Returns\n -------\n mod : tvm.relay.Module\n The module that optimizations will be performed on.\n\n params : dict of str to tvm.ndarray\n Dict of converted parameters stored in tvm.ndarray format\n \"\"\"\n g = GraphProto()\n mod, params = g.from_tensorflow(graph, layout, shape, outputs)\n return mod, params\n"
] | [
[
"numpy.cumsum",
"numpy.empty",
"numpy.dtype",
"tensorflow.python.framework.tensor_util.MakeNdarray",
"numpy.prod",
"numpy.array",
"tensorflow.python.framework.dtypes.as_dtype",
"tensorflow.python.framework.tensor_util.TensorShapeProtoToList"
]
] |
kopanya/good-sunday | [
"dcd92edfa1866ca7b5806879ba6bd1f7c628da6e"
] | [
"tensorFlow/sklearn/a3.py"
] | [
"from sklearn import datasets\nfrom sklearn.linear_model import LinearRegression\nimport matplotlib.pyplot as plt\n\n\nloaded_data = datasets.load_boston()\ndata_x = loaded_data.data\ndata_y = loaded_data.target\n\nmodel = LinearRegression()\n\nmodel.fit(data_x, data_y)\n## print(model.predict(data_x[:4, :]))\n\nprint(model.coef_)\nprint(model.intercept_)\nprint(model.get_params())\nprint(model.score(data_x, data_y))"
] | [
[
"sklearn.datasets.load_boston",
"sklearn.linear_model.LinearRegression"
]
] |
jtran10/pyNastran | [
"4aed8e05b91576c2b50ee835f0497a9aad1d2cb0"
] | [
"pyNastran/op2/result_objects/stress_object.py"
] | [
"from __future__ import print_function\nimport sys\nfrom collections import OrderedDict\nimport numpy as np\n\n#vm_word = get_plate_stress_strain(\n #model, key, is_stress, vm_word, itime,\n #oxx, oyy, txy, max_principal, min_principal, ovm, is_element_on,\n #header_dict, keys_map)\n\nclass StressObject(object):\n def __init__(self, model, key, all_eids, is_stress=True):\n #print('--StressObject--')\n self.model = model\n self.vm_word = None\n self.header_dict = OrderedDict()\n self.keys_map = {}\n self.composite_ieids = {}\n self.is_stress = is_stress\n\n self.composite_data_dict = create_composite_plates(model, key, is_stress, self.keys_map)\n #self.plates_data_dict = create_plates(model, key, is_stress)\n\n #for key in self.plates_data_dict.keys():\n #(case.element_node, ueids, data2, vm_word, ntimes) = self.plates_data_dict[key]\n #(min_data, max_data) = data2\n\n for element_type, composite_data in self.composite_data_dict.items():\n for key in composite_data:\n element_layer, ueids, data2, vm_word, ntimes, headers = composite_data[key]\n #all_eids = ueids\n\n ntimes, neids, nlayers, nresults = data2.shape\n #data2[itime, eid, layer, oxx/oyy/...]\n ieids = np.searchsorted(all_eids, ueids)\n self.composite_ieids[element_type] = ieids\n #if len(self.composite_data_dict) > 0:\n #print(str(self))\n #print('-------------********------------')\n\n\n def set_composite_stress_old(self,\n key, itime, oxx, oyy, txy, tyz, txz,\n max_principal, min_principal, ovm,\n is_element_on, header_dict):\n #print(\"setting...\")\n\n for element_type, composite_data in self.composite_data_dict.items():\n try:\n element_layer, ueids, data2, vm_word, ntimes, headers = composite_data[key]\n except KeyError:\n print(composite_data)\n raise\n #print(\"vm_word = \", key, vm_word)\n for itime2, header in enumerate(headers):\n header_dict[(key, itime2)] = header\n\n ntimes, neids, nlayers, nresults = data2.shape\n #data2[itime, eid, layer, oxx/oyy/...]\n\n ieids = self.composite_ieids[element_type]\n #print('setting...')\n data3 = data2[itime, :, :, :]\n oxx[ieids] = np.nanmax(data3[:, :, 0], axis=1)\n oyy[ieids] = np.nanmax(data3[:, :, 1], axis=1)\n txy[ieids] = np.nanmax(data3[:, :, 2], axis=1)\n txz[ieids] = np.nanmax(data3[:, :, 3], axis=1)\n tyz[ieids] = np.nanmax(data3[:, :, 4], axis=1)\n # angle\n max_principal[ieids] = np.nanmax(data3[:, :, 6], axis=1)\n min_principal[ieids] = np.nanmin(data3[:, :, 7], axis=1)\n ovm[ieids] = np.nanmax(data3[:, :, 8], axis=1)\n if itime == 0:\n is_element_on[ieids] = 1\n #assert oxxi.shape == (ntimes, neids)\n return vm_word\n\n def set_composite_stress(self,\n oxx, oyy, txy, tyz, txz,\n max_principal, min_principal, ovm,\n ): # pragma: no cover\n\n for element_type, composite_data in self.composite_data_dict.items():\n element_layer, ueids, data2, vm_word, ntimes, headers = composite_data[key]\n\n ntimes, neids, nlayers, nresults = data2.shape\n #data2[itime, eid, layer, oxx/oyy/...]\n\n ieids = self.composite_ieids[element_type]\n oxx[ieids] = np.nanmax(data2[:, :, :, 0], axis=2)\n oyy[ieids] = np.nanmax(data2[:, :, :, 1], axis=2)\n txy[ieids] = np.nanmax(data2[:, :, :, 2], axis=2)\n txz[ieids] = np.nanmax(data2[:, :, :, 3], axis=2)\n tyz[ieids] = np.nanmax(data2[:, :, :, 4], axis=2)\n # angle\n max_principal[ieids] = np.nanmax(data2[:, :, :, 6], axis=2)\n min_principal[ieids] = np.nanmin(data2[:, :, :, 7], axis=2)\n ovm[ieids] = np.nanmax(data2[:, :, :, 8], axis=2)\n assert oxxi.shape == (ntimes, neids)\n\n def __repr__(self):\n if self.is_stress:\n msg = 'StressObject:\\n'\n else:\n msg = 'StrainObject:\\n'\n msg += ' composite_data_dict.keys() = %s\\n' % str(list(self.composite_data_dict.keys()))\n msg += ' composite_ieids = %s\\n' % self.composite_ieids\n return msg\n\ndef create_plates(model, key, is_stress):\n \"\"\"helper method for _fill_op2_time_centroidal_stress\"\"\"\n if is_stress:\n plates = [\n model.ctria3_stress, model.cquad4_stress,\n model.ctria6_stress, model.cquad8_stress,\n model.ctriar_stress, model.cquadr_stress,\n ]\n else:\n plates = [\n model.ctria3_strain, model.cquad4_strain,\n model.ctria6_strain, model.cquad8_strain,\n model.ctriar_strain, model.cquadr_strain,\n ]\n\n #[o11, o22, t12, t1z, t2z, angle, major, minor, max_shear]\n isotropic_data_dict = {}\n for obj_dict in plates:\n cases_to_delete = []\n for case_key, case in obj_dict.items():\n if case_key == key:\n #data_dict[element_type] = [ueids, data]\n case_to_delete = case_key\n cases_to_delete.append(case_to_delete)\n\n if case.is_von_mises:\n vm_word = 'vonMises'\n else:\n vm_word = 'maxShear'\n\n nnodes_per_element = case.nnodes\n nlayers_per_element = nnodes_per_element * 2 # *2 for every other layer\n #eidsi = case.element_node[::nlayers_per_element, 0] # ::2 is for layer skipping\n ueids = np.unique(case.element_node[:, 0])\n neids = len(ueids)\n\n #if 0:\n #i = np.searchsorted(eids, eidsi)\n #if len(i) != len(np.unique(i)):\n #print(case.element_node)\n #print('element_name=%s nnodes_per_element=%s' % (\n #case.element_name, nnodes_per_element))\n #print('iplate = %s' % i)\n #print('eids = %s' % eids)\n #print('eidsiA = %s' % case.element_node[:, 0])\n #print('eidsiB = %s' % eidsi)\n #msg = 'iplate=%s is not unique' % str(i)\n #raise RuntimeError(msg)\n\n ntotal = case.data.shape[1] # (ndt, ntotal, nresults)\n if nlayers_per_element == 1:\n j = None\n else:\n j = np.arange(ntotal)[::nlayers_per_element]\n\n #self.data[self.itime, self.itotal, :] = [fd, oxx, oyy,\n # txy, angle,\n # majorP, minorP, ovm]\n\n #print(\"nlayers_per_element = \", case.element_name, nlayers_per_element)\n max_vals = [1, 2, 3, 5, 7]\n ntimes = case.data.shape[0]\n min_start = case.data[:, j, 6]\n max_start = case.data[:, j, :][:, :, max_vals]\n min_data_list = [min_start]\n max_data_list = [max_start]\n for inode in range(1, nlayers_per_element):\n datai = case.data[:, j+inode, :]\n min_data_list.append(case.data[:, j+inode, :][:, :, max_vals])\n max_data_list.append(case.data[:, j+inode, :])\n if len(min_data_list) == 1:\n min_data = min_data_list[0]\n max_data = max_data_list[0]\n else:\n #print(np.dstack(max_data_list).shape)\n # (ntimes, neids, nresults)\n # (1, 4, 13) = np.dstack(max_data_list)\n min_data = np.amin(np.dstack(min_data_list), axis=0)\n max_data = np.amax(np.dstack(max_data_list), axis=0)\n #assert min_data.shape == (ntimes, neids, 1), min_data.shape\n #assert max_data.shape == (ntimes, neids, 5), max_data.shape\n del min_data_list, max_data_list\n\n #eidsi = case.element_node[:, 0]\n #layers = case.element_node[:, 1]\n data2 = (min_data, max_data)\n isotropic_data_dict[key] = [case.element_node, ueids, data2, vm_word, ntimes]\n #for case_key in cases_to_delete:\n #del obj_dict[case_key]\n return isotropic_data_dict\n\ndef create_composite_plates(model, key, is_stress, keys_map):\n \"\"\"helper method for _fill_op2_time_centroidal_stress\"\"\"\n if is_stress:\n cplates = [\n ('CTRIA3', model.ctria3_composite_stress),\n ('CQUAD4', model.cquad4_composite_stress),\n ('CTRIA6', model.ctria6_composite_stress),\n ('CQUAD8', model.cquad8_composite_stress),\n #model.ctriar_composite_stress,\n #model.cquadr_composite_stress,\n ]\n else:\n cplates = [\n ('CTRIA3', model.ctria3_composite_strain),\n ('CQUAD4', model.cquad4_composite_strain),\n ('CTRIA6', model.ctria6_composite_strain),\n ('CQUAD8', model.cquad8_composite_strain),\n #model.ctriar_composite_strain,\n #model.cquadr_composite_strain,\n ]\n\n #[o11, o22, t12, t1z, t2z, angle, major, minor, max_shear]\n composite_data_dict = {}\n for element_type, obj_dict in cplates:\n cases_to_delete = []\n if len(obj_dict) == 0:\n continue\n\n composite_data_dict[element_type] = {}\n for case_key, case in obj_dict.items():\n if case_key == key:\n keys_map[key] = (case.subtitle, case.label,\n case.superelement_adaptivity_index, case.pval_step)\n #data_dict[element_type] = [ueids, data]\n case_to_delete = case_key\n cases_to_delete.append(case_to_delete)\n\n if case.is_von_mises:\n vm_word = 'vonMises'\n else:\n vm_word = 'maxShear'\n eidsi = case.element_layer[:, 0]\n layers = case.element_layer[:, 1]\n ntimes = case.data.shape[0]\n data2, ueids = pivot(case.data, eidsi, layers)\n\n headers = []\n for itime, dt in enumerate(case._times):\n header = _get_nastran_header(case, dt, itime)\n headers.append(header)\n composite_data_dict[element_type][key] = [\n case.element_layer, ueids, data2, vm_word, ntimes, headers]\n if len(composite_data_dict[element_type]) == 0:\n del composite_data_dict[element_type]\n #for case_key in cases_to_delete:\n #del obj_dict[case_key]\n\n\n return composite_data_dict\n\n\ndef pivot(data, rows, cols):\n \"\"\"\n PCOMP: rows=element_ids, cols=layer\n \"\"\"\n ncount = len(rows)\n icount = np.arange(ncount)\n assert len(data.shape) == 3\n ntimes = data.shape[0]\n nresults = data.shape[-1]\n\n rows_new, row_pos_new = np.unique(rows, return_inverse=True)\n cols_new, col_pos_new = np.unique(cols, return_inverse=True)\n nrows = len(rows_new)\n ncols = len(cols_new)\n\n pivot_table = np.full((nrows, ncols), -1, dtype='int32')\n pivot_table[row_pos_new, col_pos_new] = icount\n #print(pivot_table)\n\n ipivot_row, ipivot_col = np.where(pivot_table != -1)\n data2 = np.full((ntimes, nrows, ncols, nresults), np.nan, dtype=data.dtype)\n data2[:, ipivot_row, ipivot_col, :] = data[:, icount, :]\n\n return data2, rows_new\n\ndef _get_nastran_header(case, dt, itime):\n #if case is None:\n #return None\n try:\n code_name = case.data_code['name']\n except KeyError:\n return 'Static'\n\n if isinstance(dt, float):\n header = ' %s = %.4E' % (code_name, dt)\n else:\n header = ' %s = %i' % (code_name, dt)\n\n # cases:\n # 1. lsftsfqs\n # 2. loadIDs, eigrs\n # 3. lsdvmns, eigrs\n # ???\n if hasattr(case, 'mode_cycle'):\n header += '; freq = %g Hz' % case.mode_cycles[itime]\n elif hasattr(case, 'cycles'):\n header += '; freq = %g Hz' % case.cycles[itime]\n elif hasattr(case, 'eigis'):\n eigi = case.eigis[itime]\n cycle = np.abs(eigi) / (2. * np.pi)\n header += '; freq = %g Hz' % cycle\n elif hasattr(case, 'eigns'): # eign is not eigr; it's more like eigi\n eigi = case.eigrs[itime] # but |eigi| = sqrt(|eign|)\n cycle = np.sqrt(np.abs(eigi)) / (2. * np.pi)\n header += '; freq = %g Hz' % cycle\n elif hasattr(case, 'dt'):\n time = case._times[itime]\n header += '; time = %g sec' % time\n elif hasattr(case, 'lftsfqs') or hasattr(case, 'lsdvmns') or hasattr(case, 'loadIDs'):\n pass\n #raise RuntimeError(header)\n else:\n msg = 'unhandled case; header=%r\\n%s' % (header, str(case))\n print(msg)\n #raise RuntimeError(msg)\n\n return header.strip('; ')\n\n\ndef get_rod_stress_strain(model, key, is_stress, vm_word, itime,\n oxx, txy,\n max_principal, min_principal, ovm, is_element_on,\n eids, header_dict, keys_map):\n \"\"\"helper method for _fill_op2_time_centroidal_stress\"\"\"\n if is_stress:\n rods = [model.crod_stress, model.conrod_stress, model.ctube_stress,]\n else:\n rods = [model.crod_strain, model.conrod_strain, model.ctube_strain,]\n\n for result in rods:\n if key not in result:\n continue\n\n case = result[key]\n if case.is_complex:\n continue\n eidsi = case.element\n i = np.searchsorted(eids, eidsi)\n if len(i) != len(np.unique(i)):\n msg = 'irod=%s is not unique\\n' % str(i)\n print('eids = %s\\n' % str(list(eids)))\n print('eidsi = %s\\n' % str(list(eidsi)))\n raise RuntimeError(msg)\n\n is_element_on[i] = 1\n dt = case._times[itime]\n header = _get_nastran_header(case, dt, itime)\n header_dict[(key, itime)] = header\n keys_map[key] = (case.subtitle, case.label,\n case.superelement_adaptivity_index, case.pval_step)\n\n # data=[1, nnodes, 4] where 4=[axial, SMa, torsion, SMt]\n oxx[i] = case.data[itime, :, 0]\n txy[i] = case.data[itime, :, 2]\n try:\n ovm[i] = np.sqrt(oxx[i]**2 + 3*txy[i]**2) # plane stress\n except FloatingPointError:\n ovm[i] = 0.\n assert np.allclose(oxx[i], 0.)\n assert np.allclose(txy[i], 0.)\n # max_principal[i] = sqrt(oxx[i]**2 + txy[i]**2)\n # min_principal[i] = max_principal[i] - 2 * txy[i]\n # simplification of:\n # eig(A) = [oxx, txy]\n # [txy, 0.0]\n # per Equation 7: http://www.soest.hawaii.edu/martel/Courses/GG303/Eigenvectors.pdf\n try:\n max_principal[i] = (oxx[i] + np.sqrt(oxx[i]**2 + 4 * txy[i]**2)) / 2.\n min_principal[i] = (oxx[i] - np.sqrt(oxx[i]**2 + 4 * txy[i]**2)) / 2.\n except FloatingPointError:\n # underflow is a thing...we can promote the dtype from float32 to float64\n # but we'll hold off until there's a real example\n assert np.allclose(oxx[i], 0.)\n assert np.allclose(txy[i], 0.)\n max_principal[i] = 0.\n min_principal[i] = 0.\n del rods\n return vm_word\n\ndef get_bar_stress_strain(model, key, is_stress, vm_word, itime,\n oxx,\n max_principal, min_principal, ovm, is_element_on,\n eids, header_dict, keys_map):\n \"\"\"helper method for _fill_op2_time_centroidal_stress\"\"\"\n if is_stress:\n bars = model.cbar_stress\n else:\n bars = model.cbar_strain\n\n if key in bars:\n case = bars[key]\n if case.is_complex:\n pass\n else:\n dt = case._times[itime]\n header = _get_nastran_header(case, dt, itime)\n header_dict[(key, itime)] = header\n keys_map[key] = (case.subtitle, case.label,\n case.superelement_adaptivity_index, case.pval_step)\n #s1a = case.data[itime, :, 0]\n #s2a = case.data[itime, :, 1]\n #s3a = case.data[itime, :, 2]\n #s4a = case.data[itime, :, 3]\n\n axial = case.data[itime, :, 4]\n smaxa = case.data[itime, :, 5]\n smina = case.data[itime, :, 6]\n #MSt = case.data[itime, :, 7]\n\n #s1b = case.data[itime, :, 8]\n #s2b = case.data[itime, :, 9]\n #s3b = case.data[itime, :, 10]\n #s4b = case.data[itime, :, 11]\n\n smaxb = case.data[itime, :, 12]\n sminb = case.data[itime, :, 13]\n #MSc = case.data[itime, :, 14]\n\n eidsi = case.element # [:, 0]\n\n i = np.searchsorted(eids, eidsi)\n if len(i) != len(np.unique(i)):\n print('ibar = %s' % i)\n print('eids = %s' % eids)\n msg = 'ibar=%s is not unique' % str(i)\n raise RuntimeError(msg)\n\n is_element_on[i] = 1.\n oxx[i] = axial\n\n ## TODO :not sure if this block is general for multiple CBAR elements\n samax = np.amax([smaxa, smaxb], axis=0)\n samin = np.amin([smaxa, smaxb], axis=0)\n assert len(samax) == len(i), len(samax)\n assert len(samin) == len(i)\n savm = np.amax(np.abs(\n [smina, sminb,\n smaxa, smaxb, axial]), axis=0)\n\n max_principal[i] = samax\n min_principal[i] = samin\n ovm[i] = savm\n del axial, smaxa, smina, smaxb, sminb, eidsi, i, samax, samin, savm\n del bars\n return vm_word\n\ndef try_except_return3(func):\n def try_except_func(*args, **kwargs):\n try:\n out = func(*args, **kwargs)\n except(MemoryError, NameError):\n raise\n except(RuntimeError, IndexError):\n if 'test_' in sys.argv[0]:\n raise\n out = args[3]\n return out\n return try_except_func\n\n@try_except_return3\ndef get_bar100_stress_strain(model, key, is_stress, vm_word, itime,\n oxx,\n max_principal, min_principal, ovm, is_element_on,\n eids, header_dict, keys_map):\n \"\"\"helper method for _fill_op2_time_centroidal_stress\"\"\"\n if is_stress:\n bars2 = model.cbar_stress_10nodes\n else:\n bars2 = model.cbar_strain_10nodes\n\n if key in bars2:\n case = bars2[key]\n if case.is_complex:\n pass\n else:\n dt = case._times[itime]\n header = _get_nastran_header(case, dt, itime)\n header_dict[(key, itime)] = header\n keys_map[key] = (case.subtitle, case.label,\n case.superelement_adaptivity_index, case.pval_step)\n\n # 0 1 2 3 4 5 6 7 8\n # [sd, sxc, sxd, sxe, sxf, axial, smax, smin, MS]\n\n eidsi = case.element # [:, 0]\n ueidsi = np.unique(eidsi)\n istart = np.searchsorted(eidsi, ueidsi)\n unused_iend = np.hstack([istart[1:], [len(eidsi)]])\n axial = case.data[itime, :, 5]\n\n nbars = len(eidsi) // 10\n if nbars * 10 != len(eidsi):\n msg = 'nbars=%s neids=%s; expected neids=10*nbars=%s' % (nbars, len(eidsi), 10*nbars)\n raise RuntimeError(msg)\n\n axial = case.data[itime, :, 5].reshape(nbars, 10).min(axis=1)\n smax = case.data[itime, :, 6].reshape(nbars, 10).max(axis=1)\n smin = case.data[itime, :, 7].reshape(nbars, 10).min(axis=1)\n\n\n i = np.searchsorted(eids, eidsi)\n if len(i) != len(np.unique(i)):\n print('ibar = %s' % i)\n print('eids = %s' % eids)\n msg = 'ibar=%s is not unique' % str(i)\n raise RuntimeError(msg)\n\n is_element_on[i] = 1.\n oxx[i] = axial\n\n ## TODO :not sure if this block is general for multiple CBAR elements\n svm = np.amax(np.abs([smin, smin]), axis=0)\n\n max_principal[i] = smax\n min_principal[i] = smin\n ovm[i] = svm\n #del axial, smaxa, smina, smaxb, sminb, eidsi, i, samax, samin, savm\n del bars2\n return vm_word\n\ndef get_beam_stress_strain(model, key, is_stress, vm_word, itime,\n oxx,\n max_principal, min_principal, ovm, is_element_on,\n header_dict, keys_map, eid_map):\n \"\"\"helper method for _fill_op2_time_centroidal_stress\"\"\"\n if is_stress:\n beams = model.cbeam_stress\n else:\n beams = model.cbeam_strain\n\n if key in beams:\n case = beams[key]\n if case.is_complex:\n pass\n else:\n eidsi = case.element_node[:, 0]\n ueids = np.unique(eidsi)\n #neids = len(ueids)\n\n # sxc, sxd, sxe, sxf\n # smax, smin, MSt, MSc\n dt = case._times[itime]\n header = _get_nastran_header(case, dt, itime)\n header_dict[(key, itime)] = header\n keys_map[key] = (case.subtitle, case.label,\n case.superelement_adaptivity_index, case.pval_step)\n sxc = case.data[itime, :, 0]\n sxd = case.data[itime, :, 1]\n sxe = case.data[itime, :, 2]\n sxf = case.data[itime, :, 3]\n smax = case.data[itime, :, 4]\n smin = case.data[itime, :, 5]\n\n imin = np.searchsorted(eidsi, ueids)\n imax = np.searchsorted(eidsi, ueids, side='right')\n #sxxi = smax[imin:imax]\n for eid, imini, imaxi in zip(ueids, imin, imax):\n oxxi = 0.\n smaxi = 0.\n smini = 0.\n eid2 = eid_map[eid]\n is_element_on[eid2] = 1.\n oxxi = max(\n sxc[imini:imaxi].max(),\n sxd[imini:imaxi].max(),\n sxe[imini:imaxi].max(),\n sxf[imini:imaxi].max(),\n )\n smaxi = smax[imini:imaxi].max()\n smini = smin[imini:imaxi].min()\n ovmi = max(np.abs(smaxi), np.abs(smini))\n oxxi = oxx[eid2]\n max_principal[eid2] = smaxi\n min_principal[eid2] = smini\n ovm[eid2] = ovmi\n del eidsi, ueids, sxc, sxd, sxe, sxf, smax, smin, oxxi, smaxi, smini, ovmi\n del beams\n return vm_word\n\ndef get_plate_stress_strain(model, key, is_stress, vm_word, itime,\n oxx, oyy, txy, max_principal, min_principal, ovm, is_element_on,\n eids, header_dict, keys_map):\n \"\"\"helper method for _fill_op2_time_centroidal_stress\"\"\"\n if is_stress:\n plates = [\n model.ctria3_stress, model.cquad4_stress,\n model.ctria6_stress, model.cquad8_stress,\n model.ctriar_stress, model.cquadr_stress,\n ]\n else:\n plates = [\n model.ctria3_strain, model.cquad4_strain,\n model.ctria6_strain, model.cquad8_strain,\n model.ctriar_strain, model.cquadr_strain,\n ]\n\n for result in plates:\n if key not in result:\n continue\n case = result[key]\n if case.is_complex:\n continue\n\n if case.is_von_mises:\n vm_word = 'vonMises'\n else:\n vm_word = 'maxShear'\n\n nnodes_per_element = case.nnodes\n nlayers_per_element = nnodes_per_element * 2 # *2 for every other layer\n eidsi = case.element_node[::nlayers_per_element, 0] # ::2 is for layer skipping\n\n i = np.searchsorted(eids, eidsi)\n if len(i) != len(np.unique(i)):\n print(case.element_node)\n print('element_name=%s nnodes_per_element=%s' % (case.element_name, nnodes_per_element))\n print('iplate = %s' % i)\n print('eids = %s' % eids)\n print('eidsiA = %s' % case.element_node[:, 0])\n print('eidsiB = %s' % eidsi)\n msg = 'iplate=%s is not unique' % str(i)\n raise RuntimeError(msg)\n #self.data[self.itime, self.itotal, :] = [fd, oxx, oyy,\n # txy, angle,\n # majorP, minorP, ovm]\n try:\n is_element_on[i] = 1\n except IndexError:\n print(case.element_node)\n print('i = %s' % i)\n print('eids = %s' % eids)\n print('eidsi = %s' % eidsi)\n raise\n\n ntotal = case.data.shape[1] # (ndt, ntotal, nresults)\n if nlayers_per_element == 1:\n j = None\n else:\n j = np.arange(ntotal)[::nlayers_per_element]\n\n #self.data[self.itime, self.itotal, :] = [fd, oxx, oyy,\n # txy, angle,\n # majorP, minorP, ovm]\n dt = case._times[itime]\n header = _get_nastran_header(case, dt, itime)\n header_dict[(key, itime)] = header\n keys_map[key] = (case.subtitle, case.label,\n case.superelement_adaptivity_index, case.pval_step)\n oxxi = case.data[itime, j, 1]\n oyyi = case.data[itime, j, 2]\n txyi = case.data[itime, j, 3]\n o1i = case.data[itime, j, 5]\n o3i = case.data[itime, j, 6]\n ovmi = case.data[itime, j, 7]\n\n #print(\"nlayers_per_element = \", case.element_name, nlayers_per_element)\n for inode in range(1, nlayers_per_element):\n #print('%s - ilayer = %s' % (case.element_name, inode))\n #print(case.data[itime, j + inode, 1])\n #print(case.data[itime, :, 1])\n oxxi = np.amax(np.vstack([oxxi, case.data[itime, j + inode, 1]]), axis=0)\n oyyi = np.amax(np.vstack([oyyi, case.data[itime, j + inode, 2]]), axis=0)\n txyi = np.amax(np.vstack([txyi, case.data[itime, j + inode, 3]]), axis=0)\n o1i = np.amax(np.vstack([o1i, case.data[itime, j + inode, 5]]), axis=0)\n o3i = np.amin(np.vstack([o3i, case.data[itime, j + inode, 6]]), axis=0)\n ovmi = np.amax(np.vstack([ovmi, case.data[itime, j + inode, 7]]), axis=0)\n assert len(oxxi) == len(j)\n #print('-------')\n\n oxx[i] = oxxi\n oyy[i] = oyyi\n txy[i] = txyi\n max_principal[i] = o1i\n min_principal[i] = o3i\n ovm[i] = ovmi\n return vm_word\n\n\ndef get_solid_stress_strain(model, key, is_stress, vm_word, itime,\n oxx, oyy, ozz, txy, tyz, txz,\n max_principal, mid_principal, min_principal, ovm, is_element_on,\n eids, header_dict, keys_map):\n \"\"\"helper method for _fill_op2_time_centroidal_stress\"\"\"\n if is_stress:\n solids = [(model.ctetra_stress),\n (model.cpenta_stress),\n (model.chexa_stress),]\n else:\n solids = [(model.ctetra_strain),\n (model.cpenta_strain),\n (model.chexa_strain),]\n\n for result in solids:\n if key not in result:\n continue\n case = result[key]\n if case.is_complex:\n continue\n\n if case.is_von_mises:\n vm_word = 'vonMises'\n else:\n vm_word = 'maxShear'\n\n nnodes_per_element = case.nnodes\n eidsi = case.element_cid[:, 0]\n ntotal = len(eidsi) * nnodes_per_element\n\n i = np.searchsorted(eids, eidsi)\n if len(i) != len(np.unique(i)):\n print('isolid = %s' % str(i))\n print('eids = %s' % eids)\n print('eidsi = %s' % eidsi)\n assert len(i) == len(np.unique(i)), 'isolid=%s is not unique' % str(i)\n\n is_element_on[i] = 1\n #self.data[self.itime, self.itotal, :] = [oxx, oyy, ozz,\n # txy, tyz, txz,\n # o1, o2, o3, ovm]\n\n if nnodes_per_element == 1:\n j = None\n else:\n j = np.arange(ntotal)[::nnodes_per_element]\n ueidsi = np.unique(eidsi)\n assert len(j) == len(ueidsi), 'j=%s ueidsi=%s' % (j, ueidsi)\n\n dt = case._times[itime]\n header = _get_nastran_header(case, dt, itime)\n header_dict[(key, itime)] = header\n keys_map[key] = (case.subtitle, case.label,\n case.superelement_adaptivity_index, case.pval_step)\n oxxi = case.data[itime, j, 0]\n oyyi = case.data[itime, j, 1]\n ozzi = case.data[itime, j, 2]\n txyi = case.data[itime, j, 3]\n tyzi = case.data[itime, j, 4]\n txzi = case.data[itime, j, 5]\n o1i = case.data[itime, j, 6]\n o2i = case.data[itime, j, 7]\n o3i = case.data[itime, j, 8]\n ovmi = case.data[itime, j, 9]\n\n for inode in range(1, nnodes_per_element):\n oxxi = np.amax(np.vstack([oxxi, case.data[itime, j + inode, 0]]), axis=0)\n oyyi = np.amax(np.vstack([oyyi, case.data[itime, j + inode, 1]]), axis=0)\n ozzi = np.amax(np.vstack([ozzi, case.data[itime, j + inode, 2]]), axis=0)\n txyi = np.amax(np.vstack([txyi, case.data[itime, j + inode, 3]]), axis=0)\n tyzi = np.amax(np.vstack([tyzi, case.data[itime, j + inode, 4]]), axis=0)\n txzi = np.amax(np.vstack([txzi, case.data[itime, j + inode, 2]]), axis=0)\n\n o1i = np.amax(np.vstack([o1i, case.data[itime, j + inode, 6]]), axis=0)\n o2i = np.amax(np.vstack([o2i, case.data[itime, j + inode, 7]]), axis=0)\n o3i = np.amin(np.vstack([o3i, case.data[itime, j + inode, 8]]), axis=0)\n ovmi = np.amax(np.vstack([ovmi, case.data[itime, j + inode, 9]]), axis=0)\n assert len(oxxi) == len(j)\n\n oxx[i] = oxxi\n oyy[i] = oyyi\n ozz[i] = ozzi\n txy[i] = txyi\n tyz[i] = tyzi\n txz[i] = txzi\n max_principal[i] = o1i\n mid_principal[i] = o2i\n min_principal[i] = o3i\n ovm[i] = ovmi\n del solids\n return vm_word\n"
] | [
[
"numpy.vstack",
"numpy.allclose",
"numpy.nanmax",
"numpy.searchsorted",
"numpy.abs",
"numpy.nanmin",
"numpy.arange",
"numpy.amax",
"numpy.amin",
"numpy.dstack",
"numpy.sqrt",
"numpy.where",
"numpy.full",
"numpy.unique"
]
] |
xlla/openvino_contrib | [
"bc2bd3007375883580fe2923478b8bf849a357b6"
] | [
"modules/optimum/tests/openvino/test_modeling_ov_auto.py"
] | [
"# Copyright (C) 2018-2021 Intel Corporation\n# SPDX-License-Identifier: Apache-2.0\n\nimport os\nimport unittest\nfrom packaging import version\n\nimport numpy as np\n\nimport transformers\nfrom transformers import AutoTokenizer\nimport datasets\nfrom datasets import DatasetDict, load_dataset\n\ntry:\n from transformers.testing_utils import require_tf, require_torch\nexcept ImportError:\n from transformers.file_utils import is_torch_available, is_tf_available\n\n def require_torch(test_case):\n if not is_torch_available():\n return unittest.skip(\"test requires PyTorch\")(test_case)\n else:\n return test_case\n\n def require_tf(test_case):\n if not is_tf_available():\n return unittest.skip(\"test requires TensorFlow\")(test_case)\n else:\n return test_case\n\n\ntry:\n from openvino.runtime import Core\n\n Core()\n is_openvino_api_2 = True\nexcept ImportError:\n is_openvino_api_2 = False\n\nfrom optimum.intel.openvino import (\n OVAutoModel,\n OVAutoModelForMaskedLM,\n OVAutoModelForQuestionAnswering,\n OVAutoModelWithLMHead,\n OVAutoModelForAudioClassification,\n)\n\n\nclass OVBertForQuestionAnsweringTest(unittest.TestCase):\n def check_model(self, model, tok):\n context = \"\"\"\n Soon her eye fell on a little glass box that\n was lying under the table: she opened it, and\n found in it a very small cake, on which the\n words “EAT ME” were beautifully marked in\n currants. “Well, I’ll eat it,” said Alice, “ and if\n it makes me grow larger, I can reach the key ;\n and if it makes me grow smaller, I can creep\n under the door; so either way I’ll get into the\n garden, and I don’t care which happens !”\n \"\"\"\n\n question = \"Where Alice should go?\"\n\n # For better OpenVINO efficiency it's recommended to use fixed input shape.\n # So pad input_ids up to specific max_length.\n input_ids = tok.encode(\n question + \" \" + tok.sep_token + \" \" + context, return_tensors=\"np\", max_length=128, padding=\"max_length\"\n )\n\n outputs = model(input_ids)\n\n start_pos = outputs.start_logits.argmax()\n end_pos = outputs.end_logits.argmax() + 1\n\n answer_ids = input_ids[0, start_pos:end_pos]\n answer = tok.convert_tokens_to_string(tok.convert_ids_to_tokens(answer_ids))\n\n self.assertEqual(answer, \"the garden\")\n\n @require_torch\n @unittest.skipIf(is_openvino_api_2 and \"GITHUB_ACTIONS\" in os.environ, \"Memory limit exceed\")\n def test_from_pt(self):\n tok = AutoTokenizer.from_pretrained(\"bert-large-uncased-whole-word-masking-finetuned-squad\")\n model = OVAutoModelForQuestionAnswering.from_pretrained(\n \"bert-large-uncased-whole-word-masking-finetuned-squad\", from_pt=True\n )\n self.check_model(model, tok)\n\n @unittest.skipIf(\n version.parse(transformers.__version__) < version.parse(\"4.0.0\"),\n \"Too old version of Transformers to test uploaded IR\",\n )\n def test_from_ir(self):\n tok = AutoTokenizer.from_pretrained(\"dkurt/bert-large-uncased-whole-word-masking-squad-int8-0001\")\n model = OVAutoModelForQuestionAnswering.from_pretrained(\n \"dkurt/bert-large-uncased-whole-word-masking-squad-int8-0001\"\n )\n self.check_model(model, tok)\n\n\n@require_torch\nclass GPT2ModelTest(unittest.TestCase):\n def test_model_from_pretrained(self):\n for model_name in [\"gpt2\"]:\n model = OVAutoModel.from_pretrained(model_name, from_pt=True, use_cache=False)\n self.assertIsNotNone(model)\n\n input_ids = np.random.randint(0, 255, (1, 6))\n attention_mask = np.random.randint(0, 2, (1, 6))\n\n expected_shape = (1, 6, 768)\n output = model(input_ids, attention_mask=attention_mask)[0]\n self.assertEqual(output.shape, expected_shape)\n\n\n@require_torch\nclass OVAlbertModelIntegrationTest(unittest.TestCase):\n def test_inference_no_head_absolute_embedding(self):\n model = OVAutoModel.from_pretrained(\"albert-base-v2\", from_pt=True)\n input_ids = np.array([[0, 345, 232, 328, 740, 140, 1695, 69, 6078, 1588, 2]])\n attention_mask = np.array([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]])\n output = model(input_ids, attention_mask=attention_mask)[0]\n expected_shape = (1, 11, 768)\n self.assertEqual(output.shape, expected_shape)\n expected_slice = np.array(\n [[[-0.6513, 1.5035, -0.2766], [-0.6515, 1.5046, -0.2780], [-0.6512, 1.5049, -0.2784]]]\n )\n\n self.assertTrue(np.allclose(output[:, 1:4, 1:4], expected_slice, atol=1e-4))\n\n\n@require_torch\nclass OVOPENAIGPTModelLanguageGenerationTest(unittest.TestCase):\n def test_lm_generate_openai_gpt(self):\n model = OVAutoModelWithLMHead.from_pretrained(\"openai-gpt\", from_pt=True)\n input_ids = np.array([[481, 4735, 544]], dtype=np.int64) # the president is\n expected_output_ids = [\n 481,\n 4735,\n 544,\n 246,\n 963,\n 870,\n 762,\n 239,\n 244,\n 40477,\n 244,\n 249,\n 719,\n 881,\n 487,\n 544,\n 240,\n 244,\n 603,\n 481,\n ] # the president is a very good man. \" \\n \" i\\'m sure he is, \" said the\n\n output_ids = model.generate(input_ids, do_sample=False)\n self.assertListEqual(output_ids[0].tolist(), expected_output_ids)\n\n\n@require_torch\nclass RobertaModelIntegrationTest(unittest.TestCase):\n def test_inference_masked_lm(self):\n model = OVAutoModelForMaskedLM.from_pretrained(\"roberta-base\", from_pt=True)\n\n input_ids = np.array([[0, 31414, 232, 328, 740, 1140, 12695, 69, 46078, 1588, 2]])\n output = model(input_ids)[0]\n expected_shape = (1, 11, 50265)\n self.assertEqual(output.shape, expected_shape)\n # compare the actual values for a slice.\n expected_slice = np.array(\n [[[33.8802, -4.3103, 22.7761], [4.6539, -2.8098, 13.6253], [1.8228, -3.6898, 8.8600]]]\n )\n\n # roberta = torch.hub.load('pytorch/fairseq', 'roberta.base')\n # roberta.eval()\n # expected_slice = roberta.model.forward(input_ids)[0][:, :3, :3].detach()\n self.assertTrue(np.allclose(output[:, :3, :3], expected_slice, atol=1e-4))\n\n def test_inference_no_head(self):\n model = OVAutoModel.from_pretrained(\"roberta-base\", from_pt=True)\n\n input_ids = np.array([[0, 31414, 232, 328, 740, 1140, 12695, 69, 46078, 1588, 2]])\n output = model(input_ids)[0]\n # compare the actual values for a slice.\n expected_slice = np.array([[[-0.0231, 0.0782, 0.0074], [-0.1854, 0.0540, -0.0175], [0.0548, 0.0799, 0.1687]]])\n\n # roberta = torch.hub.load('pytorch/fairseq', 'roberta.base')\n # roberta.eval()\n # expected_slice = roberta.extract_features(input_ids)[:, :3, :3].detach()\n\n self.assertTrue(np.allclose(output[:, :3, :3], expected_slice, atol=1e-4))\n\n def test_inference_batch(self):\n model = OVAutoModel.from_pretrained(\"roberta-base\", from_pt=True)\n tok = AutoTokenizer.from_pretrained(\"roberta-base\")\n\n inputs = [\"Good evening.\", \"here is the sentence I want embeddings for.\"]\n input_ids = np.concatenate(\n [tok.encode(inp, return_tensors=\"np\", max_length=16, padding=\"max_length\") for inp in inputs]\n )\n\n output = model(input_ids)[0]\n\n # compare the actual values for a slice.\n expected_slice = np.array(\n [\n [\n [-0.09037264, 0.10670696, -0.06938689],\n [-0.10737953, 0.20106763, 0.04490039],\n [0.0991028, 0.18117547, 0.0122529],\n ],\n [\n [-0.09360617, 0.11848789, -0.03424963],\n [0.1246291, -0.3622079, -0.02089296],\n [0.36143878, 0.27680993, 0.28920814],\n ],\n ]\n )\n\n self.assertTrue(np.allclose(output[:, :3, :3], expected_slice, atol=1e-4))\n\n\n@require_tf\nclass TFRobertaModelIntegrationTest(unittest.TestCase):\n def test_inference_masked_lm(self):\n model = OVAutoModelForMaskedLM.from_pretrained(\"roberta-base\", from_tf=True)\n\n input_ids = np.array([[0, 31414, 232, 328, 740, 1140, 12695, 69, 46078, 1588, 2]])\n output = model(input_ids)[0]\n expected_shape = [1, 11, 50265]\n self.assertEqual(list(output.shape), expected_shape)\n # compare the actual values for a slice.\n expected_slice = np.array(\n [[[33.8802, -4.3103, 22.7761], [4.6539, -2.8098, 13.6253], [1.8228, -3.6898, 8.8600]]]\n )\n self.assertTrue(np.allclose(output[:, :3, :3], expected_slice, atol=1e-4))\n\n def test_inference_no_head(self):\n model = OVAutoModel.from_pretrained(\"roberta-base\", from_tf=True)\n\n input_ids = np.array([[0, 31414, 232, 328, 740, 1140, 12695, 69, 46078, 1588, 2]])\n output = model(input_ids)[0]\n # compare the actual values for a slice.\n expected_slice = np.array([[[-0.0231, 0.0782, 0.0074], [-0.1854, 0.0540, -0.0175], [0.0548, 0.0799, 0.1687]]])\n self.assertTrue(np.allclose(output[:, :3, :3], expected_slice, atol=1e-4))\n\n\n@require_tf\nclass OVTFDistilBertModelIntegrationTest(unittest.TestCase):\n def test_inference_masked_lm(self):\n model = OVAutoModel.from_pretrained(\"distilbert-base-uncased\", from_tf=True)\n input_ids = np.array([[0, 1, 2, 3, 4, 5]])\n output = model(input_ids)[0]\n\n expected_shape = (1, 6, 768)\n self.assertEqual(output.shape, expected_shape)\n\n expected_slice = np.array(\n [\n [\n [0.19261885, -0.13732955, 0.4119799],\n [0.22150156, -0.07422661, 0.39037204],\n [0.22756018, -0.0896414, 0.3701467],\n ]\n ]\n )\n self.assertTrue(np.allclose(output[:, :3, :3], expected_slice, atol=1e-4))\n\n\n@require_torch\nclass OVDistilBertModelIntegrationTest(unittest.TestCase):\n def test_inference_no_head_absolute_embedding(self):\n model = OVAutoModel.from_pretrained(\"distilbert-base-uncased\", from_pt=True)\n model.to(device=\"CPU\")\n model.set_config(config={\"CPU_BIND_THREAD\": \"YES\"})\n\n input_ids = np.array([[0, 345, 232, 328, 740, 140, 1695, 69, 6078, 1588, 2]])\n attention_mask = np.array([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]])\n output = model(input_ids, attention_mask=attention_mask)[0]\n expected_shape = (1, 11, 768)\n self.assertEqual(output.shape, expected_shape)\n expected_slice = np.array([[[-0.1639, 0.3299, 0.1648], [-0.1746, 0.3289, 0.1710], [-0.1884, 0.3357, 0.1810]]])\n\n self.assertTrue(np.allclose(output[:, 1:4, 1:4], expected_slice, atol=1e-4))\n\n\[email protected](version.parse(transformers.__version__) < version.parse(\"4.12.0\"), \"Too old version for Audio models\")\nclass OVAutoModelForAudioClassificationTest(unittest.TestCase):\n def check_model(self, model):\n raw_datasets = DatasetDict()\n raw_datasets[\"eval\"] = load_dataset(\"superb\", \"ks\", split=\"validation\")\n raw_datasets = raw_datasets.cast_column(\"audio\", datasets.features.Audio(sampling_rate=16000))\n\n sample = raw_datasets[\"eval\"][0]\n out = model(sample[\"audio\"][\"array\"].reshape(1, 16000))\n\n self.assertEqual(np.argmax(out.logits), 11)\n\n def test_from_ir(self):\n model = OVAutoModelForAudioClassification.from_pretrained(\"dkurt/wav2vec2-base-ft-keyword-spotting-int8\")\n self.check_model(model)\n\n @require_torch\n def test_from_pt(self):\n model = OVAutoModelForAudioClassification.from_pretrained(\n \"anton-l/wav2vec2-base-ft-keyword-spotting\", from_pt=True\n )\n self.check_model(model)\n\n\n@require_torch\[email protected](\"GITHUB_ACTIONS\" in os.environ, \"Memory limit exceed\")\nclass OVMBartForConditionalGenerationTest(unittest.TestCase):\n def check_model(self, use_cache):\n from optimum.intel.openvino import OVMBartForConditionalGeneration\n from transformers import MBart50TokenizerFast\n\n model = OVMBartForConditionalGeneration.from_pretrained(\n \"facebook/mbart-large-50-many-to-many-mmt\", use_cache=use_cache, from_pt=True\n )\n tokenizer = MBart50TokenizerFast.from_pretrained(\"facebook/mbart-large-50-many-to-many-mmt\")\n\n article_hi = \"संयुक्त राष्ट्र के प्रमुख का कहना है कि सीरिया में कोई सैन्य समाधान नहीं है\"\n tokenizer.src_lang = \"hi_IN\"\n encoded_hi = tokenizer(article_hi, return_tensors=\"pt\")\n generated_tokens = model.generate(**encoded_hi, forced_bos_token_id=tokenizer.lang_code_to_id[\"fr_XX\"])\n\n expected_tokens = [\n [\n 2,\n 250008,\n 636,\n 21861,\n 8,\n 96,\n 242,\n 136840,\n 222939,\n 1103,\n 242,\n 379,\n 653,\n 242,\n 53,\n 10,\n 452,\n 8,\n 29806,\n 128683,\n 22,\n 51712,\n 5,\n 2,\n ]\n ]\n\n self.assertListEqual(generated_tokens.tolist(), expected_tokens)\n\n decoded_fr = tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)[0]\n self.assertEqual(decoded_fr, \"Le chef de l 'ONU affirme qu 'il n 'y a pas de solution militaire en Syria.\")\n\n def test_no_cache(self):\n self.check_model(use_cache=False)\n\n def test_with_cache(self):\n self.check_model(use_cache=True)\n"
] | [
[
"numpy.array",
"numpy.allclose",
"numpy.random.randint",
"numpy.argmax"
]
] |
thhsieh00/utoolbox-core | [
"d1430967458204b99780c547eaca60d066490946"
] | [
"tests/dataset/bdv/test_bdv.py"
] | [
"import logging\r\nimport os\r\nfrom pprint import pprint\r\nfrom shutil import rmtree\r\n\r\nimport pandas as pd\r\nfrom dask.distributed import Client\r\nfrom prompt_toolkit.shortcuts import button_dialog\r\n\r\nfrom utoolbox.io import open_dataset\r\nfrom utoolbox.io.dataset import BigDataViewerDataset, TiledDatasetIterator\r\n\r\nlogger = logging.getLogger(\"test_zarr\")\r\n\r\n\r\ndef main(ds_src_dir, ds_dst_dir, client=None):\r\n logger.info(\"loading source dataset\")\r\n ds_src = open_dataset(ds_src_dir)\r\n\r\n pprint(ds_src.metadata)\r\n\r\n logger.info(\"dump dataset info\")\r\n for key, value in TiledDatasetIterator(\r\n ds_src, return_key=True, return_format=\"both\"\r\n ):\r\n print(key)\r\n print(value)\r\n print()\r\n\r\n with pd.option_context(\"display.max_rows\", None):\r\n print(\">> tile_coords\")\r\n print(ds_src.tile_coords)\r\n print()\r\n print(\">> inventory\")\r\n print(ds_src.inventory)\r\n print()\r\n\r\n if os.path.exists(ds_dst_dir):\r\n dump = button_dialog(\r\n title=\"BDV dataset exists\",\r\n text=\"What should we do?\",\r\n buttons=[(\"Skip\", False), (\"Overwrite\", True),],\r\n ).run()\r\n if dump:\r\n # we have to unlink first\r\n logger.warning(\"remove previous dataset dump\")\r\n rmtree(ds_dst_dir)\r\n else:\r\n dump = True\r\n\r\n if dump:\r\n logger.info(\"convert to zarr dataset\")\r\n BigDataViewerDataset.dump(\r\n ds_dst_dir, ds_src, pyramid=[(1, 1, 1), (2, 4, 4)], chunks=(16, 128, 128)\r\n )\r\n\r\n\r\nif __name__ == \"__main__\":\r\n import coloredlogs\r\n\r\n logging.getLogger(\"tifffile\").setLevel(logging.ERROR)\r\n coloredlogs.install(\r\n level=\"DEBUG\", fmt=\"%(asctime)s %(levelname)s %(message)s\", datefmt=\"%H:%M:%S\"\r\n )\r\n\r\n if False:\r\n # Case 1)\r\n ds_src_dir = \"X:/charm/20200424_ExM_Thy1_testis_dapi_z2um_1\"\r\n ds_dst_dir = \"U:/charm/20200424_ExM_Thy1_testis_dapi_z2um_1.zarr\"\r\n else:\r\n # Case 2)\r\n cwd = os.path.dirname(os.path.abspath(__file__))\r\n # ds_src_dir = os.path.join(cwd, \"../data/demo_3D_2x2x2_CMTKG-V3\")\r\n path = os.path.join(cwd, \"../data/ExM_E15_olympus4X_canon300mm_2x3_1\")\r\n ds_src_dir = os.path.abspath(path)\r\n parent, dname = os.path.split(ds_src_dir)\r\n ds_dst_dir = os.path.join(parent, f\"{dname}_bdv\")\r\n\r\n # ensure paths are properly expanded\r\n ds_src_dir = os.path.abspath(os.path.expanduser(ds_src_dir))\r\n ds_dst_dir = os.path.abspath(os.path.expanduser(ds_dst_dir))\r\n\r\n # client = Client(\"10.109.20.6:8786\")\r\n # print(client)\r\n client = None\r\n\r\n main(ds_src_dir, ds_dst_dir, client=client)\r\n"
] | [
[
"pandas.option_context"
]
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.