Datasets:

semeru

/

text-code-galeras-code-generation-from-docstring-3k-deduped

like 0

{ "docstring": "\n Given a `pythonfinder.Finder` instance and an optional line, find a corresponding python\n\n :param finder: A :class:`pythonfinder.Finder` instance to use for searching\n :type finder: :class:pythonfinder.Finder`\n :param str line: A version, path, name, or nothing, defaults to None\n :return: A path to python\n :rtype: str\n ", "language": "en", "n_whitespaces": 65, "n_words": 43, "vocab_size": 33 }

{ "docstring": "\n NA values that should generally be valid_na for *all* dtypes.\n\n Include both python float NaN and np.float64; only np.float64 has a\n `dtype` attribute.\n ", "language": "en", "n_whitespaces": 52, "n_words": 23, "vocab_size": 23 }

{ "docstring": "Creates a 1D tensor containing a sequence of integers.\n\n The function arguments use the same convention as\n Theano's arange: if only one argument is provided,\n it is in fact the \"stop\" argument and \"start\" is 0.\n\n The default type of the returned tensor is `'int32'` to\n match TensorFlow's default.\n\n Args:\n start: Start value.\n stop: Stop value.\n step: Difference between two successive values.\n dtype: Integer dtype to use.\n\n Returns:\n An integer tensor.\n\n Example:\n\n >>> tf.keras.backend.arange(start=0, stop=10, step=1.5)\n <tf.Tensor: shape=(7,), dtype=float32,\n numpy=array([0. , 1.5, 3. , 4.5, 6. , 7.5, 9. ], dtype=float32)>\n\n\n\n ", "language": "en", "n_whitespaces": 178, "n_words": 91, "vocab_size": 77 }

{ "docstring": "Test the generation and verification of guest access tokens", "language": "en", "n_whitespaces": 8, "n_words": 9, "vocab_size": 9 }

{ "docstring": "Do a best-effort guess if the caller is already in a docker network\n\n Check if `hostname` exists in list of docker containers.\n If a container is found, check its network id\n\n :param client: docker client object\n :return: network id if exists\n ", "language": "en", "n_whitespaces": 56, "n_words": 41, "vocab_size": 29 }

{ "docstring": "\n Sets the value of either the percentage (if `type` is set to\n \"percent\") or the constant (if `type` is set to \"constant\")\n corresponding to the lengths of the error bars in the bottom\n (left) direction for vertical (horizontal) bars\n\n The 'valueminus' property is a number and may be specified as:\n - An int or float in the interval [0, inf]\n\n Returns\n -------\n int|float\n ", "language": "en", "n_whitespaces": 136, "n_words": 63, "vocab_size": 46 }

{ "docstring": "Any extra python dependencies required for this component to run.", "language": "en", "n_whitespaces": 9, "n_words": 10, "vocab_size": 10 }

{ "docstring": "Get UOM conversion factor from uom to stock_uom\n\te.g. uom = \"Kg\", stock_uom = \"Gram\" then returns 1000.0\n\t\n\t\t\tselect (first.value / second.value) as value\n\t\t\tfrom `tabUOM Conversion Factor` first\n\t\t\tjoin `tabUOM Conversion Factor` second\n\t\t\t\ton first.from_uom = second.from_uom\n\t\t\twhere\n\t\t\t\tfirst.to_uom = %(to_uom)s\n\t\t\t\tand second.to_uom = %(from_uom)s\n\t\t\tlimit 1\n\t\t\t", "language": "en", "n_whitespaces": 38, "n_words": 48, "vocab_size": 38 }

{ "docstring": "A set of stacked residual blocks.\n\n Args:\n x: input tensor.\n filters: integer, filters of the bottleneck layer in a block.\n blocks: integer, blocks in the stacked blocks.\n stride1: default 2, stride of the first layer in the first block.\n name: string, stack label.\n\n Returns:\n Output tensor for the stacked blocks.\n ", "language": "en", "n_whitespaces": 89, "n_words": 50, "vocab_size": 34 }

{ "docstring": " Returns a generator with lines to represent the facts and rules ", "language": "en", "n_whitespaces": 12, "n_words": 11, "vocab_size": 11 }

{ "docstring": " Process the input to the aligner model multiple times based on the user selected\n `re-feed` command line option. This adjusts the bounding box for the face to be fed\n into the model by a random amount within 0.05 pixels of the detected face's shortest axis.\n\n References\n ----------\n https://studios.disneyresearch.com/2020/06/29/high-resolution-neural-face-swapping-for-visual-effects/\n\n Parameters\n ----------\n batch: dict\n Contains the batch that is currently being passed through the plugin process\n\n Returns\n -------\n dict\n The batch with input processed\n ", "language": "en", "n_whitespaces": 179, "n_words": 72, "vocab_size": 58 }

{ "docstring": "Attempt to reduce the structure `values` to single values.\n\n Given `values` (a `tf.Tensor` or a `PerReplica` structure),\n which represents the values across all the replicas, `reduce_per_replica`\n attempts to \"reduce\" those values and returns the corresponding structure\n that represents only single values.\n\n Currently, `reduce_per_replica` is only used for reducing the metric results\n from `tf.distribute.Strategy.run()`. Depending on the underlying\n `Strategy` implementation, `values` may be a `PerReplica` object,\n which can be thought of as a collection of values across the replicas,\n or a `tf.Tensor`, if the strategy has already conducted the reduction\n for the downstream library.\n\n There are five possible outcomes of reduction:\n\n 1) if the `values` is a structure of simple `tf.Tensor`s, meaning that\n reduction is not actually needed, `reduce_per_replica` returns the\n structure as-is.\n 2) else, if `reduction=\"auto\"`, then it assumes \"first\" if running\n under `TPUStrategy`, and \"sum\" otherwise. This should only be used\n for training cases (`fit()`).\n 3) else, if `reduction=\"first\"`, then `reduce_per_replica`\n returns the values of the first replica. This is used in the case of\n training and evaluation, where `values` is expected to hold the same\n value across the replicas as a result of `Strategy`'s synchronization\n across the replicas.\n `reduce_per_replica` does not synchronize the values.\n 4) else, if `reduction=\"sum\"`, then `reduce_per_replica` returns the sum\n of values for all replicas. This is used in the custom training loop\n case, where each replica contain different values which are not\n synchronized.\n 5) else, if `reduction=\"concat\"`, then `reduce_per_replica`\n returns the concatenation of the values across the replicas, along the\n axis of dimension 0. This is used in the inference case (`predict()`).\n\n Args:\n values: Structure of `PerReplica` objects or `tf.Tensor`s. `tf.Tensor`s\n are returned as-is.\n strategy: `tf.distribute.Strategy` object.\n reduction: One of `\"auto\"`, `\"first\"`, `\"concat\"`, or `\"sum\"`.\n `\"auto\"` will select `\"first\"` when used under a TPUStrategy, or\n `\"sum\"` otherwise.\n\n Returns:\n Structure of `Tensor`s, representing the result of reduction.\n\n Raises:\n ValueError: if the reduction method is not supported.\n ", "language": "en", "n_whitespaces": 502, "n_words": 311, "vocab_size": 161 }

{ "docstring": "Compute Area Under the Curve (AUC) using the trapezoidal rule.\n\n This is a general function, given points on a curve. For computing the\n area under the ROC-curve, see :func:`roc_auc_score`. For an alternative\n way to summarize a precision-recall curve, see\n :func:`average_precision_score`.\n\n Parameters\n ----------\n x : ndarray of shape (n,)\n X coordinates. These must be either monotonic increasing or monotonic\n decreasing.\n y : ndarray of shape, (n,)\n Y coordinates.\n\n Returns\n -------\n auc : float\n Area Under the Curve.\n\n See Also\n --------\n roc_auc_score : Compute the area under the ROC curve.\n average_precision_score : Compute average precision from prediction scores.\n precision_recall_curve : Compute precision-recall pairs for different\n probability thresholds.\n\n Examples\n --------\n >>> import numpy as np\n >>> from sklearn import metrics\n >>> y = np.array([1, 1, 2, 2])\n >>> pred = np.array([0.1, 0.4, 0.35, 0.8])\n >>> fpr, tpr, thresholds = metrics.roc_curve(y, pred, pos_label=2)\n >>> metrics.auc(fpr, tpr)\n 0.75\n ", "language": "en", "n_whitespaces": 258, "n_words": 143, "vocab_size": 103 }

{ "docstring": "Return the name of the file without it's extension.", "language": "en", "n_whitespaces": 8, "n_words": 9, "vocab_size": 8 }

{ "docstring": "Pop the smallest item off the heap, maintaining the heap invariant.", "language": "en", "n_whitespaces": 10, "n_words": 11, "vocab_size": 9 }

{ "docstring": "Test significant states when significant_states_only is set.", "language": "en", "n_whitespaces": 6, "n_words": 7, "vocab_size": 7 }

{ "docstring": "\n Returns labels of ner tags and pos tags.\n ", "language": "en", "n_whitespaces": 23, "n_words": 8, "vocab_size": 8 }

{ "docstring": "select {field} from `tabSupplier`\n\t\twhere docstatus < 2\n\t\t\tand ({key} like %(txt)s\n\t\t\tor supplier_name like %(txt)s) and disabled=0\n\t\t\tand (on_hold = 0 or (on_hold = 1 and CURDATE() > release_date))\n\t\t\t{mcond}\n\t\torder by\n\t\t\tif(locate(%(_txt)s, name), locate(%(_txt)s, name), 99999),\n\t\t\tif(locate(%(_txt)s, supplier_name), locate(%(_txt)s, supplier_name), 99999),\n\t\t\tidx desc,\n\t\t\tname, supplier_name\n\t\tlimit %(start)s, %(page_len)s ", "language": "en", "n_whitespaces": 39, "n_words": 50, "vocab_size": 37 }

{ "docstring": "Returns the floating point approximations (decimal numbers) of the quaternion.\n\n Returns\n =======\n\n Quaternion\n Floating point approximations of quaternion(self)\n\n Examples\n ========\n\n >>> from sympy import Quaternion\n >>> from sympy import sqrt\n >>> q = Quaternion(1/sqrt(1), 1/sqrt(2), 1/sqrt(3), 1/sqrt(4))\n >>> q.evalf()\n 1.00000000000000\n + 0.707106781186547*i\n + 0.577350269189626*j\n + 0.500000000000000*k\n\n ", "language": "en", "n_whitespaces": 155, "n_words": 46, "vocab_size": 32 }

{ "docstring": "\n Deploy remote tasks to the workers with passed parameters.\n\n Parameters\n ----------\n fname : str, path object or file-like object\n Name of the file to read.\n col_partitions : list\n List of arrays with columns names that should be read\n by each partition.\n **kwargs : dict\n Parameters of deploying read_* function.\n\n Returns\n -------\n np.ndarray\n Array with references to the task deploy result for each partition.\n ", "language": "en", "n_whitespaces": 189, "n_words": 63, "vocab_size": 49 }

{ "docstring": "\n every Flow created inside JinaD lives inside a container. It is important to know the\n list of ports to be published with localhost before actually starting the container.\n\n 1. `load` the flow yaml here.\n - yaml is stored in `workspace` directory, so we'll `cd` there\n - yaml might include env vars. so we'll set them (passed via query params)\n 2. `build` the Flow so that `gateway` gets added.\n - get the list of ports to be published (port_expose, port_in, port_out, port_ctrl)\n - ports need to be published for gateway & executors that are not `ContainerRuntime` or `JinadRuntime` based\n - Pod level args for ports are enough, as we don't need to publish Pea ports\n - all the above Pods also run in docker, hence we set `runs_in_docker`\n 3. `save` the Flow config.\n - saves port configs of all `executors` into the new yaml.\n - set `JINA_FULL_CLI` envvar, so that `gateway` args are also added.\n - save the config into a new file.\n 4. pass this new file as filename to `partial-daemon` to start the Flow\n ", "language": "en", "n_whitespaces": 324, "n_words": 175, "vocab_size": 109 }

{ "docstring": "Return the current running hvac operation if supported.", "language": "en", "n_whitespaces": 7, "n_words": 8, "vocab_size": 8 }

{ "docstring": "Test that size and timeout attrs are mapped to seconds correctly.\n\n Assert that each of the fake rules is mapped correctly.\n ", "language": "en", "n_whitespaces": 27, "n_words": 21, "vocab_size": 18 }

{ "docstring": "Configs corresponding mesh given test context.\n\n If runs on a CPU mesh, set virtual device on CPU.\n If runs on a GPU mesh, sets virtual device on GPU with proper memory limits.\n if runs on a TPU mesh, initializes TPU system.\n\n Args:\n device_type_mesh_map: A dictionary containing device_type -> mesh mapping.\n\n Returns:\n A properly configured mesh for use in test.\n ", "language": "en", "n_whitespaces": 119, "n_words": 59, "vocab_size": 41 }

{ "docstring": "Test if all v2 lights get created with correct features.", "language": "en", "n_whitespaces": 9, "n_words": 10, "vocab_size": 10 }

{ "docstring": "Will return all known devices connected to the Smart Bridge.", "language": "en", "n_whitespaces": 9, "n_words": 10, "vocab_size": 10 }

{ "docstring": "\n Returns the appropriate search backend for the current 'default' database system\n ", "language": "en", "n_whitespaces": 18, "n_words": 11, "vocab_size": 10 }

{ "docstring": "\n Select values at particular time of day (e.g., 9:30AM).\n ", "language": "en", "n_whitespaces": 24, "n_words": 9, "vocab_size": 9 }

{ "docstring": "\n Autocorrelation plot for time series.\n\n Parameters\n ----------\n series : Time series\n ax : Matplotlib axis object, optional\n **kwargs\n Options to pass to matplotlib plotting method.\n\n Returns\n -------\n class:`matplotlib.axis.Axes`\n\n Examples\n --------\n\n The horizontal lines in the plot correspond to 95% and 99% confidence bands.\n\n The dashed line is 99% confidence band.\n\n .. plot::\n :context: close-figs\n\n >>> spacing = np.linspace(-9 * np.pi, 9 * np.pi, num=1000)\n >>> s = pd.Series(0.7 * np.random.rand(1000) + 0.3 * np.sin(spacing))\n >>> pd.plotting.autocorrelation_plot(s)\n <AxesSubplot:title={'center':'width'}, xlabel='Lag', ylabel='Autocorrelation'>\n ", "language": "en", "n_whitespaces": 167, "n_words": 79, "vocab_size": 64 }

{ "docstring": "Return atom-like quantities as far as substitution is\n concerned: Derivatives, Functions and Symbols. Do not\n return any 'atoms' that are inside such quantities unless\n they also appear outside, too, unless `recursive` is True.\n\n Examples\n ========\n\n >>> from sympy import Derivative, Function, cos\n >>> from sympy.abc import x, y\n >>> from sympy.core.basic import _atomic\n >>> f = Function('f')\n >>> _atomic(x + y)\n {x, y}\n >>> _atomic(x + f(y))\n {x, f(y)}\n >>> _atomic(Derivative(f(x), x) + cos(x) + y)\n {y, cos(x), Derivative(f(x), x)}\n\n ", "language": "en", "n_whitespaces": 128, "n_words": 80, "vocab_size": 60 }

{ "docstring": "\n Returns the order of a given differential\n equation with respect to func.\n\n This function is implemented recursively.\n\n Examples\n ========\n\n >>> from sympy import Function\n >>> from sympy.solvers.deutils import ode_order\n >>> from sympy.abc import x\n >>> f, g = map(Function, ['f', 'g'])\n >>> ode_order(f(x).diff(x, 2) + f(x).diff(x)**2 +\n ... f(x).diff(x), f(x))\n 2\n >>> ode_order(f(x).diff(x, 2) + g(x).diff(x, 3), f(x))\n 2\n >>> ode_order(f(x).diff(x, 2) + g(x).diff(x, 3), g(x))\n 3\n\n ", "language": "en", "n_whitespaces": 119, "n_words": 67, "vocab_size": 46 }

{ "docstring": "\n Add a function to the call queue.\n\n Parameters\n ----------\n func : callable or ray.ObjectRef\n Function to be added to the call queue.\n *args : iterable\n Additional positional arguments to be passed in `func`.\n **kwargs : dict\n Additional keyword arguments to be passed in `func`.\n\n Returns\n -------\n PandasOnRayDataframeVirtualPartition\n A new ``PandasOnRayDataframeVirtualPartition`` object.\n\n Notes\n -----\n It does not matter if `func` is callable or an ``ray.ObjectRef``. Ray will\n handle it correctly either way. The keyword arguments are sent as a dictionary.\n ", "language": "en", "n_whitespaces": 222, "n_words": 79, "vocab_size": 58 }

{ "docstring": "Return True if there is an active loop and it's rejected.", "language": "en", "n_whitespaces": 10, "n_words": 11, "vocab_size": 11 }

{ "docstring": "Reset the internal flag to false. Subsequently, coroutines calling\n wait() will block until set() is called to set the internal flag\n to true again.", "language": "en", "n_whitespaces": 37, "n_words": 24, "vocab_size": 19 }

{ "docstring": "Get the \"normal\" Operator after applying the current mapping", "language": "en", "n_whitespaces": 8, "n_words": 9, "vocab_size": 8 }

{ "docstring": "\n Utilised by Wagtail's 'register_admin_urls' hook to register urls for\n used by any associated ModelAdmin instances\n ", "language": "en", "n_whitespaces": 37, "n_words": 15, "vocab_size": 14 }

{ "docstring": "Print help\n[param]Ticker: [/param]{self.ticker.upper()}[cmds]\n\n whatif what if you had bought X shares on day Y\n\n ema buy when price exceeds EMA(l)\n ema_cross buy when EMA(short) > EMA(long)\n rsi buy when RSI < low and sell when RSI > high[/cmds]\n ", "language": "en", "n_whitespaces": 80, "n_words": 39, "vocab_size": 32 }

{ "docstring": "Return an extension url.\n\n Apply url stitching when these 3 conditions are met:\n - url starts with /\n - openAs == \"POPUP\"\n - appUrl is defined\n ", "language": "en", "n_whitespaces": 73, "n_words": 26, "vocab_size": 23 }

{ "docstring": "\n Returns the training [`~paddle.io.DataLoader`].\n\n Will use no sampler if `self.train_dataset` does not implement `__len__`, a random sampler (adapted to\n distributed training if necessary) otherwise.\n\n Subclass and override this method if you want to inject some custom behavior.\n ", "language": "en", "n_whitespaces": 73, "n_words": 37, "vocab_size": 32 }

{ "docstring": "\n Args:\n samples (list): a batch of sample, each is dict.\n ", "language": "en", "n_whitespaces": 36, "n_words": 10, "vocab_size": 10 }

{ "docstring": "\n Check whether an array-like is a Categorical instance.\n\n .. deprecated:: 1.1.0\n Use ``is_categorical_dtype`` instead.\n\n Parameters\n ----------\n arr : array-like\n The array-like to check.\n\n Returns\n -------\n boolean\n Whether or not the array-like is of a Categorical instance.\n\n Examples\n --------\n >>> is_categorical([1, 2, 3])\n False\n\n Categoricals, Series Categoricals, and CategoricalIndex will return True.\n\n >>> cat = pd.Categorical([1, 2, 3])\n >>> is_categorical(cat)\n True\n >>> is_categorical(pd.Series(cat))\n True\n >>> is_categorical(pd.CategoricalIndex([1, 2, 3]))\n True\n ", "language": "en", "n_whitespaces": 153, "n_words": 68, "vocab_size": 51 }

{ "docstring": "Off-Diagonal and Intercept Regularisation (ODIR).\n\n Described in \"Beyond temperature scaling: Obtaining well-calibrated multiclass probabilities with Dirichlet\n calibration\"\n https://proceedings.neurips.cc/paper/2019/file/8ca01ea920679a0fe3728441494041b9-Paper.pdf\n ", "language": "en", "n_whitespaces": 46, "n_words": 18, "vocab_size": 18 }

{ "docstring": "\n returns a list of available names of VideoInputDevice's\n\n ole32 should be initialized before use\n ", "language": "en", "n_whitespaces": 24, "n_words": 14, "vocab_size": 13 }

{ "docstring": "\n Wraps functions where the first param is a SQL statement and enforces\n any exceptions thrown will also contain the statement in the message.\n ", "language": "en", "n_whitespaces": 33, "n_words": 23, "vocab_size": 20 }

{ "docstring": "Normalize an array to appropriate meta object\n\n Parameters\n ----------\n x: array-like, callable\n Either an object that looks sufficiently like a Numpy array,\n or a callable that accepts shape and dtype keywords\n ndim: int\n Number of dimensions of the array\n dtype: Numpy dtype\n A valid input for ``np.dtype``\n\n Returns\n -------\n array-like with zero elements of the correct dtype\n ", "language": "en", "n_whitespaces": 112, "n_words": 57, "vocab_size": 45 }

{ "docstring": "\n Find all deleted models (managed and unmanaged) and make delete\n operations for them as well as separate operations to delete any\n foreign key or M2M relationships (these are optimized later, if\n possible).\n\n Also bring forward removal of any model options that refer to\n collections of fields - the inverse of generate_created_models().\n ", "language": "en", "n_whitespaces": 101, "n_words": 51, "vocab_size": 43 }

{ "docstring": "Returns recursively-generated list of all children classes inheriting from given `cls`.", "language": "en", "n_whitespaces": 10, "n_words": 11, "vocab_size": 11 }

{ "docstring": "A second room upgrade is not deduplicated after some time has passed.", "language": "en", "n_whitespaces": 11, "n_words": 12, "vocab_size": 12 }

{ "docstring": "Test setting up the connection for a sqlite dialect.", "language": "en", "n_whitespaces": 8, "n_words": 9, "vocab_size": 9 }

{ "docstring": "\n Prints out the pod definition that would be created by this operator.\n Does not include labels specific to the task instance (since there isn't\n one in a dry_run) and excludes all empty elements.\n ", "language": "en", "n_whitespaces": 62, "n_words": 33, "vocab_size": 32 }

{ "docstring": "\n Create 2D sin/cos positional embeddings.\n\n Args:\n embed_dim (`int`):\n Embedding dimension.\n grid_size (`int`):\n The grid height and width.\n add_cls_token (`bool`, *optional*, defaults to `False`):\n Whether or not to add a classification (CLS) token.\n\n Returns:\n (`tf.Tensor` of shape (grid_size*grid_size, embed_dim) or (1+grid_size*grid_size, embed_dim): the position\n embeddings (with or without classification token)\n ", "language": "en", "n_whitespaces": 130, "n_words": 49, "vocab_size": 44 }

{ "docstring": " Check whether the source video file contains an audio stream.\n\n If we attempt to mux audio from a source video that does not contain an audio stream\n ffmpeg will crash faceswap in a fairly ugly manner.\n\n Returns\n -------\n bool\n ``True if an audio stream is found in the source video file, otherwise ``False``\n\n Raises\n ------\n RuntimeError\n If a subprocess error is raised scanning the input video file\n ", "language": "en", "n_whitespaces": 153, "n_words": 67, "vocab_size": 48 }

{ "docstring": "\n Removes ANSI escape sequences recursively for all strings in dict.\n\n We often need to use yaml.dump() to print dictionaries that contain exception\n tracebacks, which can contain ANSI escape sequences that color printed text. However\n yaml.dump() will format the tracebacks incorrectly if ANSI escape sequences are\n present, so we need to remove them before dumping.\n ", "language": "en", "n_whitespaces": 73, "n_words": 54, "vocab_size": 42 }

{ "docstring": "\n Regression test for async-mangling behavior of inject_db() decorator.\n\n Previously, when wrapping a coroutine function, the decorator returned\n that function's coroutine object, instead of the coroutine function.\n\n This worked fine in most cases because both a coroutine function and a\n coroutine object can be awaited, but it broke our Pytest setup because\n we were auto-marking coroutine functions as async, and any async test\n wrapped by inject_db() was no longer a coroutine function, but instead\n a coroutine object, so we skipped marking it.\n ", "language": "en", "n_whitespaces": 109, "n_words": 81, "vocab_size": 59 }

{ "docstring": "Construct the action and observation spaces\n\n Description of actions and observations:\n https://github.com/google-research/football/blob/master/gfootball/doc/\n observation.md\n ", "language": "en", "n_whitespaces": 41, "n_words": 13, "vocab_size": 12 }

{ "docstring": "Names of the columns in the dataset.\n\n Example:\n\n ```py\n >>> from datasets import load_dataset\n >>> ds = load_dataset(\"rotten_tomatoes\", split=\"validation\")\n >>> ds.column_names\n ['text', 'label']\n ```\n ", "language": "en", "n_whitespaces": 80, "n_words": 24, "vocab_size": 21 }

{ "docstring": "\n This method return a copy of self, but clean up the search_permissions and\n read_permissions attributes.\n ", "language": "en", "n_whitespaces": 37, "n_words": 15, "vocab_size": 15 }

{ "docstring": "\nimport time\nimport ray\nfrom ray import tune\n\nray.init(address=\"{address}\")\n\n\ntune.run(\n \"PG\",\n name=\"experiment\",\n config=dict(env=\"CartPole-v1\", framework=\"tf\"),\n stop=dict(training_iteration=10),\n local_dir=\"{checkpoint_dir}\",\n checkpoint_freq=1,\n max_failures=1,\n dict(experiment=kwargs),\n raise_on_failed_trial=False)\n", "language": "en", "n_whitespaces": 42, "n_words": 20, "vocab_size": 17 }

{ "docstring": "Predict the logical relationship between the premise and hypothesis.\n\n Defined in :numref:`sec_natural-language-inference-attention`", "language": "en", "n_whitespaces": 14, "n_words": 12, "vocab_size": 11 }

{ "docstring": "\n Prepares the return part of the docstring using `output_type`.\n \n Example:\n\n ```python\n >>> from transformers import {processor_class}, {model_class}\n >>> import torch\n\n >>> tokenizer = {processor_class}.from_pretrained(\"{checkpoint}\")\n >>> model = {model_class}.from_pretrained(\"{checkpoint}\")\n\n >>> inputs = tokenizer(\"Hello, my dog is cute\", return_tensors=\"pt\")\n >>> labels = torch.tensor([1] * inputs[\"input_ids\"].size(1)).unsqueeze(0) # Batch size 1\n\n >>> outputs = model(**inputs, labels=labels)\n >>> loss = outputs.loss\n >>> logits = outputs.logits\n ```\n\n Example:\n\n ```python\n >>> from transformers import {processor_class}, {model_class}\n >>> import torch\n\n >>> torch.manual_seed(0) # doctest: +IGNORE_RESULT\n\n >>> tokenizer = {processor_class}.from_pretrained(\"{checkpoint}\")\n >>> model = {model_class}.from_pretrained(\"{checkpoint}\")\n\n >>> question, text = \"Who was Jim Henson?\", \"Jim Henson was a nice puppet\"\n >>> inputs = tokenizer(question, text, return_tensors=\"pt\")\n >>> start_positions = torch.tensor([1])\n >>> end_positions = torch.tensor([3])\n\n >>> outputs = model(**inputs, start_positions=start_positions, end_positions=end_positions)\n >>> loss = outputs.loss\n >>> round(loss.item(), 2)\n {expected_loss}\n\n >>> start_scores = outputs.start_logits\n >>> list(start_scores.shape)\n {expected_output}\n\n >>> end_scores = outputs.end_logits\n >>> list(end_scores.shape)\n {expected_output}\n ```\n\n Example of single-label classification:\n\n ```python\n >>> import torch\n >>> from transformers import {processor_class}, {model_class}\n\n >>> torch.manual_seed(0) # doctest: +IGNORE_RESULT\n\n >>> tokenizer = {processor_class}.from_pretrained(\"{checkpoint}\")\n >>> model = {model_class}.from_pretrained(\"{checkpoint}\", num_labels=2)\n\n >>> inputs = tokenizer(\"Hello, my dog is cute\", return_tensors=\"pt\")\n >>> labels = torch.tensor([1]).unsqueeze(0) # Batch size 1\n >>> outputs = model(**inputs, labels=labels)\n >>> loss = outputs.loss\n >>> logits = outputs.logits\n >>> list(logits.shape)\n {expected_output}\n ```\n\n Example of multi-label classification:\n\n ```python\n >>> import torch\n >>> from transformers import {processor_class}, {model_class}\n\n >>> torch.manual_seed(0) # doctest: +IGNORE_RESULT\n\n >>> tokenizer = {processor_class}.from_pretrained(\"{checkpoint}\")\n >>> model = {model_class}.from_pretrained(\"{checkpoint}\", problem_type=\"multi_label_classification\", num_labels=2)\n\n >>> inputs = tokenizer(\"Hello, my dog is cute\", return_tensors=\"pt\")\n >>> labels = torch.tensor([[1, 1]], dtype=torch.float) # need dtype=float for BCEWithLogitsLoss\n >>> outputs = model(**inputs, labels=labels)\n >>> loss = outputs.loss\n >>> list(logits.shape)\n {expected_output}\n ```\n\n Example:\n\n ```python\n >>> from transformers import {processor_class}, {model_class}\n >>> import torch\n\n >>> tokenizer = {processor_class}.from_pretrained(\"{checkpoint}\")\n >>> model = {model_class}.from_pretrained(\"{checkpoint}\")\n\n >>> inputs = tokenizer(\"The capital of France is {mask}.\", return_tensors=\"pt\")\n >>> labels = tokenizer(\"The capital of France is Paris.\", return_tensors=\"pt\")[\"input_ids\"]\n\n >>> outputs = model(**inputs, labels=labels)\n >>> loss = outputs.loss\n >>> logits = outputs.logits\n ```\n\n Example:\n\n ```python\n >>> from transformers import {processor_class}, {model_class}\n >>> import torch\n\n >>> tokenizer = {processor_class}.from_pretrained(\"{checkpoint}\")\n >>> model = {model_class}.from_pretrained(\"{checkpoint}\")\n\n >>> inputs = tokenizer(\"Hello, my dog is cute\", return_tensors=\"pt\")\n >>> outputs = model(**inputs)\n\n >>> last_hidden_states = outputs.last_hidden_state\n ```\n\n Example:\n\n ```python\n >>> from transformers import {processor_class}, {model_class}\n >>> import torch\n\n >>> tokenizer = {processor_class}.from_pretrained(\"{checkpoint}\")\n >>> model = {model_class}.from_pretrained(\"{checkpoint}\")\n\n >>> prompt = \"In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced.\"\n >>> choice0 = \"It is eaten with a fork and a knife.\"\n >>> choice1 = \"It is eaten while held in the hand.\"\n >>> labels = torch.tensor(0).unsqueeze(0) # choice0 is correct (according to Wikipedia ;)), batch size 1\n\n >>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors=\"pt\", padding=True)\n >>> outputs = model(**{{k: v.unsqueeze(0) for k, v in encoding.items()}}, labels=labels) # batch size is 1\n\n >>> # the linear classifier still needs to be trained\n >>> loss = outputs.loss\n >>> logits = outputs.logits\n ```\n\n Example:\n\n ```python\n >>> import torch\n >>> from transformers import {processor_class}, {model_class}\n\n >>> tokenizer = {processor_class}.from_pretrained(\"{checkpoint}\")\n >>> model = {model_class}.from_pretrained(\"{checkpoint}\")\n\n >>> inputs = tokenizer(\"Hello, my dog is cute\", return_tensors=\"pt\")\n >>> outputs = model(**inputs, labels=inputs[\"input_ids\"])\n >>> loss = outputs.loss\n >>> logits = outputs.logits\n ```\n\n Example:\n\n ```python\n >>> from transformers import {processor_class}, {model_class}\n >>> import torch\n >>> from datasets import load_dataset\n\n >>> dataset = load_dataset(\"hf-internal-testing/librispeech_asr_demo\", \"clean\", split=\"validation\")\n >>> dataset = dataset.sort(\"id\")\n >>> sampling_rate = dataset.features[\"audio\"].sampling_rate\n\n >>> processor = {processor_class}.from_pretrained(\"{checkpoint}\")\n >>> model = {model_class}.from_pretrained(\"{checkpoint}\")\n\n >>> # audio file is decoded on the fly\n >>> inputs = processor(dataset[0][\"audio\"][\"array\"], sampling_rate=sampling_rate, return_tensors=\"pt\")\n >>> with torch.no_grad():\n ... outputs = model(**inputs)\n\n >>> last_hidden_states = outputs.last_hidden_state\n >>> list(last_hidden_states.shape)\n {expected_output}\n ```\n\n Example:\n\n ```python\n >>> from transformers import {processor_class}, {model_class}\n >>> from datasets import load_dataset\n >>> import torch\n\n >>> dataset = load_dataset(\"hf-internal-testing/librispeech_asr_demo\", \"clean\", split=\"validation\")\n >>> dataset = dataset.sort(\"id\")\n >>> sampling_rate = dataset.features[\"audio\"].sampling_rate\n\n >>> processor = {processor_class}.from_pretrained(\"{checkpoint}\")\n >>> model = {model_class}.from_pretrained(\"{checkpoint}\")\n\n >>> # audio file is decoded on the fly\n >>> inputs = processor(dataset[0][\"audio\"][\"array\"], sampling_rate=sampling_rate, return_tensors=\"pt\")\n >>> with torch.no_grad():\n ... logits = model(**inputs).logits\n >>> predicted_ids = torch.argmax(logits, dim=-1)\n\n >>> # transcribe speech\n >>> transcription = processor.batch_decode(predicted_ids)\n >>> transcription[0]\n {expected_output}\n ```\n\n ```python\n >>> with processor.as_target_processor():\n ... inputs[\"labels\"] = processor(dataset[0][\"text\"], return_tensors=\"pt\").input_ids\n\n >>> # compute loss\n >>> loss = model(**inputs).loss\n >>> round(loss.item(), 2)\n {expected_loss}\n ```\n\n Example:\n\n ```python\n >>> from transformers import {processor_class}, {model_class}\n >>> from datasets import load_dataset\n >>> import torch\n\n >>> dataset = load_dataset(\"hf-internal-testing/librispeech_asr_demo\", \"clean\", split=\"validation\")\n >>> dataset = dataset.sort(\"id\")\n >>> sampling_rate = dataset.features[\"audio\"].sampling_rate\n\n >>> feature_extractor = {processor_class}.from_pretrained(\"{checkpoint}\")\n >>> model = {model_class}.from_pretrained(\"{checkpoint}\")\n\n >>> # audio file is decoded on the fly\n >>> inputs = feature_extractor(dataset[0][\"audio\"][\"array\"], sampling_rate=sampling_rate, return_tensors=\"pt\")\n\n >>> with torch.no_grad():\n ... logits = model(**inputs).logits\n\n >>> predicted_class_ids = torch.argmax(logits, dim=-1).item()\n >>> predicted_label = model.config.id2label[predicted_class_ids]\n >>> predicted_label\n {expected_output}\n ```\n\n ```python\n >>> # compute loss - target_label is e.g. \"down\"\n >>> target_label = model.config.id2label[0]\n >>> inputs[\"labels\"] = torch.tensor([model.config.label2id[target_label]])\n >>> loss = model(**inputs).loss\n >>> round(loss.item(), 2)\n {expected_loss}\n ```\n\n Example:\n\n ```python\n >>> from transformers import {processor_class}, {model_class}\n >>> from datasets import load_dataset\n >>> import torch\n\n >>> dataset = load_dataset(\"hf-internal-testing/librispeech_asr_demo\", \"clean\", split=\"validation\")\n >>> dataset = dataset.sort(\"id\")\n >>> sampling_rate = dataset.features[\"audio\"].sampling_rate\n\n >>> feature_extractor = {processor_class}.from_pretrained(\"{checkpoint}\")\n >>> model = {model_class}.from_pretrained(\"{checkpoint}\")\n\n >>> # audio file is decoded on the fly\n >>> inputs = feature_extractor(dataset[0][\"audio\"][\"array\"], return_tensors=\"pt\", sampling_rate=sampling_rate)\n >>> with torch.no_grad():\n ... logits = model(**inputs).logits\n\n >>> probabilities = torch.sigmoid(logits[0])\n >>> # labels is a one-hot array of shape (num_frames, num_speakers)\n >>> labels = (probabilities > 0.5).long()\n >>> labels[0].tolist()\n {expected_output}\n ```\n\n Example:\n\n ```python\n >>> from transformers import {processor_class}, {model_class}\n >>> from datasets import load_dataset\n >>> import torch\n\n >>> dataset = load_dataset(\"hf-internal-testing/librispeech_asr_demo\", \"clean\", split=\"validation\")\n >>> dataset = dataset.sort(\"id\")\n >>> sampling_rate = dataset.features[\"audio\"].sampling_rate\n\n >>> feature_extractor = {processor_class}.from_pretrained(\"{checkpoint}\")\n >>> model = {model_class}.from_pretrained(\"{checkpoint}\")\n\n >>> # audio file is decoded on the fly\n >>> inputs = feature_extractor(\n ... [d[\"array\"] for d in dataset[:2][\"audio\"]], sampling_rate=sampling_rate, return_tensors=\"pt\", padding=True\n ... )\n >>> with torch.no_grad():\n ... embeddings = model(**inputs).embeddings\n\n >>> embeddings = torch.nn.functional.normalize(embeddings, dim=-1).cpu()\n\n >>> # the resulting embeddings can be used for cosine similarity-based retrieval\n >>> cosine_sim = torch.nn.CosineSimilarity(dim=-1)\n >>> similarity = cosine_sim(embeddings[0], embeddings[1])\n >>> threshold = 0.7 # the optimal threshold is dataset-dependent\n >>> if similarity < threshold:\n ... print(\"Speakers are not the same!\")\n >>> round(similarity.item(), 2)\n {expected_output}\n ```\n\n Example:\n\n ```python\n >>> from transformers import {processor_class}, {model_class}\n >>> import torch\n >>> from datasets import load_dataset\n\n >>> dataset = load_dataset(\"huggingface/cats-image\")\n >>> image = dataset[\"test\"][\"image\"][0]\n\n >>> feature_extractor = {processor_class}.from_pretrained(\"{checkpoint}\")\n >>> model = {model_class}.from_pretrained(\"{checkpoint}\")\n\n >>> inputs = feature_extractor(image, return_tensors=\"pt\")\n\n >>> with torch.no_grad():\n ... outputs = model(**inputs)\n\n >>> last_hidden_states = outputs.last_hidden_state\n >>> list(last_hidden_states.shape)\n {expected_output}\n ```\n\n Example:\n\n ```python\n >>> from transformers import {processor_class}, {model_class}\n >>> import torch\n >>> from datasets import load_dataset\n\n >>> dataset = load_dataset(\"huggingface/cats-image\")\n >>> image = dataset[\"test\"][\"image\"][0]\n\n >>> feature_extractor = {processor_class}.from_pretrained(\"{checkpoint}\")\n >>> model = {model_class}.from_pretrained(\"{checkpoint}\")\n\n >>> inputs = feature_extractor(image, return_tensors=\"pt\")\n\n >>> with torch.no_grad():\n ... logits = model(**inputs).logits\n\n >>> # model predicts one of the 1000 ImageNet classes\n >>> predicted_label = logits.argmax(-1).item()\n >>> print(model.config.id2label[predicted_label])\n {expected_output}\n ```\n\n Example:\n\n ```python\n >>> from transformers import {processor_class}, {model_class}\n >>> import tensorflow as tf\n\n >>> tokenizer = {processor_class}.from_pretrained(\"{checkpoint}\")\n >>> model = {model_class}.from_pretrained(\"{checkpoint}\")\n\n >>> inputs = tokenizer(\"Hello, my dog is cute\", return_tensors=\"tf\")\n >>> input_ids = inputs[\"input_ids\"]\n >>> inputs[\"labels\"] = tf.reshape(\n ... tf.constant([1] * tf.size(input_ids).numpy()), (-1, tf.size(input_ids))\n >>> ) # Batch size 1\n\n >>> outputs = model(inputs)\n >>> loss = outputs.loss\n >>> logits = outputs.logits\n ```\n\n Example:\n\n ```python\n >>> from transformers import {processor_class}, {model_class}\n >>> import tensorflow as tf\n\n >>> tokenizer = {processor_class}.from_pretrained(\"{checkpoint}\")\n >>> model = {model_class}.from_pretrained(\"{checkpoint}\")\n\n >>> question, text = \"Who was Jim Henson?\", \"Jim Henson was a nice puppet\"\n >>> input_dict = tokenizer(question, text, return_tensors=\"tf\")\n >>> outputs = model(input_dict)\n >>> start_logits = outputs.start_logits\n >>> end_logits = outputs.end_logits\n\n >>> all_tokens = tokenizer.convert_ids_to_tokens(input_dict[\"input_ids\"].numpy()[0])\n >>> answer = \" \".join(all_tokens[tf.math.argmax(start_logits, 1)[0] : tf.math.argmax(end_logits, 1)[0] + 1])\n ```\n\n Example:\n\n ```python\n >>> from transformers import {processor_class}, {model_class}\n >>> import tensorflow as tf\n\n >>> tokenizer = {processor_class}.from_pretrained(\"{checkpoint}\")\n >>> model = {model_class}.from_pretrained(\"{checkpoint}\")\n\n >>> inputs = tokenizer(\"Hello, my dog is cute\", return_tensors=\"tf\")\n >>> inputs[\"labels\"] = tf.reshape(tf.constant(1), (-1, 1)) # Batch size 1\n\n >>> outputs = model(inputs)\n >>> loss = outputs.loss\n >>> logits = outputs.logits\n ```\n\n Example:\n\n ```python\n >>> from transformers import {processor_class}, {model_class}\n >>> import tensorflow as tf\n\n >>> tokenizer = {processor_class}.from_pretrained(\"{checkpoint}\")\n >>> model = {model_class}.from_pretrained(\"{checkpoint}\")\n\n >>> inputs = tokenizer(\"The capital of France is {mask}.\", return_tensors=\"tf\")\n >>> inputs[\"labels\"] = tokenizer(\"The capital of France is Paris.\", return_tensors=\"tf\")[\"input_ids\"]\n\n >>> outputs = model(inputs)\n >>> loss = outputs.loss\n >>> logits = outputs.logits\n ```\n\n Example:\n\n ```python\n >>> from transformers import {processor_class}, {model_class}\n >>> import tensorflow as tf\n\n >>> tokenizer = {processor_class}.from_pretrained(\"{checkpoint}\")\n >>> model = {model_class}.from_pretrained(\"{checkpoint}\")\n\n >>> inputs = tokenizer(\"Hello, my dog is cute\", return_tensors=\"tf\")\n >>> outputs = model(inputs)\n\n >>> last_hidden_states = outputs.last_hidden_state\n ```\n\n Example:\n\n ```python\n >>> from transformers import {processor_class}, {model_class}\n >>> import tensorflow as tf\n\n >>> tokenizer = {processor_class}.from_pretrained(\"{checkpoint}\")\n >>> model = {model_class}.from_pretrained(\"{checkpoint}\")\n\n >>> prompt = \"In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced.\"\n >>> choice0 = \"It is eaten with a fork and a knife.\"\n >>> choice1 = \"It is eaten while held in the hand.\"\n\n >>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors=\"tf\", padding=True)\n >>> inputs = {{k: tf.expand_dims(v, 0) for k, v in encoding.items()}}\n >>> outputs = model(inputs) # batch size is 1\n\n >>> # the linear classifier still needs to be trained\n >>> logits = outputs.logits\n ```\n\n Example:\n\n ```python\n >>> from transformers import {processor_class}, {model_class}\n >>> import tensorflow as tf\n\n >>> tokenizer = {processor_class}.from_pretrained(\"{checkpoint}\")\n >>> model = {model_class}.from_pretrained(\"{checkpoint}\")\n\n >>> inputs = tokenizer(\"Hello, my dog is cute\", return_tensors=\"tf\")\n >>> outputs = model(inputs)\n >>> logits = outputs.logits\n ```\n\n Example:\n\n ```python\n >>> from transformers import {processor_class}, {model_class}\n\n >>> tokenizer = {processor_class}.from_pretrained(\"{checkpoint}\")\n >>> model = {model_class}.from_pretrained(\"{checkpoint}\")\n\n >>> inputs = tokenizer(\"Hello, my dog is cute\", return_tensors=\"jax\")\n\n >>> outputs = model(**inputs)\n >>> logits = outputs.logits\n ```\n\n Example:\n\n ```python\n >>> from transformers import {processor_class}, {model_class}\n\n >>> tokenizer = {processor_class}.from_pretrained(\"{checkpoint}\")\n >>> model = {model_class}.from_pretrained(\"{checkpoint}\")\n\n >>> question, text = \"Who was Jim Henson?\", \"Jim Henson was a nice puppet\"\n >>> inputs = tokenizer(question, text, return_tensors=\"jax\")\n\n >>> outputs = model(**inputs)\n >>> start_scores = outputs.start_logits\n >>> end_scores = outputs.end_logits\n ```\n\n Example:\n\n ```python\n >>> from transformers import {processor_class}, {model_class}\n\n >>> tokenizer = {processor_class}.from_pretrained(\"{checkpoint}\")\n >>> model = {model_class}.from_pretrained(\"{checkpoint}\")\n\n >>> inputs = tokenizer(\"Hello, my dog is cute\", return_tensors=\"jax\")\n\n >>> outputs = model(**inputs)\n >>> logits = outputs.logits\n ```\n\n Example:\n\n ```python\n >>> from transformers import {processor_class}, {model_class}\n\n >>> tokenizer = {processor_class}.from_pretrained(\"{checkpoint}\")\n >>> model = {model_class}.from_pretrained(\"{checkpoint}\")\n\n >>> inputs = tokenizer(\"The capital of France is {mask}.\", return_tensors=\"jax\")\n\n >>> outputs = model(**inputs)\n >>> logits = outputs.logits\n ```\n\n Example:\n\n ```python\n >>> from transformers import {processor_class}, {model_class}\n\n >>> tokenizer = {processor_class}.from_pretrained(\"{checkpoint}\")\n >>> model = {model_class}.from_pretrained(\"{checkpoint}\")\n\n >>> inputs = tokenizer(\"Hello, my dog is cute\", return_tensors=\"jax\")\n >>> outputs = model(**inputs)\n\n >>> last_hidden_states = outputs.last_hidden_state\n ```\n\n Example:\n\n ```python\n >>> from transformers import {processor_class}, {model_class}\n\n >>> tokenizer = {processor_class}.from_pretrained(\"{checkpoint}\")\n >>> model = {model_class}.from_pretrained(\"{checkpoint}\")\n\n >>> prompt = \"In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced.\"\n >>> choice0 = \"It is eaten with a fork and a knife.\"\n >>> choice1 = \"It is eaten while held in the hand.\"\n\n >>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors=\"jax\", padding=True)\n >>> outputs = model(**{{k: v[None, :] for k, v in encoding.items()}})\n\n >>> logits = outputs.logits\n ```\n\n Example:\n\n ```python\n >>> from transformers import {processor_class}, {model_class}\n\n >>> tokenizer = {processor_class}.from_pretrained(\"{checkpoint}\")\n >>> model = {model_class}.from_pretrained(\"{checkpoint}\")\n\n >>> inputs = tokenizer(\"Hello, my dog is cute\", return_tensors=\"np\")\n >>> outputs = model(**inputs)\n\n >>> # retrieve logts for next token\n >>> next_token_logits = outputs.logits[:, -1]\n ```\n", "language": "en", "n_whitespaces": 3163, "n_words": 1837, "vocab_size": 302 }

{ "docstring": "Tests that both a lookup for a medium that does not exist and a user that\n doesn't exist with that third party ID returns a 404", "language": "en", "n_whitespaces": 32, "n_words": 26, "vocab_size": 19 }

{ "docstring": "Stub for abstract class implementation. Not a pollable attribute.", "language": "en", "n_whitespaces": 8, "n_words": 9, "vocab_size": 9 }

{ "docstring": "\n Perform an indirect partition along the given axis using the\n algorithm specified by the `kind` keyword. It returns an array of\n indices of the same shape as `a` that index data along the given\n axis in partitioned order.\n\n .. versionadded:: 1.8.0\n\n Parameters\n ----------\n a : array_like\n Array to sort.\n kth : int or sequence of ints\n Element index to partition by. The k-th element will be in its\n final sorted position and all smaller elements will be moved\n before it and all larger elements behind it. The order all\n elements in the partitions is undefined. If provided with a\n sequence of k-th it will partition all of them into their sorted\n position at once.\n\n .. deprecated:: 1.22.0\n Passing booleans as index is deprecated.\n axis : int or None, optional\n Axis along which to sort. The default is -1 (the last axis). If\n None, the flattened array is used.\n kind : {'introselect'}, optional\n Selection algorithm. Default is 'introselect'\n order : str or list of str, optional\n When `a` is an array with fields defined, this argument\n specifies which fields to compare first, second, etc. A single\n field can be specified as a string, and not all fields need be\n specified, but unspecified fields will still be used, in the\n order in which they come up in the dtype, to break ties.\n\n Returns\n -------\n index_array : ndarray, int\n Array of indices that partition `a` along the specified axis.\n If `a` is one-dimensional, ``a[index_array]`` yields a partitioned `a`.\n More generally, ``np.take_along_axis(a, index_array, axis)``\n always yields the partitioned `a`, irrespective of dimensionality.\n\n See Also\n --------\n partition : Describes partition algorithms used.\n ndarray.partition : Inplace partition.\n argsort : Full indirect sort.\n take_along_axis : Apply ``index_array`` from argpartition\n to an array as if by calling partition.\n\n Notes\n -----\n See `partition` for notes on the different selection algorithms.\n\n Examples\n --------\n One dimensional array:\n\n >>> x = np.array([3, 4, 2, 1])\n >>> x[np.argpartition(x, 3)]\n array([2, 1, 3, 4])\n >>> x[np.argpartition(x, (1, 3))]\n array([1, 2, 3, 4])\n\n >>> x = [3, 4, 2, 1]\n >>> np.array(x)[np.argpartition(x, 3)]\n array([2, 1, 3, 4])\n\n Multi-dimensional array:\n\n >>> x = np.array([[3, 4, 2], [1, 3, 1]])\n >>> index_array = np.argpartition(x, kth=1, axis=-1)\n >>> np.take_along_axis(x, index_array, axis=-1) # same as np.partition(x, kth=1)\n array([[2, 3, 4],\n [1, 1, 3]])\n\n ", "language": "en", "n_whitespaces": 681, "n_words": 374, "vocab_size": 213 }

{ "docstring": "\n Return the y-axis view limits.\n\n Returns\n -------\n bottom, top : (float, float)\n The current y-axis limits in data coordinates.\n\n See Also\n --------\n .Axes.set_ylim\n set_ybound, get_ybound\n invert_yaxis, yaxis_inverted\n\n Notes\n -----\n The y-axis may be inverted, in which case the *bottom* value\n will be greater than the *top* value.\n ", "language": "en", "n_whitespaces": 157, "n_words": 47, "vocab_size": 40 }

{ "docstring": "Remove a vertex from the graph, disconnecting all edges from/to it.", "language": "en", "n_whitespaces": 10, "n_words": 11, "vocab_size": 11 }

{ "docstring": "\n The \"Adaptive Parzen Estimator\" described in paper section 4.2, for normal distribution.\n\n Because TPE internally only supports categorical and normal distributed space (domain),\n this function is used for everything other than \"choice\" and \"randint\".\n\n Parameters\n ----------\n args: TpeArguments\n Algorithm arguments.\n history_mus: 1-d array of float\n Parameter values evaluated in history.\n These are the \"observations\" in paper section 4.2. (\"placing density in the vicinity of K observations\")\n prior_mu: float\n µ value of normal search space.\n piror_sigma: float\n σ value of normal search space.\n\n Returns\n -------\n Tuple of three 1-d float arrays: (weight, µ, σ).\n\n The tuple represents N+1 \"vicinity of observations\" and each one's weight,\n calculated from \"N\" history and \"1\" user provided prior.\n\n The result is sorted by µ.\n ", "language": "en", "n_whitespaces": 203, "n_words": 119, "vocab_size": 91 }

{ "docstring": "Test that printing in the LightningModule redirects arguments to the progress bar without training.", "language": "en", "n_whitespaces": 13, "n_words": 14, "vocab_size": 13 }

{ "docstring": "\n Get the last stream ordering position for the appservice process.\n ", "language": "en", "n_whitespaces": 25, "n_words": 10, "vocab_size": 9 }

{ "docstring": "Check that we raise a `NotFittedError` when the passed regressor is not\n fit.", "language": "en", "n_whitespaces": 15, "n_words": 13, "vocab_size": 13 }

{ "docstring": "Pagination tokens from /sync and /messages can be used to paginate /relations.", "language": "en", "n_whitespaces": 11, "n_words": 12, "vocab_size": 12 }

{ "docstring": "\n Return the URL for a VCS requirement.\n\n Args:\n repo_url: the remote VCS url, with any needed VCS prefix (e.g. \"git+\").\n project_name: the (unescaped) project name.\n ", "language": "en", "n_whitespaces": 45, "n_words": 25, "vocab_size": 21 }

{ "docstring": "Change the value of each `char1` block to `foo`\n\n Check whether the value of each `char1` block has changed to `foo`.\n Check whether the values of other blocks are intact.\n ", "language": "en", "n_whitespaces": 51, "n_words": 30, "vocab_size": 19 }

{ "docstring": "Apply Rename concurrency column in dag table to max_active_tasks", "language": "en", "n_whitespaces": 8, "n_words": 9, "vocab_size": 9 }

{ "docstring": "Adds a try except block if the user is not in development mode\n\n Parameters\n ----------\n f: function\n The function to be wrapped\n ", "language": "en", "n_whitespaces": 41, "n_words": 22, "vocab_size": 21 }

{ "docstring": "\n Return a list of supported extra checks after testing them against\n the compiler.\n\n Parameters\n ----------\n names : str\n CPU feature name in uppercase.\n ", "language": "en", "n_whitespaces": 77, "n_words": 23, "vocab_size": 23 }

{ "docstring": "Decides whether there is a path from `s` to `t` in the\n tournament.\n\n This function is more theoretically efficient than the reachability\n checks than the shortest path algorithms in\n :mod:`networkx.algorithms.shortest_paths`.\n\n The given graph **must** be a tournament, otherwise this function's\n behavior is undefined.\n\n Parameters\n ----------\n G : NetworkX graph\n A directed graph representing a tournament.\n\n s : node\n A node in the graph.\n\n t : node\n A node in the graph.\n\n Returns\n -------\n bool\n Whether there is a path from `s` to `t` in `G`.\n\n Examples\n --------\n >>> from networkx.algorithms import tournament\n >>> G = nx.DiGraph([(1, 0), (1, 3), (1, 2), (2, 3), (2, 0), (3, 0)])\n >>> tournament.is_reachable(G, 1, 3)\n True\n >>> tournament.is_reachable(G, 3, 2)\n False\n\n Notes\n -----\n Although this function is more theoretically efficient than the\n generic shortest path functions, a speedup requires the use of\n parallelism. Though it may in the future, the current implementation\n does not use parallelism, thus you may not see much of a speedup.\n\n This algorithm comes from [1].\n\n References\n ----------\n .. [1] Tantau, Till.\n \"A note on the complexity of the reachability problem for\n tournaments.\"\n *Electronic Colloquium on Computational Complexity*. 2001.\n <http://eccc.hpi-web.de/report/2001/092/>\n ", "language": "en", "n_whitespaces": 357, "n_words": 190, "vocab_size": 119 }

{ "docstring": "\n Args:\n start_pos (optional, `Variable` of shape [batch_size]):\n token index of start of answer span in `context`\n end_pos (optional, `Variable` of shape [batch_size]):\n token index of end of answer span in `context`\n Returns:\n loss (`Variable` of shape []):\n Cross entropy loss mean over batch and time, ignore positions where label == -100\n if labels not set, returns None\n start_logits (`Variable` of shape [batch_size, hidden_size]):\n output logits of start position\n end_logits (`Variable` of shape [batch_size, hidden_size]):\n output logits of end position\n ", "language": "en", "n_whitespaces": 246, "n_words": 79, "vocab_size": 46 }

{ "docstring": "Given requirement or candidate, return an identifier for it.\n\n This is used to identify a requirement or candidate, e.g.\n whether two requirements should have their specifier parts\n (version ranges or pins) merged, whether two candidates would\n conflict with each other (because they have same name but\n different versions).\n ", "language": "en", "n_whitespaces": 90, "n_words": 48, "vocab_size": 41 }

{ "docstring": "Auto-detect indentation of code.\n\n Returns:\n int: Number of spaces used to indent code.\n ", "language": "en", "n_whitespaces": 38, "n_words": 13, "vocab_size": 11 }

{ "docstring": "Save a zip-archive representing a Keras model to the given filepath.\n\n The zip-based archive contains the following structure:\n\n - JSON-based configuration file (config.json): Records of model, layer, and\n other trackables' configuration.\n - NPZ-based trackable state files, found in respective directories, such as\n model/states.npz, model/dense_layer/states.npz, etc.\n - Metadata file.\n\n The states of Keras trackables (layers, optimizers, loss, and metrics) are\n automatically saved as long as they can be discovered through the attributes\n returned by `dir(Model)`. Typically, the state includes the variables\n associated with the trackable, but some specially purposed layers may\n contain more such as the vocabularies stored in the hashmaps. The trackables\n define how their states are saved by exposing `save_state()` and\n `load_state()` APIs.\n\n For the case of layer states, the variables will be visited as long as\n they are either 1) referenced via layer attributes, or 2) referenced via a\n container (list, tuple, or dict), and the container is referenced via a\n layer attribute.\n ", "language": "en", "n_whitespaces": 217, "n_words": 155, "vocab_size": 106 }

{ "docstring": "Converts deferred income/expense into income/expense\n\tExecuted via background jobs on every month end", "language": "en", "n_whitespaces": 11, "n_words": 13, "vocab_size": 12 }

{ "docstring": "\n Receiving a logout token should do nothing if it is disabled in the config\n ", "language": "en", "n_whitespaces": 29, "n_words": 14, "vocab_size": 14 }

{ "docstring": "\n Tests that a literal slice can be used\n as an argument to a JIT function.\n ", "language": "en", "n_whitespaces": 45, "n_words": 15, "vocab_size": 14 }

{ "docstring": "Whether the call function uses 'training' as a parameter.", "language": "en", "n_whitespaces": 8, "n_words": 9, "vocab_size": 9 }

{ "docstring": "\n Get called after a ufunc and other functions.\n\n Parameters\n ----------\n result : np.ndarray\n The result of the ufunc or other function called on the NumPy array\n returned by __array__.\n context : tuple of (func, tuple, int), optional\n This parameter is returned by ufuncs as a 3-element tuple: (name of the\n ufunc, arguments of the ufunc, domain of the ufunc), but is not set by\n other NumPy functions.\n\n Returns\n -------\n BasePandasDataset\n Wrapped Modin object.\n ", "language": "en", "n_whitespaces": 203, "n_words": 73, "vocab_size": 51 }

{ "docstring": "\n SELECT\n cols.column_name\n FROM\n user_constraints,\n user_cons_columns cols\n WHERE\n user_constraints.constraint_name = cols.constraint_name AND\n user_constraints.constraint_type = 'P' AND\n user_constraints.table_name = UPPER(%s) AND\n cols.position = 1\n ", "language": "en", "n_whitespaces": 172, "n_words": 22, "vocab_size": 17 }

{ "docstring": "\n Parse the `extra_loggers` CSV and trim whitespace from logger names\n ", "language": "en", "n_whitespaces": 25, "n_words": 10, "vocab_size": 10 }

{ "docstring": "Get elements from the iterator and verify the input shape and type.", "language": "en", "n_whitespaces": 11, "n_words": 12, "vocab_size": 10 }

{ "docstring": "Return the list of (id, resource_key) to deploy HTTP servers on.", "language": "en", "n_whitespaces": 10, "n_words": 11, "vocab_size": 11 }

{ "docstring": "\n Drain the to_cancel queue and ensure all triggers that are not in the\n DB are cancelled, so the cleanup job deletes them.\n ", "language": "en", "n_whitespaces": 44, "n_words": 22, "vocab_size": 19 }

{ "docstring": "\n Populate the url_path field based on this page's slug and the specified parent page.\n (We pass a parent in here, rather than retrieving it via get_parent, so that we can give\n new unsaved pages a meaningful URL when previewing them; at that point the page has not\n been assigned a position in the tree, as far as treebeard is concerned.\n ", "language": "en", "n_whitespaces": 96, "n_words": 60, "vocab_size": 51 }

{ "docstring": "\n Number of points in Finite field.\n\n Examples\n ========\n\n >>> from sympy.ntheory.elliptic_curve import EllipticCurve\n >>> e2 = EllipticCurve(1, 0, modulus=19)\n >>> e2.order\n 19\n\n ", "language": "en", "n_whitespaces": 79, "n_words": 22, "vocab_size": 20 }

{ "docstring": "Test fossil_energy_consumption with co2 sensor data.", "language": "en", "n_whitespaces": 5, "n_words": 6, "vocab_size": 6 }

{ "docstring": "\n Test that when a user sends >100 to-device messages at once, any\n interested AS's will receive them in separate transactions.\n\n Also tests that uninterested application services do not receive messages.\n ", "language": "en", "n_whitespaces": 59, "n_words": 30, "vocab_size": 28 }

{ "docstring": "\n The 'imaginaryaxis' property is an instance of Imaginaryaxis\n that may be specified as:\n - An instance of :class:`plotly.graph_objs.layout.smith.Imaginaryaxis`\n - A dict of string/value properties that will be passed\n to the Imaginaryaxis constructor\n\n Supported dict properties:\n\n color\n Sets default for all colors associated with\n this axis all at once: line, font, tick, and\n grid colors. Grid color is lightened by\n blending this with the plot background\n Individual pieces can override this.\n gridcolor\n Sets the color of the grid lines.\n gridwidth\n Sets the width (in px) of the grid lines.\n hoverformat\n Sets the hover text formatting rule using d3\n formatting mini-languages which are very\n similar to those in Python. For numbers, see: h\n ttps://github.com/d3/d3-format/tree/v1.4.5#d3-f\n ormat. And for dates see:\n https://github.com/d3/d3-time-\n format/tree/v2.2.3#locale_format. We add two\n items to d3's date formatter: \"%h\" for half of\n the year as a decimal number as well as \"%{n}f\"\n for fractional seconds with n digits. For\n example, *2016-10-13 09:15:23.456* with\n tickformat \"%H~%M~%S.%2f\" would display\n \"09~15~23.46\"\n layer\n Sets the layer on which this axis is displayed.\n If *above traces*, this axis is displayed above\n all the subplot's traces If *below traces*,\n this axis is displayed below all the subplot's\n traces, but above the grid lines. Useful when\n used together with scatter-like traces with\n `cliponaxis` set to False to show markers\n and/or text nodes above this axis.\n linecolor\n Sets the axis line color.\n linewidth\n Sets the width (in px) of the axis line.\n showgrid\n Determines whether or not grid lines are drawn.\n If True, the grid lines are drawn at every tick\n mark.\n showline\n Determines whether or not a line bounding this\n axis is drawn.\n showticklabels\n Determines whether or not the tick labels are\n drawn.\n showtickprefix\n If \"all\", all tick labels are displayed with a\n prefix. If \"first\", only the first tick is\n displayed with a prefix. If \"last\", only the\n last tick is displayed with a suffix. If\n \"none\", tick prefixes are hidden.\n showticksuffix\n Same as `showtickprefix` but for tick suffixes.\n tickcolor\n Sets the tick color.\n tickfont\n Sets the tick font.\n tickformat\n Sets the tick label formatting rule using d3\n formatting mini-languages which are very\n similar to those in Python. For numbers, see: h\n ttps://github.com/d3/d3-format/tree/v1.4.5#d3-f\n ormat. And for dates see:\n https://github.com/d3/d3-time-\n format/tree/v2.2.3#locale_format. We add two\n items to d3's date formatter: \"%h\" for half of\n the year as a decimal number as well as \"%{n}f\"\n for fractional seconds with n digits. For\n example, *2016-10-13 09:15:23.456* with\n tickformat \"%H~%M~%S.%2f\" would display\n \"09~15~23.46\"\n ticklen\n Sets the tick length (in px).\n tickprefix\n Sets a tick label prefix.\n ticks\n Determines whether ticks are drawn or not. If\n \"\", this axis' ticks are not drawn. If\n \"outside\" (\"inside\"), this axis' are drawn\n outside (inside) the axis lines.\n ticksuffix\n Sets a tick label suffix.\n tickvals\n Sets the values at which ticks on this axis\n appear. Defaults to `realaxis.tickvals` plus\n the same as negatives and zero.\n tickvalssrc\n Sets the source reference on Chart Studio Cloud\n for `tickvals`.\n tickwidth\n Sets the tick width (in px).\n visible\n A single toggle to hide the axis while\n preserving interaction like dragging. Default\n is true when a cheater plot is present on the\n axis, otherwise false\n\n Returns\n -------\n plotly.graph_objs.layout.smith.Imaginaryaxis\n ", "language": "en", "n_whitespaces": 2370, "n_words": 517, "vocab_size": 232 }

{ "docstring": "Examines whether G1 and G2 are isomorphic.\n\n Parameters\n ----------\n G1, G2 : NetworkX Graph or MultiGraph instances.\n The two graphs to check for isomorphism.\n\n node_label : str, optional\n The name of the node attribute to be used when comparing nodes.\n The default is `None`, meaning node attributes are not considered\n in the comparison. Any node that doesn't have the `node_label`\n attribute uses `default_label` instead.\n\n default_label : scalar\n Default value to use when a node doesn't have an attribute\n named `node_label`. Default is `None`.\n\n Returns\n -------\n bool\n True if the two graphs are isomorphic, False otherwise.\n ", "language": "en", "n_whitespaces": 178, "n_words": 95, "vocab_size": 71 }

{ "docstring": "Returns commit SHA of current repo. Cached for various usages.", "language": "en", "n_whitespaces": 9, "n_words": 10, "vocab_size": 10 }

{ "docstring": "\n For source_objects with no wildcard, this operator would first list\n all files in source_objects, using provided delimiter if any. Then copy\n files from source_objects to destination_object and rename each source\n file.\n\n Example 1:\n\n\n The following Operator would copy all the files from ``a/``folder\n (i.e a/a.csv, a/b.csv, a/c.csv)in ``data`` bucket to the ``b/`` folder in\n the ``data_backup`` bucket (b/a.csv, b/b.csv, b/c.csv) ::\n\n copy_files = GCSToGCSOperator(\n task_id='copy_files_without_wildcard',\n source_bucket='data',\n source_objects=['a/'],\n destination_bucket='data_backup',\n destination_object='b/',\n gcp_conn_id=google_cloud_conn_id\n )\n\n Example 2:\n\n\n The following Operator would copy all avro files from ``a/``folder\n (i.e a/a.avro, a/b.avro, a/c.avro)in ``data`` bucket to the ``b/`` folder in\n the ``data_backup`` bucket (b/a.avro, b/b.avro, b/c.avro) ::\n\n copy_files = GCSToGCSOperator(\n task_id='copy_files_without_wildcard',\n source_bucket='data',\n source_objects=['a/'],\n destination_bucket='data_backup',\n destination_object='b/',\n delimiter='.avro',\n gcp_conn_id=google_cloud_conn_id\n )\n ", "language": "en", "n_whitespaces": 443, "n_words": 112, "vocab_size": 68 }