File size: 137,069 Bytes
934a9a4 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 |
---
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.*
--> |