| --- |
| base_model: sentence-transformers/all-mpnet-base-v2 |
| datasets: |
| - code-search-net/code_search_net |
| language: |
| - code |
| library_name: sentence-transformers |
| metrics: |
| - pearson_cosine |
| - spearman_cosine |
| - pearson_manhattan |
| - spearman_manhattan |
| - pearson_euclidean |
| - spearman_euclidean |
| - pearson_dot |
| - spearman_dot |
| - pearson_max |
| - spearman_max |
| pipeline_tag: sentence-similarity |
| tags: |
| - sentence-transformers |
| - sentence-similarity |
| - feature-extraction |
| - generated_from_trainer |
| - dataset_size:20000 |
| - loss:CoSENTLoss |
| - loss:MultipleNegativesRankingLoss |
| widget: |
| - source_sentence: KeypointsOnImage.to_xy_array |
| sentences: |
| - "def to_xy_array(self):\n \"\"\"\n Convert keypoint coordinates\ |
| \ to ``(N,2)`` array.\n\n Returns\n -------\n (N, 2) ndarray\n\ |
| \ Array containing the coordinates of all keypoints.\n Shape\ |
| \ is ``(N,2)`` with coordinates in xy-form.\n\n \"\"\"\n result\ |
| \ = np.zeros((len(self.keypoints), 2), dtype=np.float32)\n for i, keypoint\ |
| \ in enumerate(self.keypoints):\n result[i, 0] = keypoint.x\n \ |
| \ result[i, 1] = keypoint.y\n return result" |
| - "def _generateMetricSpecs(options):\n \"\"\" Generates the Metrics for a given\ |
| \ InferenceType\n\n Parameters:\n -------------------------------------------------------------------------\n\ |
| \ options: ExpGenerator options\n retval: (metricsList, optimizeMetricLabel)\n\ |
| \ metricsList: list of metric string names\n optimizeMetricLabel:\ |
| \ Name of the metric which to optimize over\n\n \"\"\"\n inferenceType = options['inferenceType']\n\ |
| \ inferenceArgs = options['inferenceArgs']\n predictionSteps = inferenceArgs['predictionSteps']\n\ |
| \ metricWindow = options['metricWindow']\n if metricWindow is None:\n metricWindow\ |
| \ = int(Configuration.get(\"nupic.opf.metricWindow\"))\n\n metricSpecStrings\ |
| \ = []\n optimizeMetricLabel = \"\"\n\n # -----------------------------------------------------------------------\n\ |
| \ # Generate the metrics specified by the expGenerator paramters\n metricSpecStrings.extend(_generateExtraMetricSpecs(options))\n\ |
| \n # -----------------------------------------------------------------------\n\ |
| \n optimizeMetricSpec = None\n # If using a dynamically computed prediction\ |
| \ steps (i.e. when swarming\n # over aggregation is requested), then we will\ |
| \ plug in the variable\n # predictionSteps in place of the statically provided\ |
| \ predictionSteps\n # from the JSON description.\n if options['dynamicPredictionSteps']:\n\ |
| \ assert len(predictionSteps) == 1\n predictionSteps = ['$REPLACE_ME']\n\ |
| \n # -----------------------------------------------------------------------\n\ |
| \ # Metrics for temporal prediction\n if inferenceType in (InferenceType.TemporalNextStep,\n\ |
| \ InferenceType.TemporalAnomaly,\n \ |
| \ InferenceType.TemporalMultiStep,\n InferenceType.NontemporalMultiStep,\n\ |
| \ InferenceType.NontemporalClassification,\n \ |
| \ 'MultiStep'):\n\n predictedFieldName, predictedFieldType = _getPredictedField(options)\n\ |
| \ isCategory = _isCategory(predictedFieldType)\n metricNames = ('avg_err',)\ |
| \ if isCategory else ('aae', 'altMAPE')\n trivialErrorMetric = 'avg_err' if\ |
| \ isCategory else 'altMAPE'\n oneGramErrorMetric = 'avg_err' if isCategory\ |
| \ else 'altMAPE'\n movingAverageBaselineName = 'moving_mode' if isCategory\ |
| \ else 'moving_mean'\n\n # Multi-step metrics\n for metricName in metricNames:\n\ |
| \ metricSpec, metricLabel = \\\n _generateMetricSpecString(field=predictedFieldName,\n\ |
| \ inferenceElement=InferenceElement.multiStepBestPredictions,\n\ |
| \ metric='multiStep',\n params={'errorMetric':\ |
| \ metricName,\n 'window':metricWindow,\n \ |
| \ 'steps': predictionSteps},\n returnLabel=True)\n\ |
| \ metricSpecStrings.append(metricSpec)\n\n # If the custom error metric\ |
| \ was specified, add that\n if options[\"customErrorMetric\"] is not None :\n\ |
| \ metricParams = dict(options[\"customErrorMetric\"])\n metricParams['errorMetric']\ |
| \ = 'custom_error_metric'\n metricParams['steps'] = predictionSteps\n \ |
| \ # If errorWindow is not specified, make it equal to the default window\n \ |
| \ if not \"errorWindow\" in metricParams:\n metricParams[\"errorWindow\"\ |
| ] = metricWindow\n metricSpec, metricLabel =_generateMetricSpecString(field=predictedFieldName,\n\ |
| \ inferenceElement=InferenceElement.multiStepPredictions,\n\ |
| \ metric=\"multiStep\",\n params=metricParams,\n\ |
| \ returnLabel=True)\n metricSpecStrings.append(metricSpec)\n\ |
| \n # If this is the first specified step size, optimize for it. Be sure to\n\ |
| \ # escape special characters since this is a regular expression\n optimizeMetricSpec\ |
| \ = metricSpec\n metricLabel = metricLabel.replace('[', '\\\\[')\n metricLabel\ |
| \ = metricLabel.replace(']', '\\\\]')\n optimizeMetricLabel = metricLabel\n\ |
| \n if options[\"customErrorMetric\"] is not None :\n optimizeMetricLabel\ |
| \ = \".*custom_error_metric.*\"\n\n # Add in the trivial metrics\n if options[\"\ |
| runBaselines\"] \\\n and inferenceType != InferenceType.NontemporalClassification:\n\ |
| \ for steps in predictionSteps:\n metricSpecStrings.append(\n \ |
| \ _generateMetricSpecString(field=predictedFieldName,\n \ |
| \ inferenceElement=InferenceElement.prediction,\n \ |
| \ metric=\"trivial\",\n \ |
| \ params={'window':metricWindow,\n \ |
| \ \"errorMetric\":trivialErrorMetric,\n \ |
| \ 'steps': steps})\n )\n\n ##Add in the\ |
| \ One-Gram baseline error metric\n #metricSpecStrings.append(\n \ |
| \ # _generateMetricSpecString(field=predictedFieldName,\n # \ |
| \ inferenceElement=InferenceElement.encodings,\n # \ |
| \ metric=\"two_gram\",\n # \ |
| \ params={'window':metricWindow,\n # \ |
| \ \"errorMetric\":oneGramErrorMetric,\n # \ |
| \ 'predictionField':predictedFieldName,\n # \ |
| \ 'steps': steps})\n # )\n \ |
| \ #\n #Include the baseline moving mean/mode metric\n if isCategory:\n\ |
| \ metricSpecStrings.append(\n _generateMetricSpecString(field=predictedFieldName,\n\ |
| \ inferenceElement=InferenceElement.prediction,\n\ |
| \ metric=movingAverageBaselineName,\n \ |
| \ params={'window':metricWindow\n \ |
| \ ,\"errorMetric\":\"avg_err\",\n \ |
| \ \"mode_window\":200,\n \ |
| \ \"steps\": steps})\n \ |
| \ )\n else :\n metricSpecStrings.append(\n _generateMetricSpecString(field=predictedFieldName,\n\ |
| \ inferenceElement=InferenceElement.prediction,\n\ |
| \ metric=movingAverageBaselineName,\n \ |
| \ params={'window':metricWindow\n \ |
| \ ,\"errorMetric\":\"altMAPE\",\n \ |
| \ \"mean_window\":200,\n \ |
| \ \"steps\": steps})\n \ |
| \ )\n\n\n\n\n # -----------------------------------------------------------------------\n\ |
| \ # Metrics for classification\n elif inferenceType in (InferenceType.TemporalClassification):\n\ |
| \n metricName = 'avg_err'\n trivialErrorMetric = 'avg_err'\n oneGramErrorMetric\ |
| \ = 'avg_err'\n movingAverageBaselineName = 'moving_mode'\n\n optimizeMetricSpec,\ |
| \ optimizeMetricLabel = \\\n _generateMetricSpecString(inferenceElement=InferenceElement.classification,\n\ |
| \ metric=metricName,\n \ |
| \ params={'window':metricWindow},\n returnLabel=True)\n\ |
| \n metricSpecStrings.append(optimizeMetricSpec)\n\n if options[\"runBaselines\"\ |
| ]:\n # If temporal, generate the trivial predictor metric\n if inferenceType\ |
| \ == InferenceType.TemporalClassification:\n metricSpecStrings.append(\n\ |
| \ _generateMetricSpecString(inferenceElement=InferenceElement.classification,\n\ |
| \ metric=\"trivial\",\n \ |
| \ params={'window':metricWindow,\n \ |
| \ \"errorMetric\":trivialErrorMetric})\n )\n \ |
| \ metricSpecStrings.append(\n _generateMetricSpecString(inferenceElement=InferenceElement.classification,\n\ |
| \ metric=\"two_gram\",\n \ |
| \ params={'window':metricWindow,\n \ |
| \ \"errorMetric\":oneGramErrorMetric})\n )\n \ |
| \ metricSpecStrings.append(\n _generateMetricSpecString(inferenceElement=InferenceElement.classification,\n\ |
| \ metric=movingAverageBaselineName,\n \ |
| \ params={'window':metricWindow\n \ |
| \ ,\"errorMetric\":\"avg_err\",\n \ |
| \ \"mode_window\":200})\n )\n\ |
| \n\n # Custom Error Metric\n if not options[\"customErrorMetric\"] == None\ |
| \ :\n #If errorWindow is not specified, make it equal to the default window\n\ |
| \ if not \"errorWindow\" in options[\"customErrorMetric\"]:\n options[\"\ |
| customErrorMetric\"][\"errorWindow\"] = metricWindow\n optimizeMetricSpec\ |
| \ = _generateMetricSpecString(\n inferenceElement=InferenceElement.classification,\n\ |
| \ metric=\"custom\",\n \ |
| \ params=options[\"customErrorMetric\"])\n optimizeMetricLabel = \"\ |
| .*custom_error_metric.*\"\n\n metricSpecStrings.append(optimizeMetricSpec)\n\ |
| \n\n # -----------------------------------------------------------------------\n\ |
| \ # If plug in the predictionSteps variable for any dynamically generated\n \ |
| \ # prediction steps\n if options['dynamicPredictionSteps']:\n for i in range(len(metricSpecStrings)):\n\ |
| \ metricSpecStrings[i] = metricSpecStrings[i].replace(\n \"'$REPLACE_ME'\"\ |
| , \"predictionSteps\")\n optimizeMetricLabel = optimizeMetricLabel.replace(\n\ |
| \ \"'$REPLACE_ME'\", \".*\")\n return metricSpecStrings, optimizeMetricLabel" |
| - "def create_perf_attrib_stats(perf_attrib, risk_exposures):\n \"\"\"\n Takes\ |
| \ perf attribution data over a period of time and computes annualized\n multifactor\ |
| \ alpha, multifactor sharpe, risk exposures.\n \"\"\"\n summary = OrderedDict()\n\ |
| \ total_returns = perf_attrib['total_returns']\n specific_returns = perf_attrib['specific_returns']\n\ |
| \ common_returns = perf_attrib['common_returns']\n\n summary['Annualized\ |
| \ Specific Return'] =\\\n ep.annual_return(specific_returns)\n summary['Annualized\ |
| \ Common Return'] =\\\n ep.annual_return(common_returns)\n summary['Annualized\ |
| \ Total Return'] =\\\n ep.annual_return(total_returns)\n\n summary['Specific\ |
| \ Sharpe Ratio'] =\\\n ep.sharpe_ratio(specific_returns)\n\n summary['Cumulative\ |
| \ Specific Return'] =\\\n ep.cum_returns_final(specific_returns)\n summary['Cumulative\ |
| \ Common Return'] =\\\n ep.cum_returns_final(common_returns)\n summary['Total\ |
| \ Returns'] =\\\n ep.cum_returns_final(total_returns)\n\n summary =\ |
| \ pd.Series(summary, name='')\n\n annualized_returns_by_factor = [ep.annual_return(perf_attrib[c])\n\ |
| \ for c in risk_exposures.columns]\n cumulative_returns_by_factor\ |
| \ = [ep.cum_returns_final(perf_attrib[c])\n \ |
| \ for c in risk_exposures.columns]\n\n risk_exposure_summary = pd.DataFrame(\n\ |
| \ data=OrderedDict([\n (\n 'Average Risk Factor\ |
| \ Exposure',\n risk_exposures.mean(axis='rows')\n ),\n\ |
| \ ('Annualized Return', annualized_returns_by_factor),\n \ |
| \ ('Cumulative Return', cumulative_returns_by_factor),\n ]),\n \ |
| \ index=risk_exposures.columns,\n )\n\n return summary, risk_exposure_summary" |
| - source_sentence: _generateEncoderChoicesV1 |
| sentences: |
| - "def common_arg_parser():\n \"\"\"\n Create an argparse.ArgumentParser for\ |
| \ run_mujoco.py.\n \"\"\"\n parser = arg_parser()\n parser.add_argument('--env',\ |
| \ help='environment ID', type=str, default='Reacher-v2')\n parser.add_argument('--env_type',\ |
| \ help='type of environment, used when the environment type cannot be automatically\ |
| \ determined', type=str)\n parser.add_argument('--seed', help='RNG seed', type=int,\ |
| \ default=None)\n parser.add_argument('--alg', help='Algorithm', type=str,\ |
| \ default='ppo2')\n parser.add_argument('--num_timesteps', type=float, default=1e6),\n\ |
| \ parser.add_argument('--network', help='network type (mlp, cnn, lstm, cnn_lstm,\ |
| \ conv_only)', default=None)\n parser.add_argument('--gamestate', help='game\ |
| \ state to load (so far only used in retro games)', default=None)\n parser.add_argument('--num_env',\ |
| \ help='Number of environment copies being run in parallel. When not specified,\ |
| \ set to number of cpus for Atari, and to 1 for Mujoco', default=None, type=int)\n\ |
| \ parser.add_argument('--reward_scale', help='Reward scale factor. Default:\ |
| \ 1.0', default=1.0, type=float)\n parser.add_argument('--save_path', help='Path\ |
| \ to save trained model to', default=None, type=str)\n parser.add_argument('--save_video_interval',\ |
| \ help='Save video every x steps (0 = disabled)', default=0, type=int)\n parser.add_argument('--save_video_length',\ |
| \ help='Length of recorded video. Default: 200', default=200, type=int)\n parser.add_argument('--play',\ |
| \ default=False, action='store_true')\n return parser" |
| - "def check_intraday(estimate, returns, positions, transactions):\n \"\"\"\n\ |
| \ Logic for checking if a strategy is intraday and processing it.\n\n Parameters\n\ |
| \ ----------\n estimate: boolean or str, optional\n Approximate returns\ |
| \ for intraday strategies.\n See description in tears.create_full_tear_sheet.\n\ |
| \ returns : pd.Series\n Daily returns of the strategy, noncumulative.\n\ |
| \ - See full explanation in create_full_tear_sheet.\n positions : pd.DataFrame\n\ |
| \ Daily net position values.\n - See full explanation in create_full_tear_sheet.\n\ |
| \ transactions : pd.DataFrame\n Prices and amounts of executed trades.\ |
| \ One row per trade.\n - See full explanation in create_full_tear_sheet.\n\ |
| \n Returns\n -------\n pd.DataFrame\n Daily net position values,\ |
| \ adjusted for intraday movement.\n \"\"\"\n\n if estimate == 'infer':\n\ |
| \ if positions is not None and transactions is not None:\n if\ |
| \ detect_intraday(positions, transactions):\n warnings.warn('Detected\ |
| \ intraday strategy; inferring positi' +\n 'ons from\ |
| \ transactions. Set estimate_intraday' +\n '=False\ |
| \ to disable.')\n return estimate_intraday(returns, positions,\ |
| \ transactions)\n else:\n return positions\n \ |
| \ else:\n return positions\n\n elif estimate:\n if positions\ |
| \ is not None and transactions is not None:\n return estimate_intraday(returns,\ |
| \ positions, transactions)\n else:\n raise ValueError('Positions\ |
| \ and txns needed to estimate intraday')\n else:\n return positions" |
| - "def _generateEncoderChoicesV1(fieldInfo):\n \"\"\" Return a list of possible\ |
| \ encoder parameter combinations for the given\n field and the default aggregation\ |
| \ function to use. Each parameter combination\n is a dict defining the parameters\ |
| \ for the encoder. Here is an example\n return value for the encoderChoicesList:\n\ |
| \n [\n None,\n {'fieldname':'timestamp',\n 'name': 'timestamp_timeOfDay',\n\ |
| \ 'type':'DateEncoder'\n 'dayOfWeek': (7,1)\n },\n {'fieldname':'timestamp',\n\ |
| \ 'name': 'timestamp_timeOfDay',\n 'type':'DateEncoder'\n 'dayOfWeek':\ |
| \ (7,3)\n },\n ],\n\n Parameters:\n --------------------------------------------------\n\ |
| \ fieldInfo: item from the 'includedFields' section of the\n \ |
| \ description JSON object\n\n retval: (encoderChoicesList, aggFunction)\n\ |
| \ encoderChoicesList: a list of encoder choice lists for this field.\n\ |
| \ Most fields will generate just 1 encoder choice list.\n \ |
| \ DateTime fields can generate 2 or more encoder choice lists,\n \ |
| \ one for dayOfWeek, one for timeOfDay, etc.\n aggFunction:\ |
| \ name of aggregation function to use for this\n field\ |
| \ type\n\n \"\"\"\n\n width = 7\n fieldName = fieldInfo['fieldName']\n fieldType\ |
| \ = fieldInfo['fieldType']\n encoderChoicesList = []\n\n # Scalar?\n if fieldType\ |
| \ in ['float', 'int']:\n aggFunction = 'mean'\n encoders = [None]\n for\ |
| \ n in (13, 50, 150, 500):\n encoder = dict(type='ScalarSpaceEncoder', name=fieldName,\ |
| \ fieldname=fieldName,\n n=n, w=width, clipInput=True,space=\"\ |
| absolute\")\n if 'minValue' in fieldInfo:\n encoder['minval'] = fieldInfo['minValue']\n\ |
| \ if 'maxValue' in fieldInfo:\n encoder['maxval'] = fieldInfo['maxValue']\n\ |
| \ encoders.append(encoder)\n encoderChoicesList.append(encoders)\n\n \ |
| \ # String?\n elif fieldType == 'string':\n aggFunction = 'first'\n encoders\ |
| \ = [None]\n encoder = dict(type='SDRCategoryEncoder', name=fieldName,\n \ |
| \ fieldname=fieldName, n=100, w=width)\n encoders.append(encoder)\n\ |
| \ encoderChoicesList.append(encoders)\n\n\n # Datetime?\n elif fieldType\ |
| \ == 'datetime':\n aggFunction = 'first'\n\n # First, the time of day representation\n\ |
| \ encoders = [None]\n for radius in (1, 8):\n encoder = dict(type='DateEncoder',\ |
| \ name='%s_timeOfDay' % (fieldName),\n fieldname=fieldName,\ |
| \ timeOfDay=(width, radius))\n encoders.append(encoder)\n encoderChoicesList.append(encoders)\n\ |
| \n # Now, the day of week representation\n encoders = [None]\n for radius\ |
| \ in (1, 3):\n encoder = dict(type='DateEncoder', name='%s_dayOfWeek' % (fieldName),\n\ |
| \ fieldname=fieldName, dayOfWeek=(width, radius))\n encoders.append(encoder)\n\ |
| \ encoderChoicesList.append(encoders)\n\n else:\n raise RuntimeError(\"\ |
| Unsupported field type '%s'\" % (fieldType))\n\n\n # Return results\n return\ |
| \ (encoderChoicesList, aggFunction)" |
| - source_sentence: leaky_relu6 |
| sentences: |
| - "def list_string_to_dict(string):\n \"\"\"Inputs ``['a', 'b', 'c']``, returns\ |
| \ ``{'a': 0, 'b': 1, 'c': 2}``.\"\"\"\n dictionary = {}\n for idx, c in\ |
| \ enumerate(string):\n dictionary.update({c: idx})\n return dictionary" |
| - "def affine_transform(x, transform_matrix, channel_index=2, fill_mode='nearest',\ |
| \ cval=0., order=1):\n \"\"\"Return transformed images by given an affine matrix\ |
| \ in Scipy format (x is height).\n\n Parameters\n ----------\n x : numpy.array\n\ |
| \ An image with dimension of [row, col, channel] (default).\n transform_matrix\ |
| \ : numpy.array\n Transform matrix (offset center), can be generated by\ |
| \ ``transform_matrix_offset_center``\n channel_index : int\n Index of\ |
| \ channel, default 2.\n fill_mode : str\n Method to fill missing pixel,\ |
| \ default `nearest`, more options `constant`, `reflect` or `wrap`, see `scipy\ |
| \ ndimage affine_transform <https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.ndimage.interpolation.affine_transform.html>`__\n\ |
| \ cval : float\n Value used for points outside the boundaries of the\ |
| \ input if mode='constant'. Default is 0.0\n order : int\n The order\ |
| \ of interpolation. The order has to be in the range 0-5:\n - 0 Nearest-neighbor\n\ |
| \ - 1 Bi-linear (default)\n - 2 Bi-quadratic\n \ |
| \ - 3 Bi-cubic\n - 4 Bi-quartic\n - 5 Bi-quintic\n \ |
| \ - `scipy ndimage affine_transform <https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.ndimage.interpolation.affine_transform.html>`__\n\ |
| \n Returns\n -------\n numpy.array\n A processed image.\n\n \ |
| \ Examples\n --------\n >>> M_shear = tl.prepro.affine_shear_matrix(intensity=0.2,\ |
| \ is_random=False)\n >>> M_zoom = tl.prepro.affine_zoom_matrix(zoom_range=0.8)\n\ |
| \ >>> M_combined = M_shear.dot(M_zoom)\n >>> transform_matrix = tl.prepro.transform_matrix_offset_center(M_combined,\ |
| \ h, w)\n >>> result = tl.prepro.affine_transform(image, transform_matrix)\n\ |
| \n \"\"\"\n # transform_matrix = transform_matrix_offset_center()\n #\ |
| \ asdihasid\n # asd\n\n x = np.rollaxis(x, channel_index, 0)\n final_affine_matrix\ |
| \ = transform_matrix[:2, :2]\n final_offset = transform_matrix[:2, 2]\n \ |
| \ channel_images = [\n ndi.interpolation.\n affine_transform(x_channel,\ |
| \ final_affine_matrix, final_offset, order=order, mode=fill_mode, cval=cval)\n\ |
| \ for x_channel in x\n ]\n x = np.stack(channel_images, axis=0)\n\ |
| \ x = np.rollaxis(x, 0, channel_index + 1)\n return x" |
| - "def leaky_relu6(x, alpha=0.2, name=\"leaky_relu6\"):\n \"\"\":func:`leaky_relu6`\ |
| \ can be used through its shortcut: :func:`tl.act.lrelu6`.\n\n This activation\ |
| \ function is a modified version :func:`leaky_relu` introduced by the following\ |
| \ paper:\n `Rectifier Nonlinearities Improve Neural Network Acoustic Models\ |
| \ [A. L. Maas et al., 2013] <https://ai.stanford.edu/~amaas/papers/relu_hybrid_icml2013_final.pdf>`__\n\ |
| \n This activation function also follows the behaviour of the activation function\ |
| \ :func:`tf.nn.relu6` introduced by the following paper:\n `Convolutional Deep\ |
| \ Belief Networks on CIFAR-10 [A. Krizhevsky, 2010] <http://www.cs.utoronto.ca/~kriz/conv-cifar10-aug2010.pdf>`__\n\ |
| \n The function return the following results:\n - When x < 0: ``f(x) =\ |
| \ alpha_low * x``.\n - When x in [0, 6]: ``f(x) = x``.\n - When x >\ |
| \ 6: ``f(x) = 6``.\n\n Parameters\n ----------\n x : Tensor\n \ |
| \ Support input type ``float``, ``double``, ``int32``, ``int64``, ``uint8``, ``int16``,\ |
| \ or ``int8``.\n alpha : float\n Slope.\n name : str\n The\ |
| \ function name (optional).\n\n Examples\n --------\n >>> import tensorlayer\ |
| \ as tl\n >>> net = tl.layers.DenseLayer(net, 100, act=lambda x : tl.act.leaky_relu6(x,\ |
| \ 0.2), name='dense')\n\n Returns\n -------\n Tensor\n A ``Tensor``\ |
| \ in the same type as ``x``.\n\n References\n ----------\n - `Rectifier\ |
| \ Nonlinearities Improve Neural Network Acoustic Models [A. L. Maas et al., 2013]\ |
| \ <https://ai.stanford.edu/~amaas/papers/relu_hybrid_icml2013_final.pdf>`__\n\ |
| \ - `Convolutional Deep Belief Networks on CIFAR-10 [A. Krizhevsky, 2010] <http://www.cs.utoronto.ca/~kriz/conv-cifar10-aug2010.pdf>`__\n\ |
| \ \"\"\"\n if not isinstance(alpha, tf.Tensor) and not (0 < alpha <= 1):\n\ |
| \ raise ValueError(\"`alpha` value must be in [0, 1]`\")\n\n with tf.name_scope(name,\ |
| \ \"leaky_relu6\") as name_scope:\n x = tf.convert_to_tensor(x, name=\"\ |
| features\")\n return tf.minimum(tf.maximum(x, alpha * x), 6, name=name_scope)" |
| - source_sentence: LineString.contains |
| sentences: |
| - "def build_act_with_param_noise(make_obs_ph, q_func, num_actions, scope=\"deepq\"\ |
| , reuse=None, param_noise_filter_func=None):\n \"\"\"Creates the act function\ |
| \ with support for parameter space noise exploration (https://arxiv.org/abs/1706.01905):\n\ |
| \n Parameters\n ----------\n make_obs_ph: str -> tf.placeholder or TfInput\n\ |
| \ a function that take a name and creates a placeholder of input with that\ |
| \ name\n q_func: (tf.Variable, int, str, bool) -> tf.Variable\n the\ |
| \ model that takes the following inputs:\n observation_in: object\n\ |
| \ the output of observation placeholder\n num_actions:\ |
| \ int\n number of actions\n scope: str\n \ |
| \ reuse: bool\n should be passed to outer variable scope\n \ |
| \ and returns a tensor of shape (batch_size, num_actions) with values of every\ |
| \ action.\n num_actions: int\n number of actions.\n scope: str or\ |
| \ VariableScope\n optional scope for variable_scope.\n reuse: bool or\ |
| \ None\n whether or not the variables should be reused. To be able to reuse\ |
| \ the scope must be given.\n param_noise_filter_func: tf.Variable -> bool\n\ |
| \ function that decides whether or not a variable should be perturbed.\ |
| \ Only applicable\n if param_noise is True. If set to None, default_param_noise_filter\ |
| \ is used by default.\n\n Returns\n -------\n act: (tf.Variable, bool,\ |
| \ float, bool, float, bool) -> tf.Variable\n function to select and action\ |
| \ given observation.\n` See the top of the file for details.\n \"\"\"\ |
| \n if param_noise_filter_func is None:\n param_noise_filter_func = default_param_noise_filter\n\ |
| \n with tf.variable_scope(scope, reuse=reuse):\n observations_ph = make_obs_ph(\"\ |
| observation\")\n stochastic_ph = tf.placeholder(tf.bool, (), name=\"stochastic\"\ |
| )\n update_eps_ph = tf.placeholder(tf.float32, (), name=\"update_eps\"\ |
| )\n update_param_noise_threshold_ph = tf.placeholder(tf.float32, (), name=\"\ |
| update_param_noise_threshold\")\n update_param_noise_scale_ph = tf.placeholder(tf.bool,\ |
| \ (), name=\"update_param_noise_scale\")\n reset_ph = tf.placeholder(tf.bool,\ |
| \ (), name=\"reset\")\n\n eps = tf.get_variable(\"eps\", (), initializer=tf.constant_initializer(0))\n\ |
| \ param_noise_scale = tf.get_variable(\"param_noise_scale\", (), initializer=tf.constant_initializer(0.01),\ |
| \ trainable=False)\n param_noise_threshold = tf.get_variable(\"param_noise_threshold\"\ |
| , (), initializer=tf.constant_initializer(0.05), trainable=False)\n\n #\ |
| \ Unmodified Q.\n q_values = q_func(observations_ph.get(), num_actions,\ |
| \ scope=\"q_func\")\n\n # Perturbable Q used for the actual rollout.\n\ |
| \ q_values_perturbed = q_func(observations_ph.get(), num_actions, scope=\"\ |
| perturbed_q_func\")\n # We have to wrap this code into a function due to\ |
| \ the way tf.cond() works. See\n # https://stackoverflow.com/questions/37063952/confused-by-the-behavior-of-tf-cond\ |
| \ for\n # a more detailed discussion.\n def perturb_vars(original_scope,\ |
| \ perturbed_scope):\n all_vars = scope_vars(absolute_scope_name(original_scope))\n\ |
| \ all_perturbed_vars = scope_vars(absolute_scope_name(perturbed_scope))\n\ |
| \ assert len(all_vars) == len(all_perturbed_vars)\n perturb_ops\ |
| \ = []\n for var, perturbed_var in zip(all_vars, all_perturbed_vars):\n\ |
| \ if param_noise_filter_func(perturbed_var):\n \ |
| \ # Perturb this variable.\n op = tf.assign(perturbed_var,\ |
| \ var + tf.random_normal(shape=tf.shape(var), mean=0., stddev=param_noise_scale))\n\ |
| \ else:\n # Do not perturb, just assign.\n \ |
| \ op = tf.assign(perturbed_var, var)\n perturb_ops.append(op)\n\ |
| \ assert len(perturb_ops) == len(all_vars)\n return tf.group(*perturb_ops)\n\ |
| \n # Set up functionality to re-compute `param_noise_scale`. This perturbs\ |
| \ yet another copy\n # of the network and measures the effect of that perturbation\ |
| \ in action space. If the perturbation\n # is too big, reduce scale of\ |
| \ perturbation, otherwise increase.\n q_values_adaptive = q_func(observations_ph.get(),\ |
| \ num_actions, scope=\"adaptive_q_func\")\n perturb_for_adaption = perturb_vars(original_scope=\"\ |
| q_func\", perturbed_scope=\"adaptive_q_func\")\n kl = tf.reduce_sum(tf.nn.softmax(q_values)\ |
| \ * (tf.log(tf.nn.softmax(q_values)) - tf.log(tf.nn.softmax(q_values_adaptive))),\ |
| \ axis=-1)\n mean_kl = tf.reduce_mean(kl)\n def update_scale():\n\ |
| \ with tf.control_dependencies([perturb_for_adaption]):\n \ |
| \ update_scale_expr = tf.cond(mean_kl < param_noise_threshold,\n \ |
| \ lambda: param_noise_scale.assign(param_noise_scale * 1.01),\n \ |
| \ lambda: param_noise_scale.assign(param_noise_scale / 1.01),\n\ |
| \ )\n return update_scale_expr\n\n # Functionality\ |
| \ to update the threshold for parameter space noise.\n update_param_noise_threshold_expr\ |
| \ = param_noise_threshold.assign(tf.cond(update_param_noise_threshold_ph >= 0,\n\ |
| \ lambda: update_param_noise_threshold_ph, lambda: param_noise_threshold))\n\ |
| \n # Put everything together.\n deterministic_actions = tf.argmax(q_values_perturbed,\ |
| \ axis=1)\n batch_size = tf.shape(observations_ph.get())[0]\n random_actions\ |
| \ = tf.random_uniform(tf.stack([batch_size]), minval=0, maxval=num_actions, dtype=tf.int64)\n\ |
| \ chose_random = tf.random_uniform(tf.stack([batch_size]), minval=0, maxval=1,\ |
| \ dtype=tf.float32) < eps\n stochastic_actions = tf.where(chose_random,\ |
| \ random_actions, deterministic_actions)\n\n output_actions = tf.cond(stochastic_ph,\ |
| \ lambda: stochastic_actions, lambda: deterministic_actions)\n update_eps_expr\ |
| \ = eps.assign(tf.cond(update_eps_ph >= 0, lambda: update_eps_ph, lambda: eps))\n\ |
| \ updates = [\n update_eps_expr,\n tf.cond(reset_ph,\ |
| \ lambda: perturb_vars(original_scope=\"q_func\", perturbed_scope=\"perturbed_q_func\"\ |
| ), lambda: tf.group(*[])),\n tf.cond(update_param_noise_scale_ph, lambda:\ |
| \ update_scale(), lambda: tf.Variable(0., trainable=False)),\n update_param_noise_threshold_expr,\n\ |
| \ ]\n _act = U.function(inputs=[observations_ph, stochastic_ph,\ |
| \ update_eps_ph, reset_ph, update_param_noise_threshold_ph, update_param_noise_scale_ph],\n\ |
| \ outputs=output_actions,\n givens={update_eps_ph:\ |
| \ -1.0, stochastic_ph: True, reset_ph: False, update_param_noise_threshold_ph:\ |
| \ False, update_param_noise_scale_ph: False},\n updates=updates)\n\ |
| \ def act(ob, reset=False, update_param_noise_threshold=False, update_param_noise_scale=False,\ |
| \ stochastic=True, update_eps=-1):\n return _act(ob, stochastic, update_eps,\ |
| \ reset, update_param_noise_threshold, update_param_noise_scale)\n return\ |
| \ act" |
| - "def contains(self, other, max_distance=1e-4):\n \"\"\"\n Estimate\ |
| \ whether the bounding box contains a point.\n\n Parameters\n ----------\n\ |
| \ other : tuple of number or imgaug.augmentables.kps.Keypoint\n \ |
| \ Point to check for.\n\n max_distance : float\n Maximum\ |
| \ allowed euclidean distance between the point and the\n closest point\ |
| \ on the line. If the threshold is exceeded, the point\n is not considered\ |
| \ to be contained in the line.\n\n Returns\n -------\n bool\n\ |
| \ True if the point is contained in the line string, False otherwise.\n\ |
| \ It is contained if its distance to the line or any of its points\n\ |
| \ is below a threshold.\n\n \"\"\"\n return self.compute_distance(other,\ |
| \ default=np.inf) < max_distance" |
| - "def is_fully_within_image(self, image):\n \"\"\"\n Estimate whether\ |
| \ the bounding box is fully inside the image area.\n\n Parameters\n \ |
| \ ----------\n image : (H,W,...) ndarray or tuple of int\n \ |
| \ Image dimensions to use.\n If an ndarray, its shape will be used.\n\ |
| \ If a tuple, it is assumed to represent the image shape\n \ |
| \ and must contain at least two integers.\n\n Returns\n -------\n\ |
| \ bool\n True if the bounding box is fully inside the image\ |
| \ area. False otherwise.\n\n \"\"\"\n shape = normalize_shape(image)\n\ |
| \ height, width = shape[0:2]\n return self.x1 >= 0 and self.x2 <\ |
| \ width and self.y1 >= 0 and self.y2 < height" |
| - source_sentence: Keypoint.copy |
| sentences: |
| - "def build_words_dataset(words=None, vocabulary_size=50000, printable=True, unk_key='UNK'):\n\ |
| \ \"\"\"Build the words dictionary and replace rare words with 'UNK' token.\n\ |
| \ The most common word has the smallest integer id.\n\n Parameters\n \ |
| \ ----------\n words : list of str or byte\n The context in list format.\ |
| \ You may need to do preprocessing on the words, such as lower case, remove marks\ |
| \ etc.\n vocabulary_size : int\n The maximum vocabulary size, limiting\ |
| \ the vocabulary size. Then the script replaces rare words with 'UNK' token.\n\ |
| \ printable : boolean\n Whether to print the read vocabulary size of\ |
| \ the given words.\n unk_key : str\n Represent the unknown words.\n\n\ |
| \ Returns\n --------\n data : list of int\n The context in a list\ |
| \ of ID.\n count : list of tuple and list\n Pair words and IDs.\n \ |
| \ - count[0] is a list : the number of rare words\n - count[1:]\ |
| \ are tuples : the number of occurrence of each word\n - e.g. [['UNK',\ |
| \ 418391], (b'the', 1061396), (b'of', 593677), (b'and', 416629), (b'one', 411764)]\n\ |
| \ dictionary : dictionary\n It is `word_to_id` that maps word to ID.\n\ |
| \ reverse_dictionary : a dictionary\n It is `id_to_word` that maps ID\ |
| \ to word.\n\n Examples\n --------\n >>> words = tl.files.load_matt_mahoney_text8_dataset()\n\ |
| \ >>> vocabulary_size = 50000\n >>> data, count, dictionary, reverse_dictionary\ |
| \ = tl.nlp.build_words_dataset(words, vocabulary_size)\n\n References\n \ |
| \ -----------------\n - `tensorflow/examples/tutorials/word2vec/word2vec_basic.py\ |
| \ <https://github.com/tensorflow/tensorflow/blob/r0.7/tensorflow/examples/tutorials/word2vec/word2vec_basic.py>`__\n\ |
| \n \"\"\"\n if words is None:\n raise Exception(\"words : list of\ |
| \ str or byte\")\n\n count = [[unk_key, -1]]\n count.extend(collections.Counter(words).most_common(vocabulary_size\ |
| \ - 1))\n dictionary = dict()\n for word, _ in count:\n dictionary[word]\ |
| \ = len(dictionary)\n data = list()\n unk_count = 0\n for word in words:\n\ |
| \ if word in dictionary:\n index = dictionary[word]\n \ |
| \ else:\n index = 0 # dictionary['UNK']\n unk_count +=\ |
| \ 1\n data.append(index)\n count[0][1] = unk_count\n reverse_dictionary\ |
| \ = dict(zip(dictionary.values(), dictionary.keys()))\n if printable:\n \ |
| \ tl.logging.info('Real vocabulary size %d' % len(collections.Counter(words).keys()))\n\ |
| \ tl.logging.info('Limited vocabulary size {}'.format(vocabulary_size))\n\ |
| \ if len(collections.Counter(words).keys()) < vocabulary_size:\n raise\ |
| \ Exception(\n \"len(collections.Counter(words).keys()) >= vocabulary_size\ |
| \ , the limited vocabulary_size must be less than or equal to the read vocabulary_size\"\ |
| \n )\n return data, count, dictionary, reverse_dictionary" |
| - "def Snowflakes(density=(0.005, 0.075), density_uniformity=(0.3, 0.9), flake_size=(0.2,\ |
| \ 0.7),\n flake_size_uniformity=(0.4, 0.8), angle=(-30, 30), speed=(0.007,\ |
| \ 0.03),\n name=None, deterministic=False, random_state=None):\n\ |
| \ \"\"\"\n Augmenter to add falling snowflakes to images.\n\n This is\ |
| \ a wrapper around ``SnowflakesLayer``. It executes 1 to 3 layers per image.\n\ |
| \n dtype support::\n\n * ``uint8``: yes; tested\n * ``uint16``:\ |
| \ no (1)\n * ``uint32``: no (1)\n * ``uint64``: no (1)\n \ |
| \ * ``int8``: no (1)\n * ``int16``: no (1)\n * ``int32``: no (1)\n\ |
| \ * ``int64``: no (1)\n * ``float16``: no (1)\n * ``float32``:\ |
| \ no (1)\n * ``float64``: no (1)\n * ``float128``: no (1)\n \ |
| \ * ``bool``: no (1)\n\n - (1) Parameters of this augmenter are optimized\ |
| \ for the value range of uint8.\n While other dtypes may be accepted,\ |
| \ they will lead to images augmented in\n ways inappropriate for\ |
| \ the respective dtype.\n\n Parameters\n ----------\n density : number\ |
| \ or tuple of number or list of number or imgaug.parameters.StochasticParameter\n\ |
| \ Density of the snowflake layer, as a probability of each pixel in low\ |
| \ resolution space to be a snowflake.\n Valid value range is ``(0.0, 1.0)``.\ |
| \ Recommended to be around ``(0.01, 0.075)``.\n\n * If a number, then\ |
| \ that value will be used for all images.\n * If a tuple ``(a, b)``,\ |
| \ then a value from the continuous range ``[a, b]`` will be used.\n \ |
| \ * If a list, then a random value will be sampled from that list per image.\n\ |
| \ * If a StochasticParameter, then a value will be sampled per image\ |
| \ from that parameter.\n\n density_uniformity : number or tuple of number or\ |
| \ list of number or imgaug.parameters.StochasticParameter\n Size uniformity\ |
| \ of the snowflakes. Higher values denote more similarly sized snowflakes.\n \ |
| \ Valid value range is ``(0.0, 1.0)``. Recommended to be around ``0.5``.\n\ |
| \n * If a number, then that value will be used for all images.\n \ |
| \ * If a tuple ``(a, b)``, then a value from the continuous range ``[a,\ |
| \ b]`` will be used.\n * If a list, then a random value will be sampled\ |
| \ from that list per image.\n * If a StochasticParameter, then a value\ |
| \ will be sampled per image from that parameter.\n\n flake_size : number or\ |
| \ tuple of number or list of number or imgaug.parameters.StochasticParameter\n\ |
| \ Size of the snowflakes. This parameter controls the resolution at which\ |
| \ snowflakes are sampled.\n Higher values mean that the resolution is closer\ |
| \ to the input image's resolution and hence each sampled\n snowflake will\ |
| \ be smaller (because of the smaller pixel size).\n\n Valid value range\ |
| \ is ``[0.0, 1.0)``. Recommended values:\n\n * On ``96x128`` a value\ |
| \ of ``(0.1, 0.4)`` worked well.\n * On ``192x256`` a value of ``(0.2,\ |
| \ 0.7)`` worked well.\n * On ``960x1280`` a value of ``(0.7, 0.95)``\ |
| \ worked well.\n\n Allowed datatypes:\n\n * If a number, then\ |
| \ that value will be used for all images.\n * If a tuple ``(a, b)``,\ |
| \ then a value from the continuous range ``[a, b]`` will be used.\n \ |
| \ * If a list, then a random value will be sampled from that list per image.\n\ |
| \ * If a StochasticParameter, then a value will be sampled per image\ |
| \ from that parameter.\n\n flake_size_uniformity : number or tuple of number\ |
| \ or list of number or imgaug.parameters.StochasticParameter\n Controls\ |
| \ the size uniformity of the snowflakes. Higher values mean that the snowflakes\ |
| \ are more similarly\n sized. Valid value range is ``(0.0, 1.0)``. Recommended\ |
| \ to be around ``0.5``.\n\n * If a number, then that value will be\ |
| \ used for all images.\n * If a tuple ``(a, b)``, then a value from\ |
| \ the continuous range ``[a, b]`` will be used.\n * If a list, then\ |
| \ a random value will be sampled from that list per image.\n * If a\ |
| \ StochasticParameter, then a value will be sampled per image from that parameter.\n\ |
| \n angle : number or tuple of number or list of number or imgaug.parameters.StochasticParameter\n\ |
| \ Angle in degrees of motion blur applied to the snowflakes, where ``0.0``\ |
| \ is motion blur that points straight\n upwards. Recommended to be around\ |
| \ ``(-30, 30)``.\n See also :func:`imgaug.augmenters.blur.MotionBlur.__init__`.\n\ |
| \n * If a number, then that value will be used for all images.\n \ |
| \ * If a tuple ``(a, b)``, then a value from the continuous range ``[a,\ |
| \ b]`` will be used.\n * If a list, then a random value will be sampled\ |
| \ from that list per image.\n * If a StochasticParameter, then a value\ |
| \ will be sampled per image from that parameter.\n\n speed : number or tuple\ |
| \ of number or list of number or imgaug.parameters.StochasticParameter\n \ |
| \ Perceived falling speed of the snowflakes. This parameter controls the motion\ |
| \ blur's kernel size.\n It follows roughly the form ``kernel_size = image_size\ |
| \ * speed``. Hence,\n Values around ``1.0`` denote that the motion blur\ |
| \ should \"stretch\" each snowflake over the whole image.\n\n Valid value\ |
| \ range is ``(0.0, 1.0)``. Recommended values:\n\n * On ``96x128``\ |
| \ a value of ``(0.01, 0.05)`` worked well.\n * On ``192x256`` a value\ |
| \ of ``(0.007, 0.03)`` worked well.\n * On ``960x1280`` a value of\ |
| \ ``(0.001, 0.03)`` worked well.\n\n\n Allowed datatypes:\n\n \ |
| \ * If a number, then that value will be used for all images.\n *\ |
| \ If a tuple ``(a, b)``, then a value from the continuous range ``[a, b]`` will\ |
| \ be used.\n * If a list, then a random value will be sampled from\ |
| \ that list per image.\n * If a StochasticParameter, then a value will\ |
| \ be sampled per image from that parameter.\n\n name : None or str, optional\n\ |
| \ See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\n deterministic\ |
| \ : bool, optional\n See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\ |
| \n random_state : None or int or numpy.random.RandomState, optional\n \ |
| \ See :func:`imgaug.augmenters.meta.Augmenter.__init__`.\n\n Examples\n \ |
| \ --------\n >>> aug = iaa.Snowflakes(flake_size=(0.1, 0.4), speed=(0.01,\ |
| \ 0.05))\n\n Adds snowflakes to small images (around ``96x128``).\n\n >>>\ |
| \ aug = iaa.Snowflakes(flake_size=(0.2, 0.7), speed=(0.007, 0.03))\n\n Adds\ |
| \ snowflakes to medium-sized images (around ``192x256``).\n\n >>> aug = iaa.Snowflakes(flake_size=(0.7,\ |
| \ 0.95), speed=(0.001, 0.03))\n\n Adds snowflakes to large images (around ``960x1280``).\n\ |
| \n \"\"\"\n if name is None:\n name = \"Unnamed%s\" % (ia.caller_name(),)\n\ |
| \n layer = SnowflakesLayer(\n density=density, density_uniformity=density_uniformity,\n\ |
| \ flake_size=flake_size, flake_size_uniformity=flake_size_uniformity,\n\ |
| \ angle=angle, speed=speed,\n blur_sigma_fraction=(0.0001, 0.001)\n\ |
| \ )\n\n return meta.SomeOf(\n (1, 3), children=[layer.deepcopy()\ |
| \ for _ in range(3)],\n random_order=False, name=name, deterministic=deterministic,\ |
| \ random_state=random_state\n )" |
| - "def copy(self, x=None, y=None):\n \"\"\"\n Create a shallow copy\ |
| \ of the Keypoint object.\n\n Parameters\n ----------\n x\ |
| \ : None or number, optional\n Coordinate of the keypoint on the x\ |
| \ axis.\n If ``None``, the instance's value will be copied.\n\n \ |
| \ y : None or number, optional\n Coordinate of the keypoint on\ |
| \ the y axis.\n If ``None``, the instance's value will be copied.\n\ |
| \n Returns\n -------\n imgaug.Keypoint\n Shallow\ |
| \ copy.\n\n \"\"\"\n return self.deepcopy(x=x, y=y)" |
| model-index: |
| - name: SentenceTransformer based on sentence-transformers/all-mpnet-base-v2 |
| results: |
| - task: |
| type: semantic-similarity |
| name: Semantic Similarity |
| dataset: |
| name: sts dev |
| type: sts-dev |
| metrics: |
| - type: pearson_cosine |
| value: 0.8806072274141987 |
| name: Pearson Cosine |
| - type: spearman_cosine |
| value: 0.8810194487011652 |
| name: Spearman Cosine |
| - type: pearson_manhattan |
| value: 0.8780911558324747 |
| name: Pearson Manhattan |
| - type: spearman_manhattan |
| value: 0.8798257355327418 |
| name: Spearman Manhattan |
| - type: pearson_euclidean |
| value: 0.8794084495321427 |
| name: Pearson Euclidean |
| - type: spearman_euclidean |
| value: 0.8810194487011652 |
| name: Spearman Euclidean |
| - type: pearson_dot |
| value: 0.8806072253861965 |
| name: Pearson Dot |
| - type: spearman_dot |
| value: 0.8810194487011652 |
| name: Spearman Dot |
| - type: pearson_max |
| value: 0.8806072274141987 |
| name: Pearson Max |
| - type: spearman_max |
| value: 0.8810194487011652 |
| name: Spearman Max |
| --- |
| |
| # SentenceTransformer based on sentence-transformers/all-mpnet-base-v2 |
|
|
| This is a [sentence-transformers](https://www.SBERT.net) model finetuned from [sentence-transformers/all-mpnet-base-v2](https://huggingface.co/sentence-transformers/all-mpnet-base-v2) on the [code-search-net/code_search_net](https://huggingface.co/datasets/code-search-net/code_search_net) dataset. It maps sentences & paragraphs to a 768-dimensional dense vector space and can be used for semantic textual similarity, semantic search, paraphrase mining, text classification, clustering, and more. |
|
|
| ## Model Details |
|
|
| ### Model Description |
| - **Model Type:** Sentence Transformer |
| - **Base model:** [sentence-transformers/all-mpnet-base-v2](https://huggingface.co/sentence-transformers/all-mpnet-base-v2) <!-- at revision 84f2bcc00d77236f9e89c8a360a00fb1139bf47d --> |
| - **Maximum Sequence Length:** 384 tokens |
| - **Output Dimensionality:** 768 tokens |
| - **Similarity Function:** Cosine Similarity |
| - **Training Dataset:** |
| - [code-search-net/code_search_net](https://huggingface.co/datasets/code-search-net/code_search_net) |
| - **Language:** code |
| <!-- - **License:** Unknown --> |
|
|
| ### Model Sources |
|
|
| - **Documentation:** [Sentence Transformers Documentation](https://sbert.net) |
| - **Repository:** [Sentence Transformers on GitHub](https://github.com/UKPLab/sentence-transformers) |
| - **Hugging Face:** [Sentence Transformers on Hugging Face](https://huggingface.co/models?library=sentence-transformers) |
|
|
| ### Full Model Architecture |
|
|
| ``` |
| SentenceTransformer( |
| (0): Transformer({'max_seq_length': 384, 'do_lower_case': False}) with Transformer model: MPNetModel |
| (1): Pooling({'word_embedding_dimension': 768, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True}) |
| (2): Normalize() |
| ) |
| ``` |
|
|
| ## Usage |
|
|
| ### Direct Usage (Sentence Transformers) |
|
|
| First install the Sentence Transformers library: |
|
|
| ```bash |
| pip install -U sentence-transformers |
| ``` |
|
|
| Then you can load this model and run inference. |
| ```python |
| from sentence_transformers import SentenceTransformer |
| |
| # Download from the 🤗 Hub |
| model = SentenceTransformer("BoghdadyJR/al-MiniLM-L6-v2") |
| # Run inference |
| sentences = [ |
| 'Keypoint.copy', |
| 'def copy(self, x=None, y=None):\n """\n Create a shallow copy of the Keypoint object.\n\n Parameters\n ----------\n x : None or number, optional\n Coordinate of the keypoint on the x axis.\n If ``None``, the instance\'s value will be copied.\n\n y : None or number, optional\n Coordinate of the keypoint on the y axis.\n If ``None``, the instance\'s value will be copied.\n\n Returns\n -------\n imgaug.Keypoint\n Shallow copy.\n\n """\n return self.deepcopy(x=x, y=y)', |
| 'def build_words_dataset(words=None, vocabulary_size=50000, printable=True, unk_key=\'UNK\'):\n """Build the words dictionary and replace rare words with \'UNK\' token.\n The most common word has the smallest integer id.\n\n Parameters\n ----------\n words : list of str or byte\n The context in list format. You may need to do preprocessing on the words, such as lower case, remove marks etc.\n vocabulary_size : int\n The maximum vocabulary size, limiting the vocabulary size. Then the script replaces rare words with \'UNK\' token.\n printable : boolean\n Whether to print the read vocabulary size of the given words.\n unk_key : str\n Represent the unknown words.\n\n Returns\n --------\n data : list of int\n The context in a list of ID.\n count : list of tuple and list\n Pair words and IDs.\n - count[0] is a list : the number of rare words\n - count[1:] are tuples : the number of occurrence of each word\n - e.g. [[\'UNK\', 418391], (b\'the\', 1061396), (b\'of\', 593677), (b\'and\', 416629), (b\'one\', 411764)]\n dictionary : dictionary\n It is `word_to_id` that maps word to ID.\n reverse_dictionary : a dictionary\n It is `id_to_word` that maps ID to word.\n\n Examples\n --------\n >>> words = tl.files.load_matt_mahoney_text8_dataset()\n >>> vocabulary_size = 50000\n >>> data, count, dictionary, reverse_dictionary = tl.nlp.build_words_dataset(words, vocabulary_size)\n\n References\n -----------------\n - `tensorflow/examples/tutorials/word2vec/word2vec_basic.py <https://github.com/tensorflow/tensorflow/blob/r0.7/tensorflow/examples/tutorials/word2vec/word2vec_basic.py>`__\n\n """\n if words is None:\n raise Exception("words : list of str or byte")\n\n count = [[unk_key, -1]]\n count.extend(collections.Counter(words).most_common(vocabulary_size - 1))\n dictionary = dict()\n for word, _ in count:\n dictionary[word] = len(dictionary)\n data = list()\n unk_count = 0\n for word in words:\n if word in dictionary:\n index = dictionary[word]\n else:\n index = 0 # dictionary[\'UNK\']\n unk_count += 1\n data.append(index)\n count[0][1] = unk_count\n reverse_dictionary = dict(zip(dictionary.values(), dictionary.keys()))\n if printable:\n tl.logging.info(\'Real vocabulary size %d\' % len(collections.Counter(words).keys()))\n tl.logging.info(\'Limited vocabulary size {}\'.format(vocabulary_size))\n if len(collections.Counter(words).keys()) < vocabulary_size:\n raise Exception(\n "len(collections.Counter(words).keys()) >= vocabulary_size , the limited vocabulary_size must be less than or equal to the read vocabulary_size"\n )\n return data, count, dictionary, reverse_dictionary', |
| ] |
| embeddings = model.encode(sentences) |
| print(embeddings.shape) |
| # [3, 768] |
| |
| # Get the similarity scores for the embeddings |
| similarities = model.similarity(embeddings, embeddings) |
| print(similarities.shape) |
| # [3, 3] |
| ``` |
|
|
| <!-- |
| ### Direct Usage (Transformers) |
|
|
| <details><summary>Click to see the direct usage in Transformers</summary> |
|
|
| </details> |
| --> |
|
|
| <!-- |
| ### Downstream Usage (Sentence Transformers) |
|
|
| You can finetune this model on your own dataset. |
|
|
| <details><summary>Click to expand</summary> |
|
|
| </details> |
| --> |
|
|
| <!-- |
| ### Out-of-Scope Use |
|
|
| *List how the model may foreseeably be misused and address what users ought not to do with the model.* |
| --> |
|
|
| ## Evaluation |
|
|
| ### Metrics |
|
|
| #### Semantic Similarity |
| * Dataset: `sts-dev` |
| * Evaluated with [<code>EmbeddingSimilarityEvaluator</code>](https://sbert.net/docs/package_reference/sentence_transformer/evaluation.html#sentence_transformers.evaluation.EmbeddingSimilarityEvaluator) |
|
|
| | Metric | Value | |
| |:--------------------|:----------| |
| | pearson_cosine | 0.8806 | |
| | **spearman_cosine** | **0.881** | |
| | pearson_manhattan | 0.8781 | |
| | spearman_manhattan | 0.8798 | |
| | pearson_euclidean | 0.8794 | |
| | spearman_euclidean | 0.881 | |
| | pearson_dot | 0.8806 | |
| | spearman_dot | 0.881 | |
| | pearson_max | 0.8806 | |
| | spearman_max | 0.881 | |
| |
| <!-- |
| ## Bias, Risks and Limitations |
| |
| *What are the known or foreseeable issues stemming from this model? You could also flag here known failure cases or weaknesses of the model.* |
| --> |
| |
| <!-- |
| ### Recommendations |
| |
| *What are recommendations with respect to the foreseeable issues? For example, filtering explicit content.* |
| --> |
| |
| ## Training Details |
| |
| ### Training Dataset |
| |
| #### code-search-net/code_search_net |
| |
| * Dataset: [code-search-net/code_search_net](https://huggingface.co/datasets/code-search-net/code_search_net) |
| * Size: 20,000 training samples |
| * Columns: <code>func_name</code> and <code>whole_func_string</code> |
| * Approximate statistics based on the first 1000 samples: |
| | | func_name | whole_func_string | |
| |:--------|:---------------------------------------------------------------------------------|:------------------------------------------------------------------------------------| |
| | type | string | string | |
| | details | <ul><li>min: 3 tokens</li><li>mean: 8.18 tokens</li><li>max: 21 tokens</li></ul> | <ul><li>min: 38 tokens</li><li>mean: 192.0 tokens</li><li>max: 384 tokens</li></ul> | |
| * Samples: |
| | func_name | whole_func_string | |
| |:-------------------------------------------------------------------|:-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| |
| | <code>ImageGraphCut.__msgc_step3_discontinuity_localization</code> | <code>def __msgc_step3_discontinuity_localization(self):<br> """<br> Estimate discontinuity in basis of low resolution image segmentation.<br> :return: discontinuity in low resolution<br> """<br> import scipy<br><br> start = self._start_time<br> seg = 1 - self.segmentation.astype(np.int8)<br> self.stats["low level object voxels"] = np.sum(seg)<br> self.stats["low level image voxels"] = np.prod(seg.shape)<br> # in seg is now stored low resolution segmentation<br> # back to normal parameters<br> # step 2: discontinuity localization<br> # self.segparams = sparams_hi<br> seg_border = scipy.ndimage.filters.laplace(seg, mode="constant")<br> logger.debug("seg_border: %s", scipy.stats.describe(seg_border, axis=None))<br> # logger.debug(str(np.max(seg_border)))<br> # logger.debug(str(np.min(seg_border)))<br> seg_border[seg_border != 0] = 1<br> logger.debug("seg_border: %s", scipy.stats.describe(seg_border, axis=None))<br> # scipy.ndimage.morphology.distance_transform_edt<br> boundary_dilatation_distance = self.segparams["boundary_dilatation_distance"]<br> seg = scipy.ndimage.morphology.binary_dilation(<br> seg_border,<br> # seg,<br> np.ones(<br> [<br> (boundary_dilatation_distance * 2) + 1,<br> (boundary_dilatation_distance * 2) + 1,<br> (boundary_dilatation_distance * 2) + 1,<br> ]<br> ),<br> )<br> if self.keep_temp_properties:<br> self.temp_msgc_lowres_discontinuity = seg<br> else:<br> self.temp_msgc_lowres_discontinuity = None<br><br> if self.debug_images:<br> import sed3<br><br> pd = sed3.sed3(seg_border) # ), contour=seg)<br> pd.show()<br> pd = sed3.sed3(seg) # ), contour=seg)<br> pd.show()<br> # segzoom = scipy.ndimage.interpolation.zoom(seg.astype('float'), zoom,<br> # order=0).astype('int8')<br> self.stats["t3"] = time.time() - start<br> return seg</code> | |
| | <code>ImageGraphCut.__multiscale_gc_lo2hi_run</code> | <code>def __multiscale_gc_lo2hi_run(self): # , pyed):<br> """<br> Run Graph-Cut segmentation with refinement of low resolution multiscale graph.<br> In first step is performed normal GC on low resolution data<br> Second step construct finer grid on edges of segmentation from first<br> step.<br> There is no option for use without `use_boundary_penalties`<br> """<br> # from PyQt4.QtCore import pyqtRemoveInputHook<br> # pyqtRemoveInputHook()<br> self._msgc_lo2hi_resize_init()<br> self.__msgc_step0_init()<br><br> hard_constraints = self.__msgc_step12_low_resolution_segmentation()<br> # ===== high resolution data processing<br> seg = self.__msgc_step3_discontinuity_localization()<br><br> self.stats["t3.1"] = (time.time() - self._start_time)<br> graph = Graph(<br> seg,<br> voxelsize=self.voxelsize,<br> nsplit=self.segparams["block_size"],<br> edge_weight_table=self._msgc_npenalty_table,<br> compute_low_nodes_index=True,<br> )<br><br> # graph.run() = graph.generate_base_grid() + graph.split_voxels()<br> # graph.run()<br> graph.generate_base_grid()<br> self.stats["t3.2"] = (time.time() - self._start_time)<br> graph.split_voxels()<br><br> self.stats["t3.3"] = (time.time() - self._start_time)<br><br> self.stats.update(graph.stats)<br> self.stats["t4"] = (time.time() - self._start_time)<br> mul_mask, mul_val = self.__msgc_tlinks_area_weight_from_low_segmentation(seg)<br> area_weight = 1<br> unariesalt = self.__create_tlinks(<br> self.img,<br> self.voxelsize,<br> self.seeds,<br> area_weight=area_weight,<br> hard_constraints=hard_constraints,<br> mul_mask=None,<br> mul_val=None,<br> )<br> # N-links prepared<br> self.stats["t5"] = (time.time() - self._start_time)<br> un, ind = np.unique(graph.msinds, return_index=True)<br> self.stats["t6"] = (time.time() - self._start_time)<br><br> self.stats["t7"] = (time.time() - self._start_time)<br> unariesalt2_lo2hi = np.hstack(<br> [unariesalt[ind, 0, 0].reshape(-1, 1), unariesalt[ind, 0, 1].reshape(-1, 1)]<br> )<br> nlinks_lo2hi = np.hstack([graph.edges, graph.edges_weights.reshape(-1, 1)])<br> if self.debug_images:<br> import sed3<br><br> ed = sed3.sed3(unariesalt[:, :, 0].reshape(self.img.shape))<br> ed.show()<br> import sed3<br><br> ed = sed3.sed3(unariesalt[:, :, 1].reshape(self.img.shape))<br> ed.show()<br> # ed = sed3.sed3(seg)<br> # ed.show()<br> # import sed3<br> # ed = sed3.sed3(graph.data)<br> # ed.show()<br> # import sed3<br> # ed = sed3.sed3(graph.msinds)<br> # ed.show()<br><br> # nlinks, unariesalt2, msinds = self.__msgc_step45678_construct_graph(area_weight, hard_constraints, seg)<br> # self.__msgc_step9_finish_perform_gc_and_reshape(nlinks, unariesalt2, msinds)<br> self.__msgc_step9_finish_perform_gc_and_reshape(<br> nlinks_lo2hi, unariesalt2_lo2hi, graph.msinds<br> )<br> self._msgc_lo2hi_resize_clean_finish()</code> | |
| | <code>ImageGraphCut.__multiscale_gc_hi2lo_run</code> | <code>def __multiscale_gc_hi2lo_run(self): # , pyed):<br> """<br> Run Graph-Cut segmentation with simplifiyng of high resolution multiscale graph.<br> In first step is performed normal GC on low resolution data<br> Second step construct finer grid on edges of segmentation from first<br> step.<br> There is no option for use without `use_boundary_penalties`<br> """<br> # from PyQt4.QtCore import pyqtRemoveInputHook<br> # pyqtRemoveInputHook()<br><br> self.__msgc_step0_init()<br> hard_constraints = self.__msgc_step12_low_resolution_segmentation()<br> # ===== high resolution data processing<br> seg = self.__msgc_step3_discontinuity_localization()<br> nlinks, unariesalt2, msinds = self.__msgc_step45678_hi2lo_construct_graph(<br> hard_constraints, seg<br> )<br> self.__msgc_step9_finish_perform_gc_and_reshape(nlinks, unariesalt2, msinds)</code> | |
| * Loss: [<code>MultipleNegativesRankingLoss</code>](https://sbert.net/docs/package_reference/sentence_transformer/losses.html#multiplenegativesrankingloss) with these parameters: |
| ```json |
| { |
| "scale": 20.0, |
| "similarity_fct": "cos_sim" |
| } |
| ``` |
| |
| ### Evaluation Dataset |
| |
| #### code-search-net/code_search_net |
| |
| * Dataset: [code-search-net/code_search_net](https://huggingface.co/datasets/code-search-net/code_search_net) |
| * Size: 15,000 evaluation samples |
| * Columns: <code>func_name</code> and <code>whole_func_string</code> |
| * Approximate statistics based on the first 1000 samples: |
| | | func_name | whole_func_string | |
| |:--------|:---------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| |
| | type | string | string | |
| | details | <ul><li>min: 3 tokens</li><li>mean: 9.23 tokens</li><li>max: 24 tokens</li></ul> | <ul><li>min: 50 tokens</li><li>mean: 276.31 tokens</li><li>max: 384 tokens</li></ul> | |
| * Samples: |
| | func_name | whole_func_string | |
| |:---------------------------------|:------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| |
| | <code>learn</code> | <code>def learn(env,<br> network,<br> seed=None,<br> lr=5e-4,<br> total_timesteps=100000,<br> buffer_size=50000,<br> exploration_fraction=0.1,<br> exploration_final_eps=0.02,<br> train_freq=1,<br> batch_size=32,<br> print_freq=100,<br> checkpoint_freq=10000,<br> checkpoint_path=None,<br> learning_starts=1000,<br> gamma=1.0,<br> target_network_update_freq=500,<br> prioritized_replay=False,<br> prioritized_replay_alpha=0.6,<br> prioritized_replay_beta0=0.4,<br> prioritized_replay_beta_iters=None,<br> prioritized_replay_eps=1e-6,<br> param_noise=False,<br> callback=None,<br> load_path=None,<br> **network_kwargs<br> ):<br> """Train a deepq model.<br><br> Parameters<br> -------<br> env: gym.Env<br> environment to train on<br> network: string or a function<br> neural network to use as a q function approximator. If string, has to be one of the names of registered models in baselines.common.models<br> (mlp, cnn, conv_only). If a function, should take an observation tensor and return a latent variable tensor, which<br> will be mapped to the Q function heads (see build_q_func in baselines.deepq.models for details on that)<br> seed: int or None<br> prng seed. The runs with the same seed "should" give the same results. If None, no seeding is used.<br> lr: float<br> learning rate for adam optimizer<br> total_timesteps: int<br> number of env steps to optimizer for<br> buffer_size: int<br> size of the replay buffer<br> exploration_fraction: float<br> fraction of entire training period over which the exploration rate is annealed<br> exploration_final_eps: float<br> final value of random action probability<br> train_freq: int<br> update the model every `train_freq` steps.<br> set to None to disable printing<br> batch_size: int<br> size of a batched sampled from replay buffer for training<br> print_freq: int<br> how often to print out training progress<br> set to None to disable printing<br> checkpoint_freq: int<br> how often to save the model. This is so that the best version is restored<br> at the end of the training. If you do not wish to restore the best version at<br> the end of the training set this variable to None.<br> learning_starts: int<br> how many steps of the model to collect transitions for before learning starts<br> gamma: float<br> discount factor<br> target_network_update_freq: int<br> update the target network every `target_network_update_freq` steps.<br> prioritized_replay: True<br> if True prioritized replay buffer will be used.<br> prioritized_replay_alpha: float<br> alpha parameter for prioritized replay buffer<br> prioritized_replay_beta0: float<br> initial value of beta for prioritized replay buffer<br> prioritized_replay_beta_iters: int<br> number of iterations over which beta will be annealed from initial value<br> to 1.0. If set to None equals to total_timesteps.<br> prioritized_replay_eps: float<br> epsilon to add to the TD errors when updating priorities.<br> param_noise: bool<br> whether or not to use parameter space noise (https://arxiv.org/abs/1706.01905)<br> callback: (locals, globals) -> None<br> function called at every steps with state of the algorithm.<br> If callback returns true training stops.<br> load_path: str<br> path to load the model from. (default: None)<br> **network_kwargs<br> additional keyword arguments to pass to the network builder.<br><br> Returns<br> -------<br> act: ActWrapper<br> Wrapper over act function. Adds ability to save it and load it.<br> See header of baselines/deepq/categorical.py for details on the act function.<br> """<br> # Create all the functions necessary to train the model<br><br> sess = get_session()<br> set_global_seeds(seed)<br><br> q_func = build_q_func(network, **network_kwargs)<br><br> # capture the shape outside the closure so that the env object is not serialized<br> # by cloudpickle when serializing make_obs_ph<br><br> observation_space = env.observation_space<br> def make_obs_ph(name):<br> return ObservationInput(observation_space, name=name)<br><br> act, train, update_target, debug = deepq.build_train(<br> make_obs_ph=make_obs_ph,<br> q_func=q_func,<br> num_actions=env.action_space.n,<br> optimizer=tf.train.AdamOptimizer(learning_rate=lr),<br> gamma=gamma,<br> grad_norm_clipping=10,<br> param_noise=param_noise<br> )<br><br> act_params = {<br> 'make_obs_ph': make_obs_ph,<br> 'q_func': q_func,<br> 'num_actions': env.action_space.n,<br> }<br><br> act = ActWrapper(act, act_params)<br><br> # Create the replay buffer<br> if prioritized_replay:<br> replay_buffer = PrioritizedReplayBuffer(buffer_size, alpha=prioritized_replay_alpha)<br> if prioritized_replay_beta_iters is None:<br> prioritized_replay_beta_iters = total_timesteps<br> beta_schedule = LinearSchedule(prioritized_replay_beta_iters,<br> initial_p=prioritized_replay_beta0,<br> final_p=1.0)<br> else:<br> replay_buffer = ReplayBuffer(buffer_size)<br> beta_schedule = None<br> # Create the schedule for exploration starting from 1.<br> exploration = LinearSchedule(schedule_timesteps=int(exploration_fraction * total_timesteps),<br> initial_p=1.0,<br> final_p=exploration_final_eps)<br><br> # Initialize the parameters and copy them to the target network.<br> U.initialize()<br> update_target()<br><br> episode_rewards = [0.0]<br> saved_mean_reward = None<br> obs = env.reset()<br> reset = True<br><br> with tempfile.TemporaryDirectory() as td:<br> td = checkpoint_path or td<br><br> model_file = os.path.join(td, "model")<br> model_saved = False<br><br> if tf.train.latest_checkpoint(td) is not None:<br> load_variables(model_file)<br> logger.log('Loaded model from {}'.format(model_file))<br> model_saved = True<br> elif load_path is not None:<br> load_variables(load_path)<br> logger.log('Loaded model from {}'.format(load_path))<br><br><br> for t in range(total_timesteps):<br> if callback is not None:<br> if callback(locals(), globals()):<br> break<br> # Take action and update exploration to the newest value<br> kwargs = {}<br> if not param_noise:<br> update_eps = exploration.value(t)<br> update_param_noise_threshold = 0.<br> else:<br> update_eps = 0.<br> # Compute the threshold such that the KL divergence between perturbed and non-perturbed<br> # policy is comparable to eps-greedy exploration with eps = exploration.value(t).<br> # See Appendix C.1 in Parameter Space Noise for Exploration, Plappert et al., 2017<br> # for detailed explanation.<br> update_param_noise_threshold = -np.log(1. - exploration.value(t) + exploration.value(t) / float(env.action_space.n))<br> kwargs['reset'] = reset<br> kwargs['update_param_noise_threshold'] = update_param_noise_threshold<br> kwargs['update_param_noise_scale'] = True<br> action = act(np.array(obs)[None], update_eps=update_eps, **kwargs)[0]<br> env_action = action<br> reset = False<br> new_obs, rew, done, _ = env.step(env_action)<br> # Store transition in the replay buffer.<br> replay_buffer.add(obs, action, rew, new_obs, float(done))<br> obs = new_obs<br><br> episode_rewards[-1] += rew<br> if done:<br> obs = env.reset()<br> episode_rewards.append(0.0)<br> reset = True<br><br> if t > learning_starts and t % train_freq == 0:<br> # Minimize the error in Bellman's equation on a batch sampled from replay buffer.<br> if prioritized_replay:<br> experience = replay_buffer.sample(batch_size, beta=beta_schedule.value(t))<br> (obses_t, actions, rewards, obses_tp1, dones, weights, batch_idxes) = experience<br> else:<br> obses_t, actions, rewards, obses_tp1, dones = replay_buffer.sample(batch_size)<br> weights, batch_idxes = np.ones_like(rewards), None<br> td_errors = train(obses_t, actions, rewards, obses_tp1, dones, weights)<br> if prioritized_replay:<br> new_priorities = np.abs(td_errors) + prioritized_replay_eps<br> replay_buffer.update_priorities(batch_idxes, new_priorities)<br><br> if t > learning_starts and t % target_network_update_freq == 0:<br> # Update target network periodically.<br> update_target()<br><br> mean_100ep_reward = round(np.mean(episode_rewards[-101:-1]), 1)<br> num_episodes = len(episode_rewards)<br> if done and print_freq is not None and len(episode_rewards) % print_freq == 0:<br> logger.record_tabular("steps", t)<br> logger.record_tabular("episodes", num_episodes)<br> logger.record_tabular("mean 100 episode reward", mean_100ep_reward)<br> logger.record_tabular("% time spent exploring", int(100 * exploration.value(t)))<br> logger.dump_tabular()<br><br> if (checkpoint_freq is not None and t > learning_starts and<br> num_episodes > 100 and t % checkpoint_freq == 0):<br> if saved_mean_reward is None or mean_100ep_reward > saved_mean_reward:<br> if print_freq is not None:<br> logger.log("Saving model due to mean reward increase: {} -> {}".format(<br> saved_mean_reward, mean_100ep_reward))<br> save_variables(model_file)<br> model_saved = True<br> saved_mean_reward = mean_100ep_reward<br> if model_saved:<br> if print_freq is not None:<br> logger.log("Restored model with mean reward: {}".format(saved_mean_reward))<br> load_variables(model_file)<br><br> return act</code> | |
| | <code>ActWrapper.save_act</code> | <code>def save_act(self, path=None):<br> """Save model to a pickle located at `path`"""<br> if path is None:<br> path = os.path.join(logger.get_dir(), "model.pkl")<br><br> with tempfile.TemporaryDirectory() as td:<br> save_variables(os.path.join(td, "model"))<br> arc_name = os.path.join(td, "packed.zip")<br> with zipfile.ZipFile(arc_name, 'w') as zipf:<br> for root, dirs, files in os.walk(td):<br> for fname in files:<br> file_path = os.path.join(root, fname)<br> if file_path != arc_name:<br> zipf.write(file_path, os.path.relpath(file_path, td))<br> with open(arc_name, "rb") as f:<br> model_data = f.read()<br> with open(path, "wb") as f:<br> cloudpickle.dump((model_data, self._act_params), f)</code> | |
| | <code>nature_cnn</code> | <code>def nature_cnn(unscaled_images, **conv_kwargs):<br> """<br> CNN from Nature paper.<br> """<br> scaled_images = tf.cast(unscaled_images, tf.float32) / 255.<br> activ = tf.nn.relu<br> h = activ(conv(scaled_images, 'c1', nf=32, rf=8, stride=4, init_scale=np.sqrt(2),<br> **conv_kwargs))<br> h2 = activ(conv(h, 'c2', nf=64, rf=4, stride=2, init_scale=np.sqrt(2), **conv_kwargs))<br> h3 = activ(conv(h2, 'c3', nf=64, rf=3, stride=1, init_scale=np.sqrt(2), **conv_kwargs))<br> h3 = conv_to_fc(h3)<br> return activ(fc(h3, 'fc1', nh=512, init_scale=np.sqrt(2)))</code> | |
| * Loss: [<code>MultipleNegativesRankingLoss</code>](https://sbert.net/docs/package_reference/sentence_transformer/losses.html#multiplenegativesrankingloss) with these parameters: |
| ```json |
| { |
| "scale": 20.0, |
| "similarity_fct": "cos_sim" |
| } |
| ``` |
| |
| ### Training Hyperparameters |
| #### Non-Default Hyperparameters |
| |
| - `eval_strategy`: steps |
| - `per_device_train_batch_size`: 16 |
| - `per_device_eval_batch_size`: 16 |
| - `learning_rate`: 2e-05 |
| - `num_train_epochs`: 1 |
| - `warmup_ratio`: 0.1 |
| - `fp16`: True |
| - `batch_sampler`: no_duplicates |
| |
| #### All Hyperparameters |
| <details><summary>Click to expand</summary> |
| |
| - `overwrite_output_dir`: False |
| - `do_predict`: False |
| - `eval_strategy`: steps |
| - `prediction_loss_only`: True |
| - `per_device_train_batch_size`: 16 |
| - `per_device_eval_batch_size`: 16 |
| - `per_gpu_train_batch_size`: None |
| - `per_gpu_eval_batch_size`: None |
| - `gradient_accumulation_steps`: 1 |
| - `eval_accumulation_steps`: None |
| - `learning_rate`: 2e-05 |
| - `weight_decay`: 0.0 |
| - `adam_beta1`: 0.9 |
| - `adam_beta2`: 0.999 |
| - `adam_epsilon`: 1e-08 |
| - `max_grad_norm`: 1.0 |
| - `num_train_epochs`: 1 |
| - `max_steps`: -1 |
| - `lr_scheduler_type`: linear |
| - `lr_scheduler_kwargs`: {} |
| - `warmup_ratio`: 0.1 |
| - `warmup_steps`: 0 |
| - `log_level`: passive |
| - `log_level_replica`: warning |
| - `log_on_each_node`: True |
| - `logging_nan_inf_filter`: True |
| - `save_safetensors`: True |
| - `save_on_each_node`: False |
| - `save_only_model`: False |
| - `restore_callback_states_from_checkpoint`: False |
| - `no_cuda`: False |
| - `use_cpu`: False |
| - `use_mps_device`: False |
| - `seed`: 42 |
| - `data_seed`: None |
| - `jit_mode_eval`: False |
| - `use_ipex`: False |
| - `bf16`: False |
| - `fp16`: True |
| - `fp16_opt_level`: O1 |
| - `half_precision_backend`: auto |
| - `bf16_full_eval`: False |
| - `fp16_full_eval`: False |
| - `tf32`: None |
| - `local_rank`: 0 |
| - `ddp_backend`: None |
| - `tpu_num_cores`: None |
| - `tpu_metrics_debug`: False |
| - `debug`: [] |
| - `dataloader_drop_last`: False |
| - `dataloader_num_workers`: 0 |
| - `dataloader_prefetch_factor`: None |
| - `past_index`: -1 |
| - `disable_tqdm`: False |
| - `remove_unused_columns`: True |
| - `label_names`: None |
| - `load_best_model_at_end`: False |
| - `ignore_data_skip`: False |
| - `fsdp`: [] |
| - `fsdp_min_num_params`: 0 |
| - `fsdp_config`: {'min_num_params': 0, 'xla': False, 'xla_fsdp_v2': False, 'xla_fsdp_grad_ckpt': False} |
| - `fsdp_transformer_layer_cls_to_wrap`: None |
| - `accelerator_config`: {'split_batches': False, 'dispatch_batches': None, 'even_batches': True, 'use_seedable_sampler': True, 'non_blocking': False, 'gradient_accumulation_kwargs': None} |
| - `deepspeed`: None |
| - `label_smoothing_factor`: 0.0 |
| - `optim`: adamw_torch |
| - `optim_args`: None |
| - `adafactor`: False |
| - `group_by_length`: False |
| - `length_column_name`: length |
| - `ddp_find_unused_parameters`: None |
| - `ddp_bucket_cap_mb`: None |
| - `ddp_broadcast_buffers`: False |
| - `dataloader_pin_memory`: True |
| - `dataloader_persistent_workers`: False |
| - `skip_memory_metrics`: True |
| - `use_legacy_prediction_loop`: False |
| - `push_to_hub`: False |
| - `resume_from_checkpoint`: None |
| - `hub_model_id`: None |
| - `hub_strategy`: every_save |
| - `hub_private_repo`: False |
| - `hub_always_push`: False |
| - `gradient_checkpointing`: False |
| - `gradient_checkpointing_kwargs`: None |
| - `include_inputs_for_metrics`: False |
| - `eval_do_concat_batches`: True |
| - `fp16_backend`: auto |
| - `push_to_hub_model_id`: None |
| - `push_to_hub_organization`: None |
| - `mp_parameters`: |
| - `auto_find_batch_size`: False |
| - `full_determinism`: False |
| - `torchdynamo`: None |
| - `ray_scope`: last |
| - `ddp_timeout`: 1800 |
| - `torch_compile`: False |
| - `torch_compile_backend`: None |
| - `torch_compile_mode`: None |
| - `dispatch_batches`: None |
| - `split_batches`: None |
| - `include_tokens_per_second`: False |
| - `include_num_input_tokens_seen`: False |
| - `neftune_noise_alpha`: None |
| - `optim_target_modules`: None |
| - `batch_eval_metrics`: False |
| - `eval_on_start`: False |
| - `batch_sampler`: no_duplicates |
| - `multi_dataset_batch_sampler`: proportional |
| |
| </details> |
| |
| ### Training Logs |
| | Epoch | Step | Training Loss | loss | sts-dev_spearman_cosine | |
| |:-----:|:----:|:-------------:|:------:|:-----------------------:| |
| | 0 | 0 | - | - | 0.8810 | |
| | 0.08 | 100 | 0.4124 | 0.2191 | - | |
| | 0.16 | 200 | 0.108 | 0.0993 | - | |
| | 0.24 | 300 | 0.127 | 0.0756 | - | |
| | 0.32 | 400 | 0.0728 | - | - | |
| | 0.08 | 100 | 0.0662 | 0.0683 | - | |
| | 0.16 | 200 | 0.0321 | 0.0660 | - | |
| | 0.24 | 300 | 0.0815 | 0.0584 | - | |
| | 0.32 | 400 | 0.049 | 0.0591 | - | |
| | 0.4 | 500 | 0.0636 | 0.0612 | - | |
| | 0.48 | 600 | 0.0929 | 0.0577 | - | |
| | 0.56 | 700 | 0.0342 | 0.0568 | - | |
| | 0.64 | 800 | 0.0265 | 0.0572 | - | |
| | 0.72 | 900 | 0.0406 | 0.0551 | - | |
| | 0.8 | 1000 | 0.039 | 0.0549 | - | |
| | 0.88 | 1100 | 0.0376 | 0.0551 | - | |
| | 0.96 | 1200 | 0.0823 | 0.0556 | - | |
| |
| |
| ### Framework Versions |
| - Python: 3.10.13 |
| - Sentence Transformers: 3.0.1 |
| - Transformers: 4.42.3 |
| - PyTorch: 2.1.2 |
| - Accelerate: 0.32.1 |
| - Datasets: 2.20.0 |
| - Tokenizers: 0.19.1 |
| |
| ## Citation |
| |
| ### BibTeX |
| |
| #### Sentence Transformers |
| ```bibtex |
| @inproceedings{reimers-2019-sentence-bert, |
| title = "Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks", |
| author = "Reimers, Nils and Gurevych, Iryna", |
| booktitle = "Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing", |
| month = "11", |
| year = "2019", |
| publisher = "Association for Computational Linguistics", |
| url = "https://arxiv.org/abs/1908.10084", |
| } |
| ``` |
| |
| #### MultipleNegativesRankingLoss |
| ```bibtex |
| @misc{henderson2017efficient, |
| title={Efficient Natural Language Response Suggestion for Smart Reply}, |
| author={Matthew Henderson and Rami Al-Rfou and Brian Strope and Yun-hsuan Sung and Laszlo Lukacs and Ruiqi Guo and Sanjiv Kumar and Balint Miklos and Ray Kurzweil}, |
| year={2017}, |
| eprint={1705.00652}, |
| archivePrefix={arXiv}, |
| primaryClass={cs.CL} |
| } |
| ``` |
| |
| <!-- |
| ## Glossary |
| |
| *Clearly define terms in order to be accessible across audiences.* |
| --> |
| |
| <!-- |
| ## Model Card Authors |
| |
| *Lists the people who create the model card, providing recognition and accountability for the detailed work that goes into its construction.* |
| --> |
| |
| <!-- |
| ## Model Card Contact |
| |
| *Provides a way for people who have updates to the Model Card, suggestions, or questions, to contact the Model Card authors.* |
| --> |
